@solidev/data 1.0.1 → 1.1.1

package/types/solidev-data.d.ts

@@ -1,14 +1,14 @@
 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';
+import { SafeHtml } from '@angular/platform-browser';
 
 /**
  * Base URL of the REST API every {@link Collection} builds its endpoints on.
@@ -70,15 +70,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,406 +111,148 @@ 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.
-     */
-    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;
-    /**
-     * 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.
+     * 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
      */
-    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);
+    action<T extends DataModel, RT>(collection: Collection<T>, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', url: string, { body, params, headers }?: IActionParams): Observable<RT>;
     /**
-     * Which editor widget `dispedit` renders for this field in edit mode.
+     * Issues a request whose response is taken as binary rather than JSON.
      *
-     * 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.
+     * 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`
      */
-    editorType: DISPEDIT_EDITOR_TYPES;
+    blob<T extends DataModel>(collection: Collection<T>, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', url: string, { body, params, headers }?: IActionParams): Observable<Blob>;
     /**
-     * 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`, ...).
+     * 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.
+     *
+     * @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}
      */
-    displayType: DISPEDIT_DISPLAY_TYPES;
+    put<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<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.
+     * Creates a record (HTTP POST). Chosen by `Collection.save()`/`update()` when
+     * the model has no `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 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`
      */
-    constructor(params: IFieldMetadata<FT>);
+    post<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.
+     * Partially updates a record (HTTP PATCH). Chosen by
+     * `Collection.save()`/`update()` when the model already has an `id`.
+     *
+     * @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}
      */
-    get validators(): ValidatorFn[];
+    patch<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<Partial<T>>;
     /**
-     * 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.
+     * 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 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}.
-     *
-     * Note the seed uses `||`, so falsy current values (`0`, `''`, `false`) fall
-     * back to the default rather than being kept.
-     *
-     * @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`).
-     *
-     * @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.
-     *
-     * @param data current model value
-     */
-    toJson(data: FT): any;
-    /**
-     * Renders the value for display. The base implementation is plain string
-     * interpolation.
-     *
-     * @param data value to render
-     * @param format reserved; ignored by the base implementation
-     */
-    toString(data: FT, format?: string): string;
-    /**
-     * Public accessor for this field's default value, invoking the
-     * `defaultValue` factory with `args` when one was declared.
-     *
-     * @param args passed through to a `defaultValue` function
-     */
-    default(args?: any): FT | undefined;
-    /**
-     * Builds the base validator list: `Validators.required` when the field is
-     * required, nothing otherwise. Subclasses call it and push their own.
-     *
-     * @protected
-     */
-    protected getValidators(): ValidatorFn[];
-    /**
-     * Resolves the default value: calls `defaultValue` when it is a function,
-     * otherwise returns it as-is.
-     *
-     * **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 args passed through to a `defaultValue` function
-     * @throws Error if `required` is set and `defaultValue` is `undefined`
-     * @protected
-     */
-    protected getDefaultValue(args?: any): 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>;
-}
-/**
- * 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: any, propertyKey: string | symbol) => void;
-
-/**
- * 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.
- *
- * 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.
- *
- * 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.
- *
- * @example
- * ```ts
- * @Injectable({ providedIn: 'root' })
- * export class AuthBackend extends DataBackend {
- *   protected override headers(headers: { [k: string]: string }) {
- *     return { ...super.headers(headers), Authorization: `Bearer ${token}` };
- *   }
- * }
- *
- * providers: [
- *   { provide: DATA_API_URL, useValue: 'https://api.example.com' },
- *   { provide: DataBackend, useClass: AuthBackend },
- * ];
- * ```
- */
-declare class DataBackend {
-    private _http;
-    private _transferState;
-    private _platform;
-    private _apiUrl;
-    private _maxTransferstateTime;
-    /**
-     * 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.
-     */
-    private _created;
-    /**
-     * @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
-     */
-    constructor(_http: HttpClient, _transferState: TransferState, _platform: any, _apiUrl: string, _maxTransferstateTime?: number);
-    /**
-     * 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.
-     */
-    get apiUrl(): string;
-    /**
-     * 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.
-     *
-     * @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
-     */
-    action<T extends DataModel, RT>(collection: Collection<T>, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', url: string, { body, params, headers }?: IActionParams): Observable<RT>;
-    /**
-     * 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`
-     */
-    blob<T extends DataModel>(collection: Collection<T>, method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', url: string, { body, params, headers }?: IActionParams): Observable<Blob>;
-    /**
-     * 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.
-     *
-     * @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}
-     */
-    put<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<T>;
-    /**
-     * 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`
-     */
-    post<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<Partial<T>>;
-    /**
-     * Partially updates a record (HTTP PATCH). Chosen by
-     * `Collection.save()`/`update()` when the model already has an `id`.
-     *
-     * @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}
-     */
-    patch<T extends DataModel>(collection: Collection<T>, url: string, { body, params, headers }?: IActionParams): Observable<Partial<T>>;
-    /**
-     * 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}
-     */
-    delete<T extends DataModel, R>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<R>;
+    delete<T extends DataModel, R>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<R>;
     /**
      * Performs a GET, transparently replaying the server-rendered response from
      * `TransferState` when that is still allowed.
@@ -559,7 +299,9 @@ declare class DataBackend {
      * @param params query parameters, typically the queryset's filters and paging
      * @param headers extra headers
      */
-    list<T extends DataModel>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<any>;
+    list<T extends DataModel>(collection: Collection<T>, url: string, { params, headers }?: IActionParams): Observable<{
+        results: Partial<T>[];
+    }>;
     /**
      * Resolves the headers actually sent with a request.
      *
@@ -576,470 +318,168 @@ declare class DataBackend {
      * @param headers per-request headers supplied by the caller
      * @returns the complete header set to send
      */
-    protected headers(headers: {
-        [key: string]: string;
-    }): {
-        [key: string]: string;
-    };
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataBackend, [null, null, null, null, { optional: true; }]>;
+    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';
 /**
- * Filter criteria as authored by the caller, keyed by the query parameter the API
- * expects (`{ status: 'active', min_price: 10 }`).
+ * Per-request options shared by every {@link Collection} and {@link DataBackend}
+ * call: body, headers and query parameters.
  *
- * `undefined` and `null` are meaningful here: passing either for a key *removes*
- * that filter, which is what lets a form bind a cleared control straight to a
- * queryset filter.
+ * All members are optional, so `{}` is a valid "nothing special" argument.
  */
-interface FilterData {
-    [index: string]: string | number | boolean | undefined | null;
+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';
 }
 /**
- * Filter criteria flattened to strings, as they go on the wire. This is what
- * {@link Queryset.getQueryParams} produces.
+ * 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.
  */
-interface OutFilterData {
-    [index: string]: string;
+interface ICollectionCacheParams {
+    transferState?: {
+        enabled: boolean;
+        maxTime: number;
+        maxCount: number;
+    };
 }
 /**
- * A single ordering term: a field name, optionally prefixed with `-` to reverse
- * it (`'name'`, `'-created'`) — the DRF `ordering` convention.
+ * 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 SortData = string;
+type DataModelType<T extends DataModel> = new (_coll?: Collection<T>) => T;
 /**
- * Construction options for a {@link Queryset}, passed through
- * `Collection.queryset()`.
- */
-interface IQuerysetOptions {
-    /**
-     * Whether the selected field list is sent to the API as a `fields` query
-     * parameter, letting the server return only those columns. Defaults to `true`;
-     * set it to `false` against an endpoint that does not understand `fields`.
-     */
-    emitFields?: boolean;
-    /** Identifier for this queryset, used to tell several of them apart. */
-    name?: string;
-    /**
-     * Intended to let the queryset sync its state with the URL. Currently inert —
-     * nothing in the implementation reads it (the router code in `setPage` is
-     * commented out).
-     */
-    route?: ActivatedRoute;
-    /**
-     * Intended to let the queryset push page changes into the URL. Currently inert
-     * — see the commented-out block in `setPage`.
-     */
-    router?: Router;
-    /**
-     * Intended as the URL fragment identifying this queryset when several share a
-     * page. Currently inert.
-     */
-    hash?: string;
-}
-/** Pagination request parameters: which page, and how many rows on it. */
-interface IQueryNav {
-    page: number;
-    page_size: number;
-}
-/**
- * Pagination state as reported by the API, and what a paginator component binds
- * to: total row count, current page, total pages, and the neighbouring page
- * numbers (`null` at either end).
- */
-interface IQueryMetaNav {
-    /** Total number of rows matching the filters, across all pages. */
-    count: number;
-    /** Next page number, or `null` on the last page. */
-    next: number | null;
-    /** Current page number. */
-    page: number;
-    /** Total number of pages. */
-    pages: number;
-    /** Previous page number, or `null` on the first page. */
-    prev: number | null;
-    /** Rows per page. */
-    size: number;
-}
-/**
- * Names the API uses for its pagination query parameters, echoed back so a client
- * can build page links without hard-coding them.
- */
-interface IQueryMetaNavParams {
-    page: string;
-    page_size: string;
-}
-/** Everything a list response says about itself apart from the rows. */
-interface IQueryMeta {
-    nav: IQueryMetaNav;
-    parameters: IQueryMetaNavParams;
-}
-/**
- * Full shape of a paginated list response: the rows under `results`, alongside
- * the {@link IQueryMeta} envelope. This is the contract {@link Queryset} expects
- * of every list endpoint it reads.
- */
-interface IQueryFullResponse<T> extends IQueryMeta {
-    results: T[];
-}
-/**
- * A filtered, sorted, paginated view over a {@link Collection}, exposing its
- * results as observables ready to bind in a template.
+ * Binds a {@link DataModel} class to a REST endpoint and provides the CRUD
+ * operations over it.
  *
- * Obtained from `Collection.queryset()`. The mutators ({@link filter},
- * {@link sort}, {@link paginateBy}, {@link setPage}, {@link setFields}) are
- * chainable and only accumulate state locally — **nothing is requested until
- * {@link get} is called**, and calling `get()` again after changing filters is
- * what re-runs the query.
+ * 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.
  *
- * Consumers normally subscribe to {@link results} (or {@link full}) once and keep
- * that subscription for the component's lifetime, then call `get()` on each
- * change: the observables are `ReplaySubject`-backed, so every new emission flows
- * to the existing subscribers and late subscribers immediately get the last value.
+ * 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
- * const qs = things.queryset();
- * qs.results.subscribe((things) => (this.things = things));
- * qs.filter({ status: 'active' }).sort('-created').paginateBy(20).get().subscribe();
+ * @Injectable({ providedIn: 'root' })
+ * export class ThingService extends Collection<Thing> {
+ *   constructor() {
+ *     super(inject(DataBackend), '/path/to/things', Thing);
+ *   }
+ * }
+ *
+ * // then
+ * things.fetch(1).subscribe((thing) => ...);
+ * things.queryset().filter({ status: 'active' }).get().subscribe((list) => ...);
  * ```
  */
-declare class Queryset<T extends DataModel> {
-    protected _coll: Collection<T>;
-    /** Filters currently staged, as last set by {@link filter}. */
-    filterData: FilterData;
-    /** Ordering terms currently staged, as last set by {@link sort}. */
-    sortData: SortData[];
-    /**
-     * Field names to request from the API, as last set by {@link setFields}. Only
-     * sent when `options.emitFields` is on and the list is non-empty.
-     */
-    fields: string[];
-    /**
-     * Rows per page. Note the default is 500, not the API's own default: a queryset
-     * you never call {@link paginateBy} on asks for a large page rather than a
-     * small one.
-     */
-    pageSize: number;
-    /** Page number to request, 1-based. */
-    page: number;
-    /** Options this queryset was built with, merged over the defaults. */
-    options: IQuerysetOptions;
-    private _loading;
-    /**
-     * Emits `true` when a fetch starts and `false` when its results have been
-     * processed — bind it to a spinner. Nothing is emitted before the first
-     * {@link get}, and note that a failed request leaves this at `true`.
-     */
-    loading: Observable<boolean>;
-    private _meta;
-    /**
-     * Emits the pagination envelope of each response — row count, page, total
-     * pages. This is what a paginator component binds to, since {@link results}
-     * only carries the current page's rows.
-     */
-    meta: Observable<IQueryMeta>;
-    private _results;
-    /**
-     * Emits the current page's rows as model instances on every successful fetch.
-     * The main output of a queryset. Being replayed, a late subscriber immediately
-     * receives the most recent page rather than waiting for the next `get()`.
-     */
-    results: Observable<T[]>;
-    private _full;
+declare class Collection<T extends DataModel> {
+    protected backend: DataBackend;
+    protected path: string;
+    model: DataModelType<T>;
     /**
-     * The three streams combined into `[results, loading, meta]`, for templates
-     * that would otherwise need three `async` pipes.
+     * Whether GET responses for this collection may be served from / stored in
+     * Angular's `TransferState` during SSR hydration.
      *
-     * Being a `combineLatest`, it emits nothing until all three have produced a
-     * value — i.e. not until the first fetch completes — and then emits once per
-     * change of any of them, so a single fetch produces several tuples as loading
-     * flips and results land.
+     * 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.
      */
-    full: Observable<[T[], boolean, IQueryMeta]>;
+    useTransferState: boolean;
     /**
-     * @param _coll collection this queryset reads from
-     * @param options queryset options, merged over the defaults (`emitFields: true`)
+     * @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(_coll: Collection<T>, options?: IQuerysetOptions);
-    private _pristine;
+    constructor(backend: DataBackend, path: string, model: DataModelType<T>);
     /**
-     * `true` until the first successful fetch, `false` forever after.
+     * Builds a new, unsaved model instance attached to this collection.
      *
-     * Distinguishes "no results yet" from "no results found", which a bare empty
-     * array cannot: use it to choose between a loading placeholder and an empty
-     * state. It is also what makes `get(false)` decide whether it may serve the
-     * cached results.
-     */
-    get pristine(): boolean;
-    /**
-     * Stages the filters for the next {@link get}. Chainable; issues no request.
+     * 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 params filter criteria. A key whose value is `null` or `undefined` is
-     *   *removed* rather than sent, so a cleared form control can be passed
-     *   straight through.
-     * @param update when `true`, merge into the existing filters; when `false` (the
-     *   default), replace them wholesale
+     * @param data initial field values; omit for an empty instance
      *
      * @example
      * ```ts
-     * qs.filter({ status: 'active' });            // replaces all filters
-     * qs.filter({ q: search || null }, true);     // merges; drops `q` when empty
+     * const thing = things.create({ name: 'draft' });
+     * thing.save().subscribe(); // POST /path/to/things
      * ```
      */
-    filter(params?: FilterData, update?: boolean): Queryset<T>;
+    create(data?: Partial<T>): T;
     /**
-     * Stages the ordering for the next {@link get}. Chainable; issues no request.
-     *
-     * Terms are sent joined into a single `ordering` query parameter, in the order
-     * given, so the first term is the primary sort key.
+     * Turns raw API JSON into model instances attached to this collection.
      *
-     * @param sorting field names, `-` prefixed to reverse; replaces any previous
-     *   ordering, and calling with no arguments clears it
+     * 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).
      *
-     * @example
-     * ```ts
-     * qs.sort('-created', 'name').get().subscribe();
-     * ```
+     * @param data one JSON object, or an array of them
      */
-    sort(...sorting: string[]): Queryset<T>;
+    fromJson(data: Partial<T>): T;
+    fromJson(data: Partial<T>[]): T[];
     /**
-     * Stages the page size for the next {@link get}. Chainable; issues no request.
+     * Opens a filterable, sortable, paginated view over this collection.
      *
-     * Does not reset {@link page}, so changing the size while on a high page number
-     * can land past the end of the result set — call `setPage(1)` alongside it.
+     * 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 pageSize rows per page; defaults to 20 when called with no argument,
-     *   which is *not* the queryset's own default of 500
+     * @param options queryset behaviour; see {@link IQuerysetOptions}
      */
-    paginateBy(pageSize?: number): Queryset<T>;
+    queryset(options?: IQuerysetOptions): Queryset<T>;
     /**
-     * Stages the page number for the next {@link get}. Chainable; issues no
-     * request, so a paginator must call {@link get} afterwards.
+     * Retrieves a single record by primary key and returns it as a model.
      *
-     * @param page 1-based page number
-     * @param fragment currently ignored; reserved for the URL-syncing behaviour
-     *   that is commented out in the implementation
+     * @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
+     *
+     * @example
+     * ```ts
+     * things.fetch(42).subscribe((thing) => ...); // GET /path/to/things/42
+     * ```
      */
-    setPage(page?: number, fragment?: string): Queryset<T>;
+    fetch(id: number, { prefix, suffix, params, headers, }?: {
+        prefix?: string;
+        suffix?: string;
+        params?: Record<string, string>;
+        headers?: Record<string, string>;
+    }): Observable<T>;
     /**
-     * Stages which fields the API should return. Chainable; issues no request.
+     * 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.
      *
-     * Lets a list view ask only for the columns it actually shows, which matters on
-     * wide models. Sent as a `fields` query parameter, and only when
-     * `options.emitFields` is on — with it off, this is recorded but never
-     * transmitted.
-     *
-     * @param fields field names to request; an empty array means "no restriction"
-     */
-    setFields(fields: string[]): Queryset<T>;
-    /**
-     * Flattens the staged filter/sort/page/fields state into the query parameters
-     * that will actually be sent.
-     *
-     * Exposed mainly for debugging and for building links that mirror the current
-     * view; {@link get} calls it itself. Ordering goes out as `ordering`, paging as
-     * `page`/`page_size`, and the field selection as `fields`.
-     *
-     * The `OutFilterData` return type is an assertion rather than a conversion —
-     * numeric values such as `page` are still numbers at runtime, and are
-     * stringified later by `HttpClient`.
-     */
-    getQueryParams(): OutFilterData;
-    /**
-     * Runs the staged query and pushes the outcome through {@link results},
-     * {@link meta} and {@link loading}.
-     *
-     * The one method that talks to the network. Call it after each change to the
-     * filter/sort/page state; subscribers of `results` do not need to resubscribe,
-     * they simply receive the new page. The returned observable is `results`
-     * itself, so subscribing to the return value is a convenience, not a
-     * requirement — though something must subscribe for the request to be sent.
-     *
-     * @param refresh when `false`, an already-fetched queryset (see
-     *   {@link pristine}) short-circuits and hands back the cached `results`
-     *   without any request. Use it where a component may be re-entered and should
-     *   reuse what is already loaded. A pristine queryset always fetches, whatever
-     *   this says.
-     * @param sync adds `db=sync` to the query, asking the API to read from its
-     *   primary rather than a replica — for the read-after-write case where
-     *   replication lag would otherwise return stale rows
-     *
-     * @example
-     * ```ts
-     * qs.get().subscribe();            // always refetches
-     * qs.get(false).subscribe();       // reuses results if already loaded once
-     * ```
-     */
-    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.
- *
- * All members are optional, so `{}` is a valid "nothing special" argument.
- */
-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';
-}
-/**
- * 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.
- */
-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.
- */
-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.
- *
- * 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.
- *
- * 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 ThingService extends Collection<Thing> {
- *   constructor() {
- *     super(inject(DataBackend), '/path/to/things', Thing);
- *   }
- * }
- *
- * // then
- * things.fetch(1).subscribe((thing) => ...);
- * things.queryset().filter({ status: 'active' }).get().subscribe((list) => ...);
- * ```
- */
-declare class Collection<T extends DataModel> {
-    protected backend: DataBackend;
-    protected path: string;
-    model: DataModelType<T>;
-    /**
-     * 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.
-     */
-    useTransferState: boolean;
-    /**
-     * @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(backend: DataBackend, path: string, model: DataModelType<T>);
-    /**
-     * 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
-     * ```
-     */
-    create(data?: Partial<T>): T;
-    /**
-     * 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
-     */
-    fromJson(data: Partial<T>): T;
-    fromJson(data: Partial<T>[]): T[];
-    /**
-     * 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.
-     *
-     * @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
-     *
-     * @example
-     * ```ts
-     * things.fetch(42).subscribe((thing) => ...); // GET /path/to/things/42
-     * ```
-     */
-    fetch(id: number, { prefix, suffix, params, headers, }?: {
-        prefix?: string;
-        suffix?: string;
-        params?: {
-            [_index: string]: string;
-        };
-        headers?: {
-            [_index: string]: string;
-        };
-    }): Observable<T>;
-    /**
-     * 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.
+     * 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>`
@@ -1085,116 +525,668 @@ declare class Collection<T extends DataModel> {
      * 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 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 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
+     */
+    delete(model: T, { params, headers }?: IActionParams): Observable<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).
+     *
+     * @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
+     */
+    list(query?: FilterData, { prefix, suffix, params, headers, }?: {
+        prefix?: string;
+        suffix?: string;
+        params?: Record<string, string>;
+        headers?: Record<string, string>;
+    }): Observable<T[]>;
+    /**
+     * 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.
+     *
+     * @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
+     */
+    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>;
+    /**
+     * 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.
+     *
+     * @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
+     */
+    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>;
+    /**
+     * 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).
+     *
+     * 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 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
+     */
+    getUrl(id?: number | null, { prefix, suffix }?: {
+        prefix?: string;
+        suffix?: string;
+    }): string;
+}
+
+/**
+ * Filter criteria as authored by the caller, keyed by the query parameter the API
+ * expects (`{ status: 'active', min_price: 10 }`).
+ *
+ * `undefined` and `null` are meaningful here: passing either for a key *removes*
+ * that filter, which is what lets a form bind a cleared control straight to a
+ * queryset filter.
+ */
+/**
+ * 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.
+ */
+type OutFilterData = Record<string, string>;
+/**
+ * A single ordering term: a field name, optionally prefixed with `-` to reverse
+ * it (`'name'`, `'-created'`) — the DRF `ordering` convention.
+ */
+type SortData = string;
+/**
+ * Construction options for a {@link Queryset}, passed through
+ * `Collection.queryset()`.
+ */
+interface IQuerysetOptions {
+    /**
+     * Whether the selected field list is sent to the API as a `fields` query
+     * parameter, letting the server return only those columns. Defaults to `true`;
+     * set it to `false` against an endpoint that does not understand `fields`.
+     */
+    emitFields?: boolean;
+    /** Identifier for this queryset, used to tell several of them apart. */
+    name?: string;
+    /**
+     * Intended to let the queryset sync its state with the URL. Currently inert —
+     * nothing in the implementation reads it (the router code in `setPage` is
+     * commented out).
+     */
+    route?: ActivatedRoute;
+    /**
+     * Intended to let the queryset push page changes into the URL. Currently inert
+     * — see the commented-out block in `setPage`.
+     */
+    router?: Router;
+    /**
+     * Intended as the URL fragment identifying this queryset when several share a
+     * page. Currently inert.
+     */
+    hash?: string;
+}
+/** Pagination request parameters: which page, and how many rows on it. */
+interface IQueryNav {
+    page: number;
+    page_size: number;
+}
+/**
+ * Pagination state as reported by the API, and what a paginator component binds
+ * to: total row count, current page, total pages, and the neighbouring page
+ * numbers (`null` at either end).
+ */
+interface IQueryMetaNav {
+    /** Total number of rows matching the filters, across all pages. */
+    count: number;
+    /** Next page number, or `null` on the last page. */
+    next: number | null;
+    /** Current page number. */
+    page: number;
+    /** Total number of pages. */
+    pages: number;
+    /** Previous page number, or `null` on the first page. */
+    prev: number | null;
+    /** Rows per page. */
+    size: number;
+}
+/**
+ * Names the API uses for its pagination query parameters, echoed back so a client
+ * can build page links without hard-coding them.
+ */
+interface IQueryMetaNavParams {
+    page: string;
+    page_size: string;
+}
+/** Everything a list response says about itself apart from the rows. */
+interface IQueryMeta {
+    nav: IQueryMetaNav;
+    parameters: IQueryMetaNavParams;
+}
+/**
+ * Full shape of a paginated list response: the rows under `results`, alongside
+ * the {@link IQueryMeta} envelope. This is the contract {@link Queryset} expects
+ * of every list endpoint it reads.
+ */
+interface IQueryFullResponse<T> extends IQueryMeta {
+    results: T[];
+}
+/**
+ * A filtered, sorted, paginated view over a {@link Collection}, exposing its
+ * results as observables ready to bind in a template.
+ *
+ * Obtained from `Collection.queryset()`. The mutators ({@link filter},
+ * {@link sort}, {@link paginateBy}, {@link setPage}, {@link setFields}) are
+ * chainable and only accumulate state locally — **nothing is requested until
+ * {@link get} is called**, and calling `get()` again after changing filters is
+ * what re-runs the query.
+ *
+ * Consumers normally subscribe to {@link results} (or {@link full}) once and keep
+ * that subscription for the component's lifetime, then call `get()` on each
+ * change: the observables are `ReplaySubject`-backed, so every new emission flows
+ * to the existing subscribers and late subscribers immediately get the last value.
+ *
+ * @example
+ * ```ts
+ * const qs = things.queryset();
+ * qs.results.subscribe((things) => (this.things = things));
+ * qs.filter({ status: 'active' }).sort('-created').paginateBy(20).get().subscribe();
+ * ```
+ */
+declare class Queryset<T extends DataModel> {
+    protected _coll: Collection<T>;
+    /** Filters currently staged, as last set by {@link filter}. */
+    filterData: FilterData;
+    /** Ordering terms currently staged, as last set by {@link sort}. */
+    sortData: SortData[];
+    /**
+     * Field names to request from the API, as last set by {@link setFields}. Only
+     * sent when `options.emitFields` is on and the list is non-empty.
+     */
+    fields: string[];
+    /**
+     * Rows per page. Note the default is 500, not the API's own default: a queryset
+     * you never call {@link paginateBy} on asks for a large page rather than a
+     * small one.
+     */
+    pageSize: number;
+    /** Page number to request, 1-based. */
+    page: number;
+    /** Options this queryset was built with, merged over the defaults. */
+    options: IQuerysetOptions;
+    private _loading;
+    /**
+     * Emits `true` when a fetch starts and `false` when its results have been
+     * processed — bind it to a spinner. Nothing is emitted before the first
+     * {@link get}, and note that a failed request leaves this at `true`.
+     */
+    loading: Observable<boolean>;
+    private _meta;
+    /**
+     * Emits the pagination envelope of each response — row count, page, total
+     * pages. This is what a paginator component binds to, since {@link results}
+     * only carries the current page's rows.
+     */
+    meta: Observable<IQueryMeta>;
+    private _results;
+    /**
+     * Emits the current page's rows as model instances on every successful fetch.
+     * The main output of a queryset. Being replayed, a late subscriber immediately
+     * receives the most recent page rather than waiting for the next `get()`.
+     */
+    results: Observable<T[]>;
+    private _full;
+    /**
+     * The three streams combined into `[results, loading, meta]`, for templates
+     * that would otherwise need three `async` pipes.
+     *
+     * Being a `combineLatest`, it emits nothing until all three have produced a
+     * value — i.e. not until the first fetch completes — and then emits once per
+     * change of any of them, so a single fetch produces several tuples as loading
+     * flips and results land.
+     */
+    full: Observable<[T[], boolean, IQueryMeta]>;
+    /**
+     * @param _coll collection this queryset reads from
+     * @param options queryset options, merged over the defaults (`emitFields: true`)
+     */
+    constructor(_coll: Collection<T>, options?: IQuerysetOptions);
+    private _pristine;
+    /**
+     * `true` until the first successful fetch, `false` forever after.
+     *
+     * Distinguishes "no results yet" from "no results found", which a bare empty
+     * array cannot: use it to choose between a loading placeholder and an empty
+     * state. It is also what makes `get(false)` decide whether it may serve the
+     * cached results.
+     */
+    get pristine(): boolean;
+    /**
+     * Stages the filters for the next {@link get}. Chainable; issues no request.
+     *
+     * @param params filter criteria. A key whose value is `null` or `undefined` is
+     *   *removed* rather than sent, so a cleared form control can be passed
+     *   straight through.
+     * @param update when `true`, merge into the existing filters; when `false` (the
+     *   default), replace them wholesale
+     *
+     * @example
+     * ```ts
+     * qs.filter({ status: 'active' });            // replaces all filters
+     * qs.filter({ q: search || null }, true);     // merges; drops `q` when empty
+     * ```
+     */
+    filter(params?: FilterData, update?: boolean): Queryset<T>;
+    /**
+     * Stages the ordering for the next {@link get}. Chainable; issues no request.
+     *
+     * Terms are sent joined into a single `ordering` query parameter, in the order
+     * given, so the first term is the primary sort key.
+     *
+     * @param sorting field names, `-` prefixed to reverse; replaces any previous
+     *   ordering, and calling with no arguments clears it
+     *
+     * @example
+     * ```ts
+     * qs.sort('-created', 'name').get().subscribe();
+     * ```
+     */
+    sort(...sorting: string[]): Queryset<T>;
+    /**
+     * Stages the page size for the next {@link get}. Chainable; issues no request.
+     *
+     * Does not reset {@link page}, so changing the size while on a high page number
+     * can land past the end of the result set — call `setPage(1)` alongside it.
+     *
+     * @param pageSize rows per page; defaults to 20 when called with no argument,
+     *   which is *not* the queryset's own default of 500
+     */
+    paginateBy(pageSize?: number): Queryset<T>;
+    /**
+     * Stages the page number for the next {@link get}. Chainable; issues no
+     * 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
+     *   that is commented out in the implementation
+     */
+    setPage(page?: number, _fragment?: string): Queryset<T>;
+    /**
+     * Stages which fields the API should return. Chainable; issues no request.
+     *
+     * Lets a list view ask only for the columns it actually shows, which matters on
+     * wide models. Sent as a `fields` query parameter, and only when
+     * `options.emitFields` is on — with it off, this is recorded but never
+     * transmitted.
+     *
+     * @param fields field names to request; an empty array means "no restriction"
+     */
+    setFields(fields: string[]): Queryset<T>;
+    /**
+     * Flattens the staged filter/sort/page/fields state into the query parameters
+     * that will actually be sent.
+     *
+     * Exposed mainly for debugging and for building links that mirror the current
+     * view; {@link get} calls it itself. Ordering goes out as `ordering`, paging as
+     * `page`/`page_size`, and the field selection as `fields`.
+     *
+     * The `OutFilterData` return type is an assertion rather than a conversion —
+     * numeric values such as `page` are still numbers at runtime, and are
+     * stringified later by `HttpClient`.
+     */
+    getQueryParams(): OutFilterData;
+    /**
+     * Runs the staged query and pushes the outcome through {@link results},
+     * {@link meta} and {@link loading}.
+     *
+     * The one method that talks to the network. Call it after each change to the
+     * filter/sort/page state; subscribers of `results` do not need to resubscribe,
+     * they simply receive the new page. The returned observable is `results`
+     * itself, so subscribing to the return value is a convenience, not a
+     * requirement — though something must subscribe for the request to be sent.
+     *
+     * @param refresh when `false`, an already-fetched queryset (see
+     *   {@link pristine}) short-circuits and hands back the cached `results`
+     *   without any request. Use it where a component may be re-entered and should
+     *   reuse what is already loaded. A pristine queryset always fetches, whatever
+     *   this says.
+     * @param sync adds `db=sync` to the query, asking the API to read from its
+     *   primary rather than a replica — for the read-after-write case where
+     *   replication lag would otherwise return stale rows
+     *
+     * @example
+     * ```ts
+     * qs.get().subscribe();            // always refetches
+     * qs.get(false).subscribe();       // reuses results if already loaded once
+     * ```
+     */
+    get(refresh?: boolean, sync?: boolean): Observable<T[]>;
+}
+
+/**
+ * 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: FilterValue;
+}
+/**
+ * Every editor widget {@link DispeditComponent} knows how to render.
+ *
+ * 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.
+ * - `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' | 'fkselect' | 'm2mselect';
+/**
+ * Every read-only renderer {@link DispeditComponent} knows how to produce.
+ *
+ * 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`.
+ *
+ * - `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).
+ * - `html`: the value injected as trusted HTML. For rich text and markdown
+ *   fields, whose rendered form is stored alongside the source — point the
+ *   dispedit at that `…_html` field and set `[viewer]="'html'"`. **The value is
+ *   not sanitized**; the value goes through `SafeHtmlPipe`.
+ */
+type DISPEDIT_DISPLAY_TYPES = 'text' | 'choice' | 'boolean' | 'decimal' | 'fkdetails' | 'm2mdetails' | 'datetime' | 'date' | 'html';
+
+/**
+ * Options common to every field decorator. All are optional; each concrete
+ * field type extends this with its own (`ICharFieldMetadata`, etc.).
+ *
+ * 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.
+ *
+ * @typeParam FT the JavaScript type the field holds on the model
+ */
+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;
+    /**
+     * 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}.
+     */
+    required?: boolean;
+    /**
+     * 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.
+     */
+    readonly?: boolean;
+    /**
+     * 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`.
+     *
+     * `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.
+     */
+    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;
+    /**
+     * 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.
+     *
+     * 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.
+     *
+     * @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.
+     */
+    get validators(): ValidatorFn[];
+    /**
+     * 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}.
+     *
+     * Note the seed uses `||`, so falsy current values (`0`, `''`, `false`) fall
+     * back to the default rather than being kept.
+     *
+     * @param instance model whose value seeds the control
      */
-    delete(model: T, { params, headers }?: IActionParams): Observable<any>;
+    formControl(instance: DataModel): FormControl<FT | null>;
     /**
-     * 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).
+     * 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 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 raw value read from the JSON payload
      */
-    list(query?: FilterData, { prefix, suffix, params, headers, }?: {
-        prefix?: string;
-        suffix?: string;
-        params?: {
-            [_index: string]: string;
-        };
-        headers?: {
-            [_index: string]: string;
-        };
-    }): Observable<T[]>;
+    fromJson(data: unknown): FT;
     /**
-     * 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.
+     * Converts the model value back into its JSON representation for save.
+     * The base implementation passes the data straight through.
      *
-     * @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 data current model value
      */
-    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>;
+    toJson(data: FT): unknown;
     /**
-     * Calls a collection-level endpoint and returns the response as a `Blob`.
+     * Renders the value for display. The base implementation is plain string
+     * interpolation.
      *
-     * Use it for binary or file downloads (CSV/XLSX/PDF exports) where the response
-     * must not be parsed as JSON.
+     * @param data value to render
+     * @param _format reserved; ignored by the base implementation
+     */
+    toString(data: FT, _format?: string): string;
+    /**
+     * 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
-     * @param headers extra headers
+     * @param args passed through to a `defaultValue` function
      */
-    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>;
+    default(args?: FieldDefaultArgs): FT | undefined;
     /**
-     * Builds the absolute URL for this collection or one of its records.
+     * Builds the base validator list: `Validators.required` when the field is
+     * required, nothing otherwise. Subclasses call it and push their own.
      *
-     * Every request the collection makes goes through here, so overriding it is the
-     * supported way to bend URL construction (versioned or nested endpoints).
+     * @protected
+     */
+    protected getValidators(): ValidatorFn[];
+    /**
+     * 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 +1196,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 +1327,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 +1368,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 +1485,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 +1529,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 +1632,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 +1869,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 +1940,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 +2041,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 +2052,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 +2062,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 +2217,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 +2522,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 +2560,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 +2588,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 +2621,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 +2639,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 +2649,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 +2689,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 +2733,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 +3278,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 +3533,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 +3632,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 +3661,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 +3679,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.
      *
@@ -3722,8 +3741,8 @@ declare class DispeditComponent<FT, T extends DataModel, R extends DataModel> {
     /**
      * Forces a display renderer, bypassing the field manager's `displayType`.
      *
-     * Writable because setting `[editor]="'quill'"` without a viewer makes the
-     * component select the `quill` viewer for you.
+     * Writable so that cross-input consistency rules can settle on a renderer;
+     * see {@link _checks}.
      */
     viewer: _angular_core.ModelSignal<DISPEDIT_DISPLAY_TYPES | undefined>;
     /**
@@ -3731,7 +3750,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 +3802,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 +3812,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 +3899,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,8 +3908,14 @@ declare class DispeditComponent<FT, T extends DataModel, R extends DataModel> {
      *
      * @param v current list of selected instances.
      */
-    onM2MValuesChanges(v: any[]): void;
-    /** Apply cross-input consistency rules (a quill editor implies a quill viewer). */
+    onM2MValuesChanges(v: DataModel[]): void;
+    /**
+     * Apply cross-input consistency rules.
+     *
+     * Nothing to reconcile at the moment: the one rule that lived here paired the
+     * `quill` editor with the `quill` viewer, and neither exists any more. Kept
+     * as the place such rules belong, since `_init` already calls it.
+     */
     private _checks;
     /**
      * Save value to database, only if model have an id.
@@ -3945,6 +3970,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 +3996,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 +4015,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 +4079,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 +4126,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 +4144,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 +4155,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 +4173,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 +4205,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 +4231,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 +4484,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 +4559,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 +4738,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 +4763,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 +4784,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 +4832,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 +4951,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 +5019,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 +5037,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 +5051,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 +5116,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 +5135,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 +5147,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 +5160,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 +5292,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 +5305,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 +5468,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 +5514,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 +5528,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 +5592,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 +5600,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 +5717,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 +5750,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 +5777,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 +5807,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 +5816,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 +5833,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 +5866,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 +5983,197 @@ 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;
+
+/**
+ * The behaviour `<data-richedit>` and `<data-mdedit>` share with
+ * `<data-dispedit>`: show the value, click to edit, save explicitly.
+ *
+ * It lives in the primary entry point so both editors can extend it — they
+ * import `@solidev/data`, and the reverse would be a circular dependency
+ * between entry points. Everything here is engine-agnostic: resolving which
+ * field to read, which control to bind, when to show the editor, and how to
+ * persist. The subclass owns its template and its editor widget.
+ *
+ * ## The source / rendered pair
+ *
+ * Long text is rarely one column. A markdown field is stored as its source
+ * plus the HTML the server rendered from it, and this base follows that shape
+ * by convention: given `field="description"` it edits `description_src` and
+ * displays `description_html` **when the model declares them**, and falls back
+ * to `description` for both when it does not. `[htmlField]` overrides the
+ * display half outright. A `field` that already ends in `_src` is understood,
+ * so `field="description_src"` resolves the same pair.
+ */
+declare abstract class FieldEditorBase<FT, T extends DataModel> implements OnInit {
+    /** Id tying the label to the editor. */
+    readonly inputId: string;
+    /** Id of the label element, wired to the editor through `aria-labelledby`. */
+    readonly labelId: string;
+    /** Model instance holding the field. */
+    model: _angular_core.InputSignal<T | undefined>;
+    /**
+     * Field to edit, or the base name of a source / rendered pair.
+     *
+     * See the class description for how `<field>_src` and `<field>_html` are
+     * resolved.
+     */
+    field: _angular_core.InputSignal<string | undefined>;
+    /** Overrides the field read for the read-only display. */
+    htmlField: _angular_core.InputSignal<string | undefined>;
+    /** Whether {@link toggleEdit} is allowed to reveal the editor. */
+    editable: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether the editor is showing, in `dd` mode.
+     *
+     * Defaults to false: the value renders and a click reveals the editor, the
+     * way `<data-dispedit>` behaves. `inline` and `form` modes ignore this and
+     * follow {@link showEditor}.
+     */
+    edit: _angular_core.ModelSignal<boolean>;
+    /**
+     * Layout, and whether {@link save} persists.
+     *
+     * `dd` renders a `<dt>`/`<dd>` block and is the only mode that saves to the
+     * API; `inline` and `form` render a label plus the editor and leave saving to
+     * the caller.
+     */
+    mode: _angular_core.InputSignal<"inline" | "dd" | "form">;
+    /** Hide label (for inline forms). */
+    hideLabel: _angular_core.InputSignal<boolean>;
+    /**
+     * Hide the built-in save button, for callers driving persistence themselves
+     * from the {@link changed} output.
+     */
+    hideButton: _angular_core.InputSignal<boolean>;
+    /**
+     * Form control backing the editor.
+     *
+     * When supplied, the component uses it as-is and skips its own setup — no
+     * field manager lookup, no seeding from the model, and no {@link changed}
+     * emissions. Takes precedence over `[form]`.
+     */
+    fc: _angular_core.InputSignal<FormControl<string | null> | undefined>;
+    /**
+     * External form group to register into, the way `<data-dispedit>` does.
+     *
+     * A control named after the resolved source field is added to it, seeded
+     * from the model. Ignored when `[fc]` is supplied.
+     */
+    form: _angular_core.InputSignal<UntypedFormGroup | undefined>;
+    /** Emits the value on every change. Not wired for a caller-supplied `[fc]`. */
+    changed: _angular_core.OutputEmitterRef<string | null>;
+    /** Field manager for the source field; only resolved when `fc` is created here. */
+    manager?: BaseFieldManager<FT>;
+    /** Whether the manager declares the field required. */
+    readonly required: _angular_core.WritableSignal<boolean>;
+    /** The control actually in use. */
+    control: FormControl<string | null>;
+    /** The base name of the pair, with any trailing `_src` removed. */
+    private readonly baseField;
+    /** The field actually edited. */
+    readonly sourceField: _angular_core.Signal<string>;
+    /** The field actually displayed in read-only mode. */
+    readonly displayField: _angular_core.Signal<string>;
+    /**
+     * Whether the editor is showing rather than the rendered value.
+     *
+     * The rule is `<data-dispedit>`'s: `dd` follows `[edit]`, `inline` shows the
+     * editor unless the field is not editable, and `form` always shows it — a
+     * form control that renders as static text would be a surprise.
+     */
+    readonly showEditor: _angular_core.Signal<boolean>;
+    /**
+     * Resolve the control: the supplied `[fc]`, one registered into `[form]`, or
+     * one of our own seeded from the model.
+     */
+    ngOnInit(): void;
+    /**
+     * Switch between the rendered value and the editor.
+     * Does nothing when `[editable]` is false.
+     */
+    toggleEdit(): void;
+    /**
+     * The rendered value, as stored on the display field.
+     *
+     * Templates pass it through {@link SafeHtmlPipe} to inject it — **trusted,
+     * not sanitized**, because Angular's sanitizer allow-list has no `style` and
+     * would drop the alignment and colours the rich text editor writes. Point
+     * these components at fields your own editor produced and your own API
+     * stored.
+     */
+    displayValue(): string;
+    /**
+     * Write the editor content back to the model's source field, and persist it
+     * in `dd` mode only.
+     *
+     * In `inline` / `form` modes the model is updated in memory but no request is
+     * sent, leaving the save to the surrounding form. Does nothing without both a
+     * `[model]` and a `[field]`.
+     */
+    save(): Promise<void>;
+    /** Whether the model declares a property under that name. */
+    private modelHas;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldEditorBase<any, any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FieldEditorBase<any, any>, never, never, { "model": { "alias": "model"; "required": false; "isSignal": true; }; "field": { "alias": "field"; "required": false; "isSignal": true; }; "htmlField": { "alias": "htmlField"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "edit": { "alias": "edit"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "hideLabel": { "alias": "hideLabel"; "required": false; "isSignal": true; }; "hideButton": { "alias": "hideButton"; "required": false; "isSignal": true; }; "fc": { "alias": "fc"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; }, { "edit": "editChange"; "changed": "changed"; }, never, never, true, never>;
+}
+
+/**
+ * Marks HTML as trusted, so `[innerHTML]` renders it as-is.
+ *
+ * Meant for the rendered half of a rich text field — the `<field>_html` column
+ * the server produces from the markdown or HTML source. Angular's sanitizer
+ * builds its allow-list from `URI_ATTRS + HTML_ATTRS + ARIA_ATTRS`, and `style`
+ * is in none of them, so a plain `[innerHTML]` silently drops every
+ * `text-align` and every colour `<data-richedit>` writes: read-only mode ends
+ * up looking nothing like the editor.
+ *
+ * **Only use it on HTML the server produced.** The value is inserted without
+ * any filtering, and trusted HTML executes scripts — pointing this at a string
+ * a user of another system can influence is an XSS vector.
+ *
+ * @example
+ * ```html
+ * <div [innerHTML]="product.description_html | safeHtml"></div>
+ * ```
+ */
+declare class SafeHtmlPipe implements PipeTransform {
+    private _sanitizer;
+    /**
+     * @param value HTML to trust; null for a nullish or empty input, which
+     *   `[innerHTML]` renders as nothing.
+     */
+    transform(value: string | null | undefined): SafeHtml | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SafeHtmlPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<SafeHtmlPipe, "safeHtml", true>;
+}
+
 /**
  * Compiles (and optionally renders) an Underscore-style string template, using ERB
  * delimiters: `<%= expr %>` interpolates, `<% code %>` evaluates, and a `print()` helper
@@ -5980,7 +6189,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 +6210,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 +6247,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, FieldEditorBase, 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, SafeHtmlPipe, 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 };