@optionfactory/fml 8.0.3 → 9.0.0-rc1

package/dist/ftl.d.mts

@@ -1,3 +1,34 @@
+/**
+ * A Map bounded by entry count, evicting in insertion order: not an LRU (a hit
+ * does not refresh an entry), just a cap keeping unbounded key spaces (parsed
+ * expressions, compiled masks, formatter instances) from growing forever. The
+ * capacity is sized so eviction never happens on a sane page: hitting it means
+ * dynamically generated keys, where FIFO's worst case (evicting a hot entry)
+ * costs one recomputation.
+ */
+declare class BoundedCache {
+    #private;
+    /** @param {number} max */
+    constructor(max: number);
+    /**
+     * The cached value for the key, computing and caching it on a miss. A
+     * computed null or undefined is cached like any value; a throwing compute
+     * caches nothing.
+     * @template K, V
+     * @param {K} key
+     * @param {(key: K) => V} compute
+     * @returns {V}
+     */
+    getOrCompute<K, V>(key: K, compute: (key: K) => V): V;
+    get size(): number;
+}
+/**
+ * The expression language: parsing to an ast, caching the parses, and
+ * interpreting one against a scope. Member access and calls are unfiltered, so
+ * an expression can do whatever the page's own javascript can. Expressions are
+ * written by the page author; untrusted data is passed in as data and never
+ * spliced into the expression text.
+ */
 declare class Expressions {
     #private;
     static MODE_EXPRESSION: symbol;
@@ -32,15 +63,29 @@ declare class Expressions {
         [x: string]: any;
     } | null | undefined, dataStack: any[], expression: string, mode?: (typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED) | null): any;
 }
+/**
+ * A scope: the modules that `#name:fn()` resolves against and the data stack
+ * that a bare identifier resolves against, as a single value. Adding an overlay
+ * returns a new evaluator instead of modifying this one, so a template can add
+ * data for one subtree without affecting the rest of the render.
+ */
 declare class ExpressionEvaluator {
     #private;
     constructor(modules: any, dataStack: any);
     withModule(name: any, value: any): ExpressionEvaluator;
     withOverlay(...data: any[]): ExpressionEvaluator;
-    evaluate(expression: any, mode: any): any;
+    /**
+     * Resolves a name against the data stack, with no parse round trip: the
+     * lookup a template's bare identifier makes, for an imperative caller.
+     * @param {string} name
+     */
+    resolve(name: string): any;
+    /** Evaluates an expression against this scope. */
     evaluateExpression(expression: any): any;
-    evaluateTemplated(expression: any): any;
+    /** Evaluates a templated text, the `{{ }}` form, against this scope. */
+    evaluateTemplated(text: any): any;
 }
+/** Creates and inspects the DocumentFragments a Template renders into. */
 declare class Fragments {
     /**
      * Creates a DocumentFragment from an string.
@@ -49,7 +94,9 @@ declare class Fragments {
      */
     static fromHtml(...html: string[]): DocumentFragment;
     /**
-     * Creates a string representation (HTML) of a DocumentFragment.
+     * Creates a string representation (HTML) of a DocumentFragment, consuming it:
+     * the nodes are moved out, not copied, and the fragment is left empty. Pass
+     * `fragment.cloneNode(true)` to keep the original usable.
      * @param {DocumentFragment} fragment
      * @returns {string} the html
      */
@@ -73,6 +120,7 @@ declare class Fragments {
      */
     static fromChildNodes(el: Node): DocumentFragment;
 }
+/** Attribute reads and writes where a nullish value removes the attribute instead of setting it to the string 'null'. */
 declare class Attributes {
     static id: number;
     /**
@@ -96,19 +144,6 @@ declare class Attributes {
      * @param {Element} to
      */
     static forward(prefix: string, from: Element, to: Element): void;
-    /**
-     * Changes the presence of an attribute.
-     * @param {Element} el
-     * @param {string} attr
-     * @param {boolean} value
-     */
-    static toggle(el: Element, attr: string, value: boolean): void;
-    /**
-     * Changes the presence of an attribute based on its current state.
-     * @param {Element} el
-     * @param {string} attr
-     */
-    static flip(el: Element, attr: string): void;
     /**
      * Sets the value of an attribute. nullish values remove the attribute.
      * @param {Element} el
@@ -117,6 +152,12 @@ declare class Attributes {
      */
     static set(el: Element, attr: string, value: string | null | undefined): void;
 }
+/**
+ * Reads an element's light-dom slots: the named `<template slot=…>` and
+ * `[slot=…]` children are removed and collected by name, and the remaining
+ * children become the default slot. fml renders into the light dom, so this
+ * replaces the slotting a shadow root would do.
+ */
 declare class LightSlots {
     /**
      * Extracts light slots from an element. For non default slots in a template tag, the content is extracted.
@@ -128,6 +169,7 @@ declare class LightSlots {
     };
     static slotFromNode(el: any): any;
 }
+/** Waits for the parser and for the document, for elements that upgrade before their own markup is complete. */
 declare class Nodes {
     /**
      * Checks if an element is already parsed.
@@ -135,6 +177,35 @@ declare class Nodes {
      * @returns
      */
     static isParsed(el: Element): boolean;
+    /**
+     * Waits for the document's DOMContentLoaded, resolving immediately when
+     * that moment already passed. 'interactive' alone cannot tell a document
+     * still waiting for deferred scripts (the event comes, however late) from
+     * a module imported past it (the event is gone): the two events order
+     * themselves, DOMContentLoaded always precedes load, so racing the two
+     * resolves with DCL whenever it is still coming and with load otherwise,
+     * never early.
+     */
+    static waitDomContentLoaded(doc: any): Promise<any>;
+    /**
+     * Waits for the element's closing tag to be parsed: one MutationObserver
+     * resolves once the element, or any of its ancestors, gains a next sibling,
+     * which is the parser having moved past this subtree. The document's
+     * DOMContentLoaded is the deadline. Resolves immediately for an element
+     * that is already parsed.
+     *
+     * Every ancestor is watched, not only the parent, because that is what the
+     * predicate reads: an element last among its siblings becomes parsed when
+     * an ancestor gains one, and a childList observer on the parent never sees
+     * that. Formatted markup usually hides the difference, the whitespace
+     * before a closing tag being a text node the parent does gain, so the gap
+     * shows on whitespace-free markup, where the wait fell back to the
+     * deadline. One observer takes many targets, so the cost is one observe()
+     * per level, and it is disconnected at the first checkpoint past the
+     * element either way.
+     * @param {any} el
+     * @returns {Promise<any>}
+     */
     static waitParsed(el: any): Promise<any>;
     /**
      * Returns the first child of the element element (if exists) matching the selector.
@@ -151,6 +222,12 @@ declare class Nodes {
      */
     static queryChildrenAll(el: Element, selector: string): Element[];
 }
+/**
+ * A compiled fragment together with the scope it renders in. Both are
+ * immutable: adding data or replacing the scope returns a new Template, so one
+ * piece of compiled markup can be rendered against any number of scopes and a
+ * registry can reuse a single template for every element that requests it.
+ */
 declare class Template {
     #private;
     /**
@@ -194,29 +271,17 @@ declare class Template {
         [k: string]: any;
     } | null, ...data: any[]): Template;
     /**
-     * Creates a template.
+     * Creates a template: a fragment plus the scope it renders in.
      * @param {DocumentFragment} fragment
-     * @param {{ [x: string]: any; } | null | undefined} modules
-     * @param {any[]} dataStack
-     */
-    constructor(fragment: DocumentFragment, modules: {
-        [x: string]: any;
-    } | null | undefined, dataStack: any[]);
-    /**
-     * Creates a new Template replacing the modules and dataStack from a context.
-     * @param {{modules: { [x: string]: any; } | null | undefined, data: any[]}} context
+     * @param {ExpressionEvaluator} evaluator the modules and data stack the expressions resolve against
      */
-    withContext({ modules, data }: {
-        modules: {
-            [x: string]: any;
-        } | null | undefined;
-        data: any[];
-    }): Template;
+    constructor(fragment: DocumentFragment, evaluator: ExpressionEvaluator);
     /**
-     * Creates a new Template replacing the modules and dataStack from a registry.
-     * @param any registry
+     * Creates a new Template rendering in another scope: the one way to rebind
+     * a compiled template to a registry's modules and data.
+     * @param {ExpressionEvaluator} evaluator
      */
-    withContextFrom(registry: any): Template;
+    withEvaluator(evaluator: ExpressionEvaluator): Template;
     /**
      * Creates a new Template replacing the fragment.
      * @param {DocumentFragment} fragment
@@ -230,31 +295,25 @@ declare class Template {
     withModule(name: string | null, value: {
         [k: string]: any;
     }): Template;
-    /**
-     * Creates a new Template replacing the modules.
-     * @param {{ [x: string]: any; }?} modules
-     */
-    withModules(modules: {
-        [x: string]: any;
-    } | null): Template;
-    /**
-     * Creates a new Template replacing the data stack.
-     * @param {any[]} dataStack the dataStack
-     */
-    withData(dataStack: any[]): Template;
     /**
      * Creates a new Template with new a data overlay added to the stack.
      * @param {...*} data
      */
     withOverlay(...data: any[]): Template;
     /**
-     * Evaluates an expression using the configured modules and data.
+     * Evaluates an expression in this template's scope, widened by the overlays.
      * @param {string} expression
-     * @param {(typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED)?} [mode]
      * @param {...*} data
      * @returns the evaluated expression result
      */
-    evaluate(expression: string, mode?: (typeof Expressions.MODE_EXPRESSION | typeof Expressions.MODE_TEMPLATED) | null, ...data: any[]): any;
+    evaluateExpression(expression: string, ...data: any[]): any;
+    /**
+     * Evaluates a templated text, the `{{ }}` form, in this template's scope.
+     * @param {string} text
+     * @param {...*} data
+     * @returns the parts the text evaluates to
+     */
+    evaluateTemplated(text: string, ...data: any[]): any;
     /**
      * Returns an expression evaluator with bound modules and dataStack.
      */
@@ -275,48 +334,208 @@ declare class Template {
      */
     appendTo(el: Element): void;
     /**
-     * Renders this template appending the resulting fragment to the first Element maching the selector, if exists.
+     * Renders this template on the first Element matching the selector (replacing children), if exists.
      * @param {string} selector
      */
     renderToSelector(selector: string): void;
     /**
-     * Renders this template appending the resulting fragment to the Element maching the selector, if exists.
+     * Renders this template appending the resulting fragment to the Element matching the selector, if exists.
      * @param {string} selector
      */
     appendToSelector(selector: string): void;
 }
+/**
+ * A render failure, one frame per nesting level. Each frame names the node it
+ * failed on and what was being evaluated there, so the chain reads as the path
+ * from the template's root down to the offending expression. The frame carries
+ * the node's identification only, an open tag rather than its whole subtree:
+ * the markup is serialized on demand through `html`, and the live node stays on
+ * `node`, so a failure costs no clone and a nested failure does not embed the
+ * page in its own message.
+ */
 declare class RenderError extends Error {
     #private;
-    node: any;
+    /**
+     * How many frames a chain keeps. The innermost are the specific ones, so a
+     * deeper nesting drops the outer context rather than the failure site: three
+     * frames name the offending node and the two levels that hold it, which is
+     * the path a reader follows without the page arriving with it.
+     */
+    static FRAMES: number;
+    /** true when the budget dropped the outer frames of this chain */
+    truncated: boolean;
+    /**
+     * Frames a failure, unless the chain already spent its budget: then the
+     * cause travels on, marked so a report can say the outer context was
+     * dropped.
+     */
+    static wrap(message: any, nodeOrFragment: any, cause: any): RenderError;
     constructor(message: any, nodeOrFragment: any, cause: any);
+    /** How many frames this chain carries, this one included. */
+    get depth(): any;
+    /** The node the render failed on, live: it keeps its place in the fragment being built. */
+    get node(): any;
+    /** The node's markup, serialized when asked for rather than on every failure. */
+    get html(): string;
+    /**
+     * What identifies a node in a frame: an element by its open tag, a text node
+     * by its source, a fragment by the open tags of the elements it holds.
+     */
+    static describe(nodeOrFragment: any): any;
     static stringify(nodeOrFragment: any): string;
 }
+/**
+ * The page's single source of truth for elements, modules, data, components
+ * and attribute mappers. Elements defined before configure() are deferred and
+ * defined by it; from then on every defineElement takes effect immediately.
+ * The exported `registry` singleton is the page's own; a `new Registry()` is a
+ * separate instance, and Rendering and the ftl:ready machinery wait on the
+ * singleton alone.
+ */
 declare class Registry {
     #private;
-    defineElement(tag: any, klass: any): this;
-    defineModule(name: any, value: any): this;
-    defineModules(ms: any): this;
-    defineComponent(name: any, value: any): this;
+    /**
+     * Registers a custom element under its tag: the class is augmented with its
+     * BITS (observed attributes, mappers, templates) and handed to the platform.
+     * Before configure() the definition is deferred, so import order never
+     * matters.
+     * @param {string} tag
+     * @param {*} klass a ParsedElement subclass
+     */
+    defineElement(tag: string, klass: any): this;
+    /**
+     * The attribute declarations a class composes along its inheritance chain,
+     * base first: `observed` stay live after the upgrade and drive the property
+     * `propertyOf` names, `attributes` are the configuration read once at it and
+     * drive no property at all. A subclass's entry for a name overrides its
+     * ancestors', so a base class declares what every subclass keeps observing
+     * (a protocol attribute such as Field's disabled claim) and a leaf refines a
+     * mapping, or moves a name's position, without repeating the whole list.
+     *
+     * The walk stops where the platform's own class hierarchy begins: no earlier
+     * stop can work, since a registered ancestor carries an own BITS of its own,
+     * and nothing above the elements declares anything.
+     *
+     * Everything deriving a component's attribute vocabulary reads it here, so
+     * the runtime and whatever documents it cannot walk the chain differently.
+     * @param {*} klass a ParsedElement subclass
+     * @returns {{ observed: string[], attributes: string[] }}
+     */
+    static declarationsOf(klass: any): {
+        observed: string[];
+        attributes: string[];
+    };
+    /**
+     * The property an observed attribute drives, by the platform's own
+     * dash-to-camel rule: the one `dataset` applies, so `clear-invalid-on-change`
+     * would reach `clearInvalidOnChange` the way `data-clear-invalid-on-change`
+     * reaches `dataset.clearInvalidOnChange`. A single-word name is returned
+     * unchanged, which is what every observed attribute in the library is.
+     *
+     * It exists because the observed tier is the one that becomes properties:
+     * without it an attribute could only be observed if its name happened to be
+     * a usable identifier, which is why every multiword observed attribute here
+     * used to be squashed into one word while the configuration tier, which
+     * never becomes a property, spelled the same idea with a dash.
+     *
+     * Only this direction is mapped. A property never derives its attribute: a
+     * setter reflects through `reflectTo`, naming the attribute it writes.
+     * @param {string} attribute
+     * @returns {string}
+     */
+    static propertyOf(attribute: string): string;
+    /**
+     * Merges one module under its name, its functions resolving as
+     * `#name:fn`; an empty name merges a whole map, whose keys resolve bare,
+     * as `#fn`.
+     * @param {string} name
+     * @param {object} value
+     */
+    defineModule(name: string, value: object): this;
+    /**
+     * Replaces the whole module map.
+     * @param {object} ms
+     */
+    defineModules(ms: object): this;
+    /**
+     * Registers a named component (a loader, a response mapper), fetched back
+     * through component().
+     * @param {string} name
+     * @param {*} value
+     */
+    defineComponent(name: string, value: any): this;
+    /**
+     * Replaces the data stack the templates evaluate over.
+     * @param {...any} data
+     */
     defineData(...data: any[]): this;
+    /**
+     * Appends to the data stack, the later entry winning a shared name.
+     * @param {...any} data
+     */
     defineOverlay(...data: any[]): this;
-    defineMapper(k: any, v: any): this;
-    plugin(p: any): this;
+    /**
+     * Registers a custom attribute mapper type, available to every later
+     * `name:type` declaration.
+     * @param {string} k
+     * @param {{ unmarshal(str: string|null, name: string, el: Element): any, marshal(value: any, name: string, el: Element): string|null }} v
+     */
+    defineMapper(k: string, v: {
+        unmarshal(str: string | null, name: string, el: Element): any;
+        marshal(value: any, name: string, el: Element): string | null;
+    }): this;
+    /**
+     * Hands the registry over to the plugin's configure.
+     * @param {{ configure(registry: Registry): void }} p
+     */
+    plugin(p: {
+        configure(registry: Registry): void;
+    }): this;
+    /**
+     * Defines every element deferred so far; from then on, defineElement takes
+     * effect immediately.
+     */
     configure(): this;
-    get upgrades(): MapIterator<[any, any]>;
-    context(): {
-        modules: any;
-        data: any[];
-    };
+    /**
+     * Waits for the queued upgrades the filter accepts, rejecting with the first
+     * that failed: the rejecting barrier Rendering is a facade over.
+     * @param {(el: Element) => boolean} accept
+     */
+    settle(accept: (el: Element) => boolean): Promise<void>;
+    /** The pending upgrade of one element, undefined when it is not queued. */
+    whenUpgraded(el: any): any;
+    /** The elements whose upgrade is still pending, in queue order. */
+    pending(): any[];
+    /**
+     * Waits for the page's readiness: the same moment the ftl:ready event is
+     * dispatched at, resolving immediately when that moment already passed.
+     * @returns {Promise<void>}
+     */
+    ready(): Promise<void>;
+    /**
+     * The scope every template on this registry renders in: the modules and the
+     * data stack, as one value. Replaced whenever either is defined, so a holder
+     * of an older one keeps rendering against what it was handed.
+     */
     evaluator(): ExpressionEvaluator;
+    /** The component registered under the name, undefined when none is. */
     component(name: any): any;
 }
 declare const registry: Registry;
+/** The Template factories, each bound to the page registry's scope. */
+/** The Template factories bound to the page's own registry: the same four sources, with its modules and data already applied. */
 declare class Templates {
     static fromHtml(html: any): Template;
     static fromSelector(selector: any): Template;
     static fromTemplate(templateEl: any): Template;
     static fromFragment(fragment: any): Template;
 }
+/**
+ * Awaitable rendering barriers over the registry's upgrade queue. These are
+ * the rejecting waits: a failed upgrade among the awaited components rejects
+ * the wait, where registry.ready() only ever means the queue drained and
+ * leaves a failed component to its own unhandled-rejection report.
+ */
 declare class Rendering {
     static waitFor(el: any): Promise<void>;
     static waitForChildren(el: any): Promise<void>;
@@ -335,51 +554,170 @@ export type Mapper = {
 declare class ParsedElement extends HTMLElement {
     #private;
     static BITS: {
+        registry: Registry;
         enqueue: (el: any) => void;
         SLOTS: boolean;
-        OBSERVED: never[];
+        /** @type {object|undefined} */
+        CONFIG: object | undefined;
+        /** @type {string[]} */
+        OBSERVED: string[];
+        /** @type {string[]} */
+        DECLARED: string[];
         /** @type {Record<string, Mapper>} */
         ATTR_TO_MAPPER: Record<string, Mapper>;
+        /** @type {Record<string, string>} */
+        ATTR_TO_PROPERTY: Record<string, string>;
         TEMPLATES: {};
     };
-    static get observedAttributes(): never[];
+    static get observedAttributes(): string[];
+    constructor();
+    /**
+     * The platform's window into the element's own state. The base attaches it
+     * for every element, so a subclass never calls attachInternals itself: the
+     * platform allows it once, and a second call throws. Form association is a
+     * property of the definition rather than of who attached, so a subclass
+     * declaring `static formAssociated` still gets the form apis here.
+     *
+     * A subclass must not redeclare it: a class field with no initializer
+     * assigns undefined after super() returns, which would wipe it.
+     */
+    internals: ElementInternals;
     unmarshal(attr: any, str: any): any;
     marshal(attr: any, value: any): string | null;
     /**
      * @param {string} [name] - The name of the template target, defaults to 'default'
      */
-    template(name?: string): any;
+    /** The registry that defined this element, the page's own for an undefined one. */
+    get _registry(): Registry;
+    /**
+     * The component registered under the name on this element's registry, the
+     * one every ful loader and mapper resolves through.
+     * @param {string} name
+     */
+    component(name: string): any;
+    template(name: any): any;
     connectedCallback(): void;
     attributeChangedCallback(attr: any, oldValue: any, newValue: any): void;
     /**
-     * The disabled protocol follows the semantics of 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 `disabled` 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.
+     * Upgrades once: reads the declared attributes, keeps the observed half open
+     * to writes made while the render is pending, applies them to the properties
+     * when the render returns, and only then lets an attribute write forward.
      *
-     * Because of this, formDisabledCallback carries nothing the framework needs to
-     * apply, and the protocol does not define it.
+     * An observed attribute drives the property the registry's `propertyOf`
+     * names, so a hyphenated attribute is authored with its dashes and read as
+     * a camelCase property. A single-word attribute is its own property name,
+     * which is what every observed attribute in the library is.
      */
     upgrade(): Promise<void>;
-    render(c: any): void;
-    reflect(fn: any): void;
-    reflectTo(attr: any, value: any): void;
+    /**
+     * Renders the element from its slots alone: it builds the dom its setters
+     * drive, and the base applies the declared state onto the properties as
+     * soon as it returns. A render needing a declared value while it builds
+     * reads it through `declared(name)`. The slots are undefined for an element
+     * declaring no slots.
+     * @param {{ slots: any }} c
+     */
+    render(c: {
+        slots: any;
+    }): void;
+    /**
+     * The declared value of an attribute, unmarshalled through its mapper.
+     *
+     * A `static attributes` name is the configuration tier: read once when the
+     * upgrade starts and answered unchanged for the element's life, so a later
+     * attribute write does not quietly change how the element behaves. An
+     * observed name answers the snapshot while the render is pending, kept
+     * open to attribute writes landing in that window, and the live attribute
+     * afterwards, the property being live by then.
+     *
+     * The snapshot exists rather than a read of the dom because an element may
+     * write its own observed attributes while it renders, whether a reflection
+     * or a value the platform normalizes on the way in, and what the author
+     * declared is what the base applies, not what the render left behind.
+     * @param {string} name
+     */
+    declared(name: string): any;
+    /** Whether the element's render completed: the moment its properties went live. */
+    get rendered(): boolean;
+    /**
+     * Projects a property back onto its observed attribute, marshalled through
+     * the mapper the attribute was declared with: the one place a property
+     * reaches its attribute, so a setter never has to know how its own type
+     * serializes.
+     *
+     * A value the attribute already carries is not written at all, so reflecting
+     * what an attribute write just delivered ends there rather than looping, and
+     * only the attribute being written is muted while it happens.
+     * @param {string} attr
+     * @param {any} value
+     */
+    reflectTo(attr: string, value: any): void;
+}
+export type Messages = Record<string, string | Record<string, string>>;
+export type Receiver = {
+    l10n?: Messages;
+    locale?: string;
+};
+/**
+ * The translations as a template module: `#l10n:t()` for messages, plus date,
+ * number and bytes formatting in the page's locale. The template form and the
+ * imperative `of()` facade both resolve through the registry's scope, so they
+ * always produce the same result for the same key.
+ */
+declare class Localization {
+    /**
+     * Resolves a message from the translations and interpolates its arguments.
+     * A single plain object argument interpolates named placeholders
+     * ({name}); anything else interpolates positional ones ({0}).
+     * A plural leaf selects its form through Intl.PluralRules over the
+     * numeric {count} named argument.
+     *
+     * @param {string} key
+     * @param {...any} args
+     * @this {Receiver}
+     * @returns {string} the message, or the key itself when the translations do not carry it
+     */
+    static t(this: Receiver, key: string, ...args: any[]): string;
+    /**
+     * Formats a date through Intl.DateTimeFormat in the receiver's locale.
+     *
+     * @param {Date | number} value
+     * @param {Intl.DateTimeFormatOptions} [options]
+     * @this {Receiver}
+     */
+    static date(this: Receiver, value: Date | number, options?: Intl.DateTimeFormatOptions): any;
+    /**
+     * Formats a number through Intl.NumberFormat in the receiver's locale.
+     *
+     * @param {number} value
+     * @param {Intl.NumberFormatOptions} [options]
+     * @this {Receiver}
+     */
+    static number(this: Receiver, value: number, options?: Intl.NumberFormatOptions): any;
+    /**
+     * Formats a byte size with binary thresholds and literal unit suffixes:
+     * the digits honor the locale, the units are the near-universal KiB/MiB/GiB.
+     * A size exactly on a threshold takes the larger unit: 1024 is 1KiB.
+     *
+     * @param {number} value
+     * @this {Receiver}
+     */
+    static bytes(this: Receiver, value: number): string;
+    /**
+     * An imperative facade over the module functions, resolving the translations
+     * and the locale from the registry overlays on every call.
+     *
+     * @param {{ locale?: string }} [overrides] an explicit locale, winning over the registry one
+     */
+    static of(overrides?: {
+        locale?: string;
+    }): {
+        t: (...args: any[]) => any;
+        date: (...args: any[]) => any;
+        number: (...args: any[]) => any;
+        bytes: (...args: any[]) => any;
+    };
 }
-export { Attributes, ExpressionEvaluator, Expressions, Fragments, LightSlots, Nodes, ParsedElement, Registry, RenderError, Rendering, Template, Templates, registry };
+export { Attributes, BoundedCache, ExpressionEvaluator, Expressions, Fragments, LightSlots, Localization, Nodes, ParsedElement, Registry, RenderError, Rendering, Template, Templates, registry };
 
 export as namespace ftl;