@zeyos/zx 4.3.0 → 4.4.0

package/dist/types/components/stat-tile/stat-tile.d.ts

@@ -0,0 +1,277 @@
+import { Component } from '../../core/component.js';
+export type StatTileFormatName = 'number' | 'currency' | 'percent' | 'fileSize' | null;
+export type StatTileFormat = StatTileFormatName | ((value: number | string | null | undefined) => string);
+export type StatTileKind = 'neutral' | 'accent' | 'success' | 'warning' | 'danger' | 'info';
+export type StatTileDeltaKind = 'positive' | 'negative' | 'neutral';
+export type StatTileDirection = 'up' | 'down' | 'flat';
+export type StatTileDelta = {
+    /**
+     * Which way the metric moved, read from the sign alone.
+     */
+    direction: StatTileDirection;
+    /**
+     * `'+'`, `'−'` (U+2212), or `''` for an unchanged metric.
+     */
+    sign: string;
+    /**
+     * The formatted absolute change, without a sign.
+     */
+    magnitude: string;
+    /**
+     * The visible change: `sign` followed by `magnitude`.
+     */
+    text: string;
+};
+export type StatTileNameParts = {
+    /**
+     * The metric's name.
+     */
+    label?: string;
+    /**
+     * The formatted value.
+     */
+    value?: string;
+    /**
+     * The change, already worded for speech (`'up 2'`, not `'+2'`).
+     */
+    delta?: string;
+    /**
+     * What the change is measured against.
+     */
+    deltaLabel?: string;
+};
+export type StatTileOptions = {
+    /**
+     * The metric's name, set small above the value.
+     */
+    label?: string;
+    /**
+     * The metric. A string is rendered as given.
+     */
+    value?: number | string | null;
+    /**
+     * How a numeric value is rendered: a named mode, a
+     * callback receiving the raw value, or null to print the value unformatted.
+     */
+    format?: StatTileFormat;
+    /**
+     * ISO 4217 code used by `format: 'currency'`.
+     */
+    currency?: string | null;
+    /**
+     * BCP 47 tag for every formatter; defaults to the active language.
+     */
+    locale?: string;
+    /**
+     * Change against the previous period. Rendered with
+     * its own sign and an arrow, never with colour alone.
+     */
+    delta?: number | string | null;
+    /**
+     * Whether the change is good, bad, or merely a
+     * change. This — not the sign's direction — picks the delta colour: a rising ticket count is not
+     * a success, so "up is good" is never assumed.
+     */
+    deltaKind?: StatTileDeltaKind;
+    /**
+     * How the delta is rendered; defaults to `format`.
+     */
+    deltaFormat?: StatTileFormat;
+    /**
+     * What the change is measured against, e.g. `'vs. last week'`.
+     */
+    deltaLabel?: string;
+    /**
+     * Values for a decorative sparkline. Fewer than two usable numbers
+     * render nothing.
+     */
+    trend?: number[];
+    /**
+     * Icon name from `icons.js`, shown beside the label.
+     */
+    icon?: string | null;
+    /**
+     * Semantic intent. It tints the icon and the sparkline
+     * and never the value, which stays at full text contrast whatever intent a record carries.
+     */
+    kind?: StatTileKind;
+    /**
+     * Destination. A tile with an href is an `<a>`.
+     */
+    href?: string | null;
+    /**
+     * Renders a `<button>` without an href. Passing `onclick`
+     * sets this implicitly; set it directly to subscribe with `on('click', …)` instead.
+     */
+    clickable?: boolean;
+    /**
+     * Renders a skeleton shaped like the tile.
+     */
+    loading?: boolean;
+    /**
+     * Message overrides, keyed as `statTile.*`.
+     */
+    msg?: Record<string, unknown>;
+    /**
+     * Activation listener; its
+     * presence is what turns a tile with no href into a button. It is the tile's `click` event, as
+     * every Zx component's `on*` option is, so it receives the `CustomEvent` carrying the native
+     * event in `detail.event`.
+     */
+    onclick?: (event: CustomEvent<{
+        event: MouseEvent;
+    }>) => void;
+};
+/**
+ * Renders a metric: a label, the number it names, and — optionally — how that number moved.
+ *
+ * The value is the loudest thing on the tile; the label sits small above it and the delta and the
+ * sparkline are subordinate to both. Nothing here assumes a fixed set of metrics: the label, the
+ * intent colour, the icon and the formatting all arrive per instance, so a tile whose content
+ * comes from a server is the normal case rather than the exception.
+ *
+ * The element shape follows the tile's behaviour, and a tag cannot be rewritten in place, so the
+ * component normally builds its own root — pass `null` as the target, or use {@link statTile}. An
+ * existing element is adopted only when its tag already is the one the options call for; a mismatch
+ * throws rather than silently shipping a `<div>` with a click handler or a link that cannot
+ * navigate.
+ *
+ * @fires StatTile#click
+ * @extends {Component<StatTileOptions>}
+ */
+export declare class StatTile extends Component<StatTileOptions> {
+    _createdRoot: boolean;
+    _snapshot: import("../../core/dom.js").TargetSnapshot;
+    _closed: boolean;
+    _state: any;
+    static cssName: string;
+    /** @type {Readonly<StatTileOptions>} */
+    static defaults: Readonly<StatTileOptions>;
+    /**
+     * Creates or adopts one metric tile.
+     * @param {Element|string|null} [target=null] Existing element of the required tag, or null.
+     * @param {StatTileOptions} [options={}] Tile options.
+     */
+    constructor(target?: Element | string | null, options?: StatTileOptions);
+    /**
+     * @returns {HTMLElement}
+     * @throws {TypeError} When an adopted target is not the tag the options require.
+     */
+    render(): HTMLElement;
+    /**
+     * Replaces any subset of the tile's content and redraws it. This is how a tile leaves
+     * `loading: true` behind once the server answers.
+     * @param {StatTileOptions} options Options to merge over the current ones.
+     * @returns {this}
+     * @throws {TypeError} When the merged options would need a different element tag.
+     */
+    update(options?: StatTileOptions): this;
+    /**
+     * Reports the tile's own accessible name, which is what assistive technology announces.
+     * @returns {string} Label, value, and delta, in that order.
+     */
+    getAccessibleName(): string;
+    /**
+     * Aborts listeners and restores an adopted target to the state it was found in.
+     * @returns {void}
+     */
+    destroy(): void;
+    /**
+     * Resolves a message through the host translator, falling back to the built-in English text.
+     * @param {string} key Message key.
+     * @param {...unknown} args Interpolation values.
+     * @returns {string}
+     */
+    _message(key: string, ...args: unknown[]): string;
+}
+/**
+ * Creates a tile that builds its own root: the convenience form of `new StatTile(null, options)`,
+ * the way `tooltip()` stands in for `new Tooltip(…)`.
+ *
+ * It returns the component, not an element, so there is one construction idiom and one click path.
+ * Call `.toElement()` for the node to place.
+ *
+ * @param {StatTileOptions} [opts={}] Tile options.
+ * @returns {StatTile} The component, whose root is an `<a>`, a `<button>`, or a `<div>`.
+ */
+export declare function statTile(opts?: StatTileOptions): StatTile;
+/**
+ * Formats the metric itself.
+ *
+ * A string value is the host's own final text and is passed through untouched; an explicit
+ * callback outranks that, because a host that supplies one has asked to decide every case.
+ *
+ * @param {number|string|null|undefined} value The metric.
+ * @param {{format?: StatTileFormat, locale?: string, currency?: string|null}} [options={}] Mode,
+ *   language, and currency.
+ * @returns {string} The text to display; empty for a missing value.
+ */
+export declare function formatStatValue(value: number | string | null | undefined, options?: {
+    format?: StatTileFormat;
+    locale?: string;
+    currency?: string | null;
+}): string;
+/**
+ * Describes a change without judging it.
+ *
+ * The direction is read from the sign and nothing else; whether that direction is good news is
+ * `deltaKind`'s business, not this function's. The magnitude is formatted from the absolute value
+ * and the sign is prepended, because no locale prints a leading `+` on its own.
+ *
+ * @param {number|string|null|undefined} delta The change.
+ * @param {{format?: StatTileFormat, locale?: string, currency?: string|null}} [options={}]
+ *   Formatting, defaulting to the tile's own.
+ * @returns {StatTileDelta|null} The change, or null when there is none to show.
+ */
+export declare function statDelta(delta: number | string | null | undefined, options?: {
+    format?: StatTileFormat;
+    locale?: string;
+    currency?: string | null;
+}): StatTileDelta | null;
+/**
+ * Chooses the element a tile must be, from what the tile does.
+ *
+ * A destination is a link, an action is a button, and a tile that does neither is a plain
+ * container. A `<div>` never gets a click handler, and an href that could execute script is not a
+ * destination at all — it falls through to whichever shape the remaining options justify.
+ *
+ * @param {{href?: string|null, clickable?: boolean, onclick?: unknown}} [options={}] The options
+ *   that carry behaviour.
+ * @returns {'a'|'button'|'div'} The tag to render.
+ */
+export declare function statTileTag(options?: {
+    href?: string | null;
+    clickable?: boolean;
+    onclick?: unknown;
+}): 'a' | 'button' | 'div';
+/**
+ * Composes the tile's accessible name: label, then value, then how it changed.
+ *
+ * The sparkline is decoration and contributes nothing, and the delta arrives already worded —
+ * `'up 2'` rather than `'+2'` — because a screen reader should not have to interpret a glyph.
+ *
+ * @param {StatTileNameParts} [parts={}] The pieces, already formatted and translated.
+ * @returns {string} The name, with empty pieces dropped rather than left as stray punctuation.
+ */
+export declare function statTileName(parts?: StatTileNameParts): string;
+/**
+ * Projects a series onto the sparkline's user-unit box.
+ *
+ * A series needs two usable numbers to be a line; a flat series is drawn down the middle rather
+ * than along the floor, which would read as zero.
+ *
+ * @param {unknown[]} values The series, in order. Unusable entries are dropped.
+ * @param {{width?: number, height?: number, inset?: number}} [box={}] The target box.
+ * @returns {string|null} An SVG `points` list, or null when there is no line to draw.
+ */
+export declare function statTrendPoints(values: unknown[], box?: {
+    width?: number;
+    height?: number;
+    inset?: number;
+}): string | null;
+/**
+ * Fired when a linked or clickable tile is activated. A tile with neither an href nor a click
+ * handler is a `<div>` and never emits it.
+ * @event StatTile#click
+ * @type {CustomEvent<{event: MouseEvent}>}
+ */

package/dist/types/components/tabbox/tabbox.d.ts

@@ -236,4 +236,11 @@ export declare class Tabbox extends Component<TabboxOptions> {
     _require(name: string): TabRecord;
     /** @param {Element} tab @returns {TabRecord|null} */
     _recordForTab(tab: Element): TabRecord | null;
+    /**
+     * Resolves a message through the host translator, falling back to the built-in English text.
+     * @param {string} key Message key.
+     * @param {string} fallback English default.
+     * @returns {string}
+     */
+    _message(key: string, fallback: string): string;
 }

package/dist/types/components/table/table.d.ts

@@ -25,6 +25,29 @@ export type TableHierarchyOptions = {
      */
     expanded?: boolean | unknown[];
 };
+export type TableRowKind = {
+    /**
+     * Draw the row as a single cell across every rendered column — a
+     * section heading rather than a record. The cell is a `<th scope="colgroup">`, not a `<td>`,
+     * because it labels the columns of the rows beneath it and a screen reader walking the table
+     * should meet it as a heading rather than as a value. A spanning row carries no selection
+     * checkbox, is never editable, and is skipped by `rowReorder`; it still emits `rowclick` and still
+     * participates in `getData()` and `updateRow()`.
+     */
+    span?: boolean;
+    /**
+     * Content
+     * of the spanning cell. Omitted, the cell falls back to the row's raw value for the first visible
+     * column, which is what a host otherwise writes by hand.
+     */
+    render?: (row: TableRow, index: number) => Node | string | number | null | undefined;
+    /**
+     * Space-separated classes added to the row, on top of `rowClass`. Zx
+     * ships no section look: a billing section is not a kanban swimlane, so the tint, the weight and
+     * the rule above it are the host's to decide.
+     */
+    class?: string;
+};
 export type TableEditorApi = {
     /**
      * Value the cell holds when the editor opens.
@@ -207,6 +230,21 @@ export type TableOptions = {
      * Additional row class callback.
      */
     rowClass?: ((row: TableRow) => string) | null;
+    /**
+     * Row property or callback
+     * naming each row's kind — the `type` on a ZeyOS transaction line, where one value is a position
+     * carrying quantities and amounts and another is a section heading that groups the positions under
+     * it. `null`, the default, renders every row exactly as before.
+     */
+    rowKind?: string | ((row: TableRow) => unknown) | null;
+    /**
+     * Presentation per kind, keyed by the
+     * resolved kind coerced to a string. A kind with no entry here renders as an ordinary row. While
+     * any row in the current data resolves to a `span` kind the header sort controls are withheld and
+     * `setSort()` is inert: sorting a grouped table scatters the positions out of their sections, and
+     * doing that silently is worse than not offering it. `sortMode: 'server'` still owns its own order.
+     */
+    rowKinds?: Record<string, TableRowKind> | null;
     /**
      * Whether alternate rows use the zebra background.
      */
@@ -487,6 +525,10 @@ export declare class Table extends Component<TableOptions> {
     _original: import("../../core/dom.js").TargetSnapshot;
     _columns: any[] | TableColumn[];
     _data: any[] | TableRow[];
+    _rowKind: string | ((row: TableRow) => unknown);
+    _rowKinds: Record<string, TableRowKind>;
+    _spanning: boolean;
+    _sortWarned: boolean;
     _selected: Set<any>;
     _selectionAnchorId: any;
     _sort: any;
@@ -533,6 +575,7 @@ export declare class Table extends Component<TableOptions> {
     _columnList: HTMLElement;
     _selectAll: HTMLElement;
     _headers: Map<any, any>;
+    _headerSpanning: boolean;
     _hierarchyMeta: Map<unknown, TableHierarchyEntry>;
     static cssName: string;
     /** @type {TableOptions} */
@@ -678,6 +721,10 @@ export declare class Table extends Component<TableOptions> {
     /**
      * Activates a column sort. Local mode stably reorders data; server mode only updates the
      * header state and emits the request event.
+     *
+     * Inert while the data holds a spanning row: a sort would scatter the positions out of the
+     * sections that group them, in either sort mode. The header withholds its controls for the same
+     * reason, so nothing on screen invites the call.
      * @param {string} id Column id.
      * @param {TableSortDirection} [dir] Direction; omitted toggles the current column.
      * @param {{silent?: boolean}} [options={}] Event options.
@@ -896,6 +943,28 @@ export declare class Table extends Component<TableOptions> {
     destroy(): void;
     /** @returns {TableColumn[]} */
     _visibleColumns(): TableColumn[];
+    /**
+     * Whether a row draws as one cell across the table instead of as a record.
+     * @param {TableRow} row Row to classify.
+     * @returns {boolean}
+     */
+    _isSpanningRow(row: TableRow): boolean;
+    /**
+     * Whether any row in the current data — not only the rendered prefix — spans. This is what
+     * withholds the sort controls, and the reader must not be offered a control that the next
+     * `growBy()` would have to take away again.
+     * @returns {boolean}
+     */
+    _hasSpanningRow(): boolean;
+    /**
+     * How many cells one row occupies: every visible column plus the structural columns the table
+     * renders beside them. Shared by the spanning cell and the empty-state cell so the two can never
+     * disagree about the table's width.
+     * @returns {number}
+     */
+    _spanColspan(): number;
+    /** @returns {TableRow[]} Rendered rows that can carry a selection; spanning rows cannot. */
+    _selectableData(): TableRow[];
     /** @returns {HTMLElement} */
     _createColumnControls(): HTMLElement;
     /**
@@ -1091,6 +1160,8 @@ export declare class Table extends Component<TableOptions> {
     _emitRowToggle(id: unknown, expanded: boolean): void;
     /** Keeps the reader's current expansion state limited to branches still present in the data. */
     _reconcileExpanded(): void;
+    /** @returns {Set<unknown>} Ids of every row in the data that may hold a selection. */
+    _selectableIds(): Set<unknown>;
     /** @returns {boolean} Whether selection changed. */
     _pruneSelection(): boolean;
     /** @param {TableRow} row @returns {unknown} */
@@ -1141,6 +1212,79 @@ export declare class Table extends Component<TableOptions> {
  * @event Table#editinvalid
  * @type {CustomEvent<TableEditInvalidDetail>}
  */
+/**
+ * Resolves a row's kind through the `rowKind` accessor and coerces it to the string `rowKinds` is
+ * keyed by.
+ *
+ * Only `null` and `undefined` mean "no kind". `0` and `''` are kinds like any other: a ZeyOS
+ * transaction line uses `0` for a position and `1` for a section, so a falsy test here would render
+ * every position as though the table had never been told about kinds at all.
+ * @param {TableRow} row Row to classify.
+ * @param {string|((row: TableRow) => unknown)|null|undefined} rowKind Field name or accessor.
+ * @returns {string|null} The kind as a string, or null when there is none.
+ */
+export declare function resolveRowKind(row: TableRow, rowKind: string | ((row: TableRow) => unknown) | null | undefined): string | null;
+/**
+ * Looks one resolved kind up in the `rowKinds` map.
+ *
+ * Own properties only: a kind read out of server data could just as easily be `toString` or
+ * `constructor`, and inherited members of `Object.prototype` are not configuration.
+ * @param {Record<string, TableRowKind>|null|undefined} rowKinds Kind map.
+ * @param {string|null} kind Resolved kind.
+ * @returns {TableRowKind|null} Matching entry, or null.
+ */
+export declare function resolveRowKindSpec(rowKinds: Record<string, TableRowKind> | null | undefined, kind: string | null): TableRowKind | null;
+/**
+ * Whether a row draws as one spanning cell under the given configuration.
+ * @param {TableRow} row Row to classify.
+ * @param {string|((row: TableRow) => unknown)|null|undefined} rowKind Field name or accessor.
+ * @param {Record<string, TableRowKind>|null|undefined} rowKinds Kind map.
+ * @returns {boolean}
+ */
+export declare function isSpanningRow(row: TableRow, rowKind: string | ((row: TableRow) => unknown) | null | undefined, rowKinds: Record<string, TableRowKind> | null | undefined): boolean;
+/**
+ * Whether a data set holds a row that spans — the question that decides whether `Table` offers its
+ * sort controls at all.
+ *
+ * Asked of the whole data rather than of the rendered prefix: with `growing` on, a sort control
+ * that disappeared the moment the reader pressed "show 20 more" would be worse than one that was
+ * never there. Asked again on every data change, so a filter that removes the last section gives
+ * the sort back.
+ * @param {TableRow[]} rows Rows to scan.
+ * @param {string|((row: TableRow) => unknown)|null|undefined} rowKind Field name or accessor.
+ * @param {Record<string, TableRowKind>|null|undefined} rowKinds Kind map.
+ * @returns {boolean}
+ */
+export declare function hasSpanningRow(rows: TableRow[], rowKind: string | ((row: TableRow) => unknown) | null | undefined, rowKinds: Record<string, TableRowKind> | null | undefined): boolean;
+/**
+ * How many cells one table row occupies.
+ *
+ * `selectable: 'multi'` and `rowReorder` each render a `<col>` and a leading cell of their own, and
+ * a spanning cell that ignored them would leave the row one or two columns short — the table would
+ * still lay out, silently and wrongly. `selectable: 'single'` adds no column: the whole row is the
+ * control there.
+ * @param {number} columnCount Number of visible data columns.
+ * @param {{selectable?: TableSelectionMode, rowReorder?: boolean}} [structure={}] Structural columns.
+ * @returns {number} Colspan covering every rendered cell, never below 1.
+ */
+export declare function tableSpanColspan(columnCount: number, structure?: {
+    selectable?: TableSelectionMode;
+    rowReorder?: boolean;
+}): number;
+/**
+ * Content for a spanning row's single cell.
+ *
+ * Without a `render` the cell shows the row's raw value for the first visible column — the same
+ * thing a host writes by hand today. Deliberately raw rather than routed through the column's own
+ * renderer or display type: that renderer was written for a record, and running it against a
+ * heading that carries no quantities or amounts is how a section row ends up showing `0,00 €`.
+ * @param {TableRow} row Row being rendered.
+ * @param {TableRowKind|null|undefined} spec Resolved kind presentation.
+ * @param {TableColumn[]} visibleColumns Columns currently rendered, in display order.
+ * @param {number} [index=0] Flat row index.
+ * @returns {Node|string|number|null|undefined} Cell content.
+ */
+export declare function spanRowContent(row: TableRow, spec: TableRowKind | null | undefined, visibleColumns: TableColumn[], index?: number): Node | string | number | null | undefined;
 /**
  * Applies a column's built-in display type. A custom renderer always wins and may still return a
  * Node; all built-in results are strings so `_renderCellContent` can insert them as text.

package/dist/types/components/table-view/table-view.d.ts

@@ -43,9 +43,11 @@ export type TableViewOptions = {
      */
     hiddenFields?: string[];
     /**
-     * Show the accessible visibility and reorder disclosure.
+     * Show the accessible visibility and reorder disclosure. `true` keeps the composed Table's own
+     * column chooser and `false` omits it; an object renders the shared record-view chooser instead,
+     * with a translated `label` and, with `target`, mounted into a host element.
      */
-    fieldControls?: boolean;
+    fieldControls?: boolean | import('../view/record-view.js').ViewFieldControlsConfig;
     /**
      * Empty-result content.
      */
@@ -93,7 +95,10 @@ export type TableViewOptions = {
  * @property {unknown[]} [selection=[]] Initially selected record ids.
  * @property {string[]} [fieldOrder=[]] Preferred stable field order.
  * @property {string[]} [hiddenFields=[]] Initially hidden field ids.
- * @property {boolean} [fieldControls=true] Show the accessible visibility and reorder disclosure.
+ * @property {boolean|import('../view/record-view.js').ViewFieldControlsConfig} [fieldControls=true]
+ * Show the accessible visibility and reorder disclosure. `true` keeps the composed Table's own
+ * column chooser and `false` omits it; an object renders the shared record-view chooser instead,
+ * with a translated `label` and, with `target`, mounted into a host element.
  * @property {string|Node|(()=>string|Node)|null} [emptyText=null] Empty-result content.
  * @property {TableOptions} [table={}] Advanced low-level Table options. Shared options win where
  * their contracts overlap; all other options and callbacks are forwarded unchanged.
@@ -126,6 +131,7 @@ export declare class TableView extends RecordView {
     _tableSyncDepth: number;
     _tableViewDestroyed: boolean;
     _tableHost: HTMLElement;
+    _tableViewToolbar: HTMLElement;
     table: Table;
     static cssName: string;
     /** @type {Readonly<TableViewOptions>} */
@@ -176,7 +182,7 @@ export declare function fieldsToTableColumns(fields: ViewField[]): TableColumn[]
  * Builds the composed Table configuration. Shared options deliberately overwrite overlapping
  * low-level options; every advanced option remains untouched.
  * @param {TableOptions|undefined} table Advanced Table options.
- * @param {{fields:ViewField[],data:TableViewRecord[],recordId:string|((record:TableViewRecord)=>unknown),sort:ViewSort|null,sortMode:'local'|'server',selectable:false|'single'|'multi',hiddenFields:string[],fieldControls:boolean,emptyText:string|Node|(()=>string|Node)|null}} shared Shared state.
+ * @param {{fields:ViewField[],data:TableViewRecord[],recordId:string|((record:TableViewRecord)=>unknown),sort:ViewSort|null,sortMode:'local'|'server',selectable:false|'single'|'multi',hiddenFields:string[],fieldControls:boolean|import('../view/record-view.js').ViewFieldControlsConfig,emptyText:string|Node|(()=>string|Node)|null}} shared Shared state.
  * @returns {TableOptions} Table configuration.
  */
 export declare function tableOptionsForView(table: TableOptions | undefined, shared: {
@@ -187,6 +193,6 @@ export declare function tableOptionsForView(table: TableOptions | undefined, sha
     sortMode: 'local' | 'server';
     selectable: false | 'single' | 'multi';
     hiddenFields: string[];
-    fieldControls: boolean;
+    fieldControls: boolean | import('../view/record-view.js').ViewFieldControlsConfig;
     emptyText: string | Node | (() => string | Node) | null;
 }): TableOptions;

package/dist/types/components/timebox/timebox.d.ts

@@ -118,4 +118,11 @@ export declare class Timebox extends Component<TimeboxOptions> {
     _syncDisabled(): void;
     /** @returns {void} */
     _emitChange(): void;
+    /**
+     * Resolves a message through the host translator, falling back to the built-in English text.
+     * @param {string} key Message key.
+     * @param {string} fallback English default.
+     * @returns {string}
+     */
+    _message(key: string, fallback: string): string;
 }

package/dist/types/components/value-list/value-list.d.ts

@@ -144,6 +144,14 @@ export declare class ValueList extends Component<ValueListOptions> {
     _removeAt(index: number, focusIndex?: number): void;
     /** @param {string} message @returns {void} */
     _showError(message: string): void;
+    /**
+     * Resolves a message through the host translator, falling back to the built-in English text.
+     * @param {string} key Message key.
+     * @param {string} fallback Built-in text, with `%1`-style placeholders.
+     * @param {...unknown} args Interpolation values.
+     * @returns {string}
+     */
+    _message(key: string, fallback: string, ...args: unknown[]): string;
     /** @returns {void} */
     destroy(): void;
 }