@solidev/data 1.0.0 → 1.1.0

package/types/solidev-data.d.ts

@@ -1,14 +1,13 @@
 import * as _angular_core from '@angular/core';
-import { InjectionToken, TransferState, OnInit, ElementRef, PipeTransform, NgZone, EventEmitter, 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 { InjectionToken, OnInit, ElementRef, PipeTransform, NgZone, EventEmitter, OnDestroy } from '@angular/core';
+import { ValidatorFn, FormControl, ValidationErrors, FormGroup, UntypedFormGroup, ControlValueAccessor, UntypedFormControl } from '@angular/forms';
 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 { NgbDropdown } from '@ng-bootstrap/ng-bootstrap';
-import { SwUpdate } from '@angular/service-worker';
+import * as _angular_common_http from '@angular/common/http';
+import { HttpClient, HttpInterceptor, HttpRequest, HttpHandler } from '@angular/common/http';
 
 /**
  * Base URL of the REST API every {@link Collection} builds its endpoints on.
@@ -70,15 +69,13 @@ interface DataDisplayConfig {
          * `"inline"` renders the value in flow, `"dd"` renders it as a definition
          * list entry.
          */
-        defaultMode: "inline" | "dd";
+        defaultMode: 'inline' | 'dd';
         /**
          * Class string per editor type, keyed by the editor names used in
          * `DISPEDIT_EDITOR_TYPES` (e.g. `"input.text"`, `"select"`). A missing key
          * simply yields no class.
          */
-        inputClasses: {
-            [index: string]: string;
-        };
+        inputClasses: Record<string, string>;
     };
 }
 /**
@@ -113,476 +110,517 @@ declare const BootstrapDataDisplayConfig: DataDisplayConfig;
 declare const DATA_DISPLAY_CONFIG: InjectionToken<DataDisplayConfig>;
 
 /**
- * A single selectable option for a `select` editor or a `choice` display.
- *
- * `value` is what is written to the model field; `desc` is the human-readable
- * label rendered in the dropdown or in display mode. Choices come either from
- * the field manager (e.g. a `charField` declared with `choices`) or from the
- * `[choices]` input of {@link DispeditComponent}, which overrides the manager.
- */
-interface IDispEditChoice {
-    /** Human-readable label shown to the user. */
-    desc: string;
-    /** Raw value written to the model field when the option is picked. */
-    value: any;
-}
-/**
- * Every editor widget {@link DispeditComponent} knows how to render.
+ * The HTTP layer every {@link Collection} sits on: it owns the API base URL,
+ * decides the headers, and optionally serves GET responses out of Angular's
+ * `TransferState` during SSR hydration.
  *
- * A field manager advertises one of these through its `editorType` property,
- * which is how declaring the model is enough to get the right editor. The
- * `[editor]` input of {@link DispeditComponent} overrides that choice.
+ * Collections never touch `HttpClient` directly, which makes this the one place
+ * to hook cross-cutting request concerns. The usual reason to care about this
+ * class is {@link headers}: subclass it, override that method to inject an auth
+ * token, and provide the subclass in place of the default.
  *
- * - `input.text` / `input.email` / `input.password`: matching `<input>` type,
- *   with min/max length and pattern validation feedback.
- * - `input.number`: numeric `<input>`, value used as-is.
- * - `input.decimal`: numeric `<input>` for a `decimalField`; the value is
- *   divided by the manager's `factor` on load and multiplied back on save.
- * - `input.date` / `input.datetime`: native date / datetime-local `<input>`.
- * - `input.checkbox`: a Oui/Non button group (not an actual checkbox).
- * - `textarea`: multi-line `<textarea>`.
- * - `select`: `<select>` built from the resolved choices. Automatically used
- *   whenever choices are available, whatever the manager advertises.
- * - `quill`: rich text editor (rendered by the caller's own integration).
- * - `fkselect`: `<data-fkselect>` typeahead, set by `ForeignKeyFieldManager`.
- * - `m2mselect`: `<data-m2mselect>` multi-value typeahead, set by
- *   `ManyToManyFieldManager`.
- */
-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';
-/**
- * Every read-only renderer {@link DispeditComponent} knows how to produce.
+ * Requires {@link DATA_API_URL}. TransferState caching applies to GET only, and
+ * only when {@link DATA_MAX_TRANSFERSTATE_TIME} is provided and greater than
+ * zero — see {@link _cachedGet} for the exact conditions.
  *
- * A field manager advertises one of these through its `displayType` property;
- * the `[viewer]` input of {@link DispeditComponent} overrides it. Booleans and
- * null values are short-circuited before the display type is consulted, and
- * rendered as `OUI` / `NON` / `non défini`.
+ * Dependencies are resolved with `inject()`, so a subclass declares **no
+ * constructor**. To point one at a different API — a second backend alongside
+ * the main one — override {@link apiUrl} rather than passing a URL through
+ * `super()`; {@link maxTransferstateTime} is overridable the same way.
  *
- * - `text`: raw value interpolated as a string. The default.
- * - `choice`: the `desc` of the matching {@link IDispEditChoice}. Automatically
- *   used whenever choices are available.
- * - `boolean`: `OUI` / `NON`.
- * - `decimal`: the value divided by the `decimalField` manager's `factor`.
- * - `fkdetails`: the `_display` of the `<field>_details` sibling property.
- * - `m2mdetails`: one line per item, each rendered via its `_display`.
- * - `datetime` / `date`: value passed through Angular's `date` pipe (`short`
- *   and `shortDate` respectively).
- * - `quill`: rich text, rendered as HTML by the caller's integration.
- */
-type DISPEDIT_DISPLAY_TYPES = 'text' | 'choice' | 'boolean' | 'decimal' | 'fkdetails' | 'm2mdetails' | 'datetime' | 'date' | 'quill';
-
-/**
- * Options common to every field decorator. All are optional; each concrete
- * field type extends this with its own (`ICharFieldMetadata`, etc.).
+ * @example
+ * ```ts
+ * @Injectable({ providedIn: 'root' })
+ * export class AuthBackend extends DataBackend {
+ *   protected override headers(headers: { [k: string]: string }) {
+ *     return { ...super.headers(headers), Authorization: `Bearer ${token}` };
+ *   }
+ * }
  *
- * Whatever you pass to a decorator is copied verbatim onto the field's manager
- * instance, so these names double as the manager's public properties.
+ * @Injectable({ providedIn: 'root' })
+ * export class SupportBackend extends DataBackend {
+ *   public override get apiUrl(): string {
+ *     return 'https://support.example.com/api';
+ *   }
+ * }
  *
- * @typeParam FT the JavaScript type the field holds on the model
+ * providers: [
+ *   { provide: DATA_API_URL, useValue: 'https://api.example.com' },
+ *   { provide: DataBackend, useClass: AuthBackend },
+ * ];
+ * ```
  */
-interface IFieldMetadata<FT> {
-    /**
-     * Wire name of the field: the key used in the JSON payload. Defaults to the
-     * decorated property name, so it only needs setting when the API name and
-     * the TypeScript property name differ.
-     */
-    name?: string;
-    /** Short hint shown next to the editor. Defaults to an empty string. */
-    help?: string;
-    /**
-     * Human-readable label used for column titles, form labels and hover
-     * details. Defaults to {@link IFieldMetadata.name} when omitted.
-     */
-    description?: string;
+declare class DataBackend {
     /**
-     * Marks the field as mandatory: adds `Validators.required` and forces a
-     * value to be present on save.
-     *
-     * Beware: combining `required: true` with no `defaultValue` throws at class
-     * definition time — see {@link BaseFieldManager.getDefaultValue}.
+     * Instantiation timestamp, used as the origin of the TransferState validity
+     * window (see {@link _cachedGet}) — the window runs from backend creation, not
+     * from each entry's insertion.
      */
-    required?: boolean;
+    private _created;
+    private _http;
+    private _transferState;
+    private _platform;
+    private _apiUrl;
+    private _maxTransferstateTime;
     /**
-     * Field is display-only: it is excluded from generated form groups and never
-     * pushed back to the API. Typical for server-maintained columns and for the
-     * `*_details` half of a relation.
+     * Base URL every collection URL is built on, as provided via
+     * {@link DATA_API_URL}. Read by `Collection.getUrl()`; exposed so custom
+     * collections can build URLs the same way.
      */
-    readonly?: boolean;
+    get apiUrl(): string;
     /**
-     * Value used when the model has no value for this field — either a constant
-     * or a factory `(args) => FT` evaluated on each call, which is how you get a
-     * fresh array/date per instance instead of a shared one.
+     * TransferState window in ms, from {@link DATA_MAX_TRANSFERSTATE_TIME}; `0`
+     * disables the cache. Overridable for the same reason as {@link apiUrl}.
      */
-    defaultValue?: FT | ((args: any) => FT) | null;
+    protected get maxTransferstateTime(): number;
     /**
-     * Display ordering weight: **higher is shown first**. `id` uses `1000`.
+     * Issues an arbitrary request and returns the parsed JSON body.
      *
-     * `priority: -1` is the established idiom for "deserialise this field but
-     * never offer it in the UI" — negative-priority fields are dropped from the
-     * default column set. It is used for the id half of every relation, whose
-     * `*_details` twin is what a human is meant to see.
+     * The general-purpose entry point, used by `Collection.action()` and
+     * `Collection.raw()`. GET requests are routed through {@link _cachedGet} and so
+     * may be answered from TransferState; every other method goes straight to the
+     * network and carries the body.
+     *
+     * @param collection collection the request belongs to; consulted for its
+     *   `useTransferState` flag
+     * @param method HTTP method
+     * @param url absolute URL, normally from `Collection.getUrl()`
+     * @param body JSON body; ignored for GET
+     * @param params query parameters
+     * @param headers extra headers, passed through {@link headers}
+     *
+     * @return an observable of the response body
      */
-    priority?: number;
-}
-/**
- * Runtime behaviour of a single field: one manager instance is built per
- * decorated property, at class definition time, and cached in the prototype's
- * metadata map. Everything the library does with a field — serialise it,
- * validate it, build its form control, pick its widget — goes through here.
- *
- * Subclass it only to add a genuinely new field type; the shipped managers
- * (`CharFieldManager`, `ForeignKeyFieldManager`, ...) cover the usual cases.
- * Override `fromJson`/`toJson` to change the wire mapping and
- * `getValidators()` to add constraints.
- */
-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;
-    /** Human-readable label; falls back to {@link name} when not given. */
-    description: string;
-    /** Input hint; normalised to `''` when not given. */
-    help: string;
-    /** Whether a value must be present. Adds `Validators.required`. */
-    required: boolean;
-    /** Whether the field is excluded from forms and never written back. */
-    readonly: boolean;
+    action<T extends DataModel, RT>(collection: Collection<T>, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', url: string, { body, params, headers }?: IActionParams): Observable<RT>;
     /**
-     * Set to `true` only by `ComputedFieldManager`. `DataModel.setFV` skips
-     * assignment entirely for computed fields, making them permanently
-     * read-only in the eyes of the model.
+     * Issues a request whose response is taken as binary rather than JSON.
+     *
+     * Backs `Collection.blob()`; use that instead of calling this directly. Never
+     * cached through TransferState, whatever the method.
+     *
+     * @param collection collection the request belongs to; not used by this method
+     * @param method HTTP method
+     * @param url absolute URL
+     * @param body JSON body
+     * @param params query parameters
+     * @param headers extra headers, passed through {@link headers}
+     *
+     * @return an observable of the response as a `Blob`
      */
-    computed: boolean;
-    /** Display ordering weight; higher is shown first. See {@link IFieldMetadata.priority}. */
-    priority: number;
-    /** Constant or factory used when the model has no value. */
-    defaultValue?: FT | ((args: any) => FT);
+    blob<T extends DataModel>(collection: Collection<T>, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', url: string, { body, params, headers }?: IActionParams): Observable<Blob>;
     /**
-     * Which editor widget `dispedit` renders for this field in edit mode.
+     * Full-replacement write (HTTP PUT). Provided for completeness — the CRUD path
+     * in `Collection` uses {@link post}/{@link patch} instead, so this is only
+     * reached by callers that need PUT semantics explicitly.
      *
-     * This is the library's central idea: **declaring the model configures the
-     * UI**. Managers set this themselves from what you declared — `charField`
-     * flips to `'select'` as soon as `choices` is present, `foreignKeyField`
-     * uses `'fkselect'`, `manyToManyField` `'m2mselect'` — so a correct model
-     * yields the right editor with no per-template wiring.
+     * @param collection collection the request belongs to; not used by this method
+     * @param url absolute URL
+     * @param body JSON body
+     * @param params query parameters
+     * @param headers extra headers, passed through {@link headers}
      */
-    editorType: DISPEDIT_EDITOR_TYPES;
+    put<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<T>;
     /**
-     * Which read-only renderer `dispedit` uses for this field. Chosen by the
-     * manager the same way as {@link editorType} (`'fkdetails'` for a foreign
-     * key, `'m2mdetails'` for a m2m, `'decimal'` for `decimalField`, ...).
+     * Creates a record (HTTP POST). Chosen by `Collection.save()`/`update()` when
+     * the model has no `id`.
+     *
+     * @param collection collection the request belongs to; not used by this method
+     * @param url absolute URL, normally the collection's list URL
+     * @param body JSON body
+     * @param params query parameters
+     * @param headers extra headers, passed through {@link headers}
+     * @returns the created record's JSON, expected to include the assigned `id`
      */
-    displayType: DISPEDIT_DISPLAY_TYPES;
+    post<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<Partial<T>>;
     /**
-     * Copies `params` onto the instance, fills in `name`/`description`/`help`
-     * defaults, then eagerly resolves the default value — which means a
-     * `required` field with no `defaultValue` throws here, at decoration time.
+     * Partially updates a record (HTTP PATCH). Chosen by
+     * `Collection.save()`/`update()` when the model already has an `id`.
      *
-     * @param params metadata as passed to the decorator
+     * @param collection collection the request belongs to; not used by this method
+     * @param url absolute URL, normally the record's detail URL
+     * @param body JSON body, holding only the fields to change
+     * @param params query parameters
+     * @param headers extra headers, passed through {@link headers}
      */
-    constructor(params: IFieldMetadata<FT>);
+    patch<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<Partial<T>>;
     /**
-     * Angular validators for this field, rebuilt on each access. Subclasses
-     * override this getter (not {@link getValidators}) to append their own —
-     * `CharFieldManager` adds length/pattern, `IntegerFieldManager` min/max.
+     * Deletes a record (HTTP DELETE). Backs `Collection.delete()`.
+     *
+     * @param collection collection the request belongs to; not used by this method
+     * @param url absolute URL of the record
+     * @param params query parameters
+     * @param headers extra headers, passed through {@link headers}
      */
-    get validators(): ValidatorFn[];
+    delete<T extends DataModel, R>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<R>;
     /**
-     * The bare property name, stripped of any `Model__` prefix: splits
-     * {@link name} on `'__'` and returns the second segment, or the whole name
-     * when there is no separator.
-     */
-    get fname(): string;
-    /**
-     * Builds a typed `FormControl` for this field on a given model instance,
-     * seeded with the instance's current value and falling back to the default
-     * value, and wired with {@link validators}.
+     * Performs a GET, transparently replaying the server-rendered response from
+     * `TransferState` when that is still allowed.
      *
-     * Note the seed uses `||`, so falsy current values (`0`, `''`, `false`) fall
-     * back to the default rather than being kept.
+     * This is what stops an SSR app from re-fetching, in the browser, everything it
+     * already fetched on the server to render the page. Entries are keyed on URL +
+     * params + resolved headers, so requests differing in any of those do not share
+     * a slot.
      *
-     * @param instance model whose value seeds the control
-     */
-    formControl(instance: DataModel): FormControl<FT | null>;
-    /**
-     * Converts a raw JSON value coming from the API into the model value.
-     * The base implementation passes the data straight through; typed managers
-     * override it to coerce (`boolean`), parse (`date`) or instantiate
-     * (`details`).
+     * A cached value is **read** only when all of these hold: the collection has
+     * `useTransferState`, {@link DATA_MAX_TRANSFERSTATE_TIME} is greater than zero,
+     * the key is present, and less than that many milliseconds have passed since
+     * *this backend instance was created*. That last condition makes the window a
+     * one-shot hydration budget rather than a per-entry TTL: once it lapses, nothing
+     * is served from TransferState again for the life of the backend.
      *
-     * @param data raw value read from the JSON payload
-     */
-    fromJson(data: any): FT;
-    /**
-     * Converts the model value back into its JSON representation for save.
-     * The base implementation passes the data straight through.
+     * A value is **written** only when the collection has `useTransferState`, the
+     * code is running on the server, and the window is greater than zero. So in the
+     * browser this degrades to a plain, uncached `HttpClient.get`.
      *
-     * @param data current model value
+     * @param collection collection the request belongs to; consulted for `useTransferState`
+     * @param url absolute URL
+     * @param params query parameters
+     * @param headers extra headers, passed through {@link headers}
      */
-    toJson(data: FT): any;
+    _cachedGet<T extends DataModel, RT>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<RT>;
     /**
-     * Renders the value for display. The base implementation is plain string
-     * interpolation.
+     * Fetches a single record's JSON. Backs `Collection.fetch()`, and is
+     * TransferState-cacheable via {@link _cachedGet}.
      *
-     * @param data value to render
-     * @param format reserved; ignored by the base implementation
+     * @param collection collection the request belongs to
+     * @param url absolute URL of the record
+     * @param params query parameters
+     * @param headers extra headers
      */
-    toString(data: FT, format?: string): string;
+    get<T extends DataModel>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<Partial<T>>;
     /**
-     * Public accessor for this field's default value, invoking the
-     * `defaultValue` factory with `args` when one was declared.
+     * Fetches a list endpoint's raw JSON — including the pagination envelope, which
+     * `Collection.list()` then unwraps. Identical to {@link get} apart from the
+     * declared return type; both funnel into {@link _cachedGet}.
      *
-     * @param args passed through to a `defaultValue` function
+     * @param collection collection the request belongs to
+     * @param url absolute URL of the list endpoint
+     * @param params query parameters, typically the queryset's filters and paging
+     * @param headers extra headers
      */
-    default(args?: any): FT | undefined;
+    list<T extends DataModel>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<{
+        results: Partial<T>[];
+    }>;
     /**
-     * Builds the base validator list: `Validators.required` when the field is
-     * required, nothing otherwise. Subclasses call it and push their own.
+     * Resolves the headers actually sent with a request.
      *
-     * @protected
-     */
-    protected getValidators(): ValidatorFn[];
-    /**
-     * Resolves the default value: calls `defaultValue` when it is a function,
-     * otherwise returns it as-is.
+     * **The designated extension point of this class.** The base implementation
+     * just copies what it is given; subclasses override it to add headers that
+     * every request needs — most often an `Authorization` token — and then get
+     * provided in place of `DataBackend`. Doing it here rather than in an HTTP
+     * interceptor keeps the headers part of the TransferState cache key, so
+     * responses fetched under different credentials do not collide.
      *
-     * **Throws** when the field is `required` and no `defaultValue` was given.
-     * Because the constructor calls this, the error surfaces when the class is
-     * defined (module evaluation), not when a model is instantiated — a
-     * `required` field without a default breaks the app at import time.
+     * Implementations should stay pure and synchronous: this is called once per
+     * request, and for GETs its result feeds the cache key.
      *
-     * @param args passed through to a `defaultValue` function
-     * @throws Error if `required` is set and `defaultValue` is `undefined`
-     * @protected
+     * @param headers per-request headers supplied by the caller
+     * @returns the complete header set to send
      */
-    protected getDefaultValue(args?: any): FT | undefined;
+    protected headers(headers: Record<string, string>): Record<string, string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataBackend, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DataBackend>;
 }
+
+/** HTTP verbs this library issues. */
+type IHttpMethod = 'POST' | 'GET' | 'DELETE' | 'PUT' | 'PATCH';
 /**
- * What is actually kept in a model's metadata map: the options you passed to
- * the decorator, plus the four entries the decorator computes. This is the
- * shape returned by {@link getFieldsMetadata}.
+ * Per-request options shared by every {@link Collection} and {@link DataBackend}
+ * call: body, headers and query parameters.
+ *
+ * All members are optional, so `{}` is a valid "nothing special" argument.
  */
-interface IFieldStoredMetadata<FT> extends IFieldMetadata<FT> {
-    /** Map key of this entry: `` `${__name}__${propertyKey}` ``. */
-    self: string;
-    /** Wire name; defaulted to the decorated property name. */
-    name: string;
-    /** Field type code, e.g. `'charField'`, `'foreignKeyField'`. */
-    type: string;
-    /** The live manager instance built for this field. */
-    manager: BaseFieldManager<FT>;
+interface IActionParams {
+    /** JSON body; ignored by GET/DELETE requests. */
+    body?: unknown;
+    /** Extra headers, merged on top of whatever the backend's `headers()` adds. */
+    headers?: Record<string, string>;
+    /** Query string parameters. */
+    params?: Record<string, string>;
+    /**
+     * Expected response type. Note that the backend does not currently read this:
+     * `DataBackend.action()` always parses JSON and `DataBackend.blob()` always
+     * requests a blob. Use `Collection.blob()` to get binary data.
+     */
+    responseType?: 'json' | 'blob';
 }
 /**
- * Shape of every field decorator returned by {@link genericDataField}: a plain
- * property decorator, applied for its side effect on the prototype's metadata
- * map.
+ * Shape for describing per-collection cache tuning.
+ *
+ * Currently unused by the runtime — TransferState behaviour is driven by
+ * `Collection.useTransferState` plus the `DATA_MAX_TRANSFERSTATE_TIME` token.
  */
-type FieldDecoratorFn = (target: any, propertyKey: string | symbol) => void;
-
+interface ICollectionCacheParams {
+    transferState?: {
+        enabled: boolean;
+        maxTime: number;
+        maxCount: number;
+    };
+}
 /**
- * The HTTP layer every {@link Collection} sits on: it owns the API base URL,
- * decides the headers, and optionally serves GET responses out of Angular's
- * `TransferState` during SSR hydration.
+ * Constructor signature of a model class, letting a collection instantiate `T`
+ * without knowing it — this is the `model` argument passed to
+ * {@link Collection}'s constructor.
+ */
+type DataModelType<T extends DataModel> = new (_coll?: Collection<T>) => T;
+/**
+ * Binds a {@link DataModel} class to a REST endpoint and provides the CRUD
+ * operations over it.
  *
- * Collections never touch `HttpClient` directly, which makes this the one place
- * to hook cross-cutting request concerns. The usual reason to care about this
- * class is {@link headers}: subclass it, override that method to inject an auth
- * token, and provide the subclass in place of the default.
+ * A collection is the seam between models and HTTP: it knows the path, builds
+ * URLs, hands raw JSON to the model for deserialization, and returns typed
+ * instances that carry a back-reference to it (so `thing.save()` works). One
+ * collection per endpoint, normally declared as a root-provided service.
  *
- * Requires {@link DATA_API_URL}. TransferState caching applies to GET only, and
- * only when {@link DATA_MAX_TRANSFERSTATE_TIME} is provided and greater than
- * zero — see {@link _cachedGet} for the exact conditions.
+ * For anything involving filtering, sorting or pagination, go through
+ * {@link queryset} rather than {@link list}.
+ *
+ * The endpoint is assumed to follow Django REST Framework conventions:
+ * `/path` for the list, `/path/<id>` for a record, `/path/<id>/<action>` for
+ * custom actions, and a *paginated* list response (see {@link list}).
  *
  * @example
  * ```ts
  * @Injectable({ providedIn: 'root' })
- * export class AuthBackend extends DataBackend {
- *   protected override headers(headers: { [k: string]: string }) {
- *     return { ...super.headers(headers), Authorization: `Bearer ${token}` };
+ * export class ThingService extends Collection<Thing> {
+ *   constructor() {
+ *     super(inject(DataBackend), '/path/to/things', Thing);
  *   }
  * }
  *
- * providers: [
- *   { provide: DATA_API_URL, useValue: 'https://api.example.com' },
- *   { provide: DataBackend, useClass: AuthBackend },
- * ];
+ * // then
+ * things.fetch(1).subscribe((thing) => ...);
+ * things.queryset().filter({ status: 'active' }).get().subscribe((list) => ...);
  * ```
  */
-declare class DataBackend {
-    private _http;
-    private _transferState;
-    private _platform;
-    private _apiUrl;
-    private _maxTransferstateTime;
+declare class Collection<T extends DataModel> {
+    protected backend: DataBackend;
+    protected path: string;
+    model: DataModelType<T>;
     /**
-     * Instantiation timestamp, used as the origin of the TransferState validity
-     * window (see {@link _cachedGet}) — the window runs from backend creation, not
-     * from each entry's insertion.
+     * Whether GET responses for this collection may be served from / stored in
+     * Angular's `TransferState` during SSR hydration.
+     *
+     * On by default, but only ever takes effect when `DATA_MAX_TRANSFERSTATE_TIME`
+     * is provided and greater than zero. Set it to `false` on collections whose
+     * data is user-specific or must not be embedded in the server-rendered HTML.
      */
-    private _created;
+    useTransferState: boolean;
     /**
-     * @param _http Angular HTTP client
-     * @param _transferState SSR state bridge, used to replay server GETs in the browser
-     * @param _platform platform id, used to write TransferState on the server only
-     * @param _apiUrl base API URL; required, see {@link DATA_API_URL}
-     * @param _maxTransferstateTime TransferState window in ms; optional, `0`
-     *   (the default) disables caching entirely
+     * @param backend HTTP layer; supplies the API base URL and applies auth headers
+     * @param path endpoint path appended to the backend's `apiUrl`, leading slash
+     *   included and trailing slash omitted (e.g. `'/path/to/things'`)
+     * @param model model class this collection instantiates
      */
-    constructor(_http: HttpClient, _transferState: TransferState, _platform: any, _apiUrl: string, _maxTransferstateTime?: number);
+    constructor(backend: DataBackend, path: string, model: DataModelType<T>);
     /**
-     * Base URL every collection URL is built on, as provided via
-     * {@link DATA_API_URL}. Read by `Collection.getUrl()`; exposed so custom
-     * collections can build URLs the same way.
+     * Builds a new, unsaved model instance attached to this collection.
+     *
+     * Use it to back a creation form: the returned instance has no `id`, so the
+     * first `save()` POSTs it. Values passed in `data` go through the field
+     * managers' deserializers, exactly as if they had come from the API.
+     *
+     * @param data initial field values; omit for an empty instance
+     *
+     * @example
+     * ```ts
+     * const thing = things.create({ name: 'draft' });
+     * thing.save().subscribe(); // POST /path/to/things
+     * ```
      */
-    get apiUrl(): string;
+    create(data?: Partial<T>): T;
     /**
-     * Issues an arbitrary request and returns the parsed JSON body.
-     *
-     * The general-purpose entry point, used by `Collection.action()` and
-     * `Collection.raw()`. GET requests are routed through {@link _cachedGet} and so
-     * may be answered from TransferState; every other method goes straight to the
-     * network and carries the body.
+     * Turns raw API JSON into model instances attached to this collection.
      *
-     * @param collection collection the request belongs to; consulted for its
-     *   `useTransferState` flag
-     * @param method HTTP method
-     * @param url absolute URL, normally from `Collection.getUrl()`
-     * @param body JSON body; ignored for GET
-     * @param params query parameters
-     * @param headers extra headers, passed through {@link headers}
+     * Every read path funnels through here, and the attachment is the point: the
+     * resulting instances can `save()`/`update()`/`action()` themselves. Call it
+     * directly when you have JSON from somewhere other than this collection's own
+     * requests (a websocket push, an embedded payload, a fixture).
      *
-     * @return an observable of the response body
+     * @param data one JSON object, or an array of them
      */
-    action<T extends DataModel, RT>(collection: Collection<T>, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', url: string, { body, params, headers }?: IActionParams): Observable<RT>;
+    fromJson(data: Partial<T>): T;
+    fromJson(data: Partial<T>[]): T[];
     /**
-     * Issues a request whose response is taken as binary rather than JSON.
+     * Opens a filterable, sortable, paginated view over this collection.
      *
-     * Backs `Collection.blob()`; use that instead of calling this directly. Never
-     * cached through TransferState, whatever the method.
+     * The normal way to read lists: a {@link Queryset} accumulates query state and
+     * exposes results/loading/meta as observables suitable for binding straight
+     * into a template. Each call returns an independent queryset, so a component
+     * showing two filtered lists of the same endpoint creates two.
      *
-     * @param collection collection the request belongs to; not used by this method
-     * @param method HTTP method
-     * @param url absolute URL
-     * @param body JSON body
+     * @param options queryset behaviour; see {@link IQuerysetOptions}
+     */
+    queryset(options?: IQuerysetOptions): Queryset<T>;
+    /**
+     * Retrieves a single record by primary key and returns it as a model.
+     *
+     * @param id primary key
+     * @param prefix inserted between the collection path and the id, for endpoints
+     *   nested under a segment
+     * @param suffix appended after the id, e.g. `'/detail'`
      * @param params query parameters
-     * @param headers extra headers, passed through {@link headers}
+     * @param headers extra headers
      *
-     * @return an observable of the response as a `Blob`
+     * @example
+     * ```ts
+     * things.fetch(42).subscribe((thing) => ...); // GET /path/to/things/42
+     * ```
      */
-    blob<T extends DataModel>(collection: Collection<T>, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', url: string, { body, params, headers }?: IActionParams): Observable<Blob>;
+    fetch(id: number, { prefix, suffix, params, headers, }?: {
+        prefix?: string;
+        suffix?: string;
+        params?: Record<string, string>;
+        headers?: Record<string, string>;
+    }): Observable<T>;
     /**
-     * Full-replacement write (HTTP PUT). Provided for completeness — the CRUD path
-     * in `Collection` uses {@link post}/{@link patch} instead, so this is only
-     * reached by callers that need PUT semantics explicitly.
+     * Calls a custom (non-CRUD) endpoint on this collection, either on one record
+     * or on the collection as a whole, and returns the raw JSON response.
      *
-     * @param collection collection the request belongs to; not used by this method
-     * @param url absolute URL
+     * This is the DRF `@action` convention. `DataModel.action()` delegates here;
+     * call this directly for collection-level actions, which have no model.
+     *
+     * @param model record to act on, targeting `/path/to/things/<id>/<action>`, or
+     *   `null` for a collection-level action targeting `/path/to/things/<action>`
+     * @param method HTTP method
+     * @param action action name
      * @param body JSON body
      * @param params query parameters
-     * @param headers extra headers, passed through {@link headers}
+     * @param headers extra headers
      */
-    put<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<T>;
+    action<RT>(model: T | null, method: IHttpMethod, action: string, { body, params, headers }?: IActionParams): Observable<RT>;
     /**
-     * Creates a record (HTTP POST). Chosen by `Collection.save()`/`update()` when
-     * the model has no `id`.
+     * Writes a whole record: POST to the list URL when the model has no `id`,
+     * PATCH to its detail URL when it does.
      *
-     * @param collection collection the request belongs to; not used by this method
-     * @param url absolute URL, normally the collection's list URL
-     * @param body JSON body
-     * @param params query parameters
-     * @param headers extra headers, passed through {@link headers}
-     * @returns the created record's JSON, expected to include the assigned `id`
+     * Sends `model.toJson()`, i.e. every non-readonly field. Usually reached via
+     * `model.save()` rather than called directly.
+     *
+     * @param model record to persist
+     * @param updateModel feed the server's response back into `model` (defaults to
+     *   `true`), which is how a freshly created record gets its `id`. The returned
+     *   observable always emits a **separate** instance built from the response
+     *   either way.
      */
-    post<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<Partial<T>>;
+    save(model: T, { updateModel }?: {
+        updateModel?: boolean;
+    }): Observable<T>;
     /**
-     * Partially updates a record (HTTP PATCH). Chosen by
-     * `Collection.save()`/`update()` when the model already has an `id`.
+     * Writes only the named fields of a record, dispatching POST/PATCH on `id`
+     * exactly like {@link save}.
      *
-     * @param collection collection the request belongs to; not used by this method
-     * @param url absolute URL, normally the record's detail URL
-     * @param body JSON body, holding only the fields to change
-     * @param params query parameters
-     * @param headers extra headers, passed through {@link headers}
+     * Sends `model.toJson(fields)`, which restricts the payload to `fields` and
+     * does **not** filter readonly ones. Usually reached via `model.update()`.
+     *
+     * @param model record to persist
+     * @param fields field names to send; an empty list (the default) sends every
+     *   non-readonly field, making this equivalent to {@link save}
+     * @param updateModel feed the server's response back into `model` (defaults to `true`)
      */
-    patch<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<Partial<T>>;
+    update(model: T, fields?: string[], { updateModel }?: {
+        updateModel?: boolean;
+    }): Observable<T>;
     /**
-     * Deletes a record (HTTP DELETE). Backs `Collection.delete()`.
+     * Deletes a record on the server. The local instance is left untouched — it is
+     * the caller's job to drop it from whatever list holds it.
      *
-     * @param collection collection the request belongs to; not used by this method
-     * @param url absolute URL of the record
+     * @param model record to delete; its `id` builds the URL, so an unsaved model
+     *   would produce a request against the list URL
      * @param params query parameters
-     * @param headers extra headers, passed through {@link headers}
+     * @param headers extra headers
      */
-    delete<T extends DataModel, R>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<R>;
+    delete(model: T, { params, headers }?: IActionParams): Observable<unknown>;
     /**
-     * Performs a GET, transparently replaying the server-rendered response from
-     * `TransferState` when that is still allowed.
-     *
-     * This is what stops an SSR app from re-fetching, in the browser, everything it
-     * already fetched on the server to render the page. Entries are keyed on URL +
-     * params + resolved headers, so requests differing in any of those do not share
-     * a slot.
+     * Fetches a list of records in one shot, discarding pagination metadata.
      *
-     * A cached value is **read** only when all of these hold: the collection has
-     * `useTransferState`, {@link DATA_MAX_TRANSFERSTATE_TIME} is greater than zero,
-     * the key is present, and less than that many milliseconds have passed since
-     * *this backend instance was created*. That last condition makes the window a
-     * one-shot hydration budget rather than a per-entry TTL: once it lapses, nothing
-     * is served from TransferState again for the life of the backend.
+     * A shortcut for the simple cases (a dropdown's options, a small fixed set).
+     * When you need paging, sorting, loading state or the result count, use
+     * {@link queryset} instead.
      *
-     * A value is **written** only when the collection has `useTransferState`, the
-     * code is running on the server, and the window is greater than zero. So in the
-     * browser this degrades to a plain, uncached `HttpClient.get`.
+     * **The response must be paginated**: this reads `result.results` and returns
+     * that array, so a DRF endpoint with pagination disabled — which answers with a
+     * bare JSON array — yields an error rather than a list. The endpoint's page size
+     * therefore also caps what you get back here; there is currently no way to point
+     * this at a different response key (see the `FIXME` in the implementation).
      *
-     * @param collection collection the request belongs to; consulted for `useTransferState`
-     * @param url absolute URL
-     * @param params query parameters
-     * @param headers extra headers, passed through {@link headers}
+     * @param query filter parameters
+     * @param prefix inserted before the suffix in the list URL
+     * @param suffix appended to the list URL, for sub-endpoints
+     * @param params extra query parameters, merged over `query`
+     * @param headers extra headers
      */
-    _cachedGet<T extends DataModel, RT>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<RT>;
+    list(query?: FilterData, { prefix, suffix, params, headers, }?: {
+        prefix?: string;
+        suffix?: string;
+        params?: Record<string, string>;
+        headers?: Record<string, string>;
+    }): Observable<T[]>;
     /**
-     * Fetches a single record's JSON. Backs `Collection.fetch()`, and is
-     * TransferState-cacheable via {@link _cachedGet}.
+     * Calls a collection-level endpoint and returns the response body **unparsed**,
+     * without turning it into models.
      *
-     * @param collection collection the request belongs to
-     * @param url absolute URL of the record
+     * The escape hatch for responses that are not a list of records: aggregates,
+     * stats, export summaries. It is also what {@link Queryset} uses internally,
+     * since a queryset needs the pagination envelope that {@link list} throws away.
+     *
+     * @param method HTTP method; defaults to GET
+     * @param prefix inserted in the URL as `collection_url/PREFIXSUFFIX`
+     * @param suffix inserted in the URL as `collection_url/PREFIXSUFFIX`
      * @param params query parameters
+     * @param body accepted but **not currently sent** — the implementation does not
+     *   forward it to the backend, so non-GET calls needing a body must go through
+     *   {@link action}
      * @param headers extra headers
      */
-    get<T extends DataModel>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<Partial<T>>;
+    raw<RT>({ method, prefix, suffix, params, body: _body, headers, }?: {
+        method?: IHttpMethod;
+        prefix?: string;
+        suffix?: string;
+        body?: unknown;
+        params?: Record<string, string>;
+        headers?: Record<string, string>;
+    }): Observable<RT>;
     /**
-     * Fetches a list endpoint's raw JSON — including the pagination envelope, which
-     * `Collection.list()` then unwraps. Identical to {@link get} apart from the
-     * declared return type; both funnel into {@link _cachedGet}.
+     * Calls a collection-level endpoint and returns the response as a `Blob`.
      *
-     * @param collection collection the request belongs to
-     * @param url absolute URL of the list endpoint
-     * @param params query parameters, typically the queryset's filters and paging
+     * Use it for binary or file downloads (CSV/XLSX/PDF exports) where the response
+     * must not be parsed as JSON.
+     *
+     * @param method HTTP method; defaults to GET
+     * @param prefix inserted in the URL as `collection_url/PREFIXSUFFIX`
+     * @param suffix inserted in the URL as `collection_url/PREFIXSUFFIX`
+     * @param params query parameters
+     * @param body accepted but **not currently sent** — the implementation does not
+     *   forward it to the backend
      * @param headers extra headers
      */
-    list<T extends DataModel>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<any>;
+    blob<RT>({ method, prefix, suffix, params, body: _body, headers, }?: {
+        method?: IHttpMethod;
+        prefix?: string;
+        suffix?: string;
+        body?: unknown;
+        params?: Record<string, string>;
+        headers?: Record<string, string>;
+    }): Observable<Blob>;
     /**
-     * Resolves the headers actually sent with a request.
+     * Builds the absolute URL for this collection or one of its records.
      *
-     * **The designated extension point of this class.** The base implementation
-     * just copies what it is given; subclasses override it to add headers that
-     * every request needs — most often an `Authorization` token — and then get
-     * provided in place of `DataBackend`. Doing it here rather than in an HTTP
-     * interceptor keeps the headers part of the TransferState cache key, so
-     * responses fetched under different credentials do not collide.
+     * Every request the collection makes goes through here, so overriding it is the
+     * supported way to bend URL construction (versioned or nested endpoints).
      *
-     * Implementations should stay pure and synchronous: this is called once per
-     * request, and for GETs its result feeds the cache key.
+     * Layout is `apiUrl + path` for the list, `apiUrl + path + '/' + prefix + id +
+     * suffix` for a record, and `apiUrl + path + '/' + prefix + suffix` for the list
+     * with affixes. Note the separating slash is only emitted when there is
+     * something after it, so a plain list URL has no trailing slash.
      *
-     * @param headers per-request headers supplied by the caller
-     * @returns the complete header set to send
+     * @param id primary key for a detail URL; `undefined` or `null` yields the list URL
+     * @param prefix inserted just before the id (or before the suffix)
+     * @param suffix appended at the very end
      */
-    protected headers(headers: {
-        [key: string]: string;
-    }): {
-        [key: string]: string;
-    };
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataBackend, [null, null, null, null, { optional: true; }]>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DataBackend>;
+    getUrl(id?: number | null, { prefix, suffix }?: {
+        prefix?: string;
+        suffix?: string;
+    }): string;
 }
 
 /**
@@ -593,16 +631,17 @@ declare class DataBackend {
  * that filter, which is what lets a form bind a cleared control straight to a
  * queryset filter.
  */
-interface FilterData {
-    [index: string]: string | number | boolean | undefined | null;
-}
+/**
+ * A value a filter can hold: whatever goes on the wire for that field. A scalar
+ * for most filters, an array for the multi-valued ones, `null` for "cleared".
+ */
+type FilterValue = string | number | boolean | null | undefined | (string | number)[];
+type FilterData = Record<string, string | number | boolean | undefined | null>;
 /**
  * Filter criteria flattened to strings, as they go on the wire. This is what
  * {@link Queryset.getQueryParams} produces.
  */
-interface OutFilterData {
-    [index: string]: string;
-}
+type OutFilterData = Record<string, string>;
 /**
  * A single ordering term: a field name, optionally prefixed with `-` to reverse
  * it (`'name'`, `'-created'`) — the DRF `ordering` convention.
@@ -819,10 +858,10 @@ declare class Queryset<T extends DataModel> {
      * request, so a paginator must call {@link get} afterwards.
      *
      * @param page 1-based page number
-     * @param fragment currently ignored; reserved for the URL-syncing behaviour
+     * @param _fragment currently ignored; reserved for the URL-syncing behaviour
      *   that is commented out in the implementation
      */
-    setPage(page?: number, fragment?: string): Queryset<T>;
+    setPage(page?: number, _fragment?: string): Queryset<T>;
     /**
      * Stages which fields the API should return. Chainable; issues no request.
      *
@@ -875,326 +914,276 @@ declare class Queryset<T extends DataModel> {
     get(refresh?: boolean, sync?: boolean): Observable<T[]>;
 }
 
-/** HTTP verbs this library issues. */
-type IHttpMethod = 'POST' | 'GET' | 'DELETE' | 'PUT' | 'PATCH';
 /**
- * Per-request options shared by every {@link Collection} and {@link DataBackend}
- * call: body, headers and query parameters.
+ * A single selectable option for a `select` editor or a `choice` display.
  *
- * All members are optional, so `{}` is a valid "nothing special" argument.
+ * `value` is what is written to the model field; `desc` is the human-readable
+ * label rendered in the dropdown or in display mode. Choices come either from
+ * the field manager (e.g. a `charField` declared with `choices`) or from the
+ * `[choices]` input of {@link DispeditComponent}, which overrides the manager.
  */
-interface IActionParams {
-    /** JSON body; ignored by GET/DELETE requests. */
-    body?: any;
-    /** Extra headers, merged on top of whatever the backend's `headers()` adds. */
-    headers?: {
-        [index: string]: string;
-    };
-    /** Query string parameters. */
-    params?: {
-        [index: string]: string;
-    };
-    /**
-     * Expected response type. Note that the backend does not currently read this:
-     * `DataBackend.action()` always parses JSON and `DataBackend.blob()` always
-     * requests a blob. Use `Collection.blob()` to get binary data.
-     */
-    responseType?: 'json' | 'blob';
+interface IDispEditChoice {
+    /** Human-readable label shown to the user. */
+    desc: string;
+    /** Raw value written to the model field when the option is picked. */
+    value: FilterValue;
 }
 /**
- * Shape for describing per-collection cache tuning.
+ * Every editor widget {@link DispeditComponent} knows how to render.
  *
- * Currently unused by the runtime — TransferState behaviour is driven by
- * `Collection.useTransferState` plus the `DATA_MAX_TRANSFERSTATE_TIME` token.
- */
-interface ICollectionCacheParams {
-    transferState?: {
-        enabled: boolean;
-        maxTime: number;
-        maxCount: number;
-    };
-}
-/**
- * Constructor signature of a model class, letting a collection instantiate `T`
- * without knowing it — this is the `model` argument passed to
- * {@link Collection}'s constructor.
+ * A field manager advertises one of these through its `editorType` property,
+ * which is how declaring the model is enough to get the right editor. The
+ * `[editor]` input of {@link DispeditComponent} overrides that choice.
+ *
+ * - `input.text` / `input.email` / `input.password`: matching `<input>` type,
+ *   with min/max length and pattern validation feedback.
+ * - `input.number`: numeric `<input>`, value used as-is.
+ * - `input.decimal`: numeric `<input>` for a `decimalField`; the value is
+ *   divided by the manager's `factor` on load and multiplied back on save.
+ * - `input.date` / `input.datetime`: native date / datetime-local `<input>`.
+ * - `input.checkbox`: a Oui/Non button group (not an actual checkbox).
+ * - `textarea`: multi-line `<textarea>`.
+ * - `select`: `<select>` built from the resolved choices. Automatically used
+ *   whenever choices are available, whatever the manager advertises.
+ * - `quill`: rich text editor (rendered by the caller's own integration).
+ * - `fkselect`: `<data-fkselect>` typeahead, set by `ForeignKeyFieldManager`.
+ * - `m2mselect`: `<data-m2mselect>` multi-value typeahead, set by
+ *   `ManyToManyFieldManager`.
  */
-type DataModelType<T extends DataModel> = new (_coll?: Collection<T>) => T;
+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';
 /**
- * Binds a {@link DataModel} class to a REST endpoint and provides the CRUD
- * operations over it.
- *
- * A collection is the seam between models and HTTP: it knows the path, builds
- * URLs, hands raw JSON to the model for deserialization, and returns typed
- * instances that carry a back-reference to it (so `thing.save()` works). One
- * collection per endpoint, normally declared as a root-provided service.
+ * Every read-only renderer {@link DispeditComponent} knows how to produce.
  *
- * For anything involving filtering, sorting or pagination, go through
- * {@link queryset} rather than {@link list}.
+ * A field manager advertises one of these through its `displayType` property;
+ * the `[viewer]` input of {@link DispeditComponent} overrides it. Booleans and
+ * null values are short-circuited before the display type is consulted, and
+ * rendered as `OUI` / `NON` / `non défini`.
  *
- * The endpoint is assumed to follow Django REST Framework conventions:
- * `/path` for the list, `/path/<id>` for a record, `/path/<id>/<action>` for
- * custom actions, and a *paginated* list response (see {@link list}).
+ * - `text`: raw value interpolated as a string. The default.
+ * - `choice`: the `desc` of the matching {@link IDispEditChoice}. Automatically
+ *   used whenever choices are available.
+ * - `boolean`: `OUI` / `NON`.
+ * - `decimal`: the value divided by the `decimalField` manager's `factor`.
+ * - `fkdetails`: the `_display` of the `<field>_details` sibling property.
+ * - `m2mdetails`: one line per item, each rendered via its `_display`.
+ * - `datetime` / `date`: value passed through Angular's `date` pipe (`short`
+ *   and `shortDate` respectively).
+ * - `quill`: rich text, rendered as HTML by the caller's integration.
+ */
+type DISPEDIT_DISPLAY_TYPES = 'text' | 'choice' | 'boolean' | 'decimal' | 'fkdetails' | 'm2mdetails' | 'datetime' | 'date' | 'quill';
+
+/**
+ * Options common to every field decorator. All are optional; each concrete
+ * field type extends this with its own (`ICharFieldMetadata`, etc.).
  *
- * @example
- * ```ts
- * @Injectable({ providedIn: 'root' })
- * export class ThingService extends Collection<Thing> {
- *   constructor() {
- *     super(inject(DataBackend), '/path/to/things', Thing);
- *   }
- * }
+ * Whatever you pass to a decorator is copied verbatim onto the field's manager
+ * instance, so these names double as the manager's public properties.
  *
- * // then
- * things.fetch(1).subscribe((thing) => ...);
- * things.queryset().filter({ status: 'active' }).get().subscribe((list) => ...);
- * ```
+ * @typeParam FT the JavaScript type the field holds on the model
  */
-declare class Collection<T extends DataModel> {
-    protected backend: DataBackend;
-    protected path: string;
-    model: DataModelType<T>;
+interface IFieldMetadata<FT> {
     /**
-     * Whether GET responses for this collection may be served from / stored in
-     * Angular's `TransferState` during SSR hydration.
-     *
-     * On by default, but only ever takes effect when `DATA_MAX_TRANSFERSTATE_TIME`
-     * is provided and greater than zero. Set it to `false` on collections whose
-     * data is user-specific or must not be embedded in the server-rendered HTML.
+     * Wire name of the field: the key used in the JSON payload. Defaults to the
+     * decorated property name, so it only needs setting when the API name and
+     * the TypeScript property name differ.
      */
-    useTransferState: boolean;
+    name?: string;
+    /** Short hint shown next to the editor. Defaults to an empty string. */
+    help?: string;
     /**
-     * @param backend HTTP layer; supplies the API base URL and applies auth headers
-     * @param path endpoint path appended to the backend's `apiUrl`, leading slash
-     *   included and trailing slash omitted (e.g. `'/path/to/things'`)
-     * @param model model class this collection instantiates
+     * Human-readable label used for column titles, form labels and hover
+     * details. Defaults to {@link IFieldMetadata.name} when omitted.
      */
-    constructor(backend: DataBackend, path: string, model: DataModelType<T>);
+    description?: string;
     /**
-     * Builds a new, unsaved model instance attached to this collection.
-     *
-     * Use it to back a creation form: the returned instance has no `id`, so the
-     * first `save()` POSTs it. Values passed in `data` go through the field
-     * managers' deserializers, exactly as if they had come from the API.
-     *
-     * @param data initial field values; omit for an empty instance
+     * Marks the field as mandatory: adds `Validators.required` and forces a
+     * value to be present on save.
      *
-     * @example
-     * ```ts
-     * const thing = things.create({ name: 'draft' });
-     * thing.save().subscribe(); // POST /path/to/things
-     * ```
+     * Beware: combining `required: true` with no `defaultValue` throws at class
+     * definition time — see {@link BaseFieldManager.getDefaultValue}.
      */
-    create(data?: Partial<T>): T;
+    required?: boolean;
     /**
-     * Turns raw API JSON into model instances attached to this collection.
-     *
-     * Every read path funnels through here, and the attachment is the point: the
-     * resulting instances can `save()`/`update()`/`action()` themselves. Call it
-     * directly when you have JSON from somewhere other than this collection's own
-     * requests (a websocket push, an embedded payload, a fixture).
-     *
-     * @param data one JSON object, or an array of them
+     * Field is display-only: it is excluded from generated form groups and never
+     * pushed back to the API. Typical for server-maintained columns and for the
+     * `*_details` half of a relation.
      */
-    fromJson(data: Partial<T>): T;
-    fromJson(data: Partial<T>[]): T[];
+    readonly?: boolean;
     /**
-     * Opens a filterable, sortable, paginated view over this collection.
-     *
-     * The normal way to read lists: a {@link Queryset} accumulates query state and
-     * exposes results/loading/meta as observables suitable for binding straight
-     * into a template. Each call returns an independent queryset, so a component
-     * showing two filtered lists of the same endpoint creates two.
+     * Value used when the model has no value for this field — either a constant
+     * or a factory `(args) => FT` evaluated on each call, which is how you get a
+     * fresh array/date per instance instead of a shared one.
+     */
+    defaultValue?: FT | ((args: FieldDefaultArgs) => FT) | null;
+    /**
+     * Display ordering weight: **higher is shown first**. `id` uses `1000`.
      *
-     * @param options queryset behaviour; see {@link IQuerysetOptions}
+     * `priority: -1` is the established idiom for "deserialise this field but
+     * never offer it in the UI" — negative-priority fields are dropped from the
+     * default column set. It is used for the id half of every relation, whose
+     * `*_details` twin is what a human is meant to see.
      */
-    queryset(options?: IQuerysetOptions): Queryset<T>;
+    priority?: number;
+}
+/**
+ * Runtime behaviour of a single field: one manager instance is built per
+ * decorated property, at class definition time, and cached in the prototype's
+ * metadata map. Everything the library does with a field — serialise it,
+ * validate it, build its form control, pick its widget — goes through here.
+ *
+ * Subclass it only to add a genuinely new field type; the shipped managers
+ * (`CharFieldManager`, `ForeignKeyFieldManager`, ...) cover the usual cases.
+ * Override `fromJson`/`toJson` to change the wire mapping and
+ * `getValidators()` to add constraints.
+ */
+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;
+    /** Human-readable label; falls back to {@link name} when not given. */
+    description: string;
+    /** Input hint; normalised to `''` when not given. */
+    help: string;
+    /** Whether a value must be present. Adds `Validators.required`. */
+    required: boolean;
+    /** Whether the field is excluded from forms and never written back. */
+    readonly: boolean;
     /**
-     * Retrieves a single record by primary key and returns it as a model.
+     * Set to `true` only by `ComputedFieldManager`. `DataModel.setFV` skips
+     * assignment entirely for computed fields, making them permanently
+     * read-only in the eyes of the model.
+     */
+    computed: boolean;
+    /** Display ordering weight; higher is shown first. See {@link IFieldMetadata.priority}. */
+    priority: number;
+    /** Constant or factory used when the model has no value. */
+    defaultValue?: FT | ((args: FieldDefaultArgs) => FT);
+    /**
+     * Which editor widget `dispedit` renders for this field in edit mode.
      *
-     * @param id primary key
-     * @param prefix inserted between the collection path and the id, for endpoints
-     *   nested under a segment
-     * @param suffix appended after the id, e.g. `'/detail'`
-     * @param params query parameters
-     * @param headers extra headers
+     * This is the library's central idea: **declaring the model configures the
+     * UI**. Managers set this themselves from what you declared — `charField`
+     * flips to `'select'` as soon as `choices` is present, `foreignKeyField`
+     * uses `'fkselect'`, `manyToManyField` `'m2mselect'` — so a correct model
+     * yields the right editor with no per-template wiring.
+     */
+    editorType: DISPEDIT_EDITOR_TYPES;
+    /**
+     * Which read-only renderer `dispedit` uses for this field. Chosen by the
+     * manager the same way as {@link editorType} (`'fkdetails'` for a foreign
+     * key, `'m2mdetails'` for a m2m, `'decimal'` for `decimalField`, ...).
+     */
+    displayType: DISPEDIT_DISPLAY_TYPES;
+    /**
+     * Copies `params` onto the instance, fills in `name`/`description`/`help`
+     * defaults, then eagerly resolves the default value — which means a
+     * `required` field with no `defaultValue` throws here, at decoration time.
      *
-     * @example
-     * ```ts
-     * things.fetch(42).subscribe((thing) => ...); // GET /path/to/things/42
-     * ```
+     * @param params metadata as passed to the decorator
+     */
+    constructor(params: IFieldMetadata<FT>);
+    /**
+     * Angular validators for this field, rebuilt on each access. Subclasses
+     * override this getter (not {@link getValidators}) to append their own —
+     * `CharFieldManager` adds length/pattern, `IntegerFieldManager` min/max.
      */
-    fetch(id: number, { prefix, suffix, params, headers, }?: {
-        prefix?: string;
-        suffix?: string;
-        params?: {
-            [_index: string]: string;
-        };
-        headers?: {
-            [_index: string]: string;
-        };
-    }): Observable<T>;
+    get validators(): ValidatorFn[];
     /**
-     * Calls a custom (non-CRUD) endpoint on this collection, either on one record
-     * or on the collection as a whole, and returns the raw JSON response.
-     *
-     * This is the DRF `@action` convention. `DataModel.action()` delegates here;
-     * call this directly for collection-level actions, which have no model.
-     *
-     * @param model record to act on, targeting `/path/to/things/<id>/<action>`, or
-     *   `null` for a collection-level action targeting `/path/to/things/<action>`
-     * @param method HTTP method
-     * @param action action name
-     * @param body JSON body
-     * @param params query parameters
-     * @param headers extra headers
+     * The bare property name, stripped of any `Model__` prefix: splits
+     * {@link name} on `'__'` and returns the second segment, or the whole name
+     * when there is no separator.
      */
-    action<RT>(model: T | null, method: IHttpMethod, action: string, { body, params, headers }?: IActionParams): Observable<RT>;
+    get fname(): string;
     /**
-     * Writes a whole record: POST to the list URL when the model has no `id`,
-     * PATCH to its detail URL when it does.
+     * Builds a typed `FormControl` for this field on a given model instance,
+     * seeded with the instance's current value and falling back to the default
+     * value, and wired with {@link validators}.
      *
-     * Sends `model.toJson()`, i.e. every non-readonly field. Usually reached via
-     * `model.save()` rather than called directly.
+     * Note the seed uses `||`, so falsy current values (`0`, `''`, `false`) fall
+     * back to the default rather than being kept.
      *
-     * @param model record to persist
-     * @param updateModel feed the server's response back into `model` (defaults to
-     *   `true`), which is how a freshly created record gets its `id`. The returned
-     *   observable always emits a **separate** instance built from the response
-     *   either way.
+     * @param instance model whose value seeds the control
      */
-    save(model: T, { updateModel }?: {
-        updateModel?: boolean;
-    }): Observable<T>;
+    formControl(instance: DataModel): FormControl<FT | null>;
     /**
-     * Writes only the named fields of a record, dispatching POST/PATCH on `id`
-     * exactly like {@link save}.
-     *
-     * Sends `model.toJson(fields)`, which restricts the payload to `fields` and
-     * does **not** filter readonly ones. Usually reached via `model.update()`.
+     * Converts a raw JSON value coming from the API into the model value.
+     * The base implementation passes the data straight through; typed managers
+     * override it to coerce (`boolean`), parse (`date`) or instantiate
+     * (`details`).
      *
-     * @param model record to persist
-     * @param fields field names to send; an empty list (the default) sends every
-     *   non-readonly field, making this equivalent to {@link save}
-     * @param updateModel feed the server's response back into `model` (defaults to `true`)
+     * @param data raw value read from the JSON payload
      */
-    update(model: T, fields?: string[], { updateModel }?: {
-        updateModel?: boolean;
-    }): Observable<T>;
+    fromJson(data: unknown): FT;
     /**
-     * Deletes a record on the server. The local instance is left untouched — it is
-     * the caller's job to drop it from whatever list holds it.
+     * Converts the model value back into its JSON representation for save.
+     * The base implementation passes the data straight through.
      *
-     * @param model record to delete; its `id` builds the URL, so an unsaved model
-     *   would produce a request against the list URL
-     * @param params query parameters
-     * @param headers extra headers
+     * @param data current model value
      */
-    delete(model: T, { params, headers }?: IActionParams): Observable<any>;
+    toJson(data: FT): unknown;
     /**
-     * Fetches a list of records in one shot, discarding pagination metadata.
-     *
-     * A shortcut for the simple cases (a dropdown's options, a small fixed set).
-     * When you need paging, sorting, loading state or the result count, use
-     * {@link queryset} instead.
-     *
-     * **The response must be paginated**: this reads `result.results` and returns
-     * that array, so a DRF endpoint with pagination disabled — which answers with a
-     * bare JSON array — yields an error rather than a list. The endpoint's page size
-     * therefore also caps what you get back here; there is currently no way to point
-     * this at a different response key (see the `FIXME` in the implementation).
+     * Renders the value for display. The base implementation is plain string
+     * interpolation.
      *
-     * @param query filter parameters
-     * @param prefix inserted before the suffix in the list URL
-     * @param suffix appended to the list URL, for sub-endpoints
-     * @param params extra query parameters, merged over `query`
-     * @param headers extra headers
+     * @param data value to render
+     * @param _format reserved; ignored by the base implementation
      */
-    list(query?: FilterData, { prefix, suffix, params, headers, }?: {
-        prefix?: string;
-        suffix?: string;
-        params?: {
-            [_index: string]: string;
-        };
-        headers?: {
-            [_index: string]: string;
-        };
-    }): Observable<T[]>;
+    toString(data: FT, _format?: string): string;
     /**
-     * Calls a collection-level endpoint and returns the response body **unparsed**,
-     * without turning it into models.
-     *
-     * The escape hatch for responses that are not a list of records: aggregates,
-     * stats, export summaries. It is also what {@link Queryset} uses internally,
-     * since a queryset needs the pagination envelope that {@link list} throws away.
+     * Public accessor for this field's default value, invoking the
+     * `defaultValue` factory with `args` when one was declared.
      *
-     * @param method HTTP method; defaults to GET
-     * @param prefix inserted in the URL as `collection_url/PREFIXSUFFIX`
-     * @param suffix inserted in the URL as `collection_url/PREFIXSUFFIX`
-     * @param params query parameters
-     * @param body accepted but **not currently sent** — the implementation does not
-     *   forward it to the backend, so non-GET calls needing a body must go through
-     *   {@link action}
-     * @param headers extra headers
+     * @param args passed through to a `defaultValue` function
      */
-    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>;
+    default(args?: FieldDefaultArgs): FT | undefined;
     /**
-     * Calls a collection-level endpoint and returns the response as a `Blob`.
-     *
-     * Use it for binary or file downloads (CSV/XLSX/PDF exports) where the response
-     * must not be parsed as JSON.
+     * Builds the base validator list: `Validators.required` when the field is
+     * required, nothing otherwise. Subclasses call it and push their own.
      *
-     * @param method HTTP method; defaults to GET
-     * @param prefix inserted in the URL as `collection_url/PREFIXSUFFIX`
-     * @param suffix inserted in the URL as `collection_url/PREFIXSUFFIX`
-     * @param params query parameters
-     * @param body accepted but **not currently sent** — the implementation does not
-     *   forward it to the backend
-     * @param headers extra headers
+     * @protected
      */
-    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>;
+    protected getValidators(): ValidatorFn[];
     /**
-     * Builds the absolute URL for this collection or one of its records.
-     *
-     * Every request the collection makes goes through here, so overriding it is the
-     * supported way to bend URL construction (versioned or nested endpoints).
+     * Resolves the default value: calls `defaultValue` when it is a function,
+     * otherwise returns it as-is.
      *
-     * Layout is `apiUrl + path` for the list, `apiUrl + path + '/' + prefix + id +
-     * suffix` for a record, and `apiUrl + path + '/' + prefix + suffix` for the list
-     * with affixes. Note the separating slash is only emitted when there is
-     * something after it, so a plain list URL has no trailing slash.
+     * **Throws** when the field is `required` and no `defaultValue` was given.
+     * Because the constructor calls this, the error surfaces when the class is
+     * defined (module evaluation), not when a model is instantiated — a
+     * `required` field without a default breaks the app at import time.
      *
-     * @param id primary key for a detail URL; `undefined` or `null` yields the list URL
-     * @param prefix inserted just before the id (or before the suffix)
-     * @param suffix appended at the very end
+     * @param args passed through to a `defaultValue` function
+     * @throws Error if `required` is set and `defaultValue` is `undefined`
+     * @protected
      */
-    getUrl(id?: number | null, { prefix, suffix }?: {
-        prefix?: string;
-        suffix?: string;
-    }): string;
+    protected getDefaultValue(args?: FieldDefaultArgs): FT | undefined;
+}
+/**
+ * What is actually kept in a model's metadata map: the options you passed to
+ * the decorator, plus the four entries the decorator computes. This is the
+ * shape returned by {@link getFieldsMetadata}.
+ */
+interface IFieldStoredMetadata<FT> extends IFieldMetadata<FT> {
+    /** Map key of this entry: `` `${__name}__${propertyKey}` ``. */
+    self: string;
+    /** Wire name; defaulted to the decorated property name. */
+    name: string;
+    /** Field type code, e.g. `'charField'`, `'foreignKeyField'`. */
+    type: string;
+    /** The live manager instance built for this field. */
+    manager: BaseFieldManager<FT>;
 }
+/**
+ * Arguments handed to a `defaultValue` factory. Free-form: callers pass
+ * whatever the factory needs, and the factory knows what to expect.
+ */
+type FieldDefaultArgs = Record<string, unknown>;
+/**
+ * Shape of every field decorator returned by {@link genericDataField}: a plain
+ * property decorator, applied for its side effect on the prototype's metadata
+ * map.
+ */
+type FieldDecoratorFn = (target: object, propertyKey: string | symbol) => void;
 
 /**
  * Resolved field metadata of a model instance, keyed by field name.
@@ -1204,7 +1193,7 @@ declare class Collection<T extends DataModel> {
  * filters, `dispedit`) read this map to render themselves without knowing the
  * concrete model.
  */
-type DataModelFields = Readonly<Map<string, IFieldStoredMetadata<any>>>;
+type DataModelFields = Readonly<Map<string, IFieldStoredMetadata<unknown>>>;
 /**
  * Base class for every model in the library: a plain class whose fields are
  * declared with field decorators, which turns it into something the rest of the
@@ -1335,9 +1324,7 @@ declare class DataModel {
      *   offending field names to their `ValidationErrors`. Note that valid fields
      *   are still applied even when others fail — this reports, it does not roll back.
      */
-    fromJson(data: {
-        [index: string]: any;
-    }, { partial, check }?: {
+    fromJson(data: object, { partial, check }?: {
         partial?: boolean;
         check?: boolean;
     }): null | ValidationErrors;
@@ -1378,21 +1365,13 @@ declare class DataModel {
      * @returns an observable of the **raw response body**, not of this model, even
      *   when `update` is `true`
      */
-    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;
-        };
+    action<T, RT extends object>(method: 'POST' | 'PATCH' | 'GET' | 'DELETE' | 'PUT', name: string, { body, update, updatePartial, updateCheck, params, headers, }?: {
+        body?: object;
         update?: boolean;
         updatePartial?: boolean;
         updateCheck?: boolean;
-        params?: {
-            [_index: string]: string;
-        };
-        headers?: {
-            [_index: string]: string;
-        };
+        params?: Record<string, string>;
+        headers?: Record<string, string>;
     }): Observable<RT>;
     /**
      * Returns a field's manager — the object holding its metadata and its
@@ -1503,6 +1482,36 @@ declare class DataModel {
     }): Observable<this>;
 }
 
+/**
+ * A model seen as the untyped property bag it also is.
+ *
+ * Fields are declared by decorators and reached by name at runtime — `dispedit`
+ * reads `<field>_details`, filters read `filter.field` — so the data layer
+ * constantly indexes models with a string the compiler cannot resolve. This is
+ * the one sanctioned way to do it: it yields `unknown`, so the value has to be
+ * narrowed where it is used instead of silently becoming `any` and disabling
+ * type-checking for the rest of the expression.
+ *
+ * ```ts
+ * const details = fieldValues(model)[`${field}_details`] as R[] | undefined;
+ * fieldValues(model)[field] = event.id;
+ * ```
+ *
+ * @param target model (or any object) to index by field name
+ */
+declare function fieldValues(target: object): Record<string, unknown>;
+/**
+ * Renders an unknown value as display text.
+ *
+ * `String(value)` is not enough here: values read through {@link fieldValues}
+ * can be objects, and `String({})` yields `[object Object]`. Nullish becomes an
+ * empty string, objects are JSON-encoded, everything else goes through
+ * `String`.
+ *
+ * @param value value read off a model, a form or a payload
+ */
+declare function asText(value: unknown): string;
+
 /**
  * One column of a list: a model field (or a {@link CustomField}) together with
  * its display state.
@@ -1517,7 +1526,7 @@ interface ModelListField {
     /** The user may enable it from the field selector. */
     allowed: boolean;
     /** The field's current value/manager, `null` for custom columns. */
-    field: any;
+    field: unknown;
     /** Sort key for display order, renumbered in steps of 10 on every change. */
     position: number;
     /** Ordering weight from the field metadata, higher first; `-1` means "never shown by default". */
@@ -1620,7 +1629,7 @@ declare class ModelListFields<T extends DataModel> {
      * @param position new sort key
      * @returns current enabled fields
      */
-    setPosition(fname: any, position: number): string[];
+    setPosition(fname: string, position: number): string[];
     private _update;
 }
 
@@ -1857,19 +1866,19 @@ interface ModelListFilterParams {
      * Not read by the constructor. {@link ModelListFilter} initialises its value
      * from {@link default} instead; see the `FIXME` in the constructor body.
      */
-    value?: any;
+    value?: FilterValue;
     /**
      * Free-form description used as the `title` (native tooltip) of this filter's
      * entry in the `data-model-list-filters-select` picker. It has no effect on
      * the query.
      */
-    desc?: any;
+    desc?: string;
     /**
      * Initial value applied at construction time. Only some subclasses act on it
      * (text, select and select-multi); the others ignore it. Its expected shape
      * depends on the subclass.
      */
-    default?: any;
+    default?: unknown;
     /**
      * CSS classes applied to the filter's container element, overriding the
      * `classes` input passed by the host component. Use it to give one filter a
@@ -1928,9 +1937,9 @@ declare class ModelListFilter implements ModelListFilterParams {
     /** Help/placeholder text. Defaults to a French string set by each subclass. */
     help: string;
     /** Tooltip text for the filter picker entry; does not affect the query. */
-    desc?: any;
+    desc?: string;
     /** Initial value, applied at construction by the subclasses that support it. */
-    default?: any;
+    default?: unknown;
     /** Discriminator telling {@link ModelListFiltersComponent} which widget to render. */
     type: FILTER_TYPE;
     /**
@@ -2029,7 +2038,7 @@ declare class ModelListFilter implements ModelListFilterParams {
      * @returns `true` when the value actually changed, `false` when it was
      *   already set. Callers use this to avoid re-querying the list needlessly.
      */
-    set(value: any, desc: string, notify?: boolean): boolean;
+    set(value: FilterValue, desc: string, notify?: boolean): boolean;
     /**
      * Removes `value` from the filter. On a multi-valued filter only that value
      * is dropped, which is what the chips' delete buttons call; on a
@@ -2040,7 +2049,7 @@ declare class ModelListFilter implements ModelListFilterParams {
      * @param notify Whether to emit on the value stream.
      * @returns `true` when something was actually removed.
      */
-    unset(value: any, desc: string, notify?: boolean): boolean;
+    unset(value: FilterValue, desc: string, notify?: boolean): boolean;
     /**
      * Adds `value` if absent, removes it if present. Convenient for checkbox-like
      * widgets where the same gesture selects and deselects.
@@ -2050,7 +2059,7 @@ declare class ModelListFilter implements ModelListFilterParams {
      * @param notify Whether to emit on the value stream.
      * @returns Always `true`.
      */
-    toggle(value: any, desc: string, notify?: boolean): boolean;
+    toggle(value: FilterValue, desc: string, notify?: boolean): boolean;
     /**
      * The current single value, stringified, as sent to the server. Only
      * meaningful for single-valued filters.
@@ -2205,9 +2214,7 @@ interface CustomField {
  * This is scoping/context (the current tenant, the parent object of a nested
  * list), not user-facing filtering — see {@link ModelListParams.filter}.
  */
-interface FilterDefaults {
-    [index: string]: string | number | undefined;
-}
+type FilterDefaults = Record<string, string | number | undefined>;
 /**
  * Initial sort keys, as `field` / `+field` (ascending) or `-field` (descending).
  */
@@ -2512,7 +2519,7 @@ declare class ModelListFieldsSelectorComponent<T extends DataModel> implements O
     /** Open the field selector panel. */
     open(): void;
     /** Reorder the dropped column, placing it between its new neighbours. */
-    drop($event: CdkDragDrop<T, any>): void;
+    drop($event: CdkDragDrop<T, T>): void;
     /** Show or hide column `f`, depending on its current state. */
     toggle(f: ModelListField): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModelListFieldsSelectorComponent<any>, never>;
@@ -2550,11 +2557,11 @@ declare class ModelListFieldHeaderComponent<T extends DataModel> implements OnIn
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModelListFieldHeaderComponent<any>, "data-model-list-field-header", never, { "list": { "alias": "list"; "required": true; "isSignal": true; }; "field": { "alias": "field"; "required": true; "isSignal": true; }; "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "sortField": { "alias": "sortField"; "required": false; "isSignal": true; }; "menuMode": { "alias": "menuMode"; "required": false; "isSignal": true; }; "sortMode": { "alias": "sortMode"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; }, { "display": "displayChange"; }, never, ["*"], true, never>;
 }
 
-declare class ModelListSorterComponent {
+declare class ModelListSorterComponent<T extends DataModel = DataModel> {
     /**
      * ModelList reference.
      */
-    list: _angular_core.InputSignal<ModelList<any>>;
+    list: _angular_core.InputSignal<ModelList<T>>;
     /**
      * Sort field name.
      */
@@ -2578,13 +2585,13 @@ declare class ModelListSorterComponent {
     cancel(): void;
     private getIsDown;
     private getIsUp;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModelListSorterComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModelListSorterComponent, "data-model-list-sorter", never, { "list": { "alias": "list"; "required": true; "isSignal": true; }; "field": { "alias": "field"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModelListSorterComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModelListSorterComponent<any>, "data-model-list-sorter", never, { "list": { "alias": "list"; "required": true; "isSignal": true; }; "field": { "alias": "field"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 
-declare class ModelListFiltersSelectComponent implements OnInit {
+declare class ModelListFiltersSelectComponent<T extends DataModel = DataModel> implements OnInit {
     /** The list whose filters can be toggled. Required. */
-    list: _angular_core.InputSignal<ModelList<any>>;
+    list: _angular_core.InputSignal<ModelList<T>>;
     /** CSS classes for the element wrapping the picker. */
     containerClasses: _angular_core.InputSignal<string | string[]>;
     /** CSS classes for an enabled filter's badge, in the badge modes. */
@@ -2611,8 +2618,8 @@ declare class ModelListFiltersSelectComponent implements OnInit {
      * it and resets the control, leaving the dropdown ready for the next pick.
      */
     ngOnInit(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModelListFiltersSelectComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModelListFiltersSelectComponent, "data-model-list-filters-select", never, { "list": { "alias": "list"; "required": true; "isSignal": true; }; "containerClasses": { "alias": "containerClasses"; "required": false; "isSignal": true; }; "itemActiveClasses": { "alias": "itemActiveClasses"; "required": false; "isSignal": true; }; "itemInactiveClasses": { "alias": "itemInactiveClasses"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModelListFiltersSelectComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModelListFiltersSelectComponent<any>, "data-model-list-filters-select", never, { "list": { "alias": "list"; "required": true; "isSignal": true; }; "containerClasses": { "alias": "containerClasses"; "required": false; "isSignal": true; }; "itemActiveClasses": { "alias": "itemActiveClasses"; "required": false; "isSignal": true; }; "itemInactiveClasses": { "alias": "itemInactiveClasses"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -2629,9 +2636,9 @@ declare class ModelListFiltersSelectComponent implements OnInit {
  * <data-model-list-filters [list]="list" itemClasses="col-4" />
  * ```
  */
-declare class ModelListFiltersComponent {
+declare class ModelListFiltersComponent<T extends DataModel = DataModel> {
     /** The list whose filters are displayed. Required. */
-    list: _angular_core.InputSignal<ModelList<any>>;
+    list: _angular_core.InputSignal<ModelList<T>>;
     /** CSS classes for the element wrapping all the filter widgets. */
     containerClasses: _angular_core.InputSignal<string | string[]>;
     /**
@@ -2639,8 +2646,8 @@ declare class ModelListFiltersComponent {
      * declaring `displayClasses` overrides this for itself.
      */
     itemClasses: _angular_core.InputSignal<string | string[]>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModelListFiltersComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModelListFiltersComponent, "data-model-list-filters", never, { "list": { "alias": "list"; "required": true; "isSignal": true; }; "containerClasses": { "alias": "containerClasses"; "required": false; "isSignal": true; }; "itemClasses": { "alias": "itemClasses"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModelListFiltersComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModelListFiltersComponent<any>, "data-model-list-filters", never, { "list": { "alias": "list"; "required": true; "isSignal": true; }; "containerClasses": { "alias": "containerClasses"; "required": false; "isSignal": true; }; "itemClasses": { "alias": "itemClasses"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -2679,22 +2686,27 @@ declare class FkselectComponent<T extends DataModel, R extends DataModel> implem
     search: _angular_core.InputSignal<string>;
     /** Label shown next to the control. */
     label: _angular_core.InputSignal<string>;
+    /**
+     * Id put on the search input, and pointed at by `[label]`'s `for`. Defaults
+     * to a generated one; dispedit passes its own so its label drives this input.
+     */
+    inputId: _angular_core.InputSignal<string>;
     /** Placeholder for the search input. */
     placeholder: _angular_core.InputSignal<string>;
     /** CSS classes applied to the search input. */
     inputClasses: _angular_core.InputSignal<string | string[]>;
     /** Emits the instance the user picked from the dropdown. */
-    selected: _angular_core.OutputEmitterRef<T>;
+    selected: _angular_core.OutputEmitterRef<R>;
     /** Emits when the user aborts editing (escape). */
     cancelled: _angular_core.OutputEmitterRef<void>;
     /** Emits when the user clears the selection, via {@link clearAction}. */
     cleared: _angular_core.OutputEmitterRef<void>;
     /** Form control backing the typeahead search input. */
-    fc: UntypedFormControl;
+    fc: FormControl<R | null>;
     /** Search callback handed to ng-bootstrap's typeahead. */
-    searchFn: (text$: Observable<string>) => Observable<any>;
+    searchFn: (text$: Observable<string>) => Observable<R[]>;
     /** Option formatter handed to ng-bootstrap's typeahead. */
-    displayFn: (x: any) => any;
+    displayFn: (x: R | null | undefined) => string;
     private _tpl;
     private destroy$;
     /**
@@ -2718,7 +2730,7 @@ declare class FkselectComponent<T extends DataModel, R extends DataModel> implem
      */
     private _search;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FkselectComponent<any, any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FkselectComponent<any, any>, "data-fkselect", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "field": { "alias": "field"; "required": false; "isSignal": true; }; "edit": { "alias": "edit"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "queryset": { "alias": "queryset"; "required": false; "isSignal": true; }; "collection": { "alias": "collection"; "required": false; "isSignal": true; }; "update": { "alias": "update"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "inputClasses": { "alias": "inputClasses"; "required": false; "isSignal": true; }; }, { "queryset": "querysetChange"; "collection": "collectionChange"; "selected": "selected"; "cancelled": "cancelled"; "cleared": "cleared"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FkselectComponent<any, any>, "data-fkselect", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "field": { "alias": "field"; "required": false; "isSignal": true; }; "edit": { "alias": "edit"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "queryset": { "alias": "queryset"; "required": false; "isSignal": true; }; "collection": { "alias": "collection"; "required": false; "isSignal": true; }; "update": { "alias": "update"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "inputClasses": { "alias": "inputClasses"; "required": false; "isSignal": true; }; }, { "queryset": "querysetChange"; "collection": "collectionChange"; "selected": "selected"; "cancelled": "cancelled"; "cleared": "cleared"; }, never, never, true, never>;
 }
 
 interface ModelListAutocompleteParams<T extends DataModel> extends ModelListFilterParams {
@@ -3263,6 +3275,8 @@ declare class ModelListSelectMultiFilter<T extends DataModel> extends ModelListS
      * choice. The parent constructor has already resolved the choices and
      * enforced the `choices`-or-`model` requirement.
      */
+    /** The options selected from the start, as full choice objects. */
+    default?: IDispEditChoice[];
     constructor(params: ModelListMultiSelectFilterParams<T>);
 }
 
@@ -3516,7 +3530,7 @@ declare class PChoicePipe<T extends DataModel> implements PipeTransform {
      * @param mode `desc` for the label alone, `code` for the raw value alone,
      *   `both` for `[code] label`.
      */
-    transform(value: any, model: T, field: string, mode?: 'code' | 'desc' | 'both'): string;
+    transform(value: unknown, model: T, field: string, mode?: 'code' | 'desc' | 'both'): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PChoicePipe<any>, never>;
     static ɵpipe: _angular_core.ɵɵPipeDeclaration<PChoicePipe<any>, "pchoice", true>;
 }
@@ -3615,7 +3629,7 @@ declare class FactorcPipe<T extends DataModel> implements PipeTransform {
      * @param digitsInfo digit format, as accepted by Angular's `currency` pipe.
      * @param locale locale to format in; defaults to the ambient `LOCALE_ID`.
      */
-    transform(value: T | null, field: string, currencyCode?: string, display?: 'code' | 'symbol' | 'symbol-narrow' | string, digitsInfo?: string, locale?: string): string | null;
+    transform(value: T | null, field: string, currencyCode?: string, display?: 'code' | 'symbol' | 'symbol-narrow' | (string & {}), digitsInfo?: string, locale?: string): string | null;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FactorcPipe<any>, never>;
     static ɵpipe: _angular_core.ɵɵPipeDeclaration<FactorcPipe<any>, "factorc", true>;
 }
@@ -3644,7 +3658,7 @@ declare class PFactorcPipe<T extends DataModel> implements PipeTransform {
      * @param digitsInfo digit format, as accepted by Angular's `currency` pipe.
      * @param locale locale to format in; defaults to the ambient `LOCALE_ID`.
      */
-    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;
+    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: _angular_core.ɵɵFactoryDeclaration<PFactorcPipe<any>, never>;
     static ɵpipe: _angular_core.ɵɵPipeDeclaration<PFactorcPipe<any>, "pfactorc", true>;
 }
@@ -3662,6 +3676,8 @@ declare class DispeditComponent<FT, T extends DataModel, R extends DataModel> {
      * the model, and nothing checks it at compile time.
      */
     field: _angular_core.InputSignal<string>;
+    /** Id tying the label to whichever control the editor renders. */
+    readonly inputId: string;
     /**
      * External form group, for `inline` / `form` modes.
      *
@@ -3731,7 +3747,7 @@ declare class DispeditComponent<FT, T extends DataModel, R extends DataModel> {
      *
      * The reset control only appears in edit mode when this is not undefined.
      */
-    default: _angular_core.InputSignal<any>;
+    default: _angular_core.InputSignal<unknown>;
     /** Input placeholder. Falls back to the field manager's `description`. */
     placeholder: _angular_core.InputSignal<string>;
     /** Help text shown under the editor. Falls back to the manager's `help`. */
@@ -3783,7 +3799,7 @@ declare class DispeditComponent<FT, T extends DataModel, R extends DataModel> {
     /** Display renderer actually in use, after manager lookup and overrides. */
     realDisplay: _angular_core.WritableSignal<DISPEDIT_DISPLAY_TYPES>;
     /** Raw field value backing the current display, before formatting. */
-    dispValue: _angular_core.WritableSignal<any>;
+    dispValue: _angular_core.WritableSignal<unknown>;
     /** Choices actually in use, or undefined when the field has none. */
     realChoices: _angular_core.WritableSignal<IDispEditChoice[] | undefined>;
     /** Help text actually shown, after the manager fallback. */
@@ -3793,9 +3809,9 @@ declare class DispeditComponent<FT, T extends DataModel, R extends DataModel> {
     /** Whether the manager declares the field required. */
     required: _angular_core.WritableSignal<boolean>;
     /** Default value actually applied by {@link setDefault}. */
-    realDefault: _angular_core.WritableSignal<any>;
+    realDefault: _angular_core.WritableSignal<unknown>;
     /** Latest M2M instances reported by the child select, used for display. */
-    m2mValues?: any[];
+    m2mValues?: DataModel[];
     /** Form group driving the editor: the external `[form]`, or a local one. */
     fg: _angular_core.WritableSignal<UntypedFormGroup | undefined>;
     /** Resolved display function for FK / M2M options, built from `display`. */
@@ -3880,7 +3896,7 @@ declare class DispeditComponent<FT, T extends DataModel, R extends DataModel> {
      *
      * @param $event selected instance, or null when the selection was cleared.
      */
-    selectedRefItem($event: T | null): Promise<void>;
+    selectedRefItem($event: R | null): Promise<void>;
     /**
      * Cache the M2M instances reported by the child select.
      *
@@ -3889,7 +3905,7 @@ declare class DispeditComponent<FT, T extends DataModel, R extends DataModel> {
      *
      * @param v current list of selected instances.
      */
-    onM2MValuesChanges(v: any[]): void;
+    onM2MValuesChanges(v: DataModel[]): void;
     /** Apply cross-input consistency rules (a quill editor implies a quill viewer). */
     private _checks;
     /**
@@ -3945,6 +3961,11 @@ declare class M2mselectComponent<T extends DataModel, R extends DataModel> imple
     search: _angular_core.InputSignal<string>;
     /** Label shown next to the control. */
     label: _angular_core.InputSignal<string>;
+    /**
+     * Id put on the search input, and pointed at by `[label]`'s `for`. Defaults
+     * to a generated one; dispedit passes its own so its label drives this input.
+     */
+    inputId: _angular_core.InputSignal<string>;
     /** Placeholder for the search input. */
     placeholder: _angular_core.InputSignal<string>;
     /** Text shown when nothing is selected. */
@@ -3966,17 +3987,17 @@ declare class M2mselectComponent<T extends DataModel, R extends DataModel> imple
     /** Form control backing the typeahead search input. */
     fc: UntypedFormControl;
     /** Search callback handed to ng-bootstrap's typeahead. */
-    searchFn: (text$: Observable<string>) => Observable<any>;
+    searchFn: (text$: Observable<string>) => Observable<R[]>;
     /** Option formatter handed to ng-bootstrap's typeahead. */
-    displayFn: (x: any) => any;
+    displayFn: (x: R | null | undefined) => string;
     private touched;
     private _tpl;
     private destroy$;
     /**
      * Control value accessor onChange dummy callback;
-     * @param fks
+     * @param _fks
      */
-    onChange: (fks: number[]) => void;
+    onChange: (_fks: number[]) => void;
     /**
      * Control value accessor onTouched dummy callback;
      */
@@ -3985,18 +4006,18 @@ declare class M2mselectComponent<T extends DataModel, R extends DataModel> imple
      * OnChange register from controlValueAccessor
      * @param onChange callback
      */
-    registerOnChange(onChange: any): void;
+    registerOnChange(onChange: (fks: number[]) => void): void;
     /**
      * OnTouched register from controlValueAccessor
      * @param onTouched callback
      */
-    registerOnTouched(onTouched: any): void;
+    registerOnTouched(onTouched: () => void): void;
     /**
      * OnInit :
      * - ensures queryset is available
      * - creates form control for input
      * - creates display function
-     * - ensure values are set from any source
+     * - ensure values are set from whichever source is available
      */
     ngOnInit(): void;
     /**
@@ -4049,7 +4070,7 @@ declare class M2mselectComponent<T extends DataModel, R extends DataModel> imple
      */
     private _search;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<M2mselectComponent<any, any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<M2mselectComponent<any, any>, "data-m2mselect", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "field": { "alias": "field"; "required": false; "isSignal": true; }; "edit": { "alias": "edit"; "required": false; "isSignal": true; }; "values": { "alias": "values"; "required": false; "isSignal": true; }; "queryset": { "alias": "queryset"; "required": false; "isSignal": true; }; "collection": { "alias": "collection"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; "isSignal": true; }; "inputClasses": { "alias": "inputClasses"; "required": false; "isSignal": true; }; }, { "values": "valuesChange"; "queryset": "querysetChange"; "collection": "collectionChange"; "added": "added"; "removed": "removed"; "cancelled": "cancelled"; "cleared": "cleared"; "detailsChanged": "detailsChanged"; "changed": "changed"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<M2mselectComponent<any, any>, "data-m2mselect", never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "field": { "alias": "field"; "required": false; "isSignal": true; }; "edit": { "alias": "edit"; "required": false; "isSignal": true; }; "values": { "alias": "values"; "required": false; "isSignal": true; }; "queryset": { "alias": "queryset"; "required": false; "isSignal": true; }; "collection": { "alias": "collection"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "display": { "alias": "display"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; "isSignal": true; }; "inputClasses": { "alias": "inputClasses"; "required": false; "isSignal": true; }; }, { "values": "valuesChange"; "queryset": "querysetChange"; "collection": "collectionChange"; "added": "added"; "removed": "removed"; "cancelled": "cancelled"; "cleared": "cleared"; "detailsChanged": "detailsChanged"; "changed": "changed"; }, never, never, true, never>;
 }
 
 /**
@@ -4096,9 +4117,9 @@ declare class FlagsComponent<T extends DataModel> implements OnInit {
      */
     action: _angular_core.InputSignal<boolean>;
     /** Control for the free-text "new flag" input. */
-    ft: FormControl;
+    ft: FormControl<string | null>;
     /** Control for the known-flags dropdown; selecting a value adds it. */
-    fs: FormControl;
+    fs: FormControl<string | null>;
     /** Flags currently on the model, rendered as badges. */
     curflags: _angular_core.WritableSignal<string[]>;
     /** Unused; kept for backwards compatibility. */
@@ -4114,9 +4135,9 @@ declare class FlagsComponent<T extends DataModel> implements OnInit {
      * from the model field, and wire the dropdown so that selecting a value adds
      * the flag (debounced 250ms).
      */
-    ngOnInit(): Promise<any>;
+    ngOnInit(): void;
     /** Add the flag currently typed in the free-text input. */
-    addFreeFlag(): Promise<any>;
+    addFreeFlag(): Promise<void>;
     /**
      * Add a flag and persist, unless it is already present.
      *
@@ -4125,12 +4146,12 @@ declare class FlagsComponent<T extends DataModel> implements OnInit {
      *
      * @param flag flag value to add.
      */
-    addFlag(flag: string): Promise<any>;
+    addFlag(flag: string): Promise<void>;
     /**
      * Write the current flags back to the model field and save it, then reset
      * both inputs. Reports success or failure through the message service.
      */
-    update(): Promise<any>;
+    update(): Promise<void>;
     /**
      * Whether the flag is already on the model.
      *
@@ -4143,7 +4164,7 @@ declare class FlagsComponent<T extends DataModel> implements OnInit {
      *
      * @param flag flag value to remove.
      */
-    removeFlag(flag: string): Promise<any>;
+    removeFlag(flag: string): Promise<void>;
     /**
      * Switch between badge display and the editor.
      *
@@ -4175,9 +4196,7 @@ declare class SafeDeleteComponent<T extends DataModel> {
         success: boolean;
     }>) | undefined>;
     /** Translations of database objects names to human names */
-    checks: _angular_core.InputSignal<{
-        [index: string]: string;
-    }>;
+    checks: _angular_core.InputSignal<Record<string, string>>;
     /** Messages to be displayed on success or error, default messages are used if not provided */
     messages: _angular_core.InputSignal<{
         success?: string;
@@ -4203,9 +4222,9 @@ declare class SafeDeleteComponent<T extends DataModel> {
      * First step: run the dry-run delete and open the confirmation panel with its
      * result. Nothing is destroyed here.
      *
-     * @param model unused; the component always acts on its own `[model]` input.
+     * @param _model unused; the component always acts on its own `[model]` input.
      */
-    checkDelete(model: DataModel): Promise<void>;
+    checkDelete(_model: DataModel): Promise<void>;
     /**
      * Second step: perform the actual deletion once the user has confirmed, then
      * close the panel and emit {@link deleted} with the dry-run result.
@@ -4456,7 +4475,7 @@ interface IDetailsFieldMetadata<T> extends IFieldMetadata<T> {
      * `forwardRef`, not a lambda). This is the real link of a relation: it is
      * what instantiates and populates the nested payload.
      */
-    model?: T;
+    model?: DataModelType<DataModel>;
     /**
      * Custom deserialiser, taking precedence over `model`. Use it for payloads
      * that are not models — a plain shape, or a value needing transformation.
@@ -4531,7 +4550,7 @@ declare const reverseForeignKeyField: (updates: IReverseForeignKeyFieldMetadata)
  * @detailsField({ description: 'Labels', readonly: true })
  * public labels_details?: string[];
  */
-declare const detailsField: (meta?: IDetailsFieldMetadata<any>) => FieldDecoratorFn;
+declare const detailsField: (meta?: IDetailsFieldMetadata<unknown>) => FieldDecoratorFn;
 /**
  * Declares the id half of a many-to-many relation: an array of ids, rendered
  * as a multi-select. Pairs with a `many: true` {@link detailsField} named
@@ -4710,7 +4729,7 @@ interface IComputedFieldMetadata<T> extends IFieldMetadata<T> {
  *   }
  * }
  */
-declare const computedField: (meta?: IComputedFieldMetadata<any>) => FieldDecoratorFn;
+declare const computedField: (meta?: IComputedFieldMetadata<unknown>) => FieldDecoratorFn;
 
 /** Severity of a {@link Message}; drives both the CSS classes and the default lifetime. */
 declare const enum TYPE {
@@ -4735,9 +4754,7 @@ declare enum STATUS {
 /**
  * Maps a sound key (`success`, `info`, `warning`, `error`, `notify`) to an audio file url.
  */
-interface ISoundTypes {
-    [index: string]: string;
-}
+type ISoundTypes = Record<string, string>;
 /**
  * Optional per-severity notification sounds ({@link ISoundTypes}) played by
  * {@link DataMessageService.play}.
@@ -4758,11 +4775,11 @@ declare class Message {
     title: string;
     type: TYPE;
     message: string;
-    trace: any;
+    trace: unknown;
     ttl: number;
     status: string;
     showTrace: boolean;
-    constructor(title: string, type?: TYPE, message?: string, trace?: any, ttl?: number);
+    constructor(title: string, type?: TYPE, message?: string, trace?: unknown, ttl?: number);
     /** Bootstrap alert classes matching this message's severity, bound by the message zone template. */
     get style(): string;
     /** Marks the message as dismissed so it is filtered out of the next emission. Prefer {@link DataMessageService.ack}, which also refreshes the stream. */
@@ -4806,22 +4823,22 @@ declare class DataMessageService {
      */
     close(): void;
     /** Reports a completed operation. Short-lived by default (3 s) and plays the `success` sound if configured. */
-    success(title: string, message?: string, trace?: any, timeout?: number): void;
+    success(title: string, message?: string, trace?: unknown, timeout?: number): void;
     /** Reports neutral information the user does not have to act on. Defaults to a 4 s lifetime. */
-    info(title: string, message?: string, trace?: any, timeout?: number): void;
+    info(title: string, message?: string, trace?: unknown, timeout?: number): void;
     /** Reports a problem the user should notice but that did not abort the operation. Stays 10 s by default. */
-    warning(title: string, message?: string, trace?: any, timeout?: number): void;
+    warning(title: string, message?: string, trace?: unknown, timeout?: number): void;
     /**
      * Reports a failure, with the longest lifetime (30 s) and the `error` sound.
      *
      * Note that the `timeout` argument is currently ignored: the message is always created
      * with {@link DEFAULT_TIMEOUTS.DANGER}.
      */
-    danger(title: string, message?: string, trace?: any, timeout?: number): void;
+    danger(title: string, message?: string, trace?: unknown, timeout?: number): void;
     /** Alias for {@link danger}, for callers that think in terms of "error" rather than severity. */
-    error(title: string, message?: string, trace?: any): void;
+    error(title: string, message?: string, trace?: unknown): void;
     /** Logs to the console only — nothing is shown to the user and no message is queued. */
-    debug(title: string, message?: string, trace?: any): void;
+    debug(title: string, message?: string, trace?: unknown): void;
     /**
      * Dismisses a message on the user's behalf and immediately re-emits the list, so the
      * message zone drops it without waiting for its ttl. Bound to the close button of
@@ -4925,13 +4942,13 @@ declare class QuerysetMock<T extends DataModel> {
     /** `[results, loading, meta]` combined, mirroring `Queryset.full`. */
     get full(): Observable<[T[], boolean, IQueryMeta]>;
     /** No-op returning `this`; the filter is discarded. See the class-level caveat. */
-    filter(params?: FilterData): QuerysetMock<T>;
+    filter(_params?: FilterData): QuerysetMock<T>;
     /** No-op returning `this`; the ordering is discarded. See the class-level caveat. */
-    sort(...sorting: string[]): QuerysetMock<T>;
+    sort(..._sorting: string[]): QuerysetMock<T>;
     /** No-op returning `this`; {@link pageSize} is left untouched. */
-    paginateBy(pageSize?: number): QuerysetMock<T>;
+    paginateBy(_pageSize?: number): QuerysetMock<T>;
     /** No-op returning `this`; {@link page} is left untouched. */
-    setPage(page: number): QuerysetMock<T>;
+    setPage(_page: number): QuerysetMock<T>;
     /** Always returns `{}`, since no query state is retained. */
     getQueryParams(): FilterData;
     /**
@@ -4993,13 +5010,13 @@ declare class CollectionMock<T extends DataModel> {
      * id, so a test that fetches two different ids gets the same instance back.
      * Reassign `mockValue` between calls if that matters.
      */
-    fetch(id: number, suffix?: string): Observable<T>;
+    fetch(_id: number, _suffix?: string): Observable<T>;
     /**
      * Returns {@link actionValue}, ignoring the arguments. Since it does not record
      * the call, assert on the effects rather than on the invocation, or spy on this
      * method when you need to check what was requested.
      */
-    action(model: T | null, method: IHttpMethod, action: string, params: IActionParams): Observable<any>;
+    action(_model: T | null, _method: IHttpMethod, _action: string, _params: IActionParams): Observable<any>;
     /**
      * Opens a {@link QuerysetMock} backed by this mock, mirroring
      * `Collection.queryset()`. With no `mockData` set on it, the queryset falls
@@ -5011,9 +5028,7 @@ declare class CollectionMock<T extends DataModel> {
      * real `Collection.list()` unwraps. Arguments are ignored, so filters are not
      * applied; set {@link mockValues} to whatever the filtered result should be.
      */
-    list(query?: {
-        [index: string]: string;
-    }, suffix?: string): Observable<any>;
+    list(_query?: Record<string, string>, _suffix?: string): Observable<any>;
     /**
      * Builds real model instances from JSON, exactly as a live collection would —
      * this is the method you use to prepare {@link mockValue}/{@link mockValues}.
@@ -5027,7 +5042,7 @@ declare class CollectionMock<T extends DataModel> {
      * @param data JSON object or array of them
      * @param many set to `true` when `data` is an array
      */
-    fromJson(data: any, many?: boolean): T | any;
+    fromJson(data: any, many?: boolean): any;
 }
 
 /**
@@ -5092,16 +5107,15 @@ interface UploadFile {
     /** Live status and throughput figures, updated as the transfer progresses. */
     progress: UploadProgress;
     /** Response body, parsed as JSON when possible and left as raw text otherwise. Set once done. */
-    response?: any;
+    response?: unknown;
     /** HTTP status code of the response. Set once done — note that a 4xx/5xx still completes as `done`. */
     responseStatus?: number;
-    sub?: Subscription | any;
+    /** Subscription of the in-flight request, used to cancel it. */
+    sub?: Subscription;
     /** The underlying browser `File`, i.e. what is actually transferred. */
     nativeFile?: File;
     /** Response headers, parsed into a plain object. Set once done. */
-    responseHeaders?: {
-        [key: string]: string;
-    };
+    responseHeaders?: Record<string, string>;
 }
 /**
  * An event emitted by the uploader on the `uploadOutput` output of the directives.
@@ -5112,7 +5126,7 @@ interface UploadFile {
  * `dragOver`/`dragOut`/`drop` for drop-zone hover states.
  */
 interface UploadOutput {
-    type: "addedToQueue" | "allAddedToQueue" | "uploading" | "done" | "start" | "cancelled" | "dragOver" | "dragOut" | "drop" | "removed" | "removedAll" | "rejected";
+    type: 'addedToQueue' | 'allAddedToQueue' | 'uploading' | 'done' | 'start' | 'cancelled' | 'dragOver' | 'dragOut' | 'drop' | 'removed' | 'removedAll' | 'rejected';
     file?: UploadFile;
     nativeFile?: File;
 }
@@ -5124,7 +5138,7 @@ interface UploadOutput {
  * data); the queue-management commands only need `type` and, where relevant, `id`.
  */
 interface UploadInput {
-    type: "uploadAll" | "uploadFile" | "cancel" | "cancelAll" | "remove" | "removeAll";
+    type: 'uploadAll' | 'uploadFile' | 'cancel' | 'cancelAll' | 'remove' | 'removeAll';
     /** Target endpoint for `uploadAll`/`uploadFile`. Defaults to an empty string, which posts to the current url. */
     url?: string;
     /** HTTP method to use; defaults to `POST`. */
@@ -5137,13 +5151,9 @@ interface UploadInput {
     /** The queued file to send with `uploadFile`; matched by identity against the queue. */
     file?: UploadFile;
     /** Extra form fields appended to the multipart body alongside the file. */
-    data?: {
-        [key: string]: string | Blob;
-    };
+    data?: Record<string, string | Blob>;
     /** Extra request headers. Note the uploader uses `XMLHttpRequest` directly, so Angular HTTP interceptors — including the auth interceptor — do not apply; add any `Authorization` header here yourself. */
-    headers?: {
-        [key: string]: string;
-    };
+    headers?: Record<string, string>;
     includeWebKitFormBoundary?: boolean;
     /** Sends credentials (cookies) cross-origin; defaults to `false`. */
     withCredentials?: boolean;
@@ -5273,7 +5283,7 @@ declare class NgFileDropDirective implements OnInit, OnDestroy {
     ngOnDestroy(): void;
     stopEvent: (e: Event) => void;
     /** Handles a drop: emits `drop`, then screens and queues the dropped files. Bound to the host `drop` event. */
-    onDrop(e: any): void;
+    onDrop(e: DragEvent): void;
     /** Emits `dragOver` while a drag hovers the zone, for highlighting it. Bound to the host `dragover` event. */
     onDragOver(e: Event): void;
     /** Emits `dragOut` when a drag leaves the zone, to clear the highlight. Bound to the host `dragleave` event. */
@@ -5286,7 +5296,7 @@ declare class NgFileSelectDirective implements OnInit, OnDestroy {
     /** Queue limits ({@link UploaderOptions}). Read once in `ngOnInit`; later changes have no effect. */
     options: _angular_core.InputSignal<UploaderOptions | undefined>;
     /** Command channel: emit {@link UploadInput}s on it to start, cancel or clear uploads. */
-    uploadInput: _angular_core.InputSignal<EventEmitter<any> | undefined>;
+    uploadInput: _angular_core.InputSignal<EventEmitter<UploadInput> | undefined>;
     /** Queue and transfer events ({@link UploadOutput}) for this input. */
     uploadOutput: _angular_core.OutputEmitterRef<UploadOutput>;
     /** The queue backing this input, created in `ngOnInit`. */
@@ -5449,7 +5459,7 @@ declare const DATA_AUTH_PARAMS: InjectionToken<AuthParams>;
  * Using `useClass` here would give the auth layer a private instance whose cache and
  * state diverge from the one the rest of the application uses.
  */
-declare const DATA_AUTH_USER_SERVICE: InjectionToken<Collection<any>>;
+declare const DATA_AUTH_USER_SERVICE: InjectionToken<Collection<DataModel>>;
 /**
  * Generic JWT authentication service, meant to be **extended** by the application.
  *
@@ -5495,11 +5505,6 @@ declare const DATA_AUTH_USER_SERVICE: InjectionToken<Collection<any>>;
  * @typeParam UserData - the decoded JWT payload, at least an {@link IJwtBaseData}.
  */
 declare class AuthServiceBase<User extends DataModel, UserService extends Collection<User>, UserData extends IJwtBaseData> {
-    userService: UserService;
-    private _params;
-    private _router;
-    private _http;
-    private _msgs;
     /**
      * Emits every time {@link logout} runs, whether triggered by the user, by a failed
      * token refresh, or by a login error.
@@ -5514,7 +5519,13 @@ declare class AuthServiceBase<User extends DataModel, UserService extends Collec
     private _user$;
     private _token;
     private _fetched?;
-    constructor(userService: UserService, _params: AuthParams, _router: Router, _http: HttpClient, _msgs: DataMessageService);
+    /** Collection used to fetch the logged-in user, from {@link DATA_AUTH_USER_SERVICE}. */
+    userService: UserService;
+    private _params;
+    private _router;
+    private _http;
+    private _msgs;
+    constructor();
     /** True when no access token is held, i.e. no session is active. Checked by {@link AuthInterceptor} before attaching a token. */
     get isAnonymous(): boolean;
     /** Current raw access token, or `null` when anonymous. Read by {@link AuthInterceptor} to build the `Authorization` header. */
@@ -5572,7 +5583,7 @@ declare class AuthServiceBase<User extends DataModel, UserService extends Collec
      * `'error'` when none is available), so callers can branch on the emitted string
      * rather than on an error callback.
      */
-    login(username: string, password: string): Observable<'success' | 'error' | 'invalid_token' | string>;
+    login(username: string, password: string): Observable<'success' | 'error' | 'invalid_token' | (string & {})>;
     /**
      * Opens a session from an already-obtained token pair instead of credentials, for
      * flows where the tokens arrive out of band (SSO callback, impersonation, tests).
@@ -5580,7 +5591,7 @@ declare class AuthServiceBase<User extends DataModel, UserService extends Collec
      * Like {@link login}, it fetches the user, saves the session and reports failures as
      * an emitted code rather than an error.
      */
-    loginWithToken(accessToken: string, refreshToken: string): Observable<'success' | 'error' | 'invalid_token' | string>;
+    loginWithToken(accessToken: string, refreshToken: string): Observable<'success' | 'error' | 'invalid_token' | (string & {})>;
     /**
      * Asks the backend to send an account reactivation token to the given user.
      *
@@ -5697,7 +5708,7 @@ declare class AuthInterceptor implements HttpInterceptor {
      * {@link DATA_AUTH_URLS}. Authenticated requests additionally get 401 handling with
      * automatic token refresh and replay.
      */
-    intercept(req: HttpRequest<any>, next: HttpHandler): rxjs.Observable<_angular_common_http.HttpEvent<any>>;
+    intercept(req: HttpRequest<unknown>, next: HttpHandler): rxjs.Observable<_angular_common_http.HttpEvent<any>>;
     private _handle401Error;
     private _addToken;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuthInterceptor, never>;
@@ -5730,6 +5741,10 @@ interface BaseRouteParams {
 /**
  * Route function type.
  * Takes parameters, return a route.
+ *
+ * The parameters are `any` on purpose: a route builder is written against the
+ * models it links to (`(product: Product) => [...]`), and such a function is not
+ * assignable to one declared over `unknown[]`.
  */
 type RouteFn = (...args: any[]) => (string | number)[];
 /**
@@ -5753,18 +5768,14 @@ declare function RData<T extends BaseRouteParams>(value: T): T;
  * A map of route names to their {@link RouteConfigItem}, keyed by a string-literal union
  * so that every name is known statically and typos are compile errors.
  */
-type RoutesConfig<T extends string> = {
-    readonly [Property in T]: RouteConfigItem;
-};
+type RoutesConfig<T extends string> = Readonly<Record<T, RouteConfigItem>>;
 /** An Angular {@link Route} whose `data` is mandatory and typed as {@link BaseRouteParams}. */
 interface StrictRoutes extends Route {
     data: BaseRouteParams;
 }
 /** A route table built from {@link StrictRoutes}, i.e. where every route carries breadcrumb metadata. */
 type RoutesDefinition = StrictRoutes[];
-interface RouteArg<T> {
-    [index: string]: T;
-}
+type RouteArg<T> = Record<string, T>;
 /**
  * A bound, reusable reference to a route: it pairs a {@link RouteConfigItem} with a
  * context object from which the route's named parameters are read.
@@ -5787,7 +5798,7 @@ declare class Link<T> {
      * later. A missing `config` is tolerated (it warns and produces an inert link) so that
      * a partially-initialised template does not crash.
      */
-    constructor(config?: RouteConfigItem, context?: any, router?: Router);
+    constructor(config?: RouteConfigItem, context?: object, router?: Router);
     private _name;
     /** Name of the underlying route config item, or an empty string when the link was built without config. */
     get name(): string;
@@ -5796,7 +5807,7 @@ declare class Link<T> {
      * context. Only the parameters declared by the route config are picked up; those
      * missing from `ctx` are reset to `null`, not left over from the previous context.
      */
-    context(ctx: any): void;
+    context(ctx: object): void;
     /**
      * Builds the router commands array, resolving each declared parameter from `params`
      * first and falling back to the bound context.
@@ -5813,9 +5824,7 @@ declare class Link<T> {
      * Resolves to `false` without navigating when no router is available from either
      * source; otherwise it resolves with the router's own result.
      */
-    navigate(params?: {
-        [index: string]: T;
-    }, router?: Router): Promise<boolean>;
+    navigate(params?: Record<string, T>, router?: Router): Promise<boolean>;
 }
 
 /** One rendered breadcrumb entry: its absolute path, label, icon classes, and whether it is the active leaf. */
@@ -5848,7 +5857,7 @@ declare class BreadcrumbComponent implements OnInit {
     /**
      * Additional data to be used in titleTemplate
      */
-    data: _angular_core.InputSignal<any>;
+    data: _angular_core.InputSignal<object | undefined>;
     /**
      * Do we display icons ?
      */
@@ -5965,6 +5974,34 @@ declare class TabMemoryService {
  */
 declare const slugify: (str: string) => string;
 
+/**
+ * Returns a document-unique DOM id, as `<prefix>-<n>`.
+ *
+ * Used to wire a `<label [attr.for]>` to the control its template owns: the
+ * widgets in this library are instantiated repeatedly on the same page, so a
+ * hard-coded id would collide and silently break the association.
+ *
+ * The counter is module-level and starts at zero in each JS context, so a
+ * server-rendered page and its client hydration agree as long as components are
+ * created in the same order — which is what Angular does.
+ *
+ * @param prefix identifies the widget, e.g. `data-filter`
+ */
+declare function uniqueId(prefix: string): string;
+
+/**
+ * Teach jsdom the layout APIs CodeMirror and ProseMirror expect.
+ *
+ * Both editors measure the document to place the caret and decide what to
+ * render, and jsdom has no layout engine: `getClientRects()` returns an empty
+ * list and `elementFromPoint` does not exist at all. Zeroed rectangles are
+ * enough — nothing in a spec depends on real geometry, it just has to not throw.
+ *
+ * Call it from `beforeEach` in any spec that instantiates an editor view. It is
+ * idempotent, and only patches what is missing.
+ */
+declare function installEditorDomShims(): void;
+
 /**
  * Compiles (and optionally renders) an Underscore-style string template, using ERB
  * delimiters: `<%= expr %>` interpolates, `<% code %>` evaluates, and a `print()` helper
@@ -5980,7 +6017,15 @@ declare const slugify: (str: string) => string;
  * Policy without `unsafe-eval`; and the escaping delimiter `<%- expr %>` is not usable,
  * as the code it emits calls `_.escape` while no `_` is in scope.
  */
-declare const tmpl: (text: string, data?: any, objectName?: string) => any;
+/**
+ * A template compiled by {@link tmpl} but not yet rendered: call it with the
+ * data. `source` carries the generated JS, which is handy when debugging.
+ */
+type CompiledTemplate = ((data: object) => string) & {
+    source?: string;
+};
+declare function tmpl(text: string, data: object, objectName?: string): string;
+declare function tmpl(text: string, data?: undefined, objectName?: string): CompiledTemplate;
 
 /**
  * Watches the service worker for a newly deployed version and exposes it as a simple
@@ -5993,11 +6038,17 @@ declare const tmpl: (text: string, data?: any, objectName?: string) => any;
  * Harmless without a service worker: the checks fail and are logged as warnings.
  */
 declare class UpdateService {
+    private stable;
     private appRef;
     private swUpdate;
-    private stable;
-    constructor(appRef: ApplicationRef, swUpdate: SwUpdate);
+    constructor();
     private _available$;
+    /**
+     * Asks the service worker whether a new version is available. Swallows the
+     * failure raised when no service worker is registered, which is the normal
+     * case in development.
+     */
+    private _checkForUpdate;
     /**
      * Whether a new version is ready to be activated. Starts at `false`, becomes `true` on
      * `VERSION_READY`, and returns to `false` once the user activates or dismisses it.
@@ -6024,5 +6075,5 @@ declare class UpdateComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<UpdateComponent, "data-update", never, {}, {}, never, never, true, never>;
 }
 
-export { AuthInterceptor, AuthServiceBase, BanAdapter, BaseFieldManager, 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, 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 };
+export { AuthInterceptor, AuthServiceBase, BanAdapter, BaseFieldManager, 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, STATUS, SafeDeleteComponent, TYPE, TabMemoryService, UpdateComponent, UpdateService, UploadStatus, asText, booleanField, charField, computedField, dateField, datetimeField, decimalField, detailsField, emailField, fieldValues, floatField, foreignKeyField, humanizeBytes, installEditorDomShims, integerField, isValue, manyToManyField, passwordField, primaryField, reverseForeignKeyField, slugify, strToNumber, textField, tmpl, uniqueId };
+export type { AuthParams, BanResults, BaseRouteParams, BlobFile, CompiledTemplate, CustomField, DataDisplayConfig, DataModelFields, DataModelType, FakeDeleteResult, FieldsParams, FilterData, FilterDefaults, FilterValue, 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 };