@fusion.dev/helix 0.155.0 → 0.156.0

package/types/vue.d.ts

@@ -2497,13 +2497,22 @@ units. */
 card and `{width}` and `{height}` for its new size, in the document's
 units. */
   resizedLabel?: (HelixCanvas["resizedLabel"]) | undefined;
+  /** What a screen reader calls the board in place of its role, after its
+name: "Release plan, canvas". Said only where the board has a name of its
+own, since the fallback name is the same word. Empty leaves the role. */
+  "role-label"?: (HelixCanvas["roleLabel"]) | undefined;
+  /** What a screen reader calls the board in place of its role, after its
+name: "Release plan, canvas". Said only where the board has a name of its
+own, since the fallback name is the same word. Empty leaves the role. */
+  roleLabel?: (HelixCanvas["roleLabel"]) | undefined;
   /** The names of the selected cards and connections, comma separated. Empty
 when nothing is selected.
 
 **Comma separated, the way `Listbox` writes a multiple value**, so a page
 reads one selection the same way wherever it comes from. A click, or a key
-that lands on one, selects it alone; Shift, Command or Control with a click
-adds or takes one away, and so does Space; Command or Control with A
+that lands on one, selects it alone; Command or Control with an arrow key
+moves without selecting; Shift, Command or Control with a click adds or
+takes one away, and so does Space; Command or Control with A
 selects everything; Shift and a drag across the empty board selects the
 cards the box touches. A click on the empty board, or Escape, selects
 nothing. Dragging, Shift with an arrow, and Delete act on the whole
@@ -3402,6 +3411,16 @@ say that without the component knowing what a row looks like. */
   "loading-text"?: (HelixChat["loadingText"]) | undefined;
   /** The text shown and announced while the rows load. */
   loadingText?: (HelixChat["loadingText"]) | undefined;
+  /** What a screen reader hears when a turn arrives. `{author}` is who wrote
+it, as its name says it, and `{text}` its words. A turn with no author a
+reader can be told, a turn by `them` with no `author-label`, says its
+words alone. */
+  "arrival-label"?: (HelixChat["arrivalLabel"]) | undefined;
+  /** What a screen reader hears when a turn arrives. `{author}` is who wrote
+it, as its name says it, and `{text}` its words. A turn with no author a
+reader can be told, a turn by `them` with no `author-label`, says its
+words alone. */
+  arrivalLabel?: (HelixChat["arrivalLabel"]) | undefined;
   /** Declarations for the turns from `turns` by each author, keyed by `author`,
 as JSON in the attribute: `{"ada": "--chat-message-background-color: …"}`.
 
@@ -3552,8 +3571,36 @@ export type HelixCheckboxGroupVueProps = {
   /** The direction the checkboxes run. Set `horizontal` for a row. Unset is a
 column. */
   orientation?: (HelixCheckboxGroup["orientation"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixCheckboxGroup["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixCheckboxGroup["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixCheckboxGroup["feedback"]) | undefined;
@@ -3714,8 +3761,36 @@ was, and the control says `aria-readonly`. A script can still set
 The attribute is `readonly`, which is the platform's spelling for the
 text fields. */
   readOnly?: (HelixCheckbox["readOnly"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixCheckbox["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixCheckbox["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixCheckbox["feedback"]) | undefined;
@@ -4031,8 +4106,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixColorInput["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixColorInput["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixColorInput["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixColorInput["feedback"]) | undefined;
@@ -4670,8 +4773,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixCombobox["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixCombobox["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixCombobox["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixCombobox["feedback"]) | undefined;
@@ -4774,6 +4905,22 @@ delay sends one request for a word instead of one per letter. The arrow
 keys, Enter and Escape narrow at once on what was typed. `0` narrows on
 every keystroke. See Listbox's `filter-delay`. */
   filterDelay?: (HelixCombobox["filterDelay"]) | undefined;
+  /** What the form receives for each chosen option: `key`, its `value`, or
+`text`, its words, as React Aria's ComboBox `formValue` offers.
+
+`text` is for a server that wants what the reader saw, such as a city's
+name. A value no option carries, typed with `allows-custom-value` or made
+with `creatable`, is sent as it is either way. Absent is `key`, and the
+host carries no attribute for it. */
+  "form-value"?: (HelixCombobox["formValue"]) | undefined;
+  /** What the form receives for each chosen option: `key`, its `value`, or
+`text`, its words, as React Aria's ComboBox `formValue` offers.
+
+`text` is for a server that wants what the reader saw, such as a city's
+name. A value no option carries, typed with `allows-custom-value` or made
+with `creatable`, is sent as it is either way. Absent is `key`, and the
+host carries no attribute for it. */
+  formValue?: (HelixCombobox["formValue"]) | undefined;
   /** The list's name, read by screen readers. The list has no visible name. */
   "list-label"?: (HelixCombobox["listLabel"]) | undefined;
   /** The list's name, read by screen readers. The list has no visible name. */
@@ -5003,6 +5150,13 @@ Empty turns it off, for a consumer who opens the palette from a button or
 from their own shortcut handler. There is no list of defaults to fight
 with: one key, said once. */
   hotkey?: (HelixCommand["hotkey"]) | undefined;
+  /** Draws the palette in the page, where it stands, with no dialog: a search
+over a list of commands, as React Aria's Autocomplete is drawn.
+
+The list is always shown, and `hotkey` puts focus in its filter field.
+Choosing a command says `helix-select` and leaves the list where it is,
+and `open`, `toggle` and the dialog's parts do nothing. */
+  inline?: (HelixCommand["inline"]) | undefined;
   /** Accessible name for the overlay, which has no visible heading. */
   label?: (HelixCommand["label"]) | undefined;
   /** What the list says when its commands could not be loaded, such as after a
@@ -5030,6 +5184,15 @@ some. Absent, `empty-text` shows. See Listbox's `no-results-text`. */
   /** The text shown when typing hides every one of the commands, where there are
 some. Absent, `empty-text` shows. See Listbox's `no-results-text`. */
   noResultsText?: (HelixCommand["noResultsText"]) | undefined;
+  /** The page of commands shown, by name: empty for the commands you write
+with no `slot`, or a name for the commands slotted as `page:` and the
+name, such as `slot="page:theme"`.
+
+An option with `opens` set to a name goes to that page when it is chosen,
+in place of running, and Backspace in an empty filter goes back to the
+page before. Closing the palette goes back to the first page. Set it to
+open the palette on a page of your choosing. */
+  page?: (HelixCommand["page"]) | undefined;
   /** The text shown in the filter field before anything is typed. */
   placeholder?: (HelixCommand["placeholder"]) | undefined;
   /** What a screen reader hears when typing leaves one command, where
@@ -5048,6 +5211,15 @@ how many are left, written in the locale, and each language writes the
 forms it has: `{count, plural, one {# polecenie} few {# polecenia} many
 {# poleceń} other {# polecenia}}`. */
   resultsLabel?: (HelixCommand["resultsLabel"]) | undefined;
+  /** The commands as data, for a palette too long to draw whole: each a value,
+which is also its words, or a record with a `value`, a `label` and
+`disabled`. Handed to the list, which draws only the commands in sight and
+reads no children while it is set. See Listbox's `items`.
+
+Choosing one says `helix-select` with its value, as a child option does.
+A command that is a link, or that has an `alternate`, is an option you
+write as a child. */
+  items?: (HelixCommand["items"]) | undefined;
 };
 
 export type HelixCommandVueEvents = {
@@ -5338,6 +5510,22 @@ is set. */
   "dropped-label"?: (HelixDataTable["droppedLabel"]) | undefined;
   /** What screen readers hear when a row is dropped, with `reorderable-rows`. */
   droppedLabel?: (HelixDataTable["droppedLabel"]) | undefined;
+  /** The text shown and announced when the rows could not load, such as "The
+files did not load". Set it when a fetch fails, and clear it once you try
+again. Empty, the default, shows nothing.
+
+While it is set, a line after the rows shows it, or your own content in the
+`error` slot, in place of the empty and loading lines, and the live region
+says it. */
+  "error-text"?: (HelixDataTable["errorText"]) | undefined;
+  /** The text shown and announced when the rows could not load, such as "The
+files did not load". Set it when a fetch fails, and clear it once you try
+again. Empty, the default, shows nothing.
+
+While it is set, a line after the rows shows it, or your own content in the
+`error` slot, in place of the empty and loading lines, and the live region
+says it. */
+  errorText?: (HelixDataTable["errorText"]) | undefined;
   /** The estimated height of a row before it is drawn, in pixels.
 
 Only read while `windowed`, and a starting guess rather than a claim: a
@@ -5803,8 +5991,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixDateInput["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixDateInput["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixDateInput["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixDateInput["feedback"]) | undefined;
@@ -7185,8 +7401,36 @@ export type HelixFileInputHelixRejectElementEvent =
   HelixFileInputElementEvent<HelixRejectEvent>;
 
 export type HelixFileInputVueProps = {
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixFileInput["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixFileInput["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixFileInput["feedback"]) | undefined;
@@ -7600,8 +7844,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixFilterInput["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixFilterInput["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixFilterInput["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixFilterInput["feedback"]) | undefined;
@@ -8147,6 +8419,12 @@ written in the locale, and each language writes the forms it has. */
   /** How many links from the selected note to show, for its local graph. Unset
 shows every note. The list holds what the drawing shows. */
   depth?: (HelixGraph["depth"]) | undefined;
+  /** What the panel shows when the list holds no notes: the graph has none, or
+a search or the legend hid them all. A slotted `empty` replaces it. */
+  "empty-label"?: (HelixGraph["emptyLabel"]) | undefined;
+  /** What the panel shows when the list holds no notes: the graph has none, or
+a search or the legend hid them all. A slotted `empty` replaces it. */
+  emptyLabel?: (HelixGraph["emptyLabel"]) | undefined;
   /** The graph's name where `label` is empty and the host has no
 `aria-label`. */
   "fallback-label"?: (HelixGraph["fallbackLabel"]) | undefined;
@@ -8203,6 +8481,14 @@ such as at the top of a page, where the drawing takes the whole frame. */
   "notes-label"?: (HelixGraph["notesLabel"]) | undefined;
   /** The list's name, read by screen readers, and the name of the button that opens it with `no-panel`. */
   notesLabel?: (HelixGraph["notesLabel"]) | undefined;
+  /** What a screen reader calls the graph in place of its role, after its
+name: "Research notes, graph". Said only where the graph has a name of its
+own, since the fallback name is the same word. Empty leaves the role. */
+  "role-label"?: (HelixGraph["roleLabel"]) | undefined;
+  /** What a screen reader calls the graph in place of its role, after its
+name: "Research notes, graph". Said only where the graph has a name of its
+own, since the fallback name is the same word. Empty leaves the role. */
+  roleLabel?: (HelixGraph["roleLabel"]) | undefined;
   /** The search field's name. */
   "search-label"?: (HelixGraph["searchLabel"]) | undefined;
   /** The search field's name. */
@@ -9016,8 +9302,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixInput["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixInput["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixInput["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixInput["feedback"]) | undefined;
@@ -9954,6 +10268,9 @@ export type HelixListHelixBeforeChangeElementEvent =
 /** `helix-before-reorder` event type */
 export type HelixListHelixBeforeReorderElementEvent =
   HelixListElementEvent<HelixBeforeReorderEvent>;
+/** `helix-load-more` event type */
+export type HelixListHelixLoadMoreElementEvent =
+  HelixListElementEvent<HelixLoadMoreEvent>;
 /** `helix-reorder` event type */
 export type HelixListHelixReorderElementEvent =
   HelixListElementEvent<HelixReorderEvent>;
@@ -9986,6 +10303,12 @@ refused, in a `reorderable` list. */
   "dropped-label"?: (HelixList["droppedLabel"]) | undefined;
   /** What screen readers hear when a row is dropped, in a `reorderable` list. */
   droppedLabel?: (HelixList["droppedLabel"]) | undefined;
+  /** The text of the row shown while the list has no rows, where the `empty`
+slot is empty. Empty, the default, shows no row. */
+  "empty-label"?: (HelixList["emptyLabel"]) | undefined;
+  /** The text of the row shown while the list has no rows, where the `empty`
+slot is empty. Empty, the default, shows no row. */
+  emptyLabel?: (HelixList["emptyLabel"]) | undefined;
   /** The kind of list, which follows from the content.
 
 On the headless tier because it is meaning rather than decoration, the same
@@ -10009,6 +10332,19 @@ has to survive with the stylesheet turned off.
   kind?: (HelixList["kind"]) | undefined;
   /** The list's name, read by screen readers. */
   label?: (HelixList["label"]) | undefined;
+  /** Marks the list as busy fetching more rows, and draws a row after the last
+that says so. The list asks for no more while it is set. */
+  loading?: (HelixList["loading"]) | undefined;
+  /** The text of the row drawn while `loading` is set, where the `loading` slot is empty. */
+  "loading-label"?: (HelixList["loadingLabel"]) | undefined;
+  /** The text of the row drawn while `loading` is set, where the `loading` slot is empty. */
+  loadingLabel?: (HelixList["loadingLabel"]) | undefined;
+  /** Sends `helix-load-more` once the end of the list comes within a screen of
+view, so you can add the next rows as a reader nears them. */
+  "load-more"?: (HelixList["loadMore"]) | undefined;
+  /** Sends `helix-load-more` once the end of the list comes within a screen of
+view, so you can add the next rows as a reader nears them. */
+  loadMore?: (HelixList["loadMore"]) | undefined;
   /** What screen readers hear each time an arrow key moves a held row, in a
 `reorderable` list. `{name}` is the row's words, `{position}` the place it
 would go, counting from 1, and `{count}` the number of rows. */
@@ -10064,7 +10400,7 @@ consumer would have written on an `<ol>`.
 `type` is only `list-style-type`. `start` and `reversed` move the count
 itself. */
   type?: (HelixList["type"]) | undefined;
-  /** The selected rows' values, separated by commas, in a list that selects.
+  /** The selected rows' values, separated by commas with no spaces, such as `a,c`, in a list that selects.
 
 Set it to start with rows selected. A row's value is its `value`, or its
 words where it has none. */
@@ -10080,6 +10416,8 @@ export type HelixListVueEvents = {
   "helix-before-change": HelixListHelixBeforeChangeElementEvent;
   /** Fired when a row is dropped at a new place, in a `reorderable` list, with every row's value in the new order. Cancelable: cancel it to keep the row where it is. */
   "helix-before-reorder": HelixListHelixBeforeReorderElementEvent;
+  /** Fired, in a list with `load-more`, when the end of the list comes within a screen of view, once for each number of rows. */
+  "helix-load-more": HelixListHelixLoadMoreElementEvent;
   /** Fired after `helix-before-reorder` when nobody canceled it. Move your rows to the order in `keys`. Cancelable: cancel it to say the move did not happen. */
   "helix-reorder": HelixListHelixReorderElementEvent;
 };
@@ -10132,8 +10470,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixListbox["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixListbox["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixListbox["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixListbox["feedback"]) | undefined;
@@ -11002,6 +11368,14 @@ the standard, themed map. The layers menu chooses it. */
 `connectMap` keeps it current, and the 3D button is pressed while it is
 above `0`. */
   pitch?: (HelixMap["pitch"]) | undefined;
+  /** What a screen reader calls the map in place of its role, after its
+name: "Edinburgh, map". Said only where the map has a name of its
+own, since the fallback name is the same word. Empty leaves the role. */
+  "role-label"?: (HelixMap["roleLabel"]) | undefined;
+  /** What a screen reader calls the map in place of its role, after its
+name: "Edinburgh, map". Said only where the map has a name of its
+own, since the fallback name is the same word. Empty leaves the role. */
+  roleLabel?: (HelixMap["roleLabel"]) | undefined;
   /** The rotate left button's label. */
   "rotate-left-label"?: (HelixMap["rotateLeftLabel"]) | undefined;
   /** The rotate left button's label. */
@@ -11961,8 +12335,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixNumberInput["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixNumberInput["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixNumberInput["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixNumberInput["feedback"]) | undefined;
@@ -12091,6 +12493,20 @@ filled in, written in the locale. */
   readonly?: (HelixNumberInput["readOnly"]) | undefined;
   /** Prevents editing. The value is still submitted with the form. */
   readOnly?: (HelixNumberInput["readOnly"]) | undefined;
+  /** The words screen readers announce for the field's role, set as its
+`aria-roledescription`. Translate it with the rest of your text, or empty
+it to leave the role as `spinbutton`.
+
+Never written on iOS and iPadOS, where a role description stops VoiceOver
+saying that the field is required. */
+  "role-label"?: (HelixNumberInput["roleLabel"]) | undefined;
+  /** The words screen readers announce for the field's role, set as its
+`aria-roledescription`. Translate it with the rest of your text, or empty
+it to leave the role as `spinbutton`.
+
+Never written on iOS and iPadOS, where a role description stops VoiceOver
+saying that the field is required. */
+  roleLabel?: (HelixNumberInput["roleLabel"]) | undefined;
   /** Makes the label a grip that changes the value when it is dragged.
 
 The label is what is dragged, so this adds no chrome at all. Still opt-in,
@@ -12348,6 +12764,14 @@ needs a height, which is a stylesheet rule reading this attribute. */
 Writing opens exactly these and closes every other, keeping the active row
 where it stays visible. A property, never an attribute. */
   expanded?: (HelixObjectInspector["expanded"]) | undefined;
+  /** Draws an entry's value your way, given the value and its entry. Set it as
+a property.
+
+It returns what Lit renders: a template from `html`, a string, or a DOM
+node. `undefined` draws the value as the inspector does, so a function can
+draw some entries and leave the rest, such as only the strings under
+`/links`. */
+  renderValue?: (HelixObjectInspector["renderValue"]) | undefined;
   /** The value to show, when your code already holds it as an object.
 
 Takes precedence over `for`. Anything JSON can say is drawn; anything else
@@ -12483,6 +12907,15 @@ simply the accessible name.
 `<option label>` does: written the platform's way, a select listed a row of
 nothing for every choice. */
   label?: (HelixOption["label"]) | undefined;
+  /** The page of commands this option opens, by name, where choosing it would
+otherwise run it.
+
+Declared here and acted on by whatever owns the list, as `alternate` is.
+`Command` is the only owner that reads it: choosing the option shows the
+commands slotted as `page:` and the name, such as `slot="page:theme"`,
+and Backspace in an empty filter goes back. Empty is an option that opens
+nothing, which is nearly every option. */
+  opens?: (HelixOption["opens"]) | undefined;
   /** The link's `rel`. Set it whenever you set `target="_blank"`. */
   rel?: (HelixOption["rel"]) | undefined;
   /** Whether this choice is currently chosen.
@@ -12957,8 +13390,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixPinInput["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixPinInput["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixPinInput["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixPinInput["feedback"]) | undefined;
@@ -13432,8 +13893,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixRadioGroup["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixRadioGroup["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixRadioGroup["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixRadioGroup["feedback"]) | undefined;
@@ -13728,8 +14217,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixRating["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixRating["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixRating["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixRating["feedback"]) | undefined;
@@ -13981,9 +14498,13 @@ Not reflected, for `direction`'s reason: the placement is applied by the
 document inside the frame, against its own root, so no rule on this side
 could read it. */
   layout?: (HelixSandboxPreview["layout"]) | undefined;
+  /** A script to run as a module after the markup, on every render of new
+source. A sandbox writes its `js` pane here. */
+  script?: (HelixSandboxPreview["script"]) | undefined;
   /** Markup to render. */
   source?: (HelixSandboxPreview["source"]) | undefined;
-  /** The document the frame loads. It provides the styles and the elements. */
+  /** The document the frame loads. It provides the styles and the elements.
+Empty loads the built-in document, which defines no element. */
   src?: (HelixSandboxPreview["src"]) | undefined;
   /** Stylesheet applied inside the frame, alongside the markup. */
   styles?: (HelixSandboxPreview["styles"]) | undefined;
@@ -14594,8 +15115,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixSelect["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixSelect["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixSelect["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixSelect["feedback"]) | undefined;
@@ -14843,8 +15392,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixSlider["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixSlider["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixSlider["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixSlider["feedback"]) | undefined;
@@ -15799,8 +16376,36 @@ was, and the control says `aria-readonly`. A script can still set
 The attribute is `readonly`, which is the platform's spelling for the
 text fields. */
   readOnly?: (HelixSwitch["readOnly"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixSwitch["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixSwitch["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixSwitch["feedback"]) | undefined;
@@ -16176,6 +16781,22 @@ is set. */
   "dropped-label"?: (HelixTable["droppedLabel"]) | undefined;
   /** What screen readers hear when a held row is dropped, in a `reorderable` table. */
   droppedLabel?: (HelixTable["droppedLabel"]) | undefined;
+  /** The text shown and announced when the rows could not load. Set it when a
+fetch fails, and clear it once you try again. Empty, the default, shows
+nothing.
+
+While it is set, a line after the rows shows it, or your own content in the
+`error` slot, in place of the empty and loading lines, and the live region
+says it. */
+  "error-text"?: (HelixTable["errorText"]) | undefined;
+  /** The text shown and announced when the rows could not load. Set it when a
+fetch fails, and clear it once you try again. Empty, the default, shows
+nothing.
+
+While it is set, a line after the rows shows it, or your own content in the
+`error` slot, in place of the empty and loading lines, and the live region
+says it. */
+  errorText?: (HelixTable["errorText"]) | undefined;
   /** The table's name where neither `label` nor an `aria-label` or
 `aria-labelledby` on the host gives it one. */
   "fallback-label"?: (HelixTable["fallbackLabel"]) | undefined;
@@ -16749,8 +17370,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixTextarea["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixTextarea["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixTextarea["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixTextarea["feedback"]) | undefined;
@@ -17065,8 +17714,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixTimeInput["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixTimeInput["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixTimeInput["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixTimeInput["feedback"]) | undefined;
@@ -17354,6 +18031,19 @@ A time not on the step is simply never offered, so it is not an error to
 name one, and naming every time in the list is how the empty state is
 reached honestly rather than by handing over an empty range. */
   disableTimes?: (HelixTimePicker["disableTimes"]) | undefined;
+  /** What the list says when no time falls between `min` and `max`.
+
+The fallback of the `empty` slot. */
+  "empty-text"?: (HelixTimePicker["emptyText"]) | undefined;
+  /** What the list says when no time falls between `min` and `max`.
+
+The fallback of the `empty` slot. */
+  emptyText?: (HelixTimePicker["emptyText"]) | undefined;
+  /** Help under the times, such as the hours a shop is open, read by screen
+readers as the list's description. A message in `feedback` replaces it.
+
+The fallback of the `hint` slot. */
+  hint?: (HelixTimePicker["hint"]) | undefined;
   /** The clock the times are written on: `h12` for twelve hours with a
 meridiem, `h23` for twenty-four.
 
@@ -17380,7 +18070,8 @@ English, "Stunde" in German. */
   hourLabel?: (HelixTimePicker["hourLabel"]) | undefined;
   /** Accessible name for the list, which has no visible one of its own.
 
-An `aria-label` or `aria-labelledby` on the host names the list instead. */
+An `aria-label` or `aria-labelledby` on the host names the list instead,
+and so does a label slotted into `label`, which is also drawn above it. */
   label?: (HelixTimePicker["label"]) | undefined;
   /** Language tag the times and the wheels' names are written in.
 
@@ -17606,6 +18297,11 @@ Whatever `<time>` accepts, which is a date, a time, both, a duration or a
 week. Unset, the label is written as it was given and nothing claims to
 know what instant it names. */
   datetime?: (HelixTimelineItem["datetime"]) | undefined;
+  /** Writes the time as how long ago it was, or how long until it, from
+`datetime`, where the `time` slot is empty: `long` ("3 hours ago"),
+`short` ("3 hr. ago") or `narrow` ("3h ago"). Set with no value, it is
+`long`. The words move on as they go stale. */
+  relative?: (HelixTimelineItem["relative"]) | undefined;
   /** The kind of event. It sets the color of the mark and nothing else. */
   tone?: (HelixTimelineItem["tone"]) | undefined;
 };
@@ -17781,8 +18477,36 @@ asking it meant. Writing always applies; `<helix-input value="x">` is the
 same statement in markup, and `default-value` is how markup seeds a value
 a reset should return to. */
   value?: (HelixToggleGroup["value"]) | undefined;
-  /**  */
-  "aria-label"?: unknown;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  "aria-label"?: (HelixToggleGroup["namedBy"]) | undefined;
+  /** The name a screen reader says for the field where it shows no label, as
+the platform's `aria-label`. It is drawn as a label and clipped, so it
+names the control inside, and a new one renders at once.
+
+**An `aria-label` is read when the field renders, and nothing else would
+render it again.** It is the platform's attribute and no property of this
+element's, so writing a new one scheduled no update and the label kept
+the old words. Data Table meets this on every column move: each row's
+checkbox is named by the first column, so reordering renames every one.
+
+A reactive property on the attribute, which is the one way Lit observes
+one. Overriding `observedAttributes` in a mixin compiled `this` to the
+mixin's own class, so every field observed only this mixin's attributes
+and dropped its own. Not reflected: the attribute is the consumer's. */
+  namedBy?: (HelixToggleGroup["namedBy"]) | undefined;
   /** The validation message shown under the control. It replaces the
 browser's message. */
   feedback?: (HelixToggleGroup["feedback"]) | undefined;
@@ -18859,6 +19583,20 @@ Ignored once `active` is written. */
   defaultActive?: (HelixVideoPlaylist["defaultActive"]) | undefined;
   /** The list's name, read by screen readers. */
   label?: (HelixVideoPlaylist["label"]) | undefined;
+  /** What the live region says when the playlist moves to another entry.
+`{title}` is the entry's name.
+
+**A move a reader did not make is said.** At the end of a clip the
+playlist starts the next one, and the only other trace of that is the
+`aria-current` on a button the reader is not on. */
+  "playing-label"?: (HelixVideoPlaylist["playingLabel"]) | undefined;
+  /** What the live region says when the playlist moves to another entry.
+`{title}` is the entry's name.
+
+**A move a reader did not make is said.** At the end of a clip the
+playlist starts the next one, and the only other trace of that is the
+`aria-current` on a button the reader is not on. */
+  playingLabel?: (HelixVideoPlaylist["playingLabel"]) | undefined;
   /** What happens when an entry ends with no next one to go to. `one` plays the
 same entry again, and `all` goes from the last entry back to the first.
 Absent, the playlist stops on the last entry and sends `helix-end`.
@@ -18930,6 +19668,10 @@ permitted is the browser's policy, and what follows a refused autoplay is a
 paused player showing its start control, which is the correct thing to be
 looking at. */
   autoplay?: (HelixVideo["autoplay"]) | undefined;
+  /** What the live region says when `c` turns captions off. */
+  "captions-hidden-label"?: (HelixVideo["captionsHiddenLabel"]) | undefined;
+  /** What the live region says when `c` turns captions off. */
+  captionsHiddenLabel?: (HelixVideo["captionsHiddenLabel"]) | undefined;
   /** The name of the captions control when the video has one track. The control
 turns that track on and off.
 
@@ -18950,6 +19692,10 @@ tracks. */
   /** The name of the row that turns captions off, when the video has several
 tracks. */
   captionsOffLabel?: (HelixVideo["captionsOffLabel"]) | undefined;
+  /** What the live region says when `c` turns captions on. */
+  "captions-shown-label"?: (HelixVideo["captionsShownLabel"]) | undefined;
+  /** What the live region says when `c` turns captions on. */
+  captionsShownLabel?: (HelixVideo["captionsShownLabel"]) | undefined;
   /** Whether the browser draws its native controls. When set, this element draws
 no controls of its own.
 
@@ -19126,6 +19872,10 @@ writes the current entry's name here. */
   "more-label"?: (HelixVideo["moreLabel"]) | undefined;
   /** What the button that opens `overflow-controls` is called. */
   moreLabel?: (HelixVideo["moreLabel"]) | undefined;
+  /** What the live region says when a key mutes the video. */
+  "muted-label"?: (HelixVideo["mutedLabel"]) | undefined;
+  /** What the live region says when a key mutes the video. */
+  mutedLabel?: (HelixVideo["mutedLabel"]) | undefined;
   /** The name of the mute control. The control shows as pressed while the video
 is muted. */
   "mute-label"?: (HelixVideo["muteLabel"]) | undefined;
@@ -19168,6 +19918,10 @@ So the consumer says where the fold is, which they can, having already
 named the controls in order. A name in both lists is drawn once, on the
 bar: two of the same control is worse than either placement. */
   overflowControls?: (HelixVideo["overflowControls"]) | undefined;
+  /** What the live region says when a key pauses the video. */
+  "paused-label"?: (HelixVideo["pausedLabel"]) | undefined;
+  /** What the live region says when a key pauses the video. */
+  pausedLabel?: (HelixVideo["pausedLabel"]) | undefined;
   /** The name of the play control while pressing it would pause the video. */
   "pause-label"?: (HelixVideo["pauseLabel"]) | undefined;
   /** The name of the play control while pressing it would pause the video. */
@@ -19190,6 +19944,10 @@ this is what a screen reader calls it on arriving. */
   /** The name of the player when `label` is not set. The player is a group, and
 this is what a screen reader calls it on arriving. */
   playerLabel?: (HelixVideo["playerLabel"]) | undefined;
+  /** What the live region says when a key plays the video. */
+  "playing-label"?: (HelixVideo["playingLabel"]) | undefined;
+  /** What the live region says when a key plays the video. */
+  playingLabel?: (HelixVideo["playingLabel"]) | undefined;
   /** The name of the play control while pressing it would start the video. */
   "play-label"?: (HelixVideo["playLabel"]) | undefined;
   /** The name of the play control while pressing it would start the video. */
@@ -19288,6 +20046,16 @@ negation. */
   /** How the scrubber reads out where the video is, with `{position}` and
 `{duration}` filled in. */
   timeLabel?: (HelixVideo["timeLabel"]) | undefined;
+  /** What the live region says when a key unmutes the video. */
+  "unmuted-label"?: (HelixVideo["unmutedLabel"]) | undefined;
+  /** What the live region says when a key unmutes the video. */
+  unmutedLabel?: (HelixVideo["unmutedLabel"]) | undefined;
+  /** What the live region says when a key changes the volume. `{percent}` is the
+volume from 0 to 100, written in the locale. */
+  "volume-changed-label"?: (HelixVideo["volumeChangedLabel"]) | undefined;
+  /** What the live region says when a key changes the volume. `{percent}` is the
+volume from 0 to 100, written in the locale. */
+  volumeChangedLabel?: (HelixVideo["volumeChangedLabel"]) | undefined;
   /** What the volume slider is called. */
   "volume-label"?: (HelixVideo["volumeLabel"]) | undefined;
   /** What the volume slider is called. */
@@ -19771,6 +20539,8 @@ export type CustomCssProperties = {
   "--canvas-selected-color"?: (string) | undefined;
   /** The background of the pan and zoom buttons. `Map` uses the same property. */
   "--viewport-control-background-color"?: (string) | undefined;
+  /** The board's zoom, which the board writes: 1 at the document's own size, 0.5 at half. The cards inherit it, so a card's stylesheet can draw less when the board is far out, such as a border that stays one pixel wide at `calc(1px / var(--canvas-zoom))`. */
+  "--canvas-zoom"?: (string) | undefined;
   /** How the regions pack when the card is stretched taller than its content. `start` by default, so the slack is at the bottom; `space-between` puts a footer on the floor. */
   "--card-align"?: (string) | undefined;
   /** Filter applied behind a `frosted` or `glass` card. Follows the theme's material policy; set it to override the strength on one card. */
@@ -20045,6 +20815,8 @@ export type CustomCssProperties = {
   "--data-table-drop-indicator-color"?: (string) | undefined;
   /** The thickness of the line where a moved row would land. */
   "--data-table-drop-indicator-size"?: (string) | undefined;
+  /** The color of the words in the line shown while `error-text` is set. */
+  "--data-table-error-color"?: (string) | undefined;
   /** The space between the grid and the footer below it. */
   "--data-table-footer-gap"?: (string) | undefined;
   /** The space between the pieces of the footer, such as a summary and the pagination. */
@@ -20597,8 +21369,16 @@ export type CustomCssProperties = {
   "--list-drag-preview-radius"?: (string) | undefined;
   /** The shadow that raises the copy of a row a pointer drags over the page. */
   "--list-drag-preview-shadow"?: (string) | undefined;
+  /** The color of the text in the row shown while the list has no rows. */
+  "--list-empty-color"?: (string) | undefined;
+  /** The space around the text in the row shown while the list has no rows. */
+  "--list-empty-padding"?: (string) | undefined;
   /** The space between rows. */
   "--list-gap"?: (string) | undefined;
+  /** The color of the text in the row drawn while `loading` is set. */
+  "--list-loading-color"?: (string) | undefined;
+  /** The space around the text in the row drawn while `loading` is set. */
+  "--list-loading-padding"?: (string) | undefined;
   /** The space that the markers of ordered and unordered lists sit in. */
   "--list-marker-gutter"?: (string) | undefined;
   /** The width of the rail's track. */
@@ -20911,7 +21691,7 @@ export type CustomCssProperties = {
   "--number-input-stepper-color"?: (string) | undefined;
   /** Icon color of a stepper button under the pointer. */
   "--number-input-stepper-color-hover"?: (string) | undefined;
-  /** Width and height of the stepper icons. */
+  /** Width and height of the stepper icons, drawn or slotted. */
   "--number-input-stepper-icon-size"?: (string) | undefined;
   /** Width of each stepper button. */
   "--number-input-stepper-size"?: (string) | undefined;
@@ -21477,6 +22257,8 @@ export type CustomCssProperties = {
   "--table-drag-preview-radius"?: (string) | undefined;
   /** The shadow that raises the copy of a row a pointer drags over the page. */
   "--table-drag-preview-shadow"?: (string) | undefined;
+  /** The color of the words in the line shown while `error-text` is set. */
+  "--table-error-color"?: (string) | undefined;
   /** The color of the words in the `heading` slot. */
   "--table-title-color"?: (string) | undefined;
   /** The space between the `heading` slot and the grid. */
@@ -21617,12 +22399,20 @@ export type CustomCssProperties = {
   "--time-picker-wheel-mask"?: (string) | undefined;
   /** The color of the heading. */
   "--timeline-group-heading-color"?: (string) | undefined;
+  /** Space between the rail and the time and what happened. */
+  "--timeline-column-gap"?: (string) | undefined;
+  /** The color of the mark on an entry with no `tone`. A `tone` colors the mark itself. */
+  "--timeline-marker-color"?: (string) | undefined;
   /** How round the mark is. Zero is a square, and half its size is a disc. */
   "--timeline-marker-radius"?: (string) | undefined;
   /** Edge length of the mark. */
   "--timeline-marker-size"?: (string) | undefined;
+  /** The color of the line. */
+  "--timeline-rail-color"?: (string) | undefined;
   /** Width of the line. */
   "--timeline-rail-size"?: (string) | undefined;
+  /** The color of the time. */
+  "--timeline-time-color"?: (string) | undefined;
   /** Space between one entry and the next. */
   "--timeline-gap"?: (string) | undefined;
   /** The panel's color. Follows `--helix-color-surface-overlay`. */
@@ -21893,6 +22683,8 @@ export type CustomCssProperties = {
   "--virtual-list-scrollbar-track-color"?: (string) | undefined;
   /** The fill behind a chosen row, in a list with `selection-mode`. */
   "--virtual-list-selected-background-color"?: (string) | undefined;
+  /** The color of the text in a chosen row, in a list with `selection-mode`. Inherited by default. */
+  "--virtual-list-selected-color"?: (string) | undefined;
 };
 
 // Vue SFC template type-checking (GlobalComponents) for non-Vue custom elements.
@@ -22541,13 +23333,13 @@ export interface WcToolkitVueGlobalComponents {
     HelixRatingVueProps,
     HelixRatingVueEvents
   >;
-  /** A sandboxed '<iframe>' that loads 'src', a document you provide. That document imports what the examples need, listens for a render message, and writes the markup into itself.  **Examples render in a frame**, so an example's styles and scripts do not affect the page around the sandbox, and 'position: fixed' stays inside the pane. The frame starts empty, with its own stylesheets and its own custom element registry, so 'src' must load the styles and components the examples use.  **The source is untrusted, and the frame keeps it isolated.** The frame uses 'sandbox="allow-scripts"' and never 'allow-same-origin'. Together, the two let a document on the same origin remove its own sandbox, which is the same as having none.  **A preview says where it is.** It is ':state(loading)' from the moment it has a 'src' until that document can take the example, and again through 'reload()'. It is ':state(failed)' once the example throws an error it does not catch, until the next source is sent, which a frame on 'servePreview' reports. A page draws its own spinner or message from either, such as a sibling shown by 'helix-sandbox-preview:state(failed) + .message'. */
+  /** A sandboxed '<iframe>' that loads 'src', a document you provide. That document imports what the examples need, listens for a render message, and writes the markup into itself.  **Without 'src', the frame loads a built-in document**, so a sandbox renders with nothing to host. It runs HTML, CSS, and scripts, and reports the console, uncaught errors, its height, and presses as a frame on 'servePreview' does. It defines no element, so an example that uses Helix components needs a 'src' that imports them.  **Examples render in a frame**, so an example's styles and scripts do not affect the page around the sandbox, and 'position: fixed' stays inside the pane. The frame starts empty, with its own stylesheets and its own custom element registry, so 'src' must load the styles and components the examples use.  **The source is untrusted, and the frame keeps it isolated.** The frame uses 'sandbox="allow-scripts"' and never 'allow-same-origin'. Together, the two let a document on the same origin remove its own sandbox, which is the same as having none.  **A preview says where it is.** It is ':state(loading)' from the moment it has a 'src' until that document can take the example, and again through 'reload()'. It is ':state(failed)' once the example throws an error it does not catch, until the next source is sent, which a frame on 'servePreview' reports. A page draws its own spinner or message from either, such as a sibling shown by 'helix-sandbox-preview:state(failed) + .message'. */
   "helix-sandbox-preview": DefineCustomElement<
     HelixSandboxPreview,
     HelixSandboxPreviewVueProps,
     HelixSandboxPreviewVueEvents
   >;
-  /** A source pane dispatches 'helix-before-edit', which bubbles, and the sandbox passes the value to the preview slotted into it. The source pane and the preview do not reference each other, so you can replace either one or use it alone.  The event carries the pane's 'name', so one sandbox can hold several panes. 'html' sets the preview's markup and 'css' sets its stylesheet. The sandbox ignores a pane with any other name, so that pane can show content without changing the preview.  **The dividers are two nested 'helix-splitter' elements**, which handle the pointer, the keyboard, and the corner. The inner splitter holds the panes and the outer one holds the panel, so the panel spans the full width.  On a focused divider, the arrow keys move it, and 'Home' and 'End' move it to its ends. 'Enter' on the panes divider shuts the lead pane, and pressed again it opens the pane where it was. 'Enter' on the panel divider shuts the panel to 'panel-collapsed-size', and pressed again it opens the panel to its last height. */
+  /** A source pane dispatches 'helix-before-edit', which bubbles, and the sandbox passes the value to the preview slotted into it. The source pane and the preview do not reference each other, so you can replace either one or use it alone.  The event carries the pane's 'name', so one sandbox can hold several panes. 'html' sets the preview's markup, 'css' sets its stylesheet, and 'js' sets a script that runs as a module after the markup. The sandbox ignores a pane with any other name, so that pane can show content without changing the preview.  **The dividers are two nested 'helix-splitter' elements**, which handle the pointer, the keyboard, and the corner. The inner splitter holds the panes and the outer one holds the panel, so the panel spans the full width.  On a focused divider, the arrow keys move it, and 'Home' and 'End' move it to its ends. 'Enter' on the panes divider shuts the lead pane, and pressed again it opens the pane where it was. 'Enter' on the panel divider shuts the panel to 'panel-collapsed-size', and pressed again it opens the panel to its last height. */
   "helix-sandbox": DefineCustomElement<
     HelixSandbox,
     HelixSandboxVueProps,
@@ -22763,7 +23555,7 @@ export interface WcToolkitVueGlobalComponents {
     HelixTimelineItemVueProps,
     HelixTimelineItemVueEvents
   >;
-  /** Sets the direction time runs in and the spacing between events. Each entry draws its own mark and line.  'layout' and 'orientation' move where the entries are drawn, and never the order they are read in, which is the order you write them in:  - Unset, the line runs down the start edge, with each time over what   happened. - 'layout="opposite"' runs the line down the middle, with each time on the   start side and what happened on the end side. - 'layout="alternate"' runs the line down the middle, with the first entry on   the end side, the second on the start side, and so on. - 'orientation="horizontal"' runs the line across the top, with the entries   side by side in the order they are read, and the time over what happened   under each mark. Use it for a few entries, since they share the width. */
+  /** Sets the direction time runs in and the spacing between events. Each entry draws its own mark and line.  'layout' and 'orientation' move where the entries are drawn, and never the order they are read in, which is the order you write them in:  - Unset, the line runs down the start edge, with each time over what   happened. - 'layout="opposite"' runs the line down the middle, with each time on the   start side and what happened on the end side. - 'layout="alternate"' runs the line down the middle, with the first entry on   the end side, the second on the start side, and so on. - 'orientation="horizontal"' runs the line across the top, with the entries   side by side in the order they are read, and the time over what happened   under each mark. Use it for a few entries, since they share the width.  An entry's custom properties, such as '--timeline-rail-color' and '--timeline-marker-size', inherit, so setting them on the timeline changes every entry in it. */
   "helix-timeline": DefineCustomElement<
     HelixTimeline,
     HelixTimelineVueProps,