@optionfactory/fml 9.0.0-rc3 → 9.0.0-rc30

package/dist/ful.d.mts

@@ -1,25 +1,55 @@
 import { ParsedElement } from './ftl.mjs';
-declare const LocalStorage: {
-    save: (k: any, v: any) => void;
-    load: (k: any) => any;
-    remove: (k: any) => void;
-    pop: (k: any) => any;
-};
-declare const SessionStorage: {
-    save: (k: any, v: any) => void;
-    load: (k: any) => any;
-    remove: (k: any) => void;
-    pop: (k: any) => any;
-};
-declare const VersionedLocalStorage: {
-    save(key: any, revision: any, data: any): void;
-    load(key: any, revision: any): any;
+import { HttpClient } from './httpc.mjs';
+export type JsonStorage = {
+    /**
+     * stores `JSON.stringify(v)`
+     * under `k`, throwing what the encoding or the storage throws: an unreachable
+     * storage, a full quota, a value json cannot encode
+     */
+    save: (k: string, v: any) => void;
+    /**
+     * the value stored under `k`, decoded;
+     * undefined when there is none, when the storage cannot be reached, or when the
+     * stored text is not json, in which case the entry is also removed
+     */
+    load: (k: string) => any;
+    /**
+     * removes the entry under `k`
+     */
+    remove: (k: string) => void;
+    /**
+     * what `load` answers for `k`, removing the
+     * entry
+     */
+    pop: (k: string) => any;
 };
-declare const VersionedSessionStorage: {
-    save(key: any, revision: any, data: any): void;
-    load(key: any, revision: any): any;
+export type VersionedJsonStorage = {
+    /**
+     * stores
+     * `data` with `revision` under `key`, throwing what `JsonStorage.save` throws
+     */
+    save: (key: string, revision: string, data: any) => void;
+    /**
+     * the data stored under
+     * `key` when it was saved with this exact revision; otherwise undefined, and the
+     * entry is removed, whether it holds another revision, holds no revision at
+     * all, or is missing
+     */
+    load: (key: string, revision: string) => any;
 };
+/** `localStorage`, holding json. */
+declare const LocalStorage: JsonStorage;
+/** `sessionStorage`, holding json. */
+declare const SessionStorage: JsonStorage;
+/** `localStorage`, holding json beside a revision. */
+declare const VersionedLocalStorage: VersionedJsonStorage;
+/** `sessionStorage`, holding json beside a revision. */
+declare const VersionedSessionStorage: VersionedJsonStorage;
 export type AsyncExtension = {
+    /**
+     * one per `asyncOn` listener the event
+     * reached, in the order they ran
+     */
     promises: Promise<any>[];
 };
 export type AsyncEvent = Event & {
@@ -27,7 +57,8 @@ export type AsyncEvent = Event & {
 };
 /**
  * @typedef {Object} AsyncExtension
- * @property {Promise<any>[]} promises
+ * @property {Promise<any>[]} promises one per `asyncOn` listener the event
+ * reached, in the order they ran
  * @typedef {Event & { async?: AsyncExtension }} AsyncEvent
  */
 /**
@@ -38,42 +69,80 @@ export type AsyncEvent = Event & {
  */
 declare class AsyncEvents {
     /**
-     * Dispatches an event and handles asynchronous resolution based on the execution mode.
-     * @param {HTMLElement} el - The target element dispatching the event.
-     * @param {AsyncEvent} evt - The event instance.
-     * @param {{mode?: 'broadcast' | 'pipeline' | 'delegate'}} [options] - Configuration options (defaults to 'broadcast').
-     * @returns {Promise<any>} Resolves with an array of values for broadcasts, a single value for pipelines/delegates, or undefined.
+     * Dispatches `evt` on `el` synchronously, then waits for the answers of the
+     * `asyncOn` listeners it reached, on `el` or, for a bubbling event, on its
+     * ancestors. Listeners added with a plain `addEventListener` run but are not
+     * awaited. In `broadcast` mode, the default, it resolves with every answer
+     * in the order the listeners ran, an empty array when none did. In
+     * `pipeline` mode it accepts at most one listener and resolves with its
+     * answer, or undefined when none ran. In `delegate` mode it requires exactly
+     * one listener and resolves with its answer.
+     * @param {HTMLElement} el the element to dispatch on
+     * @param {AsyncEvent} evt the event to dispatch
+     * @param {{mode?: 'broadcast' | 'pipeline' | 'delegate'}} [options]
+     * @returns {Promise<any>} the answer or answers as the mode describes
+     * @throws what the first answer to fail threw or rejected with; or an
+     * Error naming the event and the mode when `pipeline` reached more than one
+     * listener or `delegate` did not reach exactly one, in which case the
+     * listeners have already run and their outcome is discarded. Both arrive as
+     * the rejection of the returned promise.
      */
     static fireAsync(el: HTMLElement, evt: AsyncEvent, options?: {
         mode?: 'broadcast' | 'pipeline' | 'delegate';
     }): Promise<any>;
     /**
-     * Registers an asynchronous event listener wrapper.
-     * @param {HTMLElement} el - The target element.
-     * @param {string} type - The event name/type.
-     * @param {Function} fn - The async listener middleware function returning the execution result.
-     * @param {AddEventListenerOptions} [options] - Native addEventListener options.
-     * @returns {EventListener} The underlying proxy listener function needed for cleanup via asyncOff.
+     * Adds a listener whose answer `fireAsync` can await. When the event
+     * reaches it, the listener attaches a promise to `evt.async.promises`,
+     * creating the list when it is the first, then calls `fn` with the event;
+     * the promise settles with what `fn` returns or throws, awaited when it is a
+     * promise. The event is dispatched the usual way, so an event fired with a
+     * plain `dispatchEvent` runs `fn` too, and nobody awaits its answer.
+     * @param {HTMLElement} el the element to listen on
+     * @param {string} type the event type
+     * @param {(evt: any) => any} fn called with the event; its result is the answer
+     * @param {AddEventListenerOptions} [options] passed to `addEventListener`
+     * @returns {EventListener} the listener actually added, which `asyncOff` takes
      */
-    static asyncOn(el: HTMLElement, type: string, fn: Function, options?: AddEventListenerOptions): EventListener;
+    static asyncOn(el: HTMLElement, type: string, fn: (evt: any) => any, options?: AddEventListenerOptions): EventListener;
     /**
-     * Unregisters an asynchronous event listener proxy.
-     * @param {HTMLElement} el - The target element.
-     * @param {string} type - The event name/type.
-     * @param {EventListener} listener - The proxy listener instance previously returned by asyncOn.
-     * @param {EventListenerOptions} [options] - Native removeEventListener options.
+     * Removes a listener added by `asyncOn`.
+     * @param {HTMLElement} el the element it listens on
+     * @param {string} type the event type it was added for
+     * @param {EventListener} listener what `asyncOn` returned, not the `fn` given to it
+     * @param {EventListenerOptions} [options] passed to `removeEventListener`
+     * @returns {void}
      */
     static asyncOff(el: HTMLElement, type: string, listener: EventListener, options?: EventListenerOptions): void;
     /**
-     * Mixes the asynchronous execution engine extensions into target class prototypes.
-     * @param {...Function} classes - The target class constructors to decorate.
+     * Assigns `fireAsync(evt, options)`, `asyncOn(type, fn, options)` and
+     * `asyncOff(type, listener, options)` onto each class's prototype, each
+     * calling the static of the same name with the instance as the element.
+     * Members of those names already on the prototype are overwritten.
+     * @param {...Function} classes the classes to extend
+     * @returns {void}
      */
     static mixInto(...classes: Function[]): void;
 }
+/**
+ * Asks before the page is left, through the browser's own `beforeunload`
+ * prompt.
+ */
+declare class PageLeave {
+    /**
+     * Asks before the page is left while `isDirty()` answers true, until
+     * `signal` aborts. The browser words the prompt, and asks only once the
+     * user has interacted with the page.
+     * @param {() => boolean} isDirty
+     * @param {AbortSignal} [signal]
+     */
+    static guard(isDirty: () => boolean, signal?: AbortSignal): void;
+}
 export type Claim = {
     readonly stale: boolean;
 };
 /**
+ * A hold on one generation of a `Claims`: `stale` turns true once a later
+ * `take()` or `invalidate()` on it starts a newer generation.
  * @typedef {{ readonly stale: boolean }} Claim
  */
 /**
@@ -99,50 +168,95 @@ declare class Claims {
      * @returns {Claim}
      */
     hold(): Claim;
-    /** Supersedes every claim without holding a new one. */
+    /**
+     * Supersedes every claim without holding a new one.
+     * @returns {void}
+     */
     invalidate(): void;
 }
+export type Describable = {
+    describedBy(el: HTMLElement): boolean;
+};
 /**
- * Sleeping, debouncing and throttling. Debounce and throttle both return the
- * wrapped function together with a cancel function.
+ * Something that adds elements to the accessible description of the control it
+ * owns, such as a field: `describedBy(el)` adds `el` to the control's
+ * `aria-describedby` and answers whether it did.
+ * @typedef {{ describedBy(el: HTMLElement): boolean }} Describable
+ */
+/**
+ * The nearest ancestor of `el` that has a `describedBy` method. Content
+ * slotted inside a field does not write the control's `aria-describedby`
+ * itself: once it has something to offer, it hands the element carrying the
+ * words to the `describedBy` of the ancestor this answers.
+ * @param {Element} el
+ * @returns {(Element & Describable) | null} null when no ancestor has one
+ */
+declare const describable: (el: Element) => (Element & Describable) | null;
+/**
+ * Sleeping, debouncing and throttling. `debounce` and `throttle` both return
+ * the wrapped function together with an abort function, which cancels the call
+ * pending and leaves the wrapped function working.
  */
 declare class Timing {
-    /** Resolves after the given milliseconds. @param {number} ms */
-    static sleep(ms: number): Promise<any>;
     /**
-     * Executes only after a period of inactivity (pause in events).
-     * Respond to the "end" of a series of events.
+     * @param {number} ms
+     * @returns {Promise<void>} resolving after `ms` milliseconds
+     */
+    static sleep(ms: number): Promise<void>;
+    /**
+     * Collapses a burst of calls into one call of `func`, a burst ending once
+     * `timeoutMs` pass without a call. By default `func` is called at the end
+     * of the burst with the arguments of its last call. With `immediate` it is
+     * called at the first call of a burst, with that call's arguments, and not
+     * at the end. Without `immediate`, a call the wrapped function receives
+     * from inside `func` starts a new burst.
      * @param {number} timeoutMs
-     * @param {function} func
-     * @param {{ immediate?: boolean }} [options] - immediate fires on the leading edge instead of the trailing one
-     * @returns {[function, function]}
+     * @param {(...args: any[]) => any} func
+     * @param {{ immediate?: boolean }} [options]
+     * @returns {[(...args: any[]) => void, () => void]} the wrapped function
+     * and the abort function
      */
-    static debounce(timeoutMs: number, func: Function, options?: {
+    static debounce(timeoutMs: number, func: (...args: any[]) => any, options?: {
         immediate?: boolean;
-    }): [Function, Function];
+    }): [(...args: any[]) => void, () => void];
     /**
-     * Executes at most once per specified time interval, regardless of ongoing events.
+     * Calls `func` at most once per `timeoutMs`, always with the arguments of
+     * the latest call. With `leading`, on by default, a call arriving once the
+     * interval since the previous call of `func` has passed calls it at once;
+     * without it, the first call only starts the interval. With `trailing`, on
+     * by default, a call arriving inside the interval schedules `func` for the
+     * interval's end; without it, such a call is dropped.
      * @param {number} timeoutMs
-     * @param {function} func
-     * @param {{ leading?: boolean, trailing?: boolean }} [options] - which edges of the interval call, both by default
-     * @returns {[function, function]}
+     * @param {(...args: any[]) => any} func
+     * @param {{ leading?: boolean, trailing?: boolean }} [options]
+     * @returns {[(...args: any[]) => void, () => void]} the wrapped function
+     * and the abort function
      */
-    static throttle(timeoutMs: number, func: Function, options?: {
+    static throttle(timeoutMs: number, func: (...args: any[]) => any, options?: {
         leading?: boolean;
         trailing?: boolean;
-    }): [Function, Function];
+    }): [(...args: any[]) => void, () => void];
 }
-/** Field wiring: extracting and filling values, pinning problems to the fields they name. */
+/**
+ * Moves values between a form's named controls and a nested object, and pins
+ * problems onto the controls they name. Works on any native form, not only
+ * the one inside a `ful-form`. Every method reads the controls through
+ * `form.elements`, so a control in the subtree that belongs to another form
+ * (a nested form, a `form` attribute pointing elsewhere) is never read,
+ * written or marked.
+ */
 declare class Bindings {
     #private;
     /**
-     * Flattens a nested object into dotted keys, stopping wherever `stops` names
-     * a key: a field named `address` takes the whole object, while one named
-     * `address.city` takes the leaf.
+     * Flattens a nested object into dotted keys, array indexes becoming numeric
+     * segments (`a.0.b`). It does not descend below a key that `stops` names, so
+     * with a field named `address` the whole object is kept under `address`,
+     * while with one named `address.city` the leaf is kept under `address.city`.
+     * A null value is kept as a leaf.
      * @param {{ [x: string]: any; }} obj
-     * @param {string} prefix
-     * @param {Set<String>} stops - the names the form actually has fields for
-     * @return {{ [x: string]: any; }}
+     * @param {string} prefix prepended to every key, `''` at the root
+     * @param {Set<string>} stops the dotted keys to keep whole
+     * @returns {{ [x: string]: any; }} a flat object keyed by dotted path
      */
     static flatten(obj: {
         [x: string]: any;
@@ -151,19 +265,37 @@ declare class Bindings {
     };
     /**
      * Writes a value into an object at a dotted path, creating the intermediate
-     * objects and arrays the path implies. A numeric segment makes an array.
-     * @param {any} result
-     * @param {string} path - a field name, `a.b` or `a[0].b`
+     * objects and arrays the path implies: a numeric segment makes its container
+     * an array. Brackets are not parsed, so `a[0]` is a plain key.
+     *
+     * An undefined value declares the path without filling it: an entry already
+     * there is kept, a missing one is set to null. A scalar or a null left on the
+     * path by a shorter overlapping name (`a` written before `a.b`) is replaced
+     * by a container, so the longer name wins whichever order they arrive in.
+     * @param {any} result the object or array to write into
+     * @param {string} path a dotted name such as `a.b` or `a.0.b`
      * @param {any} value
+     * @returns {any} the root written into, to be used in place of `result`: a
+     * new array replaces it when the first segment is numeric and `result` is
+     * not an array
+     * @throws {Error} when a segment is `__proto__`, `prototype` or `constructor`,
+     * before anything is written
      */
     static providePath(result: any, path: string, value: any): any;
     /**
-     * Reads one control's value the way its kind demands: an unchecked radio
-     * answers undefined so it contributes nothing, a checkbox answers its
-     * checked state, a multiple select answers its selected values, and a blank
-     * native control answers null rather than an empty string.
+     * Reads one control's value by its kind. The kind is read from the `type`
+     * attribute and the tag, so a ful element answers its own `value`.
+     *
+     * - a radio answers its `value` when checked and undefined otherwise
+     * - a checkbox answers its `checked` state
+     * - `data-ful-bind-type="boolean"` decodes the value: a radio answers
+     *   whether its value is `'true'`, any other control answers null when
+     *   blank and whether its value is `'true'` otherwise
+     * - a multiple select answers the array of its selected values
+     * - a native input, select or textarea answers null when blank
+     * - anything else answers its `value` unchanged
      * @param {Element & {dataset?: any} & {checked?: boolean} & {value?: any}} el
-     * @returns {any} the value, or undefined where the control contributes none
+     * @returns {any} the value; undefined for an unchecked radio
      */
     static extract(el: Element & {
         dataset?: any;
@@ -172,13 +304,32 @@ declare class Bindings {
     } & {
         value?: any;
     }): any;
-    static extractFrom(form: any, submitter: any): {};
     /**
-     * Writes a value into one control, the inverse of `extract`: a radio is
-     * checked when its own value matches, a checkbox takes the value as its
-     * checked state, and a multiple select selects the options the list names.
+     * Reads the form's named controls into a nested object, the dotted names
+     * deciding its shape (see `providePath`) and each value read by `extract`.
+     * Controls are read in document order, so of two overlapping names the
+     * later one decides. A control is skipped when it has no `name`, when it
+     * matches `:disabled` (its own `disabled` or a disabled fieldset's), or when
+     * it is a submit, reset or plain button. The submitter is the exception to
+     * both of the last two: it contributes its name and value even while
+     * disabled.
+     * @param {HTMLFormElement} form
+     * @param {HTMLElement} [submitter] the button that submitted, when there is one
+     * @returns {any} the nested values; an array when the first segment of a name is numeric
+     * @throws {Error} when a name has a segment `providePath` refuses
+     */
+    static extractFrom(form: HTMLFormElement, submitter?: HTMLElement): any;
+    /**
+     * Writes a value into one control, the inverse of `extract`.
+     *
+     * - a radio is checked when `raw` is not null and its `value` attribute
+     *   equals `String(raw)`, so a number or a boolean matches its text
+     * - a checkbox takes `raw` as its `checked` state
+     * - a multiple select selects the options whose value is in `raw`, compared
+     *   as text: an array selects each entry, a scalar selects one, null selects none
+     * - anything else takes `raw` as its `value`
      * @param {Element & {dataset?: any} & {checked?: boolean} & {value?: any}} el
-     * @param {any} raw the value as it arrived, coerced per control kind
+     * @param {any} raw
      */
     static mutate(el: Element & {
         dataset?: any;
@@ -187,8 +338,60 @@ declare class Bindings {
     } & {
         value?: any;
     }, raw: any): void;
-    static mutateIn(form: any, values: any): void;
-    static errors(form: any, es: any, scrollOnError: any): void;
+    /**
+     * Writes a nested object onto the form's named controls: the object is
+     * flattened with the control names as stops (see `flatten`), and each key
+     * is written by `mutate` into every control carrying exactly that name. A
+     * key naming no control is ignored, and a control the object does not name
+     * keeps its value.
+     * @param {HTMLFormElement} form
+     * @param {{ [x: string]: any; }} values
+     */
+    static mutateIn(form: HTMLFormElement, values: {
+        [x: string]: any;
+    }): void;
+    /**
+     * Shows problems on the form, replacing whatever the previous call showed.
+     *
+     * Every named control's custom validity is first cleared. A problem whose
+     * `type` is `FIELD_ERROR` or `INVALID_FORMAT` and whose `context` is not
+     * empty is pinned to a control: brackets in the context are turned into
+     * dots (`users[0].name` becomes `users.0.name`), and the longest leading
+     * part of it that names a control wins, so an exact field takes the problem
+     * alone and a composite field named for a prefix catches the problems of its
+     * subtree. Each control of that name gets `setCustomValidity(reason, rest)`,
+     * `rest` being the remainder of the path (`''` on an exact match) that a
+     * composite can use to route the problem to an inner control. Several
+     * problems reaching one control with the same `rest` are joined one per
+     * line into a single call.
+     *
+     * A control counts only when it can show a problem, through a
+     * `setCustomValidity` of its own: a form-associated element that has none is
+     * skipped, so its problems fall to a shorter prefix or to the banner instead
+     * of being dropped.
+     *
+     * Every other problem, and a field problem naming no control, is shown in
+     * each `ful-errors` banner of the form: the banner gets `role="alert"`, is
+     * revealed and holds the reasons one per line. With no such problem the
+     * banner is emptied and hidden.
+     *
+     * Each `ful-field-error` of the form gets `aria-live="off"` when
+     * `scrollOnError` is set, since focusing the field announces its error, and
+     * `aria-live="polite"` otherwise. With `scrollOnError` and at least one
+     * problem, the topmost `:invalid` control is focused; a `<fieldset>`
+     * matching `:invalid` for the controls it holds is not a candidate.
+     *
+     * A banner or `ful-field-error` belongs to the nearest enclosing form, so
+     * those of a nested form are left alone.
+     * @param {HTMLFormElement} form
+     * @param {{ type: string; context?: string | null; reason: string; }[]} es the problems, as an httpc `Failure` carries them
+     * @param {boolean} scrollOnError
+     */
+    static errors(form: HTMLFormElement, es: {
+        type: string;
+        context?: string | null;
+        reason: string;
+    }[], scrollOnError: boolean): void;
 }
 /**
  * The base of every form-associated ful field: a form-associated custom element
@@ -197,181 +400,339 @@ declare class Bindings {
  *
  * A subclass owns its template, its value semantics and its change events. It
  * implements `_build(conf)`, which builds its dom and returns the pieces the
- * base drives: the control, the error region, the label, and the optional
- * `claims`, `announces`, `freeze` and `also`. The base does the wiring,
- * the mounting and the application of the declared state. Nothing in the base
- * is there to be called from a subclass's build.
- *
- * The pieces are the contract: the claim setters, the validity protocol and
- * the aria wiring all act on them, so a field with no native control returns a
- * focusable piece of its own chrome as the control. The getters and `focus()`
- * are the only members that tolerate a not-yet-rendered element, where page
- * code may read a claim or ask for the focus before the upgrade; the
- * properties go live only after the render, as ParsedElement documents. The
- * base references no ful vocabulary, only what its subclasses return to it.
+ * base drives (see `_build`), and the `value` pair. The base wires the pieces,
+ * mounts the fragment and applies the declared state. Nothing in the base is
+ * there to be called from a subclass's build.
+ *
+ * The claim setters, the validity protocol and the aria wiring all act on the
+ * pieces, so a field with no native control returns a focusable piece of its
+ * own chrome as the control. The claims, `value` and `focus()` are the
+ * members that tolerate a not yet rendered element: before the render the
+ * `value` getter answers what the rendered field would answer from its current
+ * declared state, and a value written then is held and applied by the render
+ * (see `_holdValue`). The other members need the pieces and so work only after
+ * the render.
+ *
+ * The inner controls carry `form=""`, so the host is the only element the form
+ * sees. Enter pressed in an inner `<input>` of any type but `file`, `button`,
+ * `submit`, `reset` and `image` submits the field's form through
+ * `_requestSubmit()`, as Enter in a native input would. It does not when a
+ * listener inside the field already called `preventDefault()` on the keydown,
+ * while an input method is composing, or when the input is still associated
+ * with the form itself and so submits on its own.
  */
 declare class Field extends ParsedElement {
     #private;
     static formAssociated: boolean;
     /**
-     * The claim attributes and the value are observed here so every field,
-     * including the custom ones, keeps them live after the upgrade: the
-     * attribute is a third way to author a claim, beside the markup and the
-     * property,
-     * exactly as a native input's. The value defaults to the string mapper and
-     * every field with its own vocabulary overrides it (`value:bool`,
-     * `value:csv`, `value:json`).
+     * The claim attributes and the value, observed so that every field,
+     * including a custom one that never lists them, keeps them live after the
+     * upgrade. A subclass's own `static observed` adds to this list. The value
+     * is read with the string mapper; a field with another vocabulary redeclares
+     * it with its own (`value:bool`, `value:csv`, `value:json`).
+     * @type {string[]}
      */
     static observed: string[];
-    /** the role the element internals carry, 'presentation' unless the control is its own */
+    /**
+     * The role set on the element internals at construction. A field whose host
+     * is the widget itself overrides it, as `RadioGroup` does with `'radiogroup'`.
+     * @type {string}
+     */
     static ROLE: string;
+    /** Sets the internals' role from the subclass's `static ROLE`. */
     constructor();
-    focus(options: any): void;
-    /**
-     * Clears or reports one validation problem: the text lands on the field's
-     * live region and the state on the element internals, driving `:invalid`
-     * styling. Validation is the server's: the submit travels regardless, and
-     * the problems come back pinned here. The error mapping pins on the most
-     * specific field name a problem's context reaches, handing over the
-     * remaining path ('' on an exact match): the base ignores it, a composite
-     * field owning a whole subtree overrides to route the problem to the inner
-     * control it names.
-     * @param {string} [error]
-     * @param {string} [context] the path below this field's name, '' when exact
+    /**
+     * Adds an element to the accessible description of the field and answers
+     * whether the field took it.
+     *
+     * The field takes a description before its own render as readily as after:
+     * one handed over early is written as soon as the field has rendered, so the
+     * caller does not need to know which of the two upgraded first. The element
+     * is given an id (`ful-described-*`) when it has none, is added once however
+     * often it is offered, and is referenced from the `aria-describedby`
+     * attribute of the `described` piece (the control by default). The
+     * descriptions come in the order they were offered, the error region always
+     * last.
+     *
+     * Pass the element that carries the words rather than a wrapper around it:
+     * a hidden element is part of a description only where it is referenced
+     * directly, so a popover that is closed until opened must be passed itself.
+     *
+     * This is the field's half of the description protocol; `describable` in
+     * `ful/descriptions.mjs` is the half the content uses to find the field.
+     * @param {HTMLElement | null | undefined} el
+     * @returns {boolean} false only when `el` is missing
+     */
+    describedBy(el: HTMLElement | null | undefined): boolean;
+    /**
+     * Moves the focus to the `control` piece. Asked before the render, the
+     * request is kept (the last one wins) and applied once the control is
+     * mounted.
+     * @param {FocusOptions} [options]
+     */
+    focus(options?: FocusOptions): void;
+    /**
+     * Clears or reports one validation problem. A message sets a custom error on
+     * the element internals, which makes the host match `:invalid`, renders the
+     * message into the `error` piece and sets `aria-invalid="true"` on the
+     * `announces` piece, or on the `control` when the field announces nowhere.
+     * An empty or missing message clears all three.
+     *
+     * Validation is the server's: the submit is sent regardless, and the form's
+     * error mapping calls this with the problems that come back. It calls the
+     * field with the most specific name a problem's context reaches and passes
+     * the rest of the path as `context`. The base ignores `context`; a composite
+     * field owning a whole subtree overrides this to route the message to the
+     * inner control the path names.
+     *
+     * Needs the render: before it there is no error region to write to.
+     * @param {string} [error] the message, empty or missing to clear
+     * @param {string} [context] the path below this field's name, '' on an exact match
      */
     setCustomValidity(error?: string, context?: string): void;
-    /** Submits the associated form through its first submitter, as Enter on a native control would. */
+    /**
+     * The form the platform associated the field with, as a native control's
+     * own `form`.
+     * @returns {HTMLFormElement | null} null outside a form
+     */
+    get form(): HTMLFormElement | null;
+    /**
+     * Submits the associated form with `requestSubmit`, so constraint validation
+     * and the `submit` event run as for a user's submit. The submitter is the
+     * first enabled `button` or `input` of type `submit` in the form whose own
+     * `form` is that form; with none the form is submitted without one. Does
+     * nothing outside a form.
+     */
     _requestSubmit(): void;
     /**
-     * Dispatches the field's change event: bubbling, not cancelable, the value
-     * in the detail. Every field announces through this one method, and the detail
-     * always carries the field's own `value`, so a listener can rely on
-     * `el.value === evt.detail.value` whatever the field is. A field with more to
-     * say adds keys beside it; none can replace it.
-     * @param {Record<string, any>} [extras]
+     * Dispatches the field's `change` event on the host: bubbling, not
+     * cancelable, with `{ value: this.value, ...extras }` as the detail. Call it
+     * for a change the user made. Every field in the library announces through this method and
+     * passes no `value` key in `extras`, so a listener can rely on
+     * `el.value === evt.detail.value`. The extras are spread after `value`, so a
+     * `value` key among them would replace it.
+     * @param {Record<string, any>} [extras] further detail keys beside `value`
      */
     _notifyChange(extras?: Record<string, any>): void;
     /**
-     * Whether the field's chrome should answer a gesture. Badges, dropzones,
-     * menus and labels are not form controls, so their handlers must ask the
-     * effective state: matches(':disabled') covers the fieldset ancestry the
-     * disabled property deliberately does not reflect, readonly the field's
-     * own claim.
+     * Whether the field's own chrome should act on a gesture. Badges, dropzones,
+     * menus and labels are not form controls, so the platform does not disable
+     * them: every handler on them asks this first. False while the host matches
+     * `:disabled`, which covers a disabled `<fieldset>` ancestry as well as the
+     * claim, or while the readonly claim holds.
+     * @returns {boolean}
      */
     _interactive(): boolean;
     /**
-     * The field's value: every concrete field owns its semantics and overrides
-     * this pair. The base pair exists so the form integration (the reset
-     * protocol among others) has a member to write through; a custom field
-     * forgetting its own keeps the base's inert one.
+     * Upgrades as `ParsedElement.upgrade` does, then writes the value held by
+     * `_holdValue`, if any, through the `value` setter: the value written
+     * before the render wins over the declared one.
+     * @returns {Promise<void>} rejecting with what the render threw
+     */
+    upgrade(): Promise<void>;
+    /**
+     * Keeps a value written before the field has its control, for a subclass's
+     * `value` setter to call in place of writing it: the upgrade writes it
+     * through the setter once the field has rendered, over the declared one.
+     * The `value` attribute is left alone, so a reset still restores it.
+     * @param {any} value
+     */
+    _holdValue(value: any): void;
+    /**
+     * The value a subclass's `value` getter shapes before the field has its
+     * control: the one `_holdValue` kept, else the declared `value` attribute
+     * read through its mapper.
+     * @returns {any}
+     */
+    _heldValue(): any;
+    /**
+     * The field's value, `null` when empty. Every concrete field overrides the
+     * pair with its own semantics; the form extraction, `values =` assignment,
+     * the `change` detail and `formResetCallback` all go through it. The base
+     * pair reads `undefined` and ignores writes. A concrete field answers and
+     * takes its value before the render too, through `_heldValue` and
+     * `_holdValue`.
      * @type {any}
      */
     get value(): any;
     set value(v: any);
     /**
-     * A reset restores the field's declared value, as a native control's reset
-     * restores its markup default: the `value` attribute goes back through the
-     * element's own mapper and value setter, so every field resets through its
-     * own semantics. A field whose value is not attribute backed overrides this.
+     * Restores the declared value on a form reset, as a native control restores
+     * its markup default: the current `value` attribute is decoded with the
+     * element's own mapper and written through the `value` setter. A field whose
+     * value is not attribute backed overrides this.
      */
     formResetCallback(): void;
     /**
-     * The disabled protocol follows the semantics of a native form control:
+     * The field's own disabled claim, which follows a native form control:
      *
-     * - the `disabled` attribute on the host is the field's own claim, and nothing
-     *   but its author ever writes or removes it, in markup or through the
-     *   property. The framework never claims on the form's behalf, so there is
-     *   nothing to unclaim and nothing to lose: a field declared disabled inside
-     *   a disabled `<fieldset>` stays disabled when the fieldset comes back,
-     *   exactly like a native input keeps its attribute.
-     * - the effective state is the claim OR a disabled fieldset ancestry, which
-     *   the platform maintains on its own: `:disabled` matches both, a disabled
-     *   field is left out of the submitted values, and the inner native controls
-     *   are reached by the ancestry as descendants of the fieldset.
-     * - the property reflects the claim only, like a native input's: a field
-     *   disabled by its ancestry reads `false` while `matches(':disabled')`
-     *   tells the effective state. Un-claiming inside a disabled fieldset
-     *   cannot enable the field.
-     * - the inner controls mirror the claim and nothing else: the ancestry state
-     *   is never written anywhere, so it can never go stale, and the browser
-     *   composes the two on its own when it disables and re-enables a fieldset's
-     *   descendants. Subclass setters call super for the claim, then reach their
-     *   own controls, which mirror the claim like a native input's would.
-     *
-     * Because of this, formDisabledCallback carries nothing the framework needs
-     * to apply, and the protocol does not define it.
+     * - the `disabled` attribute on the host is the claim. Only the author writes
+     *   or removes it, in markup or through this property; the library never
+     *   claims on a form's or fieldset's behalf. A field declared disabled inside
+     *   a disabled `<fieldset>` stays disabled when the fieldset is re-enabled.
+     * - the effective state is the claim or a disabled `<fieldset>` ancestry:
+     *   `:disabled` matches both, and a disabled field is left out of the
+     *   submitted values.
+     * - the property reads the claim only: a field disabled by its ancestry reads
+     *   `false` while `matches(':disabled')` is true. Removing the claim inside a
+     *   disabled fieldset does not enable the field.
+     * - writing it sets or removes the `disabled` attribute on the `claims`
+     *   piece (the control by default) and on every `also` control. The
+     *   ancestry is never written anywhere: the browser disables those controls
+     *   as descendants of the fieldset. A subclass setter calls super, then
+     *   reaches any further controls of its own.
+     * @type {boolean}
      */
     get disabled(): boolean;
     set disabled(d: boolean);
     /**
-     * A field is readonly through its control's native readOnly when it has one:
-     * the control stays focusable and its text selectable, only editing is off.
-     * Fields whose chrome must freeze too (popovers, buttons, label clicks) name
-     * a `freeze` piece instead, whose gestures the base refuses while the claim
-     * holds; the claim reflects on the host either way.
+     * The readonly claim, read from the host attribute. Writing it sets
+     * `readOnly` on the `claims` piece (the control by default) and on every
+     * `also` control, sets `aria-readonly` on the `announces` piece, and
+     * reflects the attribute. A text control stays focusable and selectable
+     * with only editing off. A field whose control has no usable native
+     * `readOnly` names a `freeze` piece, whose clicks are cancelled while the
+     * claim holds.
+     * @type {boolean}
      */
     get readonly(): boolean;
     set readonly(v: boolean);
     /**
-     * A field is required through aria: the claim reflects on the host, the
-     * announcement lives on the adopted control.
+     * The required claim, read from the host attribute. Writing it sets
+     * `aria-required` on the `announces` piece and reflects the attribute; no
+     * native `required` is set, since validation is the server's.
+     * @type {boolean}
      */
     get required(): boolean;
     set required(d: boolean);
     /**
-     * The field's render is the base's: the subclass builds its dom in `_build`
-     * and hands back what it built, the base wiring the pieces, mounting the
-     * fragment and applying the declared state. Nothing in the base is there to
-     * be called from a subclass's build. `_build` may be async (a select
-     * awaiting its prefetch); a field that builds synchronously stays so.
+     * Calls `_build(conf)` and wires the pieces it answers. When `_build`
+     * returns a promise the pieces are wired once it settles; a field that
+     * builds synchronously renders synchronously.
+     * @param {{ slots: Record<string, DocumentFragment> | undefined }} conf
+     * @returns {void | Promise<void>}
      */
-    render(conf: any): Promise<void> | undefined;
+    render(conf: {
+        slots: Record<string, DocumentFragment> | undefined;
+    }): void | Promise<void>;
     /**
-     * Builds the field's dom and answers the pieces the base drives. The one
-     * method a concrete field implements beside its value pair, and the only
-     * place its dom is created; the base does the wiring and the mounting.
+     * Builds the field's dom and answers the pieces the base drives, or a
+     * promise of them. The one method a concrete field implements beside its
+     * value pair, and the only place its dom is created. A subclass extending
+     * another field's build spreads the pieces it answered and overrides the
+     * keys it owns.
      *
-     * - `fragment` is mounted on the host
-     * - `control` is the focusable target: focus, the aria and, by default, all
-     *   three claims reach it
-     * - `error` is the field's live region
-     * - `label`, when given, names the control and focuses it on click
-     * - `described` moves the error's description off the control and onto
-     *   another element, the host where no single control can carry it
-     * - `claims` moves the three claims onto a wrapper the field disables as a
-     *   whole, leaving focus and aria on the control
-     * - `announces` is the element whose role carries `aria-readonly` and
-     *   `aria-required`, the host where the widget role lives there; `null` for a
-     *   field whose control has no role that accepts them
-     * - `freeze` is for a field with no usable native readOnly: the readonly
-     *   claim refuses the gestures inside it, leaving it focusable and readable
-     * - `also` are further controls mirroring disabled and readOnly beside the
-     *   first
+     * - `fragment` (required) replaces the host's children.
+     * - `control` (required) is the focus target of `focus()`. By default it also
+     *   carries the description, `aria-invalid`, `aria-readonly`,
+     *   `aria-required`, and the mirrored `disabled` and `readOnly`.
+     * - `error` (required) is the live region `setCustomValidity` writes into.
+     *   It is given an id (`ful-field-error-*`) when it has none and is always
+     *   the last entry of the description.
+     * - `label` names the control. For a labelable control (`button`, `input`
+     *   other than hidden, `meter`, `output`, `progress`, `select`, `textarea`)
+     *   the control is given an id when it has none and the label's `for`
+     *   points at it, so a click on the label does what it does in a plain
+     *   form. For any other control the label is given an id, the control's
+     *   `aria-labelledby` points at it, and a click on the label calls `focus()`.
+     * - `described` carries `aria-describedby` in place of the control: the
+     *   host, for a field with no single control to describe.
+     * - `claims` receives the mirrored `disabled` and `readOnly` in place of the
+     *   control, for a wrapper such as a `<fieldset>` the field disables as a
+     *   whole. Focus and the aria stay on the control.
+     * - `announces` carries `aria-readonly`, `aria-required` and `aria-invalid`
+     *   in place of the control: the host, where the widget role lives there.
+     *   `null` for a field whose control has no role that accepts
+     *   `aria-readonly` and `aria-required`; `aria-invalid` then goes on the
+     *   control.
+     * - `freeze` is for a field with no usable native `readOnly`: a capturing
+     *   click listener on it cancels the default action of every click inside
+     *   it while the readonly claim holds. It stays focusable and in the
+     *   accessibility tree.
+     * - `also` are further controls that mirror `disabled` and `readOnly`
+     *   beside the claim target.
      *
-     * A subclass extending another field's build spreads the pieces it answered
-     * and overrides the keys it owns.
-     * @param {{slots: any}} conf
-     * @returns {any}
+     * The pieces are elements the field rendered itself, native controls or
+     * wrappers of its own. A ful field is not one: it has no `readOnly`, its
+     * host's role takes no aria, and a label's `for` names its host rather than
+     * its control. A composite built from ful fields answers the inner field as
+     * `control`, which forwards `focus()`, lets it render its own label with
+     * `label` and `announces` null, and forwards the claims in its setters,
+     * calling super first.
+     * @param {{ slots: Record<string, DocumentFragment> | undefined }} conf
+     * @returns {any} the pieces, or a promise of them
+     * @throws {Error} when the subclass does not implement it
      */
     _build(conf: {
-        slots: any;
+        slots: Record<string, DocumentFragment> | undefined;
     }): any;
 }
-/** Submits a form's values as json to a url, mapping the request and the response through the configured mappers. */
+/** Sends a form's request as a json body to a url, mapping the request and the response through the configured mappers. */
 declare class RemoteJsonFormLoader {
     #private;
-    constructor(http: any, url: any, method: any, requestMapper: any, responseMapper: any);
-    prepare(values: any, form: any): any;
-    submit(request: any, form: any): Promise<any>;
-    transform(response: any, form: any): any;
+    /**
+     * @param {{ request(method: string, url: string): { json(body: any): { fetch(): Promise<any> } } }} http the `http-client` component
+     * @param {string} url
+     * @param {string} method
+     * @param {(value: any, form: Form) => any} requestMapper
+     * @param {(value: any, form: Form) => any} responseMapper
+     */
+    constructor(http: {
+        request(method: string, url: string): {
+            json(body: any): {
+                fetch(): Promise<any>;
+            };
+        };
+    }, url: string, method: string, requestMapper: (value: any, form: Form) => any, responseMapper: (value: any, form: Form) => any);
+    /**
+     * @param {any} values
+     * @param {Form} form
+     * @returns {any} what the request mapper returns
+     */
+    prepare(values: any, form: Form): any;
+    /**
+     * @param {any} request
+     * @param {Form} form
+     * @returns {Promise<any>} what the client's `fetch()` resolves to: with the
+     * library's client, the `Response` of a 2xx status, rejecting with an
+     * `HttpClientError` (a `Failure`) otherwise
+     */
+    submit(request: any, form: Form): Promise<any>;
+    /**
+     * @param {any} response
+     * @param {Form} form
+     * @returns {any} what the response mapper returns
+     */
+    transform(response: any, form: Form): any;
 }
 /** Submits a form without a request: the request mapper produces the result the response mapper then reads, for a form handled entirely on the page. */
 declare class LocalFormLoader {
     #private;
-    constructor(requestMapper: any, responseMapper: any);
-    prepare(values: any, form: any): Promise<any>;
-    submit(request: any, form: any, response: any): Promise<any>;
-    transform(response: any, form: any): Promise<any>;
+    /**
+     * @param {(value: any, form: Form) => any} requestMapper
+     * @param {(value: any, form: Form) => any} responseMapper
+     */
+    constructor(requestMapper: (value: any, form: Form) => any, responseMapper: (value: any, form: Form) => any);
+    /**
+     * @param {any} values
+     * @param {Form} form
+     * @returns {Promise<any>} what the request mapper returns or resolves to
+     */
+    prepare(values: any, form: Form): Promise<any>;
+    /**
+     * Sends nothing.
+     * @param {any} request
+     * @param {Form} form
+     * @param {any} response what a `submit:requested` listener answered
+     * @returns {Promise<any>} `response`, unchanged
+     */
+    submit(request: any, form: Form, response: any): Promise<any>;
+    /**
+     * @param {any} response
+     * @param {Form} form
+     * @returns {Promise<any>} what the response mapper returns or resolves to
+     */
+    transform(response: any, form: Form): Promise<any>;
 }
 /**
  * Builds the form's loader from its attributes: a local one when no action is
@@ -384,121 +745,464 @@ declare class LocalFormLoader {
  * - `submit(request, form, response)` performs it and returns the response. The
  *   third argument is whatever a `submit:requested` listener already answered,
  *   which is how a loader with nothing to send returns it unchanged
- * - `transform(response, form)` turns that response into the detail of the
- *   `submit:success` event
+ * - `transform(response, form)` turns that response into the `response` of the
+ *   `submit:success` detail
  *
  * A rejection from any of the three is reported as a `submit:failure`.
  */
 declare class FormLoader {
-    static create(el: any, conf: any): LocalFormLoader | RemoteJsonFormLoader;
+    /**
+     * The `request-mapper` and `response-mapper` attributes name registry
+     * components called as `(value, form)`; each defaults to the identity. A
+     * remote loader sends through the `http-client` component, with the
+     * `method` attribute or `POST`.
+     * @param {Form} el the form submitting
+     * @param {unknown} [conf] not read
+     * @returns {LocalFormLoader | RemoteJsonFormLoader}
+     */
+    static create(el: Form, conf?: unknown): LocalFormLoader | RemoteJsonFormLoader;
 }
 /**
- * Wraps its fields in a native form, extracts their values on submit and hands
- * them to a loader (loaders:form, or the action url as a json post),
- * announcing failures through the errors setter.
+ * Moves its children into a native `<form novalidate>`, extracts their values
+ * on submit and hands them to a loader, reporting problems through `errors`.
+ * Being `novalidate`, the form submits whatever the validity of its fields:
+ * the browser does not block a submit on a field still marked invalid.
+ *
+ * Attributes on the host starting with `form-` are forwarded, without the
+ * prefix, to the native form. `autocomplete` is copied onto the native form as
+ * well and stays on the host, the fields reading it from either; a
+ * `form-autocomplete` has the last word on the native form.
+ * `clear-invalid-on-change` clears the custom validity of a field of this form
+ * when a `change` event bubbles from it; the field's form is read from its
+ * `form` property, or from `internals.form` for a form-associated element
+ * that has none. `scroll-on-error` is passed to `Bindings.errors` as
+ * `scrollOnError`.
+ *
+ * A native submit, by a button or by Enter in a field, is stopped and runs
+ * `submit` instead.
+ *
+ * `track-changes` keeps track of the edits not saved yet (see `dirty`), and
+ * `guard-leave`, which implies it, asks before the page is left while there
+ * are any.
  */
 declare class Form extends ParsedElement {
     #private;
+    /** Read once at the upgrade: changing one afterwards has no effect. */
     static attributes: string[];
+    /** The native form holding the fields, created by the render. */
     form: any;
+    /** Builds the native form and moves the element's children into it. */
     render(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * Runs the submit pipeline, with the spinner up until its outcome:
+     *
+     * 1. builds the loader: the component the `loader` attribute names
+     *    (`loaders:form` by default), called as `create(form)`
+     * 2. extracts the values with `Bindings.extractFrom` and has the loader
+     *    `prepare` them into the request
+     * 3. fires a cancelable `submit` with `{ submitter, values, request }`.
+     *    Cancelling it ends the submit there, reporting nothing and leaving the
+     *    problems shown; a listener may replace `values` or `request` on the detail
+     * 4. clears the problems shown
+     * 5. fires `submit:requested` through `AsyncEvents.fireAsync` in `pipeline`
+     *    mode: at most one async listener, whose answer is handed to the
+     *    loader's `submit` as its third argument. A listener may replace
+     *    `request` on the detail
+     * 6. has the loader `submit` the request and `transform` the response
+     * 7. under `track-changes`, commits the values extracted at step 2 (see
+     *    `commit`): an edit made while the submit was in flight stays unsaved
+     * 8. releases the spinner and fires `submit:success` with `{ submitter,
+     *    values, request, response }`, `response` being the transformed one
+     *
+     * Anything thrown from step 1 on, a missing loader or a throwing mapper
+     * included, fires `submit:failure` with `{ submitter, values, request,
+     * exception }` instead; the returned promise does not reject. A `Failure`
+     * has its problems shown through `errors`, anything else is logged with
+     * `console.warn`. The `values` of both outcome events are the extracted
+     * ones, not a replacement a `submit` listener put on its detail.
+     *
+     * The form settles before either outcome event (0016): its listeners see
+     * the spinner released and the buttons no longer held off, the problems of
+     * a `Failure` already shown, and the submit no longer in flight, so one
+     * of them may submit again.
+     *
+     * A call while a submit is in flight returns at once, doing nothing.
+     * @param {HTMLElement} [submitter] the button that submitted, if any; it is
+     * the only button whose name and value are submitted
+     * @returns {Promise<boolean>} settling once the submit has finished: true
+     * after `submit:success`, false when it failed, was cancelled or was dropped
+     * for one in flight
+     */
+    submit(submitter?: HTMLElement): Promise<boolean>;
     /**
-     * Submits once: a submit while one is in flight is dropped before the
-     * values are even extracted, so nothing fires and nothing travels; the
-     * settled exchange re-arms the form. A write must not double behind a
-     * second Enter or a programmatic call racing the first.
-     * @param {HTMLElement} [submitter]
-     * @returns
+     * Saves the unsaved edits, for a page action that would lose them, such as
+     * one reloading the page: under `track-changes` it submits only while the
+     * form is dirty, and without it always submits.
+     * @param {HTMLElement} [submitter] as `submit` takes it
+     * @returns {Promise<boolean>} whether no unsaved edit is left: false when
+     * the submit did not succeed, or when the user edited the form while it
+     * was in flight
+     */
+    save(submitter?: HTMLElement): Promise<boolean>;
+    /**
+     * Resets the native form, each field returning to its default value. Under
+     * `track-changes` a reset, this one or a native reset button's, counts
+     * every control as edited: the form is dirty if the defaults differ from
+     * what was last committed.
      */
-    submit(submitter?: HTMLElement): Promise<void>;
-    /** The native reset, routing every field through its own value semantics. */
     reset(): void;
-    /** Shows the spinners and holds the submit buttons off, overlapping spins sharing one claim. */
-    spinner(spin: any): void;
-    /** The values of the fields the form contains, extracted and filled back through Bindings. */
-    set values(vs: {});
-    get values(): {};
-    /** Pins problems to the fields they name, the banner taking the nameless ones. */
-    set errors(es: any);
+    /**
+     * Whether, under `track-changes`, a control the user edited since the last
+     * commit holds a value other than the one committed. An edit is what the
+     * controls report as one: an `input` or a `change` bubbling from a control
+     * of this form (0019), so assigning `value`, a select's vocabulary dropping
+     * a key or a section delivering its fields is not one, and an edit undone
+     * is no longer dirty. A control the last commit did not see compares with
+     * its value when it was first focused. Always false without
+     * `track-changes`.
+     *
+     * While dirty, the host matches `:state(dirty)` and the submit buttons of
+     * this form carry `data-ful-dirty`; a change of the state dispatches
+     * `dirty:change` with `{ dirty }`. Both are refreshed at the next frame
+     * after an edit, while the property is exact at any time.
+     * @returns {boolean}
+     */
+    get dirty(): boolean;
+    /**
+     * Records the values of the controls as saved, so that the form is no
+     * longer dirty. A submit commits by itself on success, and the form
+     * commits once its fields have rendered: a page calls this for a save of
+     * its own, or after writing the values it loaded. Does nothing without
+     * `track-changes`.
+     */
+    commit(): void;
+    /**
+     * Counts controls as edited by the user, for values the page writes on
+     * the user's behalf: assigning `value` reports nothing, as 0019 wants.
+     * @param {...Element} els each a control, or an element inside one
+     */
+    edited(...els: Element[]): void;
+    /**
+     * Marks the form busy or releases it. Calls nest: only the first
+     * `spinner(true)` and the matching last `spinner(false)` act, so a caller's
+     * own spin may wrap a submit.
+     *
+     * Busy, the host carries `aria-busy="true"` and each `ful-spinner` of this
+     * form is revealed; one without text of its own is given `role="status"`
+     * (unless it has a role) and a visually hidden localized `spinner.loading`
+     * label. Each submit and reset button of this form is held off with
+     * `aria-disabled="true"`, keeping its focus, and a click on it is refused
+     * ahead of any listener on the button. Holding the buttons off does not
+     * stop a programmatic `submit`.
+     *
+     * Released, the spinners are hidden and lose the label they were given, and
+     * each held button gets back the `aria-disabled` it had. A button that
+     * joined the form while it was busy keeps its own state.
+     * @param {boolean} spin
+     */
+    spinner(spin: boolean): void;
+    /**
+     * Writes a nested object onto the fields of this form through
+     * `Bindings.mutateIn`: fields the object does not name keep their values.
+     * @param {{ [x: string]: any; }} vs
+     */
+    set values(vs: {
+        [x: string]: any;
+    });
+    /**
+     * The fields of this form read into a nested object by
+     * `Bindings.extractFrom`, with no submitter, so no button contributes.
+     * @returns {any}
+     */
+    get values(): any;
+    /**
+     * Shows problems through `Bindings.errors`, replacing the ones shown
+     * before: each is pinned to the field it names, and the rest go to the
+     * form's `ful-errors` banners. An empty array clears them.
+     * @param {{ type: string; context?: string | null; reason: string; }[]} es
+     */
+    set errors(es: {
+        type: string;
+        context?: string | null;
+        reason: string;
+    }[]);
 }
-/** A labelled text input over any native type or textarea; the temporal inputs are its subclasses. */
+/**
+ * A labelled text input over any native input type, or a `<textarea>` under
+ * `type="textarea"`; the temporal inputs are its subclasses. The label is the
+ * default slot, `info` follows it, and `before` and `after` are rendered as
+ * affixes around the control. Every `input-*` attribute is forwarded onto the
+ * control, after everything the field sets there, so it has the last word.
+ *
+ * `type`, `v-type`, `keep`, `reject`, `uppercase`, `trim`, `unsigned` and
+ * `autocomplete` are configuration: read once at the upgrade, so a later write
+ * to them changes nothing. `placeholder` stays live.
+ *
+ * - `type="numeric"` and `type="decimal"` render a text input carrying that
+ *   `inputmode`, so the native `min`, `max` and `step` do not apply. Typing is
+ *   filtered to digits and a leading minus; a decimal also keeps its first `.`
+ *   or `,` and drops any later one; `unsigned` drops the minus.
+ * - `keep` and `reject` are regular expressions filtering what is typed:
+ *   `keep` leaves every match, concatenated, and `reject` removes every match.
+ *   Either replaces the type's own filter, and `keep` wins over `reject` with a
+ *   warning. A pattern that does not compile is warned about once and filters
+ *   nothing. The caret stays next to the same character when text before it
+ *   is removed.
+ * - `autocomplete` is put on the control. Without one the field takes the
+ *   `autocomplete` attribute of the nearest enclosing `<form>`, which the
+ *   platform does not pass on because the control carries `form=""`.
+ * - `uppercase`, `trim` and `v-type` shape the value as it is read; see `value`.
+ * - The control's native `change` is stopped and the field dispatches its own
+ *   once the user commits a new value, as a text input does. A date, time,
+ *   datetime-local, month or week control fires its native `change` while its
+ *   segments are typed, as soon as they make a valid value; for those the field
+ *   reports when the control is left or Enter is pressed, at once for a value
+ *   picked from the browser's picker, never with the dates a year passes
+ *   through while it is typed. A control left incomplete reads as `null`, as
+ *   the native one does.
+ *
+ * A subclass template may render more than one control, as the compare filters
+ * render the two bounds of a range: the first is `_input`, the one the field is
+ * named by, and every one of them gets the inputmode, `autocomplete`, the
+ * `input-` passthrough, the keystroke filter, the placeholder and the `change`
+ * reporting. The passthrough leaves `input-id` to the first alone, so no
+ * two controls share an id.
+ */
 declare class Input extends Field {
+    #private;
+    /** @type {string[]} */
     static observed: string[];
+    /** @type {string[]} */
     static attributes: string[];
     static slots: boolean;
     static template: string;
+    /**
+     * The inner control, set by `_build`: the `<input>`, or the `<textarea>`
+     * under `type="textarea"`. A subclass reads and writes it for the
+     * attributes it adds. Typed `any` so that a subclass can treat it as the
+     * one of the two it renders.
+     * @type {any}
+     */
     _input: any;
-    _type(): any;
+    /**
+     * The type the field renders, which a subclass overrides to wrap another
+     * native type. The base answers the declared `type`, else `number` under
+     * `v-type="number"`, else `text`. It is also what selects the keystroke
+     * filter of `numeric` and `decimal` and the separator handling of `value`.
+     * @returns {string}
+     */
+    _type(): string;
+    /**
+     * @param {{ slots: Record<string, DocumentFragment> | undefined }} conf
+     * @returns {{fragment: DocumentFragment, control: any, error: Element | null, label: HTMLLabelElement | null}}
+     */
     _build({ slots }: {
-        slots: any;
+        slots: Record<string, DocumentFragment> | undefined;
     }): {
-        fragment: any;
+        fragment: DocumentFragment;
         control: any;
-        error: any;
-        label: any;
+        error: Element | null;
+        label: HTMLLabelElement | null;
     };
+    /**
+     * The control's text, shaped in this order: upper cased under `uppercase`,
+     * trimmed under `trim`, `null` when that leaves it empty, every `,` read as
+     * `.` for `type="decimal"`, and decoded to a number under
+     * `v-type="number"`, where text that does not decode is answered as it is.
+     * Writing `null`, `undefined` or `''` empties the control; anything else is
+     * written as its string, replacing whatever was being typed, as a native
+     * control's value does, and is not an edit: a date or time control that
+     * has the focus reports no `change` for it when it is left. Answers a
+     * `string`, a `number` or `null`; typed `any` because subclasses answer
+     * other values. Before the render the same shaping reads the value last
+     * written, or the `value` attribute, as its text, and a write is held for
+     * the render to apply.
+     * @type {any}
+     */
     get value(): any;
     set value(value: any);
-    get placeholder(): any;
-    set placeholder(d: any);
+    /**
+     * The control's placeholder, `null` when there is none. The control always
+     * carries one, a single space standing in for none, so `:placeholder-shown`
+     * matches an empty control and a floating label can rely on it; the blank
+     * one is neither answered here nor reflected onto the host.
+     * @type {string | null}
+     */
+    get placeholder(): string | null;
+    set placeholder(d: string | null);
 }
-/** Formats the yyyy-mm-dd date in its content in the page's locale, or the one its locale attribute names. */
+/**
+ * Formats the yyyy-mm-dd date in its content as a numeric date, in the locale
+ * its `locale` attribute names, else the page's, else the platform default.
+ * Blank content, or content that does not name a date, renders the `default`
+ * attribute, or nothing without one.
+ */
 declare class LocalDate extends ParsedElement {
     static attributes: string[];
     render(): void;
 }
-/** Formats the ISO instant in its content in the page's locale and timezone. */
+/**
+ * Formats the ISO instant in its content as a numeric date and 24 hour time
+ * with seconds, in the page's timezone and in the locale chosen as ful-local-date
+ * chooses it. Blank content, or content that does not name an instant, renders
+ * the `default` attribute, or nothing without one. A date-only value is read as
+ * local midnight of that day.
+ */
 declare class Instant extends ParsedElement {
     #private;
     static attributes: string[];
     render(): void;
-    static isoToLocal(iso: any): string;
-    static localToIso(local: any): string | null;
+    /**
+     * Converts an ISO instant to the `yyyy-mm-ddThh:mm:ss.sss` wall clock time
+     * a datetime-local input takes, in the page's timezone. A date-only value is
+     * read as local midnight of the day it names, not as UTC midnight.
+     * @param {string} iso
+     * @returns {string} with NaN fields for a value that does not parse
+     */
+    static isoToLocal(iso: string): string;
+    /**
+     * Converts a datetime-local wall clock time in the page's timezone to a UTC
+     * ISO instant. A date-only value is read as local midnight of that day.
+     * @param {string} local
+     * @returns {string|null} null for a value that does not parse
+     */
+    static localToIso(local: string): string | null;
 }
-/** A date input whose bounds accept a date, now, or an offset such as +1d. */
+/**
+ * A date input whose `min` and `max` accept a yyyy-mm-dd date, `now` for
+ * today, or an offset from today such as `+1d`, `-2m` or `+1y` (days, months,
+ * years). A month offset landing past the end of the target month takes its
+ * last day. Anything else is passed to the input unchanged. The `step`
+ * attribute is applied before `min` and `max`.
+ */
 declare class InputLocalDate extends Input {
     #private;
     static observed: string[];
     _type(): string;
-    get min(): any;
-    set min(v: any);
-    get max(): any;
-    set max(v: any);
-    get step(): any;
-    set step(v: any);
+    /**
+     * The resolved lower bound, a yyyy-mm-dd date or whatever the input was given.
+     * @returns {string|null} null when unset
+     */
+    get min(): string | null;
+    /** @param {string|null} v a date, `now` or an offset; null or blank removes the bound */
+    set min(v: string | null);
+    /**
+     * The resolved upper bound, a yyyy-mm-dd date or whatever the input was given.
+     * @returns {string|null} null when unset
+     */
+    get max(): string | null;
+    /** @param {string|null} v a date, `now` or an offset; null or blank removes the bound */
+    set max(v: string | null);
+    /**
+     * The input's native step, in days on a date input and in seconds on a time input.
+     * @returns {string|null} null when unset
+     */
+    get step(): string | null;
+    /** @param {string|null} v */
+    set step(v: string | null);
 }
-/** A time input whose bounds accept a time, now, or an hour or minute offset, snapped to the step grid. */
+/**
+ * A time input whose `min` and `max` accept a hh:mm time, `now`, or an offset
+ * from now such as `+2h` or `-30m` (hours, minutes: `m` is minutes here, not
+ * months), wrapping around midnight. A bound resolved from `now` or an offset
+ * is floored to the `step` grid (60 seconds when unset), so that the values
+ * on the grid stay valid, and carries seconds only when the step is not whole
+ * minutes. A literal bound, and anything else, is passed to the input unchanged.
+ */
 declare class InputLocalTime extends InputLocalDate {
     #private;
     _type(): string;
-    get min(): any;
-    set min(v: any);
-    get max(): any;
-    set max(v: any);
+    /**
+     * The resolved lower bound, a time or whatever the input was given.
+     * @returns {string|null} null when unset
+     */
+    get min(): string | null;
+    /** @param {string|null} v a time, `now` or an offset; null or blank removes the bound */
+    set min(v: string | null);
+    /**
+     * The resolved upper bound, a time or whatever the input was given.
+     * @returns {string|null} null when unset
+     */
+    get max(): string | null;
+    /** @param {string|null} v a time, `now` or an offset; null or blank removes the bound */
+    set max(v: string | null);
 }
-/** A datetime input whose value is read and written as an ISO instant. */
+/**
+ * A datetime-local input whose value and bounds are read and written as UTC
+ * ISO instants, shown as wall clock time in the page's timezone. A date-only
+ * value is read as local midnight of that day.
+ */
 declare class InputInstant extends Input {
     static observed: string[];
     _type(): string;
+    /**
+     * The entered time as a UTC ISO instant. Before the render it answers the
+     * value last written, or the `value` attribute, as the rendered field
+     * would, and a write is held for the render to apply.
+     * @returns {string|null} null when empty or when the input holds text that does not parse
+     */
     get value(): string | null;
-    set value(v: string | null);
+    /** @param {string|null|undefined} v an ISO instant; a falsy value empties the input */
+    set value(v: string | null | undefined);
+    /**
+     * The lower bound as a UTC ISO instant.
+     * @returns {string|null} null when unset
+     */
     get min(): string | null;
+    /** @param {string|null} v an ISO instant; a falsy value removes the bound */
     set min(v: string | null);
+    /**
+     * The upper bound as a UTC ISO instant.
+     * @returns {string|null} null when unset
+     */
     get max(): string | null;
+    /** @param {string|null} v an ISO instant; a falsy value removes the bound */
     set max(v: string | null);
-    get step(): any;
-    set step(v: any);
+    /**
+     * The input's native step, in seconds.
+     * @returns {string|null} null when unset
+     */
+    get step(): string | null;
+    /** @param {string|null} v */
+    set step(v: string | null);
 }
-/** A file input with an optional dropzone and item list, enforcing the size and count limits it declares. */
+/**
+ * A file input with an optional dropzone and item list, enforcing the type,
+ * size and count limits it declares.
+ *
+ * The `dropzone` and `item-list` attributes show the dropzone and the list of
+ * chosen files. A `dropzone` slot replaces the default dropzone's content, and
+ * an `items` slot holding a template replaces the stock item, rendered with the
+ * same `files` overlay so that it reads the File objects it lists. Clicking the
+ * dropzone opens the picker, and the host carries a `dragover` attribute while
+ * a drag hovers it. A drop selects the files it carries, ignoring entries that
+ * are not files; a drop with no file, or with several on a field that is not
+ * `multiple`, changes nothing.
+ *
+ * Every selection, picked, dropped or assigned, goes through the constraints
+ * in order: `accept` and `max-file-size` drop the files they refuse,
+ * `max-total-size` and `max-files` clear the whole selection. Each violation
+ * shows a warning. The change event fires for a pick, a drop and a removal
+ * through an item's button; the `files`, `file` and `value` setters are silent,
+ * like a native input's.
+ *
+ * While disabled or readonly, the picker, the dropzone and the item removals
+ * do nothing, and a drop still does not reach the browser's default handling.
+ */
 declare class InputFile extends Input {
     #private;
-    /** how long a warning stands before the field retires it, matching the css fade */
+    /**
+     * Milliseconds a warning stays before the field removes it, whether or not
+     * its css animation ran; read each time a warning is shown.
+     * @type {number}
+     */
     static WARNING_TIMEOUT: number;
     /**
-     * A FileList holding exactly these files. The platform gives no way to
-     * build one but through a DataTransfer, and every place that narrows a
-     * selection rebuilt it by hand: five loops and three empty ones.
+     * Builds a FileList holding exactly these files, the form `files` takes.
      * @param {Iterable<File>} [files]
+     * @returns {FileList}
      */
     static list(files?: Iterable<File>): FileList;
     static observed: string[];
@@ -509,73 +1213,187 @@ declare class InputFile extends Input {
         warning: string;
     };
     _build(conf: any): {
-        fragment: any;
+        fragment: DocumentFragment;
         control: any;
-        error: any;
-        label: any;
+        error: Element | null;
+        label: HTMLLabelElement | null;
         freeze: any;
     };
-    warning(key: any, args: any): void;
-    get accept(): any;
-    set accept(vs: any);
-    get multiple(): any;
-    set multiple(v: any);
-    get files(): any;
-    set files(vs: any);
-    get file(): any;
-    set file(v: any);
-    get value(): any;
+    /**
+     * Shows a warning in the field's polite live region: the localized message
+     * for an l10n key and its arguments. It is removed when its animation ends,
+     * or after `WARNING_TIMEOUT` milliseconds at the latest. The warnings are
+     * cleared whenever the selection changes.
+     * @param {string} key
+     * @param {Record<string, any>} [args]
+     */
+    warning(key: string, args?: Record<string, any>): void;
+    /**
+     * The accepted types, also set on the native input for its picker. A token
+     * is a dot-prefixed extension matched against the end of the file name, a
+     * mime type matched against the file's type with any parameters ignored, or
+     * a family such as `image/*`; case is ignored, and any other token matches
+     * nothing. A file matching no token is dropped with a warning; an empty list
+     * accepts every file. Enforced from the next selection on.
+     * @returns {string[]}
+     */
+    get accept(): string[];
+    /** @param {string[]} vs */
+    set accept(vs: string[]);
+    /**
+     * Whether the field takes several files; a single-file field ignores a drop of several.
+     * @returns {boolean}
+     */
+    get multiple(): boolean;
+    /** @param {boolean} v */
+    set multiple(v: boolean);
+    /**
+     * The selected files, after the constraints; none before the render.
+     * @returns {FileList}
+     */
+    get files(): FileList;
+    /**
+     * Replaces the selection and runs the constraints over it, refreshing the
+     * warnings and the item list, without firing change.
+     * @param {FileList} vs
+     */
+    set files(vs: FileList);
+    /**
+     * The first selected file.
+     * @returns {File|null}
+     */
+    get file(): File | null;
+    /**
+     * Replaces the selection with this one file, or empties it, as `files` does.
+     * @param {File|null|undefined} v
+     */
+    set file(v: File | null | undefined);
+    /**
+     * The names of the selected files: an array when `multiple`, otherwise the
+     * one name or null. Before the render no file is selected yet.
+     * @returns {string[]|string|null}
+     */
+    get value(): string[] | string | null;
+    /**
+     * Empties the selection for a falsy value and ignores any other, since a
+     * file name cannot select a file. Before the render there is nothing to
+     * empty, so it does nothing.
+     * @param {any} v
+     */
     set value(v: any);
+    /** Empties the selection, as a native file input's reset does, whatever the `value` attribute says. */
     formResetCallback(): void;
-    get totalsize(): any;
-    get maxFiles(): any;
-    set maxFiles(v: any);
-    get maxFileSize(): any;
-    set maxFileSize(v: any);
-    get maxTotalSize(): any;
-    set maxTotalSize(v: any);
-    get itemList(): any;
-    set itemList(v: any);
-    get dropzone(): any;
-    set dropzone(v: any);
+    /**
+     * The size of the selected files together, in bytes.
+     * @returns {number}
+     */
+    get totalsize(): number;
+    /**
+     * The most files a selection may hold; a larger selection is cleared
+     * entirely with a warning. Enforced from the next selection on.
+     * @returns {number|null} null for no limit
+     */
+    get maxFiles(): number | null;
+    /** @param {number|null} v */
+    set maxFiles(v: number | null);
+    /**
+     * The largest size one file may have, in bytes; a larger file is dropped
+     * from the selection with a warning. Enforced from the next selection on.
+     * @returns {number|null} null for no limit
+     */
+    get maxFileSize(): number | null;
+    /** @param {number|null} v */
+    set maxFileSize(v: number | null);
+    /**
+     * The largest size the selected files may have together, in bytes; a
+     * larger selection is cleared entirely with a warning. Enforced from the
+     * next selection on.
+     * @returns {number|null} null for no limit
+     */
+    get maxTotalSize(): number | null;
+    /** @param {number|null} v */
+    set maxTotalSize(v: number | null);
+    /**
+     * Whether the chosen files are listed, each with a button removing it; the
+     * stylesheet shows the list from the reflected `item-list` attribute.
+     * @returns {boolean}
+     */
+    get itemList(): boolean;
+    /** @param {boolean} v */
+    set itemList(v: boolean);
+    /**
+     * Whether the dropzone is shown; the stylesheet shows it from the reflected
+     * `dropzone` attribute.
+     * @returns {boolean}
+     */
+    get dropzone(): boolean;
+    /** @param {boolean} v */
+    set dropzone(v: boolean);
 }
 /**
- * CSS anchor positioning for a popover and the invoker it belongs to, with the
- * hand-placed fallback for the platforms that do not have it.
+ * Places a popover beside the element or the rectangle it belongs to.
+ *
+ * `wire` pairs a popover with one invoker for its lifetime and relies on css
+ * anchor positioning, placing the popover in script only where the platform
+ * lacks it or the caller asks for it. `show` places a popover once, beside
+ * whatever anchor the call hands over.
  */
 declare class Anchors {
     /**
-     * Anchors a popover to its invoker.
+     * Anchors a popover to its invoker for the popover's lifetime.
      *
-     * The invoker is given an `anchor-name` and the popover a `position-anchor`
-     * pointing at it, which is what a stylesheet needs to place the popover
+     * On every platform the invoker is given an inline `anchor-name` and the
+     * popover a `position-anchor` naming it, `--` followed by a unique id
+     * built from `prefix`. That is what a stylesheet needs to place the popover
      * itself: the library's own menus say `top: anchor(bottom); left:
      * anchor(left)`. **Writing that css is the caller's half of this.** Without
      * it the popover lands wherever the user agent puts a popover, which is not
      * beside the invoker.
      *
-     * Where the platform has no anchor positioning the popover is placed here
-     * instead, beside the invoker whenever it opens, clamped into the viewport,
-     * following it on scroll and resize, and cleaned up on close. That placement
-     * draws the geometry the css above describes, so the two agree.
+     * Where the platform has no css anchor positioning, or under `handPlace`,
+     * the popover is placed in script instead: beside the invoker whenever it
+     * opens, clamped 8px inside the viewport, placed again on every scroll and
+     * resize while open, and its inline placement removed on close. The gap to
+     * the invoker is read from the popover's css margins. From `beforetoggle`
+     * to the placing, in a microtask before the `toggle` event, the popover
+     * carries an inline `visibility: hidden`, so a stylesheet setting
+     * `visibility` on it competes with that. A popover removed from the
+     * document while open, or whose invoker was removed, stops being placed.
+     *
+     * The script placement puts a plain popover below the invoker,
+     * start-aligned. A popover matching `ful-note`, `.ful-note` or
+     * `[placement]` reads its `placement` attribute instead: `top`, `right`,
+     * `left`, or `bottom` by default, centred on the invoker along the other
+     * axis. Such a popover is also given `--ful-note-callout-inline` and
+     * `--ful-note-callout-block`: the invoker's centre, in pixels, measured
+     * from the popover's padding box, which stays on the invoker when the
+     * viewport pushes the popover off it.
+     *
+     * Wiring the same pair twice adds its listeners twice.
      *
      * @param {HTMLElement} invoker the element the popover belongs to
      * @param {HTMLElement} popover the `[popover]` element to place
      * @param {object} [options]
-     * @param {string} [options.prefix] prefixes the generated anchor name and id,
-     *   so the dom says which component a name belongs to
-     * @param {boolean} [options.invoke] points the invoker's `popovertarget` at
-     *   the popover, giving toggle and light dismiss with no script of your own
-     * @param {boolean} [options.expanded] keeps the invoker's `aria-expanded` in
-     *   step with the popover
-     * @param {boolean} [options.stretch] widens the popover to its invoker, which
-     *   is what a combobox dropdown wants
-     * @param {boolean} [options.handPlace] places here on every platform rather
-     *   than only as a fallback, which a popover asks for when it needs to know
-     *   where its invoker ended up: the tooltip's note points a callout at it, and
-     *   a pseudo-element cannot read an anchor outside its own containing block.
-     *   Such a popover declares no anchor placement in css, there being none to
-     *   agree with
+     * @param {string} [options.prefix] prefixes the generated anchor name and
+     *   id, `ful-anchor` by default, so the dom says which component a name
+     *   belongs to
+     * @param {boolean} [options.invoke] makes the invoker toggle the popover,
+     *   which light dismiss then closes with no script of your own. The popover
+     *   is given the generated id when it has none. A `button` or `input`
+     *   invoker gets a `popovertarget` naming it; any other element toggles it
+     *   on click and on the Enter and Space keys; a click on it while the
+     *   popover is open closes the popover rather than opening it again
+     * @param {boolean} [options.expanded] sets the invoker's `aria-expanded` to
+     *   `false` at once and keeps it in step with the popover's `toggle` events
+     * @param {boolean} [options.stretch] in the script placement, sizes the
+     *   popover to at least its invoker's width, capped by its own `max-width`
+     *   and the viewport, and flips it above the invoker where the viewport
+     *   leaves no room below, which is what a combobox dropdown wants. The
+     *   `placement` attribute is not read
+     * @param {boolean} [options.handPlace] places in script on every platform
+     *   rather than only as a fallback, for a popover that needs to know where
+     *   its invoker ended up, such as a note pointing a callout at it. Such a
+     *   popover declares no anchor placement in css
      */
     static wire(invoker: HTMLElement, popover: HTMLElement, { prefix, invoke, expanded, stretch, handPlace }?: {
         prefix?: string;
@@ -584,74 +1402,187 @@ declare class Anchors {
         stretch?: boolean;
         handPlace?: boolean;
     }): void;
+    /**
+     * Shows a popover and places it beside an anchor, once. It serves a
+     * popover shared by many invokers, each open handing over its own anchor,
+     * and an anchor that is a rectangle rather than an element, such as one
+     * read out of an iframe. Nothing is paired and nothing follows a later
+     * scroll or resize; closing is the caller's, or the platform's for a
+     * light-dismissing popover.
+     *
+     * The popover goes below the anchor, start-aligned, clamped 8px inside the
+     * viewport. `flip` moves it above the anchor where there is no room below
+     * and there is room above. The placement is written as inline `top`, `left`,
+     * `right`, `bottom` and `margin`, which stay after the popover closes and
+     * are overwritten by the next call.
+     *
+     * A popover not already open is shown with `showPopover()` and placed
+     * before the call returns, so the first position anybody sees is the right
+     * one and the caller can move the focus into it on the next line. One
+     * already open is placed without being shown again.
+     *
+     * @param {HTMLElement} popover the `[popover]` element to show, or an
+     *   already-shown element to place
+     * @param {Element|DOMRect} anchor the element, or the rectangle in
+     *   viewport coordinates, to place beside
+     * @param {object} [options]
+     * @param {boolean} [options.flip] place above the anchor where no room is
+     *   left below, `false` by default
+     * @param {number} [options.gap] the distance from the anchor, in pixels,
+     *   `0` by default
+     * @returns {HTMLElement} the popover
+     */
+    static show(popover: HTMLElement, anchor: Element | DOMRect, { flip, gap }?: {
+        flip?: boolean;
+        gap?: number;
+    }): HTMLElement;
 }
+export type SelectEntry = {
+    key: any;
+    label: string;
+    metadata: any;
+};
+export type SelectHttpClient = {
+    request(method: string, url: string): any;
+};
 /**
  * Fetches a select's whole vocabulary from a url and serves every later read
  * from it. Concurrent callers share one request, the options may be cached in
- * local storage under a revision, and reconfiguring the url discards both.
+ * local storage under a revision, and invalidating discards both.
  */
 declare class RemoteLoader {
     #private;
+    /**
+     * @param {{ http: SelectHttpClient, url: string, method: string, responseMapper: (response: any) => SelectEntry[], prefetch: boolean, revision: string|null }} conf
+     * a null revision never reads nor writes local storage
+     */
     constructor({ http, url, method, responseMapper, prefetch, revision }: {
-        http: any;
-        method: any;
-        prefetch: any;
-        responseMapper: any;
-        revision: any;
-        url: any;
+        http: SelectHttpClient;
+        url: string;
+        method: string;
+        responseMapper: (response: any) => SelectEntry[];
+        prefetch: boolean;
+        revision: string | null;
     });
+    /**
+     * Fetches the vocabulary now when the loader was built with prefetch, and
+     * does nothing otherwise.
+     * @returns {Promise<void>}
+     * @throws when the fetch fails, or when an invalidation supersedes it
+     */
     prefetch(): Promise<void>;
-    exact(...keys: any[]): Promise<any>;
-    load(needle: any): Promise<any>;
     /**
-     * Drops the cached vocabulary so the next question refetches it. Any fetch
-     * still in flight is detached: its outcome belongs to the configuration that
-     * started it and must neither be served nor stored for the new one.
+     * The entries whose key reads as the same text as one of the keys, in
+     * vocabulary order.
+     * @param {...any} keys
+     * @returns {Promise<SelectEntry[]>}
+     * @throws when the fetch fails, or when an invalidation supersedes it
+     */
+    exact(...keys: any[]): Promise<SelectEntry[]>;
+    /**
+     * The entries whose label contains the needle, ignoring case; every entry
+     * for a nullish or empty needle.
+     * @param {string|null} [needle]
+     * @returns {Promise<SelectEntry[]>}
+     * @throws when the fetch fails, or when an invalidation supersedes it
+     */
+    load(needle?: string | null): Promise<SelectEntry[]>;
+    /**
+     * Drops the vocabulary held in memory so the next question refetches it,
+     * which may still be answered from local storage under the same revision.
+     * A fetch still in flight is detached: its outcome is neither served nor
+     * stored, and the callers waiting on it reject.
+     * @returns {Promise<void>}
      */
     invalidate(): Promise<void>;
-    reconfigureUrl(url: any): Promise<void>;
 }
 /** Asks the endpoint per query instead of fetching the vocabulary once, for a list too large to hold in memory. */
 declare class PartialRemoteLoader {
     #private;
+    /**
+     * @param {{ http: SelectHttpClient, url: string, method: string, responseMapper: (response: any) => SelectEntry[] }} conf
+     */
     constructor({ http, url, method, responseMapper }: {
-        http: any;
-        method: any;
-        responseMapper: any;
-        url: any;
+        http: SelectHttpClient;
+        url: string;
+        method: string;
+        responseMapper: (response: any) => SelectEntry[];
     });
     /**
-     * Nothing is held between queries, so there is no cache to drop: the method
-     * exists so a caller can invalidate any loader without knowing which it has.
+     * Does nothing, since nothing is held between queries.
+     * @returns {Promise<void>}
      */
     invalidate(): Promise<void>;
-    reconfigureUrl(url: any): Promise<void>;
-    exact(...keys: any[]): Promise<any>;
-    load(needle: any): Promise<any>;
+    /**
+     * Asks the endpoint for the entries of the keys, sent as repeated `k`
+     * parameters.
+     * @param {...any} keys
+     * @returns {Promise<SelectEntry[]>}
+     * @throws when the request fails
+     */
+    exact(...keys: any[]): Promise<SelectEntry[]>;
+    /**
+     * Asks the endpoint for the entries matching the needle, sent as the `s`
+     * parameter; the filtering is the endpoint's.
+     * @param {string|null} [needle]
+     * @returns {Promise<SelectEntry[]>}
+     * @throws when the request fails
+     */
+    load(needle?: string | null): Promise<SelectEntry[]>;
 }
 /** Serves a select's options from an array held in memory, which is what the slotted `<option>` elements become. */
 declare class InMemoryLoader {
     #private;
-    constructor(data: any);
-    update(data: any): void;
-    /** The vocabulary is the data itself: update replaces it, so there is nothing to drop. */
-    invalidate(): Promise<void>;
-    exact(...keys: any[]): any;
-    load(needle: any): any;
+    /**
+     * @param {SelectEntry[]} data
+     */
+    constructor(data: SelectEntry[]);
+    /**
+     * Replaces the vocabulary every later question is answered from.
+     * @param {SelectEntry[]} data
+     */
+    update(data: SelectEntry[]): void;
+    /**
+     * Does nothing: the vocabulary is the data itself, which only update replaces.
+     * @returns {Promise<void>}
+     */
+    invalidate(): Promise<void>;
+    /**
+     * The entries whose key reads as the same text as one of the keys, in
+     * vocabulary order.
+     * @param {...any} keys
+     * @returns {SelectEntry[]}
+     */
+    exact(...keys: any[]): SelectEntry[];
+    /**
+     * The entries whose label contains the needle, ignoring case; every entry
+     * for a nullish or empty needle.
+     * @param {string|null} [needle]
+     * @returns {SelectEntry[]}
+     */
+    load(needle?: string | null): SelectEntry[];
 }
 /**
  * Builds the select's loader from its attributes: the slotted options in
- * memory, or a remote or chunked loader over src.
+ * memory, or a remote or chunked loader over src. It is registered as the
+ * `loaders:select` component.
  *
- * A component registered under the `loader` attribute replaces this one and
- * must implement the same three methods, each answering `{ key, label,
- * metadata }` entries:
+ * A component named by the select's `loader` attribute replaces this one: its
+ * `create(el, conf)` answers an object with these methods, each answering
+ * `{ key, label, metadata }` entries, directly or through a promise:
  *
- * - `prefetch()` warms the vocabulary if it can, and resolves either way
  * - `load(needle)` answers the entries matching the typed text, all of them
- *   when the needle is nullish, which is the empty search the list opens with
+ *   when the needle is empty, which is the search the list opens with
  * - `exact(...keys)` answers the entries for those keys, used to label a value
- *   assigned without going through the list
+ *   assigned without going through the list; a key it leaves out is dropped
+ *   from the selection
+ * - `prefetch()`, optional, warms the vocabulary; the select calls it at the
+ *   upgrade without waiting, and awaits it in `reload()`
+ * - `invalidate()`, optional, drops whatever the loader holds, called by
+ *   `reload()`
+ *
+ * An entry whose `metadata.disabled` is truthy is shown and cannot be picked,
+ * with `metadata.reason`, when present, as the row's title.
  */
 declare class SelectLoader {
     #private;
@@ -661,131 +1592,537 @@ declare class SelectLoader {
      * `mode: 'chunked'`, per query. A test, or a caller holding its own
      * configuration, builds a loader this way; `create` is the same thing with
      * an element's attributes parsed first.
-     * @param {{ data?: any[], http?: any, url?: string, method?: string, mode?: string, prefetch?: boolean, revision?: string|null, responseMapper?: any }} conf
+     *
+     * A remote loader fetches once and filters in memory, caching the response
+     * in local storage under `method@url` when a revision is given; a chunked
+     * one sends every search as `s` and every key lookup as `k`. The response
+     * mapper turns the parsed response body into entries.
+     * @param {{ data?: SelectEntry[], url?: undefined, http?: undefined, method?: undefined, mode?: undefined, prefetch?: undefined, revision?: undefined, responseMapper?: undefined }
+     *     | { data?: undefined, url: string, http: SelectHttpClient, method?: string, mode?: string, prefetch?: boolean, revision?: string|null, responseMapper: (response: any) => SelectEntry[] }} conf
+     * `method` defaults to POST
+     * @returns {InMemoryLoader|PartialRemoteLoader|RemoteLoader}
      */
     static from({ data, http, url, method, mode, prefetch, revision, responseMapper }: {
-        data?: any[];
-        http?: any;
-        url?: string;
+        data?: SelectEntry[];
+        url?: undefined;
+        http?: undefined;
+        method?: undefined;
+        mode?: undefined;
+        prefetch?: undefined;
+        revision?: undefined;
+        responseMapper?: undefined;
+    } | {
+        data?: undefined;
+        url: string;
+        http: SelectHttpClient;
         method?: string;
         mode?: string;
         prefetch?: boolean;
         revision?: string | null;
-        responseMapper?: any;
+        responseMapper: (response: any) => SelectEntry[];
+    }): InMemoryLoader | PartialRemoteLoader | RemoteLoader;
+    /**
+     * Builds the loader an element's attributes describe. Without `src` the
+     * vocabulary is the `<option>` elements of `conf.options`, each keyed by its
+     * `value` attribute or else its trimmed text. With `src` the url is
+     * requested through the `http-client` component with `method` (POST by
+     * default): once on first use, or at the upgrade under `preload`, or per
+     * query under `mode="chunked"`. A `revision` caches the whole response in local storage; a
+     * valueless one takes the `revision` component, calling it when it is a
+     * function, and warns and does not cache when none is registered.
+     *
+     * The response becomes entries through `k-expr` and `l-expr` evaluated on
+     * each row of `d-expr` (the response itself by default), with `m-expr` as
+     * the metadata (the row by default); else through the `response-mapper`
+     * component; else each row is read as a `[key, label, metadata]` array.
+     * @param {ParsedElement} el the element declaring the loader attributes
+     * @param {{ options?: DocumentFragment }} conf
+     * @returns {InMemoryLoader|PartialRemoteLoader|RemoteLoader}
+     */
+    static create(el: ParsedElement, conf: {
+        options?: DocumentFragment;
     }): InMemoryLoader | PartialRemoteLoader | RemoteLoader;
-    static create(el: any, conf: any): InMemoryLoader | PartialRemoteLoader | RemoteLoader;
 }
-/** The options popup of a select: listbox semantics, one loading claim per show, a localized empty state. */
+/**
+ * The options popup of a select, a `<ful-dropdown>` the owner shows as a
+ * popover: a spinner while the loader runs, a localized empty state, and a
+ * `role="listbox"` menu of `role="option"` rows.
+ *
+ * The owner drives it and listens to it. A pick dispatches a bubbling
+ * `change` whose detail is `{ index, entry }`, the row's index as a string
+ * and the entry it was rendered from. The active row is announced by a
+ * non-bubbling `activechange` whose detail is `{ id }`, the row's id or null
+ * when none is active, for the owner to set `aria-activedescendant`. A
+ * pressed row does not take the focus from the owner's control.
+ */
 declare class Dropdown extends ParsedElement {
     #private;
+    /**
+     * `listbox` is the id given to the menu, so an owner can set
+     * `aria-controls` before this element upgrades; a generated id otherwise.
+     */
     static attributes: string[];
+    /** The default slot, when not blank, is the row template in place of the `options` template. */
     static slots: boolean;
     static template: string;
+    /**
+     * `options` renders one row per entry, each entry carrying its `index`
+     * beside its own keys. A replacement must keep one `<li>` per entry, in
+     * order, with the index as its `value`: picking reads the entry back from it.
+     */
     static templates: {
         options: string;
     };
+    /**
+     * @param {{ slots: Record<string, DocumentFragment> }} conf
+     */
     render({ slots }: {
-        slots: any;
+        slots: Record<string, DocumentFragment>;
     }): void;
+    /**
+     * Picks the highlighted row, or the first enabled one when none is: hides
+     * the dropdown and dispatches `change`. Does nothing when the highlighted
+     * row is disabled, when no row is enabled, or while a search is loading
+     * and the rows are hidden.
+     */
     acceptSelection(): void;
-    update(values: any, keys?: any[]): void;
+    /**
+     * Renders the entries as rows and highlights the first one whose key is
+     * picked, else the row the template marked `selected`, else the first
+     * enabled row. A row is marked `picked` and
+     * `aria-selected="true"` when its key reads as the same text as one of the keys, and
+     * `aria-disabled="true"` when its `metadata.disabled` is truthy, titled with
+     * `metadata.reason`. No entries shows the empty state instead of the menu.
+     * @param {SelectEntry[]} values
+     * @param {any[]} [keys] the keys currently selected
+     * @throws {Error} when values is undefined
+     */
+    update(values: SelectEntry[], keys?: any[]): void;
+    /**
+     * Closes the popover, if open, and announces that no row is active. A
+     * `show` still waiting on its loader is superseded: its outcome is neither
+     * rendered nor thrown.
+     */
     hide(): void;
+    /**
+     * Whether the popover is open.
+     * @returns {boolean}
+     */
     get shown(): boolean;
-    show(loader: any, keys?: any[]): Promise<void>;
-    moveOrShow(forward: any, loader: any, keys?: any[]): Promise<void>;
-    jump(first: any): void;
-    page(forward: any): void;
+    /**
+     * Opens the popover with the spinner showing, then renders what the loader
+     * answers as `update` does. A show overtaken by a later `show` or by `hide`
+     * before its loader settles leaves the dropdown alone and resolves, even
+     * when its loader rejected.
+     * @param {() => SelectEntry[]|Promise<SelectEntry[]>} loader
+     * @param {any[]} [keys] the keys currently selected
+     * @returns {Promise<void>}
+     * @throws what the loader threw, after hiding the dropdown, when this show
+     * is still the current one
+     */
+    show(loader: () => SelectEntry[] | Promise<SelectEntry[]>, keys?: any[]): Promise<void>;
+    /**
+     * Moves the highlight to the next or previous enabled row when the dropdown
+     * is shown, staying put at the edge and while a search is loading, and
+     * shows it otherwise.
+     * @param {boolean} forward
+     * @param {() => SelectEntry[]|Promise<SelectEntry[]>} loader used only to show
+     * @param {any[]} [keys] the keys currently selected, used only to show
+     * @returns {Promise<void>}
+     * @throws what `show` throws
+     */
+    moveOrShow(forward: boolean, loader: () => SelectEntry[] | Promise<SelectEntry[]>, keys?: any[]): Promise<void>;
+    /**
+     * Highlights the first enabled row, or the last one. Does nothing while a
+     * search is loading and the rows are hidden.
+     * @param {boolean} first
+     */
+    jump(first: boolean): void;
+    /**
+     * Moves the highlight by as many enabled rows as the menu shows at once,
+     * one when that cannot be measured, stopping at the last enabled row.
+     * Does nothing while a search is loading.
+     * @param {boolean} forward
+     */
+    page(forward: boolean): void;
 }
-/** A combobox acting like a select over a loader's vocabulary, single or multiple. */
+/**
+ * A `<ful-select>`: a combobox over a loader's vocabulary of
+ * `{ key, label, metadata }` entries, holding one key or, under `multiple`,
+ * several. Typing filters the list, opening it from rest offers the whole
+ * vocabulary, and the keyboard follows the combobox pattern: arrows move and
+ * open (Alt+ArrowDown opens, Alt+ArrowUp closes), Home, End, PageUp and
+ * PageDown move in the open list, Enter accepts the highlighted entry or,
+ * with the list closed, submits the form, Escape reverts the edit, and Tab
+ * or leaving the field commits it. Emptying the text of a single select and
+ * leaving the field clears it. Backspace with the caret at the start removes
+ * the last entry, and ArrowLeft there moves the focus to the badges of a
+ * multiple select, where Enter, Space, Backspace or Delete remove one.
+ *
+ * Slots: the default one is the label, `info` sits beside it, `before` and
+ * `after` are affixes around the control, `options` holds the `<option>`
+ * elements of an in-memory vocabulary, `dropdown` replaces the dropdown's
+ * row template and `items` the `items` template.
+ *
+ * Every change of the selection made through the element dispatches a
+ * bubbling `change` whose detail carries `value` and `entry`, as the getters
+ * answer them; assigning `value` dispatches none.
+ */
 declare class Select extends Field {
     #private;
+    /**
+     * Read once at the upgrade, so a later write changes nothing: `name`,
+     * `loader` (the component building the loader, `loaders:select` by
+     * default), `k-type` (`number` or `boolean` coerce the keys, strings
+     * otherwise), and the loader configuration `SelectLoader.create` reads,
+     * but for `src` and `method`, which stay live.
+     */
     static attributes: string[];
+    /**
+     * Beside the field's claims: `multiple`, `item-list`, `value` as a comma
+     * separated list of keys, trimmed, whether or not the select is multiple,
+     * and `src` and `method`.
+     */
     static observed: string[];
+    /**
+     * Reads a present but empty `value` attribute of a single select as the
+     * empty key, which an `<option value="">` can carry; a multiple select reads
+     * it as no keys.
+     * @param {string} attr
+     * @param {string|null} str
+     * @returns {any}
+     * @throws when the class declares no such attribute
+     */
+    unmarshal(attr: string, str: string | null): any;
     static slots: boolean;
     static template: string;
+    /**
+     * `items` renders the selection below the control, shown under `item-list`,
+     * over `entries`, the selected entries in order. A replacement must keep one
+     * `<ful-item>` per entry, in order, each with a `<button>` that removes it.
+     */
     static templates: {
         items: string;
     };
+    /**
+     * @param {{ slots: Record<string, DocumentFragment> }} conf
+     * @returns {{ fragment: DocumentFragment, control: HTMLInputElement, error: Element|null, label: Element|null }}
+     */
     _build({ slots }: {
-        slots: any;
+        slots: Record<string, DocumentFragment>;
     }): {
-        fragment: any;
-        control: any;
-        error: any;
-        label: any;
+        fragment: DocumentFragment;
+        control: HTMLInputElement;
+        error: Element | null;
+        label: Element | null;
     };
-    /** Hands the loader to the callback, for runtime reconfigurations. */
-    withLoader(fn: any): Promise<any>;
-    /**
-     * Drops whatever the loader is holding and asks it about the current selection
-     * again, which is what a select whose vocabulary depends on another control
-     * needs when that control changes. A key the loader no longer knows is dropped
-     * from the selection, so a value invalidated by the change does not survive it,
-     * and one it still knows keeps its place with a fresh label.
+    /**
+     * Hands the loader to the callback, for runtime changes such as
+     * `update(entries)` on an in-memory loader.
+     * @template T
+     * @param {(loader: any) => T|Promise<T>} fn
+     * @returns {Promise<T>} what the callback answers
+     */
+    withLoader<T>(fn: (loader: any) => T | Promise<T>): Promise<T>;
+    /**
+     * Drops whatever the loader is holding, awaits its prefetch (which fetches
+     * again when the select declares `preload`), and asks it about the current
+     * selection again, which is what a select whose vocabulary depends on
+     * another control needs when that control changes. A key the loader no
+     * longer knows is dropped from the selection, so a value invalidated by the
+     * change does not survive it, and one it still knows keeps its place with a
+     * fresh label. The badges and items follow, an open dropdown runs its
+     * search again, and no `change` is dispatched.
      *
-     * Pass a url first where the vocabulary lives at a different address:
+     * Where the vocabulary lives at a different address, write `src` or call
+     * `reconfigure`, which build the loader for the new url and reload.
+     * @returns {Promise<void>}
+     * @throws what the loader's invalidate, prefetch, key lookup or search
+     * throws
+     */
+    reload(): Promise<void>;
+    /**
+     * The url the loader asks for the vocabulary, reflected as the `src`
+     * attribute.
+     * @returns {string|null}
+     */
+    get src(): string | null;
+    /**
+     * Points the select at another vocabulary: the dropdown closes, the loader
+     * is built again through its component's `create`, as at the render, and
+     * the select reloads as `reload()` does, so a selected key the new
+     * vocabulary does not know is dropped and one it knows is labelled again,
+     * with no `change` dispatched. A write that does not change the url does
+     * nothing.
      *
-     *     citta.addEventListener('change', async () => {
-     *         await cap.withLoader((l) => l.reconfigureUrl(`/api/cap?citta=${citta.value}`));
-     *         await cap.reload();
+     * The reload is not awaited: a failed fetch or lookup surfaces as an
+     * unhandled rejection.
+     * @param {string|null|undefined} value null or undefined removes the url,
+     * which the default loader answers with the slotted options
+     */
+    set src(value: string | null | undefined);
+    /**
+     * The http method the default loader sends, reflected as the `method`
+     * attribute; `POST` when absent.
+     * @returns {string|null}
+     */
+    get method(): string | null;
+    /**
+     * Changes the http method the way `src` changes the url: the loader is
+     * built again and the select reloads.
+     * @param {string|null|undefined} value
+     */
+    set method(value: string | null | undefined);
+    /**
+     * Writes `src` and `method` together and reloads once: the loader is built
+     * again for the pair when either changed, as a single write of either does,
+     * and the select then reloads as `reload()` does, whether or not they
+     * changed.
+     *
+     *     citta.addEventListener('change', () => {
+     *         cap.reconfigure({ src: `/api/cap?citta=${citta.value}` }, { notify: true });
      *     });
+     * @param {{ src?: string|null, method?: string|null }} attributes a name
+     * left out keeps its value, null removes the attribute
+     * @param {{ notify?: boolean }} [options] `notify` dispatches `change` when
+     * the reload dropped a selected key, so a form or a table filtered by the
+     * select sees the value it lost; nothing is dispatched otherwise
+     * @returns {Promise<void>} settling once the reload has
+     * @throws what the loader's invalidate, prefetch or key lookup throws
+     */
+    reconfigure(attributes: {
+        src?: string | null;
+        method?: string | null;
+    }, { notify }?: {
+        notify?: boolean;
+    }): Promise<void>;
+    /**
+     * The text typed to search the vocabulary: what the dropdown was last
+     * asked to match. `''` while the field is not being searched, its control
+     * then showing the selection's label rather than a query.
+     * @returns {string}
+     */
+    get query(): string;
+    /**
+     * Selects the keys, coerced by `k-type`: a key, an array of keys, or null or
+     * undefined for none. The empty string is a key like any other, and a
+     * single select keeps only the first key. The keys are applied at once, each labeled by itself until the loader's `exact`
+     * answers; a key it does not answer is then dropped, a key removed in the
+     * meantime stays removed, and a later assignment wins over the late answer.
+     * A failed lookup keeps the keys and surfaces as an unhandled rejection.
+     * No `change` is dispatched. A key containing a
+     * comma, which the value attribute cannot carry, is kept and warned about
+     * once per element. Before the render the write is held for the render to
+     * apply, over the `value` attribute, which it leaves alone.
+     * @param {any} vs
      */
-    reload(): Promise<void>;
     set value(vs: any);
+    /**
+     * The selected keys, in selection order, for a multiple select; the one
+     * key, or null, for a single one. Before the render it answers the keys
+     * last written, or the `value` attribute, coerced and cut to one key as the
+     * rendered select would.
+     * @returns {any}
+     */
     get value(): any;
-    /** The selection as {key, label, metadata} entries, the change detail's vocabulary: the only one for a single select, every one when multiple. */
-    get entry(): any;
-    get multiple(): any;
-    set multiple(v: any);
-    get itemList(): any;
-    set itemList(v: any);
+    /**
+     * The selection as entries, the ones in the `change` detail: an array for
+     * a multiple select, the one entry or null for a single one. An entry whose
+     * label has not been resolved yet carries its key as the label.
+     * @returns {SelectEntry|SelectEntry[]|null}
+     */
+    get entry(): SelectEntry | SelectEntry[] | null;
+    /**
+     * The field's disabled claim; turning it on while the dropdown is open
+     * closes it and drops a pending search.
+     * @type {boolean}
+     */
+    get disabled(): boolean;
+    set disabled(v: boolean);
+    /**
+     * The field's readonly claim; turning it on while the dropdown is open
+     * closes it and drops a pending search.
+     * @type {boolean}
+     */
+    get readonly(): boolean;
+    set readonly(v: boolean);
+    /**
+     * Whether the select holds several keys: `value` and `entry` answer arrays,
+     * the input stays empty and the selection shows as removable badges in the
+     * control. Before the render it answers the `multiple` attribute.
+     * @returns {boolean}
+     */
+    get multiple(): boolean;
+    /**
+     * Turning it off keeps only the first selected key; either way the badges,
+     * the items and the input follow at once.
+     * @param {boolean} v
+     */
+    set multiple(v: boolean);
+    /**
+     * Whether the selection shows as the `items` list below the control instead
+     * of as badges in it.
+     * @returns {boolean}
+     */
+    get itemList(): boolean;
+    /** @param {boolean} v */
+    set itemList(v: boolean);
 }
-/** A group of radios declared as ful-radio children, a fieldset carrying the group semantics. */
+/**
+ * A group of radios declared as `ful-radio` children. Each `ful-radio` becomes
+ * a radio input carrying its attributes, labelled by its content; every
+ * `input-*` attribute on the group is forwarded onto each radio as well. The
+ * default slot is the `<legend>`, and `header` and `footer` slots frame the
+ * list. The radios share a name of their own, minted afresh for each group
+ * (from `name` when there is one) so that same-named groups stay apart, and
+ * carry `form=""`, so the group is the only element the form sees. A radio's
+ * native `change` is stopped and republished as the group's own.
+ *
+ * The host carries the `radiogroup` role, `aria-readonly`, `aria-required`,
+ * `aria-invalid` and the description. The disabled and readonly claims act on
+ * the group's `<fieldset>`, and readonly refuses every click inside it.
+ * `focus()` lands on the first radio.
+ */
 declare class RadioGroup extends Field {
     #private;
+    /** @type {string[]} */
     static attributes: string[];
     static slots: boolean;
+    /** @type {string} */
     static ROLE: string;
     static template: string;
     /**
      * @param {{slots: any}} conf
-     * @returns {any}
+     * @returns {any} the pieces: the first radio as the control, the fieldset
+     * as the `claims` and `freeze` pieces, and the host as the `described` and
+     * `announces` pieces
      */
     _build({ slots }: {
         slots: any;
     }): any;
+    /**
+     * The value of the checked radio, `null` when none is. Under
+     * `type="boolean"` it answers `true` for a radio whose value is `true` and
+     * `false` for any other. Writing a value checks the radio carrying it, and
+     * writing `null` or a value no radio carries clears the selection. Before
+     * the render it answers the value last written, or the `value` attribute,
+     * when a `ful-radio` carries it, and a write is held for the render to
+     * apply.
+     * @type {string | boolean | null}
+     */
     get value(): string | boolean | null;
     set value(value: string | boolean | null);
 }
-/** A checkbox, or a switch under the type=switch claim. */
+/**
+ * A checkbox, or a switch with the `switch` role under `type="switch"`. The
+ * label is the default slot, pointed at the input with `for` and `id`, so a
+ * click on it toggles the value. Every `input-*` attribute is forwarded onto
+ * the input. The input's native `change` is stopped and republished as the
+ * field's own. Readonly freezes the whole choice, label included: no click
+ * inside it toggles the value while the claim holds.
+ */
 declare class Checkbox extends Field {
     #private;
+    /** @type {string[]} */
     static attributes: string[];
+    /** @type {string[]} */
     static observed: string[];
     static slots: boolean;
     static template: string;
+    /**
+     * @param {{ slots: Record<string, DocumentFragment> | undefined }} conf
+     * @returns {any} the pieces, the `ful-choice` container being the `freeze` piece
+     */
     _build({ slots }: {
-        slots: any;
-    }): {
-        fragment: any;
-        control: any;
-        error: any;
-        label: any;
-        freeze: any;
-    };
-    get value(): any;
-    set value(value: any);
+        slots: Record<string, DocumentFragment> | undefined;
+    }): any;
+    /**
+     * Whether the box is checked. The `value` attribute is read with the `bool`
+     * mapper, where only the text `true` means checked. Before the render it
+     * answers the value last written, or the `value` attribute, and a write is
+     * held for the render to apply.
+     * @type {boolean}
+     */
+    get value(): boolean;
+    set value(value: boolean);
 }
-/** The sort control of a table header: focusable, keyboard-activated, walking asc, desc, unsorted. */
+export type TablePageRequest = {
+    page: number;
+    size: number;
+};
+export type TableSortRequest = {
+    sorter: string;
+    order: string;
+};
+export type TablePageResponse = {
+    data: any[];
+    size: number;
+};
+export type TableRowLoader = {
+    load(pageRequest: TablePageRequest, sortRequest: TableSortRequest | null, filterRequest: Record<string, any>): Promise<TablePageResponse>;
+};
+/**
+ * @typedef {{ page: number, size: number }} TablePageRequest the zero based
+ * index of the page and the number of rows in a page
+ */
+/**
+ * @typedef {{ sorter: string, order: string }} TableSortRequest the sort key
+ * of a column and its direction, `asc` or `desc`
+ */
+/**
+ * @typedef {{ data: any[], size: number }} TablePageResponse the rows of the
+ * requested page and the total number of rows across every page
+ */
+/**
+ * @typedef {{ load(pageRequest: TablePageRequest, sortRequest: TableSortRequest|null, filterRequest: Record<string, any>): Promise<TablePageResponse> }} TableRowLoader
+ */
+/**
+ * The sort control of a table header, `ful-sorter`: a `role="button"` with
+ * `tabindex="0"`, activated by a click or by Enter, NumpadEnter or Space.
+ *
+ * Each activation dispatches `sort:requested` (bubbling, not cancelable) with
+ * `detail.value` set to `{ sorter, order }`: `sorter` is the `sorter`
+ * attribute, read once at the upgrade, and `order` is the one after the
+ * current `order` in the cycle `asc`, `desc`, `null`. The button does not
+ * change its own `order`: whoever handles the event sets it, which `ful-table`
+ * does once the sorted page has loaded.
+ */
 declare class SortButton extends ParsedElement {
     #private;
     static attributes: string[];
     static observed: string[];
     render(): void;
-    get order(): any;
-    set order(value: any);
+    /**
+     * The direction the column is sorted in, `null` when unsorted.
+     * @returns {string|null}
+     */
+    get order(): string | null;
+    /**
+     * Reflects the direction to the `order` attribute and sets `aria-sort` on
+     * the enclosing `<th>`, if any: `ascending` for `asc`, `descending` for any
+     * other non-empty value, removed for an empty one.
+     * @param {string|null} value an empty string or `null` means unsorted
+     */
+    set order(value: string | null);
 }
-/** The pager: a window of page links around the current one, and the reload control. */
+/**
+ * The pager, `ful-pagination`: a previous button, a window of page buttons
+ * around the current page, a next button, a reload button and a line saying
+ * which page of how many is shown.
+ *
+ * The window holds at most `pages` buttons (read once at the upgrade, default 5),
+ * centred on the current page and shifted back on the last pages so it stays
+ * full. The current page's button carries `aria-current="page"` and stays
+ * enabled. Previous and next are disabled where there is no page to go to.
+ *
+ * A click on an enabled button other than the current page dispatches
+ * `page:requested` (bubbling, not cancelable) with `detail.value` the zero based
+ * index of the page asked for; the reload button asks for the current page.
+ * The pager does not move itself: whoever handles the event calls `update`,
+ * which `ful-table` does once the page has loaded.
+ *
+ * The icons are the `ful-icon` names in `Pagination.config`.
+ */
 declare class Pagination extends ParsedElement {
     #private;
     static observed: string[];
@@ -798,47 +2135,130 @@ declare class Pagination extends ParsedElement {
     static template: string;
     render(): void;
     /**
-     * Moves the pager to a page, a page count, or both, and repaints once. The
-     * two are one state: writing them one at a time repainted the bar twice per
-     * load, the first pass drawing the new page against the old count.
-     * @param {{ current?: number|null, total?: number|null }} [state]
+     * Moves the pager to a page, a page count, or both, reflects both to their
+     * attributes and repaints the bar once. A key left out keeps its value; a
+     * `null` one becomes 0. A count below one is shown as one empty page.
+     *
+     * The bar is replaced on every repaint. When the focus was inside it, it
+     * moves to the equivalent control of the new bar: the button of the same
+     * page, else the same enabled control, else the current page's button.
+     * @param {{ current?: number|null, total?: number|null }} [state] `current`
+     * is the zero based index of the page shown, `total` the number of pages
      */
     update({ current: toCurrent, total: toTotal }?: {
         current?: number | null;
         total?: number | null;
     }): void;
+    /**
+     * The number of pages, as last written.
+     * @returns {number}
+     */
     get total(): number;
-    set total(value: number);
+    /**
+     * Same as `update({ total: value })`.
+     * @param {number|null} value
+     */
+    set total(value: number | null);
+    /**
+     * The zero based index of the page shown.
+     * @returns {number}
+     */
     get current(): number;
-    set current(value: number);
+    /**
+     * Same as `update({ current: value })`.
+     * @param {number|null} value
+     */
+    set current(value: number | null);
 }
 /** Reads the schema declaration into the header and row templates a table renders from. */
 declare class TableSchemaParser {
-    static parse(nodeOrFragment: any, template: any): {
-        headersTemplate: any;
-        rowsTemplate: any;
+    /**
+     * Builds a header `<tr>` and a row `<tr data-tpl-each="rows">` from the
+     * `<schema>` child of the slot. The `<schema>` attributes are copied onto
+     * both rows. Each `<column>` becomes a `<th>` and a `<td>` carrying the
+     * column's attributes except `title`, `sorter` and `order`, so a
+     * `data-tpl-*` on a column applies to both cells; the two templates carry
+     * `inHeaders` and `inRows` in their scope, so a column can tell them apart,
+     * as in `data-tpl-if="inRows"`. The header cell holds the `<title>` child
+     * element of the column, else the text of its `title` attribute, wrapped
+     * in a `ful-sorter` when the column declares `sorter` or `order`. The body
+     * cell holds the column's remaining children.
+     *
+     * The column elements are consumed: their `<title>`, `title`, `sorter` and
+     * `order` are removed and their children moved into the cells.
+     * @param {DocumentFragment|Element|undefined} nodeOrFragment the `schema`
+     * slot, undefined when the table has none
+     * @param {ReturnType<ParsedElement['template']>} template the template the
+     * header and row templates derive from, keeping its scope
+     * @returns {{ headersTemplate: ReturnType<ParsedElement['template']>, rowsTemplate: ReturnType<ParsedElement['template']>, sort: { sorter: string|null, order: string|null } | null, length: number }}
+     * `sort` is the initial sort, taken from the first column declaring both
+     * `order` and `sorter` (a column with only `order` gets an arrow but no
+     * initial sort), `null` when none does; `length` is the number of columns
+     * @throws {Error} when the slot is missing or holds no `<schema>`
+     */
+    static parse(nodeOrFragment: DocumentFragment | Element | undefined, template: ReturnType<ParsedElement['template']>): {
+        headersTemplate: ReturnType<ParsedElement['template']>;
+        rowsTemplate: ReturnType<ParsedElement['template']>;
         sort: {
             sorter: string | null;
             order: string | null;
-        };
+        } | null;
         length: number;
     };
 }
 /** Serves a table's rows from an array held in memory, applying the sort and the paging itself. */
 declare class InMemoryTableLoader {
     #private;
-    constructor(data: any);
-    load(pageRequest: any, sortRequest: any, filterRequest: any): Promise<{
-        data: any;
-        size: any;
-    }>;
-    update(data: any): void;
+    /**
+     * @param {any[]} data the rows
+     */
+    constructor(data: any[]);
+    /**
+     * Sorts a copy of the rows by the `sorter` property, rows missing it last
+     * in either direction and rows with equal values in their original order,
+     * then slices the requested page. The filters are ignored.
+     * @param {TablePageRequest} pageRequest
+     * @param {{ sorter?: string|null, order?: string|null } | null} sortRequest
+     * `order` `desc` sorts descending, anything else ascending; no `sorter`
+     * keeps the original order
+     * @param {Record<string, any>} filterRequest not read
+     * @returns {Promise<TablePageResponse>}
+     */
+    load(pageRequest: TablePageRequest, sortRequest: {
+        sorter?: string | null;
+        order?: string | null;
+    } | null, filterRequest: Record<string, any>): Promise<TablePageResponse>;
+    /**
+     * Replaces the rows. The table shows them at its next load.
+     * @param {any[]} data
+     */
+    update(data: any[]): void;
 }
 /** Requests one page of rows from a url, passing the page, the sort and the filters to the endpoint. */
 declare class RemoteTableLoader {
     #private;
-    constructor(http: any, url: any, method: any, responseMapper?: (response: any) => any);
-    load(pageRequest: any, sortRequest: any, filterRequest: any): Promise<any>;
+    /**
+     * @param {{ request(method: string, url: string): any }} http the `http-client` component
+     * @param {string} url
+     * @param {string} method
+     * @param {(response: any) => TablePageResponse} [responseMapper] turns the
+     * parsed json body into the page response; the identity when omitted
+     */
+    constructor(http: {
+        request(method: string, url: string): any;
+    }, url: string, method: string, responseMapper?: (response: any) => TablePageResponse);
+    /**
+     * Sends the query parameters `page`, `size`, `sort` as `sorter,order`
+     * (left out when `sortRequest` is null) and `filters` as a json object of
+     * the filters with a truthy value (left out when there is none), and
+     * answers the json body through the response mapper.
+     * @param {TablePageRequest} pageRequest
+     * @param {TableSortRequest|null} sortRequest
+     * @param {Record<string, any>} filterRequest
+     * @returns {Promise<TablePageResponse>} rejecting with what the client's
+     * `fetchJson()` rejects with
+     */
+    load(pageRequest: TablePageRequest, sortRequest: TableSortRequest | null, filterRequest: Record<string, any>): Promise<TablePageResponse>;
 }
 /**
  * Builds the table's loader from its attributes: an in-memory one, or the
@@ -846,98 +2266,449 @@ declare class RemoteTableLoader {
  *
  * A component registered under the `loader` attribute replaces this one and
  * must implement `load(pageRequest, sortRequest, filterRequest)`, answering
- * `{ data, page, size }` for the requested page. `pageRequest` carries the page
- * index and its size, `sortRequest` the column and direction, and
+ * `{ data, size }`: the rows of the requested page and the total count of
+ * rows. `pageRequest` carries the page index and its size, `sortRequest` the column and direction, and
  * `filterRequest` the values of the filters in the slot.
  */
 declare class TableLoader {
-    static create(el: any, conf: any): InMemoryTableLoader | RemoteTableLoader;
+    /**
+     * A table with a `src` attribute gets a `RemoteTableLoader` sending through
+     * the `http-client` component with the `method` attribute or `GET`, and
+     * mapping the response through the component named by `response-mapper`,
+     * if any. A table without `src` gets an empty `InMemoryTableLoader`, which
+     * `withLoader` reaches to give it rows.
+     * @param {Element & { component(name: string): any }} el the table
+     * @param {unknown} [conf] not read
+     * @returns {InMemoryTableLoader | RemoteTableLoader}
+     */
+    static create(el: Element & {
+        component(name: string): any;
+    }, conf?: unknown): InMemoryTableLoader | RemoteTableLoader;
 }
-/** A table loading its rows from a loader, with sorting, pagination and an optional filter form. */
+/**
+ * A table, `ful-table`, loading its rows a page at a time from a loader, with
+ * a header sorter per sortable column, a `ful-pagination` under it and an
+ * optional filter form.
+ *
+ * The loader is the component named by `loader`, default `loaders:table`
+ * (see `TableLoader`). The `schema` slot declares the columns (see
+ * `TableSchemaParser.parse`); the `filters` slot is wrapped in a `ful-form`,
+ * whose values are the filter request; the `caption`, `footer` and `empty`
+ * slots go in the table's caption, its `<tfoot>` and the panel shown for a
+ * load answering no rows. Attributes starting with `table-` are forwarded,
+ * without the prefix, to the inner `<table>`.
+ *
+ * With `autoload` the first load starts at the upgrade, which does not wait
+ * for it. Without it the table shows an initial panel until `load`,
+ * `reload` or `resetWithFilter` is called.
+ *
+ * Inside the table, and not inside a `ful-table` nested in it, a
+ * `page:requested` loads that page with the current size,
+ * sort and filters; a `sort:requested` loads the current page with the new
+ * sort (none for a `null` order) and, once that load is the one showing, sets
+ * the order of the sorter that asked and clears the others; a `submit:success`
+ * of the filter form loads the first page with the submitted request as the
+ * filters. The first load goes through the filter form too: `reload`, and so
+ * `autoload`, submits it (see `reload`), so a `submit` listener rewriting
+ * `detail.request` shapes every load alike. The filters a page, a sort or a size change carries are those of
+ * the last load asked for, whether it is still running, loaded or failed, so
+ * they are the ones the filter form shows. The loads these start, and the autoload, are not awaited by
+ * anything: a failure shows the error panel and its rejection is unhandled.
+ */
 declare class Table extends ParsedElement {
     #private;
+    /** Read once at the upgrade. */
     static attributes: string[];
-    /**
-     * The page size stays live: a rows-per-page control is a normal thing to
-     * put next to a table, and the size is the one piece of the request an
-     * author changes after the table is up. The rest of the request is the
-     * table's own state, moved by the pager, the sorters and the filter form.
-     */
+    /** These stay live after the upgrade: see `pageSize`, `src` and `method`. */
     static observed: string[];
     static slots: boolean;
     static config: {
         searchIcon: string;
+        emptyIcon: string;
     };
     static template: string;
     static templates: {
         row: string;
     };
-    /** How many rows a page asks the loader for: the size the next load will carry. */
+    /**
+     * How many rows a page asks the loader for: the size the next load will
+     * carry. Ten before the render.
+     * @returns {number}
+     */
     get pageSize(): number;
     /**
-     * Changes the page size and reloads from the first page, the current index
-     * meaning nothing under a new size. A table that has not loaded yet only
-     * records it: writing the size is not a request to start loading, which is
-     * what `autoload` and `reload()` are for.
+     * Changes the page size and reloads from the first page, keeping the sort
+     * and the filters. A table that has not loaded yet only records it:
+     * writing the size is not a request to start loading, which is what
+     * `autoload` and `reload()` are for. A write that does not change the size
+     * does nothing. A write made before the render is replaced by the declared
+     * `page-size` when the table renders.
      *
-     * Absent or null is the default of ten, so removing the attribute restores
-     * it rather than asking the loader for NaN rows.
+     * The reload is not awaited: a failure shows the error panel and its
+     * rejection is unhandled.
+     * @param {number|string|null|undefined} value a number or a string of
+     * one, such as a select's value; absent or null is the default of ten,
+     * so removing the attribute restores it, and a value that is not a
+     * number is ignored
+     */
+    set pageSize(value: number | string | null | undefined);
+    /**
+     * The url the loader asks for rows, reflected as the `src` attribute.
+     * @returns {string|null}
+     */
+    get src(): string | null;
+    /**
+     * Points the table at another url: the loader is built again through its
+     * component's `create`, as at the render, and the table reloads from the
+     * first page, keeping the size, the sort and the filters. A table that has
+     * not loaded yet only rebuilds its loader. A write that does not change the
+     * url does nothing.
+     *
+     * The reload is not awaited: a failure shows the error panel and its
+     * rejection is unhandled.
+     * @param {string|null|undefined} value null or undefined removes the url,
+     * which the default loader answers with an empty in-memory loader
+     */
+    set src(value: string | null | undefined);
+    /**
+     * The http method the default loader sends with, reflected as the `method`
+     * attribute; `GET` when absent.
+     * @returns {string|null}
+     */
+    get method(): string | null;
+    /**
+     * Changes the http method the way `src` changes the url: the loader is
+     * built again and the table reloads from the first page.
+     * @param {string|null|undefined} value
+     */
+    set method(value: string | null | undefined);
+    /**
+     * Writes `src` and `method` together and loads once: the loader is built
+     * again for the pair when either changed, the page going back to the first
+     * one as a single write of either does, and the table then reloads as
+     * `reload()` does, whether or not they changed. Unlike a write of either,
+     * it loads a table that has not loaded yet.
+     * @param {{ src?: string|null, method?: string|null }} attributes a name
+     * left out keeps its value, null removes the attribute
+     * @returns {Promise<void>} as `load`
+     */
+    reconfigure(attributes: {
+        src?: string | null;
+        method?: string | null;
+    }): Promise<void>;
+    /**
+     * @param {{ slots: Record<string, DocumentFragment> }} c
+     * @returns {Promise<void>}
+     * @throws {Error} when the `schema` slot is missing or holds no `<schema>`
      */
-    set pageSize(value: number);
     render({ slots }: {
-        slots: any;
+        slots: Record<string, DocumentFragment>;
     }): Promise<void>;
+    /**
+     * Loads the last request that loaded, or, before any has, the first page
+     * with the declared size and sort. A size written through `pageSize` since
+     * then replaces the page with the first one at that size.
+     *
+     * Before any load has loaded, a table with a `filters` slot submits its
+     * filter form instead, so the first request goes through the same
+     * `submit` listeners as the later ones, and the load its `submit:success`
+     * starts is the one awaited. A filter submit that is cancelled, fails or
+     * is dropped for one in flight loads nothing, and the promise resolves.
+     * @returns {Promise<void>} as `load`
+     */
     reload(): Promise<void>;
-    load(pageRequest: any, sortRequest: any, filterRequest: any): Promise<void>;
-    /** Hands the loader to the callback, for runtime reconfigurations. */
-    withLoader(fn: any): Promise<any>;
-    resetWithFilter(filterRequest: any): Promise<void>;
+    /**
+     * Asks the loader for a page and shows it. Its filters are, from now on,
+     * the ones a page, a sort or a size change carries, even while it runs
+     * or once it failed.
+     *
+     * While the load runs the table carries `aria-busy="true"`, and the rows
+     * already shown stay; the spinner panel shows only when there are none.
+     * When the loader answers, the rows and the pager are replaced, the empty
+     * panel shows for an answer with no rows (the `empty` slot rendered with
+     * `schema`, `pageRequest`, `filterRequest` and `pageResponse` in scope),
+     * the request becomes the one
+     * `reload` repeats; once the elements of the rows and of the empty panel
+     * have rendered, `aria-busy` is removed and `load:success` is
+     * dispatched (bubbling, not cancelable) with `detail` set to
+     * `{ pageRequest, sortRequest, filterRequest, response }`. A page beyond
+     * the last one the answer reports is not shown: the last page is loaded
+     * instead, and the returned promise settles with that load.
+     *
+     * When the loader rejects, the rows are removed, the error panel shows the
+     * `reason` of each of the error's `problems`, one per line, or the error as text,
+     * `aria-busy` is removed, `load:failure` is dispatched (bubbling, not
+     * cancelable) with `detail` set to
+     * `{ pageRequest, sortRequest, filterRequest, exception }`, and the
+     * returned promise rejects with the same error.
+     *
+     * A load started after this one supersedes it: when this one's answer or
+     * failure arrives it changes nothing, dispatches nothing and resolves;
+     * superseded while its rows render, it leaves them to the newer load and
+     * dispatches nothing.
+     * @param {TablePageRequest} pageRequest
+     * @param {TableSortRequest|null} sortRequest
+     * @param {Record<string, any>} filterRequest
+     * @returns {Promise<void>}
+     * @throws what the loader rejects with, unless a newer load superseded this one
+     */
+    load(pageRequest: TablePageRequest, sortRequest: TableSortRequest | null, filterRequest: Record<string, any>): Promise<void>;
+    /**
+     * Hands the loader to the callback, for runtime reconfigurations, such as
+     * `update(rows)` on the in-memory loader. The loader exists from the
+     * render on. Nothing is reloaded.
+     * @template T
+     * @param {(loader: any) => T | Promise<T>} fn
+     * @returns {Promise<T>} what `fn` returns or resolves to
+     */
+    withLoader<T>(fn: (loader: any) => T | Promise<T>): Promise<T>;
+    /**
+     * Loads the first page with the given filters, keeping the size and the sort.
+     * @param {Record<string, any>} filterRequest
+     * @returns {Promise<void>} as `load`
+     */
+    resetWithFilter(filterRequest: Record<string, any>): Promise<void>;
 }
+/**
+ * An invoker button paired with the `ul[popover][role=menu]` that follows it:
+ * the chrome behind every filter's operator, sensitivity and boolean value.
+ *
+ * It fills the menu from a vocabulary, wires it the first time more than one
+ * choice survives the whitelist, pins the button to a static glyph when a
+ * single one does, takes the shared menu keyboard protocol, and keeps the
+ * button's value, glyph and aria-label in step. A pick that changes the value
+ * calls back; the host decides what that means.
+ *
+ * The button's `value` attribute is the store, as it is for a native control:
+ * the menu protocol finds the current item by it, and nothing mirrors it.
+ */
+declare class ChoiceButton {
+    #private;
+    /**
+     * The declared choices narrowed to a vocabulary, in the declared order.
+     * When none of them is in the vocabulary, or none is declared, the answer
+     * is a copy of the whole vocabulary.
+     * @param {string[] | null | undefined} declared
+     * @param {string[]} vocabulary
+     * @returns {string[]}
+     */
+    static narrow(declared: string[] | null | undefined, vocabulary: string[]): string[];
+    /**
+     * Takes the button's next sibling as its menu and listens for picks on it.
+     * The menu is neither filled nor wired until `allowed` is first written.
+     *
+     * A click on an item, while `interactive()` answers true, sets the value,
+     * hides the menu and, when the value changed, calls `onPick`.
+     * @param {HTMLElement} button the invoker, whose next sibling is its menu
+     * @param {{vocabulary: string[], glyphs?: Record<string,string>, labelFor?: (v: string) => string,
+     *          display?: ((v: string) => string)|null, interactive?: () => boolean, onPick?: (v: string) => void}} conf
+     *        `vocabulary` lists every choice; `glyphs` maps a choice to its compact
+     *        glyph; `labelFor` answers the localized word, used as the button's
+     *        `aria-label` and beside the glyph in the menu (the choice itself by
+     *        default); `display` answers the button's text (by default the glyph,
+     *        or the choice where it has none); `interactive` is asked before a
+     *        pick is taken; `onPick` receives a pick that changed the value
+     */
+    constructor(button: HTMLElement, { vocabulary, glyphs, labelFor, display, interactive, onPick }: {
+        vocabulary: string[];
+        glyphs?: Record<string, string>;
+        labelFor?: (v: string) => string;
+        display?: ((v: string) => string) | null;
+        interactive?: () => boolean;
+        onPick?: (v: string) => void;
+    });
+    /**
+     * The choices the menu offers. Writing it narrows the declared set with
+     * `narrow`, refills the menu, wires the popover and the menu keyboard the
+     * first time more than one choice is allowed, and updates the button's
+     * disabled state and popup attributes. When one choice is left the button
+     * is pinned and the value is set to it.
+     * @type {string[]}
+     */
+    get allowed(): string[];
+    set allowed(declared: string[]);
+    /**
+     * The choice when the menu allows it, otherwise the first allowed one.
+     * @param {string|null} choice
+     * @returns {string}
+     */
+    preferring(choice: string | null): string;
+    /**
+     * Whether fewer than two choices are allowed. A pinned button is disabled,
+     * opens no menu and shows the single choice as its value.
+     * @returns {boolean}
+     */
+    get pinned(): boolean;
+    /**
+     * The host's fixed claim: hides the button with the `hidden` attribute
+     * while `value` keeps answering.
+     * @param {boolean} fixed
+     */
+    set fixed(fixed: boolean);
+    /**
+     * The current choice, stored as the button's `value` attribute, where the
+     * menu keyboard also finds it. Writing it sets the button's text from
+     * `display`, its `aria-label` from `labelFor`, and `aria-checked` on the
+     * menu item carrying it. It does not call `onPick`.
+     * @type {string | null}
+     */
+    get value(): string | null;
+    set value(choice: string | null);
+    /**
+     * The host's disabled claim. The button is disabled while either the claim
+     * or the pin holds, so lifting one does not enable it while the other holds.
+     * @param {boolean} claimed
+     */
+    set claimed(claimed: boolean);
+}
+export type FilterCriterion = {
+    label: string | null;
+    operator: string | null;
+    operands: string[];
+};
 /**
  * The shared shape of every operator-and-operands filter: an operator menu, one
  * or two operands of the type the subclass declares, and a tuple that mirrors
  * the data-jpa compare annotations.
+ *
+ * The value is `[operator, operand]`, or `[operator, from, to]` for BETWEEN,
+ * the only operator that shows the second operand. The `operators` attribute
+ * whitelists the menu; the `operator` attribute fixes the operator for the
+ * element's life instead, hiding its button, and every tuple then carries it.
+ * Declaring both warns and the singular wins; a fixed name outside the
+ * vocabulary warns and fixes the default operator.
+ *
+ * Both operands mirror the disabled and readonly claims, and readonly also
+ * refuses the clicks that would open the operator menu. The change event fires
+ * when either operand changes or a different operator is picked.
  */
 declare class CompareFilter extends Input {
+    #private;
     static observed: string[];
-    static OPERATORS: string[];
-    static DEFAULT_OPERATOR: string;
+    static attributes: string[];
     static template: string;
     _operator: any;
     _container: any;
     _value1: any;
     _value2: any;
     _build(conf: any): {
-        fragment: any;
+        fragment: DocumentFragment;
         control: any;
-        error: any;
-        label: any;
+        error: Element | null;
+        label: HTMLLabelElement | null;
         freeze: any;
         also: any[];
     };
     _showDefaultOperator(): void;
+    /**
+     * Restores the declared `value` tuple, operator included, as a field reset
+     * does. Without a `value` attribute it empties the operands and also shows
+     * the default operator again, or the first whitelisted one where the
+     * default is not allowed.
+     */
     formResetCallback(): void;
+    /**
+     * The native input type both operands render with.
+     * @returns {string}
+     */
     _type(): string;
-    _serialize(v: any): any;
-    _deserialize(v: any): any;
+    /**
+     * Converts an operand from its input's value to the form the tuple carries.
+     * @param {string} v
+     * @returns {string|null}
+     */
+    _serialize(v: string): string | null;
+    /**
+     * Converts an operand from the tuple to the value its input shows.
+     * @param {string} v
+     * @returns {string}
+     */
+    _deserialize(v: string): string;
+    /**
+     * The operator shown on render and after a valueless reset, when the whitelist allows it.
+     * @returns {string}
+     */
     _defaultOperator(): string;
+    /**
+     * Every operator the filter knows, which `operators` narrows.
+     * @returns {string[]}
+     */
     _vocabulary(): string[];
     _declaredOperators: any;
-    get operators(): any;
-    set operators(declared: any);
+    /**
+     * The operators the menu offers, narrowed to the vocabulary: an empty list,
+     * or one where no name is known, offers all of it. A single operator pins
+     * the button, and an assigned tuple then carries that operator whatever it
+     * names. When the operator shown leaves the list, the first listed one is
+     * shown. An assignment made before the upgrade is held narrowed and
+     * answered back until the render, when the `operators` attribute is applied
+     * over it, an absent attribute meaning the whole vocabulary. Assignments are
+     * ignored while the `operator` attribute fixes the operator.
+     * @returns {string[]|undefined} undefined before the upgrade when nothing was assigned
+     */
+    get operators(): string[] | undefined;
+    /** @param {string[]|null} declared */
+    set operators(declared: string[] | null);
+    /**
+     * The filter's tuple, `[operator, operand]` or `[operator, from, to]` for
+     * BETWEEN, each operand converted by `_serialize` (an ISO instant for the
+     * instant filter). Null while any operand the operator uses is empty.
+     * Before the render it answers the tuple last written, or the `value`
+     * attribute, as the rendered filter would show it.
+     * @returns {any[]|null}
+     */
     get value(): any[] | null;
-    set value(v: any[] | null);
+    /**
+     * Shows a tuple: the operator it names, or the first allowed one where the
+     * whitelist, a pin or a fixed operator does not allow it, and its operands, an operand missing from a shorter tuple
+     * leaving its input empty. Null or undefined empties both operands and
+     * keeps the operator. Before the render the tuple is held for the render
+     * to apply, over the `value` attribute, which it leaves alone.
+     * @param {any[]|null|undefined} v
+     */
+    set value(v: any[] | null | undefined);
+    /**
+     * The tuple `_tuple` answers once `_applyTuple(v)` has shown `v`, read
+     * from the declared `operator` and `operators` in place of the menu.
+     * @param {any[]|null|undefined} v
+     * @returns {any[]|null}
+     */
+    _shownTuple(v: any[] | null | undefined): any[] | null;
     _tuple(): any[] | null;
     _applyTuple(v: any): void;
     _showOperator(operator: any): void;
-    /** only a BETWEEN carries a second operand */
+    /** Shows the second operand only while the operator is BETWEEN. */
     _syncBetween(): void;
+    /**
+     * The operator and the operands the operator uses, as their inputs show
+     * them rather than as serialized: a date filter describes what is in its
+     * control, not the ISO string it sends. Null while every one of those
+     * operands is empty, so a BETWEEN with one bound answers that bound while
+     * its value is still null, and before the filter has rendered.
+     * @returns {FilterCriterion|null}
+     */
+    get criterion(): FilterCriterion | null;
+    /**
+     * The field's own disabled claim. Setting it disables both operands and
+     * every menu button the filter composes; a button pinned to one choice
+     * stays disabled when the claim is lifted.
+     * @returns {boolean}
+     */
     get disabled(): boolean;
+    /** @param {boolean} d */
     set disabled(d: boolean);
-    /** every menu button the filter composes, so one claim reaches them all */
-    _choices(): any[];
+    /**
+     * The menu buttons the filter composes, which the disabled claim reaches. A
+     * subclass adding a menu appends its own to the base's.
+     * @returns {ChoiceButton[]}
+     */
+    _choices(): ChoiceButton[];
 }
-/** The compare filter over ISO instants, defaulting to LTE. */
+/**
+ * The compare filter over ISO instants, defaulting to LTE. The operands are
+ * shown as local date and time in the page's timezone and carried in the tuple
+ * as UTC ISO instants.
+ */
 declare class InstantFilter extends CompareFilter {
     _defaultOperator(): string;
     _type(): string;
@@ -952,35 +2723,93 @@ declare class LocalDateFilter extends CompareFilter {
 declare class NumberFilter extends CompareFilter {
     _type(): string;
 }
-/** The compare filter over text, carrying a case sensitivity beside the operator. */
+/**
+ * The compare filter over text, defaulting to CONTAINS and adding CONTAINS,
+ * STARTS_WITH and ENDS_WITH to the compare operators.
+ *
+ * Its tuple carries a case sensitivity after the operator, `[operator,
+ * sensitivity, operand]` or `[operator, sensitivity, from, to]`, the
+ * sensitivity being IGNORE_CASE (the default) or CASE_SENSITIVE and switched
+ * through a second menu. The `sensitivities` attribute whitelists that menu and
+ * `sensitivity` fixes one mode, with the same rules and warnings as
+ * `operators` and `operator`.
+ */
 declare class TextFilter extends CompareFilter {
     static observed: string[];
+    static attributes: string[];
     static template: string;
     _defaultOperator(): string;
     _vocabulary(): string[];
     _sensitivityButton: any;
     _build(conf: any): {
-        fragment: any;
+        fragment: DocumentFragment;
         control: any;
-        error: any;
-        label: any;
+        error: Element | null;
+        label: HTMLLabelElement | null;
         freeze: any;
         also: any[];
     };
     _choices(): any[];
     get _sensitivity(): any;
     _declaredSensitivities: any;
-    get sensitivities(): any;
-    set sensitivities(declared: any);
+    /**
+     * The sensitivities the menu offers, narrowed to IGNORE_CASE and
+     * CASE_SENSITIVE: an empty list, or one where no name is known, offers both.
+     * When the mode shown leaves the list, the first listed one is shown. Held
+     * before the upgrade and ignored under a fixed `sensitivity`, as `operators` is.
+     * @returns {string[]|undefined} undefined before the upgrade when nothing was assigned
+     */
+    get sensitivities(): string[] | undefined;
+    /** @param {string[]|null} declared */
+    set sensitivities(declared: string[] | null);
+    /**
+     * The tuple with the sensitivity after the operator, `[operator,
+     * sensitivity, ...operands]`. Null while any operand the operator uses is
+     * empty. Before the render it answers the tuple last written, or the
+     * `value` attribute, as the rendered filter would show it.
+     * @returns {any[]|null}
+     */
     get value(): any[] | null;
-    set value(v: any[] | null);
+    /**
+     * Shows a tuple as the compare filter does, reading the sensitivity at
+     * index 1. A sensitivity the whitelist does not allow leaves the current
+     * one in place. Null or undefined empties the operands and keeps the
+     * operator and the sensitivity. Before the render the tuple is held, as
+     * on the compare filters.
+     * @param {any[]|null|undefined} v
+     */
+    set value(v: any[] | null | undefined);
+    /**
+     * Restores the declared `value` tuple, sensitivity included. Without a
+     * `value` attribute it also shows the default operator and IGNORE_CASE
+     * again, or the first whitelisted mode where IGNORE_CASE is not allowed.
+     */
     formResetCallback(): void;
 }
-/** The boolean filter: an EQ or NEQ operator and an any/yes/no menu. */
+/**
+ * The boolean filter: an EQ or NEQ operator menu and a value menu of any, yes
+ * and no, the value button showing the localized word.
+ *
+ * The value is `[operator, 'true']` or `[operator, 'false']`, null while the
+ * value menu is on any. The `operators` attribute whitelists the operator menu
+ * as on the compare filters. The disabled claim reaches the value button and
+ * both menus, and readonly refuses the clicks that would open them. The
+ * required and readonly claims reflect on the host only: no `aria-required` or
+ * `aria-readonly` is written, since the value button's role accepts neither.
+ */
 declare class BooleanFilter extends Field {
     static observed: string[];
     static slots: boolean;
+    /**
+     * The operators the filter knows, which `operators` narrows.
+     * @type {string[]}
+     */
     static OPERATORS: string[];
+    /**
+     * The operator shown on render and after a valueless reset, or the first
+     * whitelisted one where the whitelist excludes it.
+     * @type {string}
+     */
     static DEFAULT_OPERATOR: string;
     static template: string;
     _operator: any;
@@ -989,212 +2818,880 @@ declare class BooleanFilter extends Field {
     _build({ slots }: {
         slots: any;
     }): {
-        fragment: any;
-        control: any;
-        error: any;
-        label: any;
+        fragment: DocumentFragment;
+        control: HTMLElement;
+        error: Element | null;
+        label: HTMLLabelElement | null;
         announces: null;
         freeze: any;
     };
     _declaredOperators: any;
-    get operators(): any;
-    set operators(declared: any);
+    /**
+     * The operators the menu offers, narrowed to EQ and NEQ: an empty list, or
+     * one where no name is known, offers both, and a single one pins the
+     * button. When the operator shown leaves the list, the first listed one is
+     * shown. Held before the upgrade and replaced by the `operators` attribute
+     * at the render, as on the compare filters.
+     * @returns {string[]|undefined} undefined before the upgrade when nothing was assigned
+     */
+    get operators(): string[] | undefined;
+    /** @param {string[]|null} declared */
+    set operators(declared: string[] | null);
+    /** @returns {string[]} */
     _vocabulary(): string[];
-    get value(): any[] | null;
-    set value(v: any[] | null);
+    /**
+     * `[operator, token]`, the token being 'true' or 'false'; null while the
+     * value menu is on any. Before the render it answers the tuple last
+     * written, or the `value` attribute, as the rendered filter would show it.
+     * @returns {string[]|null}
+     */
+    get value(): string[] | null;
+    /**
+     * Shows a tuple: its operator, or the first allowed one where the whitelist
+     * does not allow it, and its token, a missing token meaning any. Null or undefined sets the value menu
+     * back to any and keeps the operator. Before the render the tuple is held,
+     * as on the compare filters.
+     * @param {any[]|null|undefined} v
+     */
+    set value(v: any[] | null | undefined);
+    /**
+     * Restores the declared `value` tuple. Without a `value` attribute it sets
+     * the value menu back to any and also shows the default operator again.
+     */
+    formResetCallback(): void;
+    /**
+     * The operator and the localized word the value menu shows, not the token.
+     * Null while the value menu is on any, and before the filter has rendered.
+     * @returns {FilterCriterion|null}
+     */
+    get criterion(): FilterCriterion | null;
+    /**
+     * The field's own disabled claim. Setting it disables the value button and
+     * both menu buttons; an operator button pinned to one choice stays disabled
+     * when the claim is lifted.
+     * @returns {boolean}
+     */
     get disabled(): boolean;
+    /** @param {boolean} d */
     set disabled(d: boolean);
 }
-/** An info icon button toggling a popover with a short explanation. */
+/**
+ * Set membership over a select's vocabulary, answering for both of data-jpa's
+ * set annotations: InEnum and InList take the same bare array of values and no
+ * operator, differing only in what the server converts them to. A declared
+ * `operator` attribute is sent in front of the keys instead, for a server field
+ * that reads the set through a compare.
+ */
+declare class InFilter extends Select {
+    #private;
+    static attributes: string[];
+    /**
+     * The chosen keys as an array, a single choice included, led by the
+     * declared `operator` when there is one. Null while nothing is chosen, so
+     * that a table drops the filter instead of sending an empty set that
+     * matches nothing. Before the render it answers the keys the select answers
+     * then.
+     * @returns {any[]|null}
+     */
+    get value(): any[] | null;
+    /**
+     * Selects the keys of an array or a single bare key; a leading element equal
+     * to the declared `operator` is dropped first, so the filter takes back what
+     * it answered. A single select takes the first key. Null or undefined clears
+     * the selection. Before the render the keys are held, as the select holds
+     * them.
+     * @param {any} v
+     */
+    set value(v: any);
+    /**
+     * The declared operator, or null, and the labels of the chosen entries. Null
+     * while nothing is chosen, as before the filter has rendered.
+     * @returns {FilterCriterion|null}
+     */
+    get criterion(): FilterCriterion | null;
+}
+/**
+ * An icon button that toggles a native popover, a `ful-note`, holding the
+ * default slot as a short explanation. The popover gives light dismiss and
+ * Escape, and the button carries an `aria-expanded` kept in step with it and
+ * a localized `aria-label`.
+ *
+ * The marker is the `ful-icon` that `Tooltip.config.icon` names for the whole
+ * page, or the one the `icon` attribute names for a single tooltip. A name the
+ * library does not paint is declared by the page as
+ * `ful-icon[name='...'] { mask-image: ... }`.
+ *
+ * `placement` picks the side of the marker the note opens on: `top` (the
+ * default), `bottom`, `left` or `right`. The note is placed in script on every
+ * platform, centred on the marker, clamped into the viewport and following the
+ * marker on scroll and resize, with a callout on the edge facing the marker.
+ *
+ * `describes` offers the note to the nearest ancestor that takes a description
+ * (see `describable`), a field's control in practice: when it is taken, the
+ * note becomes part of that control's accessible description and the marker
+ * leaves the tab order, staying clickable. When nothing takes it, the marker
+ * keeps its tab stop and a warning is logged.
+ */
 declare class Tooltip extends ParsedElement {
+    #private;
     static slots: boolean;
     static attributes: string[];
+    /** The page-wide defaults: `icon` is the `ful-icon` name of the marker. */
     static config: {
         icon: string;
     };
     static template: string;
+    /**
+     * @param {{ slots: Record<string, DocumentFragment> }} c
+     */
     render({ slots }: {
-        slots: any;
+        slots: Record<string, DocumentFragment>;
     }): void;
 }
-/** A modal dialog on the native platform, open()/ask() resolving with the closer's data-result. */
+export type DialogOutcome = {
+    dismissed: boolean;
+    result: string | null;
+    response: any;
+};
+/**
+ * How a dialog ended. `dismissed` is true for Escape, the close button, a
+ * backdrop click, a `data-result=""` button, `close()` without a result and a
+ * removal from the document; `result` is the `data-result` of the button, or
+ * the argument of `close(result)`, that answered; `response` is what the form
+ * answered with under `close-on-submit`. Whichever of `result` and `response`
+ * did not answer is null, as both are on a dismissal.
+ * @typedef {{ dismissed: boolean, result: string|null, response: any }} DialogOutcome
+ */
+/**
+ * A modal dialog on the native `<dialog>`, rendered with a header, a body and
+ * a footer. `open()` and `ask()` show it and resolve with a `DialogOutcome`.
+ *
+ * The `header` attribute is the title, rendered as an `h2` that names the
+ * dialog through `aria-labelledby`; without it the dialog is unnamed. The
+ * `header` slot is rendered in the header before the title, the default slot
+ * is the body, and the `buttons` slot is rendered in the footer. Without a
+ * `buttons` slot, and without `close-on-submit`, the footer holds a localized
+ * acknowledge button answering `acknowledged`.
+ *
+ * Any button inside the dialog carrying `data-result` closes it with that
+ * result, an empty one being a dismissal. The header carries a close button,
+ * and a press and release both on the backdrop close the dialog, each as a
+ * dismissal, as Escape does.
+ *
+ * Those three gestures go through `dismiss(reason)`, the reason being
+ * `button`, `backdrop` or `escape`: before it closes the dialog, the element
+ * dispatches a cancelable, non-bubbling `dialog:dismiss` with
+ * `detail: { reason }`, and a listener calling `preventDefault()` keeps it
+ * open. Under `guard-dismiss`, a dismissal nobody refused, while a `ful-form`
+ * of the dialog holds unsaved edits (see `Form.dirty`), first asks the user,
+ * through `Dialog.confirm`, whether to close and drop them. A `data-result`
+ * button, `close-on-submit`, `close()` and `update()` are answers or the page
+ * deciding: they dispatch nothing and ask nothing.
+ *
+ * The platform lets a page refuse Escape once per user interaction: a second
+ * Escape with no click or keystroke in between closes the dialog whatever the
+ * page does, `requires-answer` and `guard-dismiss` included. That close is
+ * still announced by a `dialog:dismiss`, which is then not cancelable.
+ *
+ * `requires-answer` withholds the close button and refuses Escape and the
+ * backdrop, so the dialog is closed only by a button carrying `data-result`
+ * or from code, through `close()` or `dismiss()`.
+ *
+ * `close-on-submit` closes the dialog when a `ful-form` that is a direct child
+ * of the body dispatches `submit:success`, answering with its
+ * `detail.response`. A form deeper in the body, such as the filter form of a
+ * `ful-table`, does not close it. The listener sits on the body, so a form
+ * delivered by `update()` is covered as well.
+ *
+ * Every close dispatches a non-bubbling `close` event on the element carrying
+ * the `DialogOutcome` as `detail`, before the pending `ask()` calls resolve.
+ * An element anywhere in the page carrying `dialog-target` set to the
+ * element's id opens it on click.
+ *
+ * The chrome is styled by class as well as by tag, so a plain `<dialog
+ * class="ful-dialog">` written by a page gets the same look: the tag form
+ * matches a direct child, and `ful-dialog-header`, `ful-dialog-body` and
+ * `ful-dialog-footer` match at any depth, as a dialog whose content is wrapped
+ * in a form needs.
+ */
 declare class Dialog extends ParsedElement {
     #private;
     static attributes: string[];
     static slots: boolean;
     static template: string;
+    /**
+     * @param {{ slots: Record<string, DocumentFragment> }} c
+     */
     render({ slots }: {
-        slots: any;
+        slots: Record<string, DocumentFragment>;
     }): void;
+    /**
+     * Resolves every pending `ask()` and `open()` with the outcome so far,
+     * a dismissal for a dialog still open, so that no caller waits on a dialog
+     * that left the document. The native dialog is not closed and no `close`
+     * event is dispatched.
+     */
     disconnectedCallback(): void;
-    open(): Promise<any>;
-    ask(): Promise<any>;
     /**
-     * Re-fires section:requested on the body, open or closed: the explicit
-     * request for a body that wants refreshing. A failed refresh paints its
-     * problems, nothing rejects: there is no caller to reject towards.
+     * The same as `ask()`.
+     * @returns {Promise<DialogOutcome>}
+     */
+    open(): Promise<DialogOutcome>;
+    /**
+     * Shows the dialog as a modal and resolves with how it ends.
+     *
+     * The call that opens the dialog resets the outcome of the previous
+     * opening, hides the error and loading sections, and dispatches
+     * `section:requested` on the element (bubbling, with
+     * `detail: { section, first, name: null, index: null }`, `section` being
+     * the body and `first` true only on the first answered request), so a
+     * listener can fill the body. A failed request is painted into the body
+     * and does not reject. On a dialog already open nothing is shown or
+     * requested, and the call waits for the same ending as the calls before it;
+     * one the page moved while open, which is no longer modal, opens anew.
+     * @returns {Promise<DialogOutcome>} resolving on close, or on removal from
+     * the document with a dismissal
+     */
+    ask(): Promise<DialogOutcome>;
+    /**
+     * Empties and hides the body, shows the loading section, opens the dialog
+     * if it is closed, and fills the body with what the callback resolves to.
+     * A rejection is shown, as the problems' reasons, in the error section,
+     * which has `role="alert"`, and the body is hidden. The title stays the
+     * `header` attribute.
+     *
+     * No `section:requested` is dispatched, and no `ask()` waiter is added:
+     * listen for the `close` event to learn how the dialog ended. When a newer
+     * `update()` starts before the callback settles, this call paints nothing
+     * and resolves `null`, the body being the newer call's; it still rejects
+     * with the callback's error.
+     * @param {() => Node|string|Promise<Node|string>} cb producing the body content
+     * @returns {Promise<Element|null>} the body section, in the document, or
+     * `null` for a call a newer one overtook
+     * @throws {any} what the callback threw or rejected with
+     */
+    update(cb: () => Node | string | Promise<Node | string>): Promise<Element | null>;
+    /**
+     * Dispatches `section:requested` for the body again, as `ask()` does,
+     * whether the dialog is open or closed. A failed request is painted into
+     * the body.
+     * @returns {Promise<any[]|undefined>} the listeners' answers, undefined when
+     * nobody answered or the request failed; it never rejects
      */
     refresh(): Promise<any[] | undefined>;
-    close(result: any): void;
+    /**
+     * Dismisses the dialog as the user would: dispatches the cancelable
+     * `dialog:dismiss` with `detail: { reason }` and, under `guard-dismiss`,
+     * asks before dropping unsaved edits, closing the dialog as a dismissal
+     * unless either refused. `requires-answer` does not refuse it, as it does
+     * not refuse `close()`. Does nothing on a closed dialog.
+     * @param {string} reason why it is dismissed, such as `navigation`
+     * @returns {Promise<boolean>} whether the dialog is closed, false when a
+     * listener or the user kept it open
+     */
+    dismiss(reason: string): Promise<boolean>;
+    /**
+     * Closes an open dialog, doing nothing on a closed one. A non-empty result
+     * answers as the button carrying that `data-result` would; no result, or
+     * an empty one, is a dismissal.
+     * @param {string} [result]
+     */
+    close(result?: string): void;
+    /**
+     * Appends a new `ful-dialog` to `document.body`, asks it, and removes it
+     * once it is answered or its render fails.
+     *
+     * A string body is set as text and never parsed as markup; a node is
+     * appended as it is. Each button is either a `[result, label, className?]`
+     * tuple, rendered as a `button` carrying `data-result`, or a node the
+     * caller built, placed in the footer in the order given. With no buttons
+     * the dialog shows its localized acknowledge button.
+     * @param {string} header the title
+     * @param {string|Node} body
+     * @param {([string, string, string?]|Node)[]} [buttons]
+     * @param {{ className?: string }} [options] `className` is set as the class
+     * of the `ful-dialog` element
+     * @returns {Promise<DialogOutcome>} rejecting with what the render threw
+     */
+    static ask(header: string, body: string | Node, buttons?: ([string, string, string?] | Node)[], { className }?: {
+        className?: string;
+    }): Promise<DialogOutcome>;
+    /**
+     * Asks a yes/no question through `Dialog.ask`, with a cancel button and a
+     * confirm button carrying the `ful-button` class.
+     * @param {string} header the title
+     * @param {string|Node} body as `Dialog.ask` takes it
+     * @param {{ confirm?: string, cancel?: string }} [labels] the button labels,
+     * `dialog.confirm` and `dialog.cancel` localized by default
+     * @param {{ className?: string }} [options] as `Dialog.ask` takes them
+     * @returns {Promise<boolean>} true only for the confirm button; the cancel
+     * button, the close button and Escape answer false
+     */
+    static confirm(header: string, body: string | Node, labels?: {
+        confirm?: string;
+        cancel?: string;
+    }, options?: {
+        className?: string;
+    }): Promise<boolean>;
 }
 /**
- * A side panel drawer on the native dialog platform, update() owning its
- * open-deliver cycle.
+ * A side panel on the native `<dialog>`, shown as a modal: a header holding
+ * the title and a localized close button, then loading, error and content
+ * sections, the default slot being the content.
+ *
+ * The `header` attribute is the initial title, rendered as an `h2` that names
+ * the panel through `aria-labelledby`. The `header` slot is rendered in the
+ * header before the title and outside it, so setting the title as text does
+ * not remove it. `placement` is copied onto the native dialog: `end` (the
+ * default, when absent) or `start`, following the writing direction.
+ *
+ * The close button, Escape, and a press and release both on the backdrop all
+ * go through `dismiss(reason)`, the reason being `button`, `backdrop` or
+ * `escape`: before it closes the drawer, the element dispatches a cancelable,
+ * non-bubbling `drawer:dismiss` with `detail: { reason }`, and a listener
+ * calling `preventDefault()` keeps it open. Under `guard-dismiss`, a dismissal
+ * nobody refused, while a `ful-form` of the drawer holds unsaved edits (see
+ * `Form.dirty`), first asks the user, through `Dialog.confirm`, whether to
+ * close and drop them. A `data-result` button, `close-on-submit`, `close()`
+ * and `update()` are answers or the page deciding: they dispatch nothing and
+ * ask nothing. The platform lets a page refuse Escape once per user
+ * interaction: a second Escape with no click or keystroke in between closes
+ * the drawer at once, without the slide, `guard-dismiss` included, and its
+ * `drawer:dismiss` is then not cancelable.
  *
- * The `header` slot is content beside the title, before it: an icon, a badge, a
- * status. It sits outside the heading rather than in it because `update()` sets
- * the title through `textContent`, which would take anything nested there with
- * it.
+ * Any button inside the drawer carrying `data-result` closes it with that
+ * result, an empty one being a dismissal. Every close dispatches a
+ * non-bubbling `close` event on the element carrying the `DialogOutcome` as
+ * `detail`, before the pending `ask()` calls resolve.
+ *
+ * `close-on-submit` closes the drawer when a `ful-form` that is a direct child
+ * of the content section dispatches `submit:success`, carrying its
+ * `detail.response`, which may be null. A form deeper in the content, such as
+ * the filter form of a `ful-table`, does not close it. The listener sits on
+ * the content section, so a form delivered by `update()` is covered as well.
+ *
+ * An element anywhere in the page carrying `dialog-target` set to the
+ * element's id calls `open()` on click.
  */
 declare class Drawer extends ParsedElement {
     #private;
     static attributes: string[];
     static slots: boolean;
     static template: string;
+    /**
+     * @param {{ slots: Record<string, DocumentFragment> }} c
+     */
     render({ slots }: {
-        slots: any;
+        slots: Record<string, DocumentFragment>;
     }): void;
-    get title(): any;
-    set title(v: any);
     /**
-     * Opens the drawer under the given title and waits for the callback: a
-     * resolved value paints the content section (which is returned), a
-     * rejection paints the problems and travels to the caller, and an update
-     * superseded by a newer one paints nothing.
+     * The title, read and written as the heading's text.
+     * @type {string}
      */
-    update(title: any, cb: any): Promise<any>;
+    get header(): string;
+    /** @param {string|null|undefined} v written as text, `''` for null or undefined */
+    set header(v: string | null | undefined);
     /**
-     * Re-fires section:requested on the content, open or closed: the explicit
-     * request for a body that wants refreshing. A failed refresh paints its
-     * problems, nothing rejects: update() stays the rejecting call.
+     * Sets the title, empties and hides the content section, shows the loading
+     * section, opens the drawer if it is closed (putting back one that is
+     * sliding out), and fills the content with what the callback resolves to.
+     * A rejection is shown, as the problems' reasons, in the error section,
+     * which has `role="alert"`, and the content is hidden.
+     *
+     * No `section:requested` is dispatched. When a newer `update()` starts
+     * before the callback settles, this call paints nothing and resolves
+     * `null`, the content section being the newer call's; it still rejects with
+     * the callback's error.
+     * @param {string} header the title, set as text
+     * @param {() => Node|string|Promise<Node|string>} cb producing the content
+     * @returns {Promise<Element|null>} the content section, in the document, or
+     * `null` for a call a newer one overtook
+     * @throws {any} what the callback threw or rejected with
+     */
+    update(header: string, cb: () => Node | string | Promise<Node | string>): Promise<Element | null>;
+    /**
+     * Dispatches `section:requested` for the content again, as `open()` does,
+     * whether the drawer is open or closed. A failed request is painted into
+     * the content section.
+     * @returns {Promise<any[]|undefined>} the listeners' answers, undefined when
+     * nobody answered or the request failed; it never rejects
      */
     refresh(): Promise<any[] | undefined>;
-    open(): void;
-    close(): void;
+    /**
+     * Resolves every pending `ask()` and `open()` with the outcome so far,
+     * a dismissal for a drawer still open, so that no caller waits on a drawer
+     * that left the document. The native dialog is not closed and no `close`
+     * event is dispatched.
+     */
+    disconnectedCallback(): void;
+    /**
+     * The same as `ask()`.
+     * @returns {Promise<{ dismissed: boolean, result: string|null, response: any }>}
+     */
+    open(): Promise<{
+        dismissed: boolean;
+        result: string | null;
+        response: any;
+    }>;
+    /**
+     * Shows the drawer as a modal and resolves with how it ends.
+     *
+     * The call that opens the drawer resets the outcome of the previous
+     * opening, hides the error and loading sections, and dispatches
+     * `section:requested` on the element (bubbling, with
+     * `detail: { section, first, name: null, index: null }`, `section` being
+     * the content section and `first` true only on the first answered request),
+     * so a listener can fill the content. A failed request is painted into the
+     * content section and does not reject. On a drawer already open nothing is
+     * shown or requested, except that one sliding out stops and stays open,
+     * forgetting the result it was closing with, and the call waits for the
+     * same ending as the calls before it, which is how a caller learns the
+     * outcome of the opening an `update()` made. One the page moved while open,
+     * which is no longer modal, opens anew.
+     * @returns {Promise<{ dismissed: boolean, result: string|null, response: any }>} resolving on
+     * close, or on removal from the document with a dismissal
+     */
+    ask(): Promise<{
+        dismissed: boolean;
+        result: string | null;
+        response: any;
+    }>;
+    /**
+     * Dismisses the drawer as the user would: dispatches the cancelable
+     * `drawer:dismiss` with `detail: { reason }` and, under `guard-dismiss`,
+     * asks before dropping unsaved edits, sliding the drawer out as a
+     * dismissal unless either refused. Does nothing on a drawer that is closed
+     * or already sliding out.
+     * @param {string} reason why it is dismissed, such as `navigation`
+     * @returns {Promise<boolean>} whether the drawer is closed or closing,
+     * false when a listener or the user kept it open
+     */
+    dismiss(reason: string): Promise<boolean>;
+    /**
+     * Slides the drawer out and closes it when the animation ends, setting the
+     * `closing` attribute on the native dialog meanwhile; the `close` event is
+     * dispatched then, after this call has returned. Where the user prefers
+     * reduced motion, or no animation runs, it closes at once. A non-empty
+     * result answers as the button carrying that `data-result` would; no
+     * result, or an empty one, is a dismissal. Does nothing on a drawer that is
+     * closed or already sliding out.
+     * @param {string} [result]
+     */
+    close(result?: string): void;
+}
+/**
+ * A menu of commands on the native popover platform. The menu is the popover
+ * itself: light dismiss and Escape come from the browser.
+ *
+ * A menu naming an invoker by id through `for` belongs to that element: the
+ * invoker toggles it, and it is anchored to the invoker through
+ * `Anchors.wire`, placed in script where the platform has no css anchor
+ * positioning. A menu without `for` is shared: one menu serves many
+ * invokers, such as the "more" button of every row of a list, and a page
+ * opens it beside the invoker it is for with `showFor(invoker)`.
+ *
+ * The items are the buttons and `a[href]` links written as its direct
+ * children, kept as they are. Activation is the item's own click, which the
+ * menu follows by hiding itself, so a page listens for the click where it
+ * already listens. The menu fires no events of its own.
+ *
+ * The keyboard is the ARIA menu protocol: the focus moves to the
+ * first item as the menu opens, the arrows, Home and End walk the items,
+ * typing searches their text, Enter and Space activate the focused one, and
+ * Escape and a close from inside the menu hand the focus back to the invoker
+ * that opened it.
+ */
+declare class Menu extends ParsedElement {
+    #private;
+    /** @type {string[]} */
+    static attributes: string[];
+    /** Upgrades the menu, and has a shared one that came back follow the presses on its invoker again. */
+    connectedCallback(): void;
+    /** Stops a shared menu following the presses while it is out of the document. */
+    disconnectedCallback(): void;
+    /**
+     * Gives the menu the `menu` role and an empty `popover` attribute unless
+     * it already has one, and marks the items. With `for`, read here once, it
+     * also gives the invoker `aria-haspopup="menu"`, an `aria-expanded` kept
+     * in step, and the toggle of the menu.
+     * @returns {void}
+     * @throws {Error} when `for` is given and names no element in the document at the render
+     */
+    render(): void;
+    /**
+     * Opens a shared menu, one without `for`, beside `invoker`, or moves it
+     * there when it is open for another one. The menu goes below the invoker,
+     * or above it where there is no room below, and is placed once, as
+     * `Anchors.show` places it. The invoker gets `aria-haspopup="menu"` and an
+     * `aria-expanded` that reads true until the menu closes, and the focus
+     * goes back to it on Escape. A call for the invoker whose press has just
+     * closed the menu does nothing, so a second click on the same button
+     * closes the menu rather than opening it again.
+     * @param {HTMLElement} invoker the element the menu opens for
+     * @returns {void}
+     * @throws {Error} when the menu names its invoker through `for`
+     */
+    showFor(invoker: HTMLElement): void;
+    /**
+     * The commands, in the order the arrows walk them: the menu's direct
+     * `button` and `a[href]` children, minus those carrying a `disabled` or
+     * `hidden` attribute, which keep their role and leave the walk. Reading it
+     * also marks any child added since the render, giving it the `menuitem`
+     * role, unless it has a role already, and a `tabIndex` of -1.
+     * @type {HTMLElement[]}
+     */
+    get items(): HTMLElement[];
 }
-/** A transient feedback region: each show() stacks a toast that retires on its own timer. */
+export type ToastOptions = {
+    /**
+     * the theme class and
+     * the announcement, `info` when absent or unknown
+     */
+    severity?: 'info' | 'success' | 'warning' | 'error';
+    /**
+     * the milliseconds before the toast retires, the
+     * region's own timeout when absent
+     */
+    timeout?: number;
+    /**
+     * a button labelled
+     * with `label` as text, beside the message
+     */
+    action?: {
+        label: any;
+        onClick?: () => void;
+    };
+};
+/**
+ * @typedef {object} ToastOptions
+ * @property {'info'|'success'|'warning'|'error'} [severity] the theme class and
+ * the announcement, `info` when absent or unknown
+ * @property {number} [timeout] the milliseconds before the toast retires, the
+ * region's own timeout when absent
+ * @property {{ label: any, onClick?: () => void }} [action] a button labelled
+ * with `label` as text, beside the message
+ */
+/**
+ * A region of transient messages, with `role="region"` and a localized
+ * `aria-label`. Each `show()` appends a `ful-toast` that retires on its own
+ * timer, so concurrent toasts stack.
+ *
+ * The region is a manual popover, whatever `popover` the page declared, and
+ * each `show()` shows it again, so it is on top of the top layer when a toast
+ * arrives: above a modal dialog or drawer opened before it. While a modal is
+ * open the page outside it is inert, the region included: its toasts show and
+ * retire on their timers, and their buttons answer once the modal closes.
+ *
+ * `timeout` is the region's default timer in milliseconds, 5000 when absent
+ * or zero.
+ *
+ * A `show-toast` event dispatched on the document, or bubbling to it, shows its
+ * `detail` in every connected region that has rendered, `detail.message` being
+ * the message and the other fields the `ToastOptions`. The document listener is
+ * added once, so a second region shows each toast once, and an event with no
+ * detail is ignored.
+ */
 declare class Toasts extends ParsedElement {
     #private;
     static attributes: string[];
+    /** Upgrades the region, and makes a re-attached one answer `show-toast` again. */
     connectedCallback(): void;
+    /** Stops the region answering `show-toast` while it is out of the document. */
     disconnectedCallback(): void;
     render(): void;
     /**
-     * Appends a toast carrying the message (a Failure shows its problems'
-     * reasons, one per line), severity picking the theme and the announcement,
-     * the toast retiring through its own timer or its dismiss button.
+     * Appends a `ful-toast` holding the message as text, a `Failure` showing
+     * its problems' reasons one per line and anything else its string form
+     * (`''` for null or undefined). The toast carries the severity as a class
+     * and has `role="alert"` for `error` and `role="status"` otherwise.
+     *
+     * The toast retires when its timer runs out, when its localized dismiss
+     * button is clicked, or when its action button is clicked, after
+     * `action.onClick` runs. The timer pauses while the pointer is over the
+     * toast or the focus is inside it, and resumes with the time that was left
+     * once both have gone. A retiring toast holding the focus moves it to the
+     * region, which has `tabindex="-1"` for this. The toast is removed once its
+     * `ful-toast-out` animation ends, or at once where the user prefers reduced
+     * motion or no animation runs.
+     *
+     * A connected region is shown again as a popover, which puts it above
+     * whatever opened in the top layer since; the focus stays where it was.
      * @param {any} message
-     * @param {any} [options] severity and timeout
-     * @returns {HTMLElement}
+     * @param {ToastOptions} [options]
+     * @returns {HTMLElement} the toast, already in the region
      */
-    show(message: any, options?: any): HTMLElement;
+    show(message: any, options?: ToastOptions): HTMLElement;
 }
 /**
  * A tab panel: one visible panel at a time, announced through the tab pattern
- * (a tablist of tab buttons, each panel a tabpanel named by its tab). The tabs
- * are declared as <tab> elements in the tabs slot, the panels as the slotless
- * children, paired in order. Entering a panel fires the section:requested
- * family on it (generic and #index, panels being nameless) and awaits the
- * answers, so a panel can deliver itself asynchronously.
+ * (a tablist of tab buttons, each panel a tabpanel labelled by its tab). The
+ * tabs are declared as `<tab>` elements in the `tabs` slot, the panels as the
+ * slotless children, paired in order. Each `<tab>` becomes a `button` with the
+ * `tab` role carrying the tab's content, inside a `ful-tablist` with the
+ * `tablist` role. A panel that already has an id keeps it and its tab points at
+ * it; a panel without one gets a generated id. Every panel carries
+ * `tabindex="0"`, so the visible one follows its tab in the tab order and the
+ * hidden ones stay out of it.
+ *
+ * The tabs use a roving tabindex and automatic activation: a click activates
+ * its tab, and on the tablist ArrowRight and ArrowLeft move to the next and
+ * previous tab, wrapping around, while Home and End jump to the first and the
+ * last, moving the focus with the activation.
+ *
+ * Entering a panel fires `section:requested` and `section:requested:#<index>`
+ * on the host, bubbling, with detail `{ name: null, section, index, first }`,
+ * and awaits the answers registered through `AsyncEvents.asyncOn`, so a panel
+ * can deliver itself asynchronously: see `SectionRequests`.
+ *
+ * The tablist stays on one line. When the tabs do not fit it scrolls sideways,
+ * and a previous and a next button appear at the side that has more tabs,
+ * each bringing the next hidden tab into view. They stay out of the tab order:
+ * the keyboard moves through the tabs with the arrow keys. The active tab is
+ * kept in view when it changes and when the tablist changes width.
  */
 declare class Tabs extends ParsedElement {
     #private;
     static slots: boolean;
     static observed: string[];
     static template: string;
+    /**
+     * Pairs the declared tabs with the panels in order. When the counts
+     * differ, the unpaired tabs and panels are left in the dom as they are and
+     * a warning is logged.
+     * @param {{ slots: Record<string, DocumentFragment> }} conf
+     * @returns {void}
+     */
     render({ slots }: {
-        slots: any;
+        slots: Record<string, DocumentFragment>;
     }): void;
+    /**
+     * The index of the visible panel, reflected to the `active` attribute.
+     * Writing it clamps the value to the paired tabs, a value that is not a
+     * number counting as 0, and selects that tab and shows its panel. When the
+     * index changes on a rendered element it dispatches `tabs:change` on the
+     * host (not bubbling) with detail `{ active, previous }`, then fires the
+     * section requests for the entered panel. The first write, which applies
+     * the attribute after the render, fires the requests without the event.
+     * A failed delivery paints the panel's error and rejects nowhere.
+     * @type {number}
+     */
     get active(): number;
     /**
-     * Re-fires the section:requested family on the panel (by index or the
-     * panel element itself), whether active or not: the explicit request for a
-     * content that wants refreshing. A failed refresh paints its problems,
-     * nothing rejects: there is no caller to reject towards.
+     * Fires the section requests again for a panel, whether it is visible or
+     * not, with `first` false once an earlier request was answered.
+     * @param {number | Element} ref the panel's index, or the panel itself
+     * @returns {Promise<any[] | undefined> | undefined} a promise resolving to
+     * the answers, or to undefined when nobody listened or the delivery
+     * failed (its error painted in the panel); undefined, with a warning, when
+     * `ref` names no panel
      */
-    refresh(ref: any): Promise<any[] | undefined> | undefined;
+    refresh(ref: number | Element): Promise<any[] | undefined> | undefined;
     set active(v: number);
 }
 /**
- * An accordion over native details/summary disclosures: the platform carries
- * the semantics, the keyboard and the toggling, the chrome paints the group.
- * With the exclusive claim the render assigns one shared name to every panel,
- * which is the platform's own exclusive grouping: opening one closes the others.
+ * An accordion over native `details`/`summary` disclosures: the browser
+ * provides the semantics, the keyboard and the toggling, and the element adds
+ * the group's styling. The `details` written as its children are rendered,
+ * unchanged, inside a `ful-accordion-group`.
  */
 declare class Accordion extends ParsedElement {
     #private;
     static slots: boolean;
+    /** @type {string[]} */
     static observed: string[];
     static template: string;
+    /**
+     * @param {{ slots: Record<string, DocumentFragment> | undefined }} c
+     * @returns {void}
+     */
     render({ slots }: {
-        slots: any;
+        slots: Record<string, DocumentFragment> | undefined;
     }): void;
+    /**
+     * Whether opening one panel closes the others, reflected to the
+     * `exclusive` attribute; only `true` turns it on. Setting it gives the
+     * group's direct `details` children one shared, newly generated `name`,
+     * the platform's exclusive grouping, or removes their `name` when off.
+     * A `details` added to the group afterwards is not named until the next
+     * write.
+     * @type {boolean}
+     */
     get exclusive(): boolean;
     set exclusive(v: boolean);
 }
 /**
- * A wizard: a progress of steps over one-of-N sections, the homeinsurance
- * layout distilled. The steps are declared as <step> elements in the steps
- * slot, the sections as the slotless children, paired in order; each section
- * may carry a data-step name, which is what move() answers to. The current
- * step is the aria-current=step claim, carried in lockstep by the step and
- * its section: the chrome (including which section is shown) follows the
- * claim alone, so the markup state and the style can never disagree. The
- * progress chrome shows the current step alone by default; the progress
- * attribute picks another shape over the same claims (timeline, dots, none).
- * Entering a section
- * fires the section:requested family on it and awaits the answers, so a
- * section can deliver itself asynchronously; move() resolves when the entered
- * section is painted, and rejects when its delivery fails.
+ * A wizard: a progress of steps over one-of-N sections. The steps are declared
+ * as `<step>` elements in the `steps` slot, the sections as the slotless
+ * children, paired in order; each section may carry a `data-step` name, which
+ * is what `move()` and `refresh()` answer to. The steps become the items of an
+ * `ol` inside `ful-steps`, labelled by the localized `wizard.progress`.
+ *
+ * The current step is the `aria-current="step"` claim, carried by the step and
+ * its section together, and the stylesheet hides every `section` child that
+ * does not carry it. A section that carries the claim in the markup when the
+ * wizard renders stays current; otherwise the first section is. Every paired
+ * section gets `tabindex="-1"`, so a move can focus it.
+ *
+ * Entering a section, the first one at the render included, fires
+ * `section:requested`, `section:requested:#<index>` and, when the section has a
+ * `data-step`, `section:requested:<name>` on the host, bubbling, with detail
+ * `{ name, section, index, first }`, and awaits the answers registered through
+ * `AsyncEvents.asyncOn`: see `SectionRequests`. A failure of the initial entry
+ * paints the section's error and rejects nowhere.
  */
 declare class Wizard extends ParsedElement {
     #private;
     static slots: boolean;
     static observed: string[];
     static template: string;
+    /**
+     * Pairs the declared steps with the sections in order. When the counts
+     * differ, the unpaired steps and sections are left in the dom as they are
+     * and a warning is logged.
+     * @param {{ slots: Record<string, DocumentFragment> }} conf
+     * @returns {void}
+     */
     render({ slots }: {
-        slots: any;
+        slots: Record<string, DocumentFragment>;
     }): void;
+    /**
+     * The zero-based position of the current step.
+     * @type {number}
+     */
     get index(): number;
-    get step(): any;
-    get progress(): any;
-    set progress(v: any);
+    /**
+     * The `data-step` of the current section, or null when it has none or no
+     * section is paired.
+     * @type {string | null}
+     */
+    get step(): string | null;
+    /**
+     * The shape of the progress chrome, reflected to the `progress` attribute:
+     * unset shows the current step alone, `timeline` every step as done,
+     * current or future, `dots` one dot per step, `none` no progress at all.
+     * The value only drives the stylesheet; the moves are the same in every
+     * shape.
+     * @type {string | null}
+     */
+    get progress(): string | null;
+    set progress(v: string | null);
+    /**
+     * Moves to the following step; at the last step nothing happens.
+     * @returns {Promise<any[] | undefined> | undefined} what `move()` answers
+     * @throws what the entered section's delivery rejected with, as the rejection
+     * of the returned promise
+     */
     next(): Promise<any[] | undefined> | undefined;
+    /**
+     * Moves to the preceding step; at the first step nothing happens.
+     * @returns {Promise<any[] | undefined> | undefined} what `move()` answers
+     * @throws what the entered section's delivery rejected with, as the rejection
+     * of the returned promise
+     */
     prev(): Promise<any[] | undefined> | undefined;
-    move(ref: any): Promise<any[] | undefined> | undefined;
     /**
-     * Re-fires the section:requested family on the named section (or the
-     * section element itself), whether active or not: the explicit request for a
-     * content that wants refreshing. A failed refresh paints its problems,
-     * nothing rejects: move() stays the rejecting call.
+     * Moves to the section carrying `data-step="<ref>"`. A move makes that step
+     * and section current, moves the focus to the section, dispatches
+     * `wizard:change` on the host (not bubbling) with detail `{ index, step }`,
+     * then fires the section requests for it.
+     * @param {string} ref the section's `data-step`
+     * @returns {Promise<any[] | undefined> | undefined} a promise resolving to
+     * the answers once they are delivered, or to undefined when nobody
+     * listened; undefined when the section is already current, and undefined
+     * with a warning when no section carries `ref` or the one carrying it has
+     * no step paired with it
+     * @throws what the entered section's delivery rejected with, as the rejection
+     * of the returned promise, after its error is painted in the section
      */
-    refresh(ref: any): Promise<any[] | undefined> | undefined;
+    move(ref: string): Promise<any[] | undefined> | undefined;
+    /**
+     * Fires the section requests again for a section, whether it is current or
+     * not, with `first` false once an earlier request was answered.
+     * @param {string | Element} ref the section's `data-step`, or the section
+     * itself
+     * @returns {Promise<any[] | undefined> | undefined} a promise resolving to
+     * the answers, or to undefined when nobody listened or the delivery failed
+     * (its error painted in the section); undefined, with a warning, when `ref`
+     * names no section or one with no step paired with it
+     */
+    refresh(ref: string | Element): Promise<any[] | undefined> | undefined;
 }
 /**
  * Registers everything ful provides on a registry: the elements, the loader
  * components, an http client, and the translations for the configured
- * language. A page calls `registry.plugin(new Plugin({…})).configure()` once.
+ * language. A page calls `registry.plugin(new Plugin({…})).configure()` once;
+ * `registry.plugin` calls this plugin's `configure`.
  */
 declare class Plugin {
     #private;
     /**
-     * @param {{ language?: string, translations?: Record<string, any>, httpClient?: any }} [options]
+     * @param {{ language?: string, translations?: Record<string, any>, httpClient?: HttpClient }} [options]
      * `language` is fixed for the page: a full BCP-47 tag or a primary subtag,
-     * defaulting to the browser's language. `translations` is a flat
-     * active-language map applied over the built-in translations: reword built-in
+     * defaulting to `navigator.language`, then to 'en'. Its primary subtag,
+     * lowercased, picks the built-in translations (en, it, es, fr); the messages
+     * are the english ones, overridden by that language's, overridden by
+     * `translations`, so a language without built-in translations reads in
+     * english. `translations` is a flat map of keys to messages: reword built-in
      * keys ('pagination.showing', …) or add your own ('checkout.total', …).
      * `httpClient` is the client every ful component fetches through, registered
-     * as the `http-client` component: where an unauthorized session goes is an
-     * application decision, so a page that does not want the default's redirect
-     * to '/' builds its own.
+     * as the `http-client` component; without one, `configure` builds a client
+     * that sends the csrf token and navigates to '/' on a 401 response.
      */
     constructor(options?: {
         language?: string;
         translations?: Record<string, any>;
-        httpClient?: any;
+        httpClient?: HttpClient;
     });
-    configure(registry: any): void;
+    /**
+     * Defines on `registry` the `l10n` module, the `http-client` component,
+     * every `ful-*` element, the `loaders:select`, `loaders:form` and
+     * `loaders:table` components, and an overlay publishing `l10n` (the merged
+     * messages) and `locale` (the `language` as given) to every template.
+     * @param {{ defineModule(name: string, module: any): any, defineComponent(name: string, component: any): any, defineElement(tag: string, klass: CustomElementConstructor): any, defineOverlay(...data: any[]): any }} registry
+     * the ftl `Registry`, each of those methods answering the registry itself
+     * @returns {void}
+     */
+    configure(registry: {
+        defineModule(name: string, module: any): any;
+        defineComponent(name: string, component: any): any;
+        defineElement(tag: string, klass: CustomElementConstructor): any;
+        defineOverlay(...data: any[]): any;
+    }): void;
+}
+export { Accordion, Anchors, AsyncEvents, Bindings, BooleanFilter, Checkbox, Claims, CompareFilter, Dialog, Drawer, Dropdown, Field, Form, FormLoader, InFilter, Input, InputFile, InputInstant, InputLocalDate, InputLocalTime, Instant, InstantFilter, LocalDate, LocalDateFilter, LocalStorage, Menu, NumberFilter, PageLeave, Pagination, Plugin, RadioGroup, Select, SelectLoader, SessionStorage, SortButton, Table, TableLoader, TableSchemaParser, Tabs, TextFilter, Timing, Toasts, Tooltip, VersionedLocalStorage, VersionedSessionStorage, Wizard, describable };
+
+declare global {
+    interface HTMLElementTagNameMap {
+        'ful-tooltip': Tooltip;
+        'ful-dialog': Dialog;
+        'ful-drawer': Drawer;
+        'ful-menu': Menu;
+        'ful-toasts': Toasts;
+        'ful-tabs': Tabs;
+        'ful-accordion': Accordion;
+        'ful-wizard': Wizard;
+        'ful-form': Form;
+        'ful-checkbox': Checkbox;
+        'ful-input': Input;
+        'ful-input-file': InputFile;
+        'ful-local-date': LocalDate;
+        'ful-instant': Instant;
+        'ful-input-local-date': InputLocalDate;
+        'ful-input-local-time': InputLocalTime;
+        'ful-input-instant': InputInstant;
+        'ful-radio-group': RadioGroup;
+        'ful-table': Table;
+        'ful-pagination': Pagination;
+        'ful-sorter': SortButton;
+        'ful-filter-instant': InstantFilter;
+        'ful-filter-local-date': LocalDateFilter;
+        'ful-filter-number': NumberFilter;
+        'ful-filter-boolean': BooleanFilter;
+        'ful-filter-text': TextFilter;
+        'ful-filter-in': InFilter;
+        'ful-select': Select;
+        'ful-dropdown': Dropdown;
+    }
 }
-export { Accordion, Anchors, AsyncEvents, Bindings, BooleanFilter, Checkbox, Claims, CompareFilter, Dialog, Drawer, Dropdown, Field, Form, FormLoader, Input, InputFile, InputInstant, InputLocalDate, InputLocalTime, Instant, InstantFilter, LocalDate, LocalDateFilter, LocalStorage, NumberFilter, Pagination, Plugin, RadioGroup, Select, SelectLoader, SessionStorage, SortButton, Table, TableLoader, TableSchemaParser, Tabs, TextFilter, Timing, Toasts, Tooltip, VersionedLocalStorage, VersionedSessionStorage, Wizard };
 
 export as namespace ful;