@fusion.dev/helix-headless 0.104.1 → 0.106.0

package/dist/notifications/group/notification-group.d.ts

@@ -7,24 +7,19 @@ declare const HelixHeadlessNotificationGroup_base: (new (...args: any[]) => impo
  * them.
  *
  * @description
- * **What groups with what is the consumer's, and this never guesses.** A feed
- * can be cut by day, by the thing being talked about, by the person doing the
- * talking, or by nothing at all, and which of those is right is a question about
- * the product. So a group is written by hand around the rows that belong
- * together and told what to call itself, exactly as `FilterField` is told what
- * its operators are.
+ * You decide what goes in each group. A feed can be grouped by day, by subject,
+ * by person, or not at all, so you write a group around the rows that belong
+ * together and give it a `label`, the same way you give `FilterField` its
+ * operators.
  *
- * **Collapsed shows the first row and assigns the rest nowhere.** Not `hidden`,
- * not `inert`, not a stylesheet: the slot is assigned imperatively, so a
- * collapsed group's later rows are absent from the layout and from the
- * accessibility tree with no CSS at all, which is what the headless tier claims
- * for itself. `Notifications` already assigns its list this way and this borrows
- * the mechanism.
+ * A collapsed group shows its first row and assigns the rest to no slot. The
+ * slot is assigned imperatively, so the later rows are absent from the layout
+ * and from the accessibility tree without any CSS. `Notifications` assigns its
+ * list the same way.
  *
- * The count is separate from how many rows are written, because it usually is: a
- * group saying five with one row under it and a link to the rest is the common
- * shape, and computing the number from the children would make that unsayable.
- * Left off, it is the number of rows.
+ * `count` is set separately from the rows, so a group can show a count of five
+ * with one row under it and a link to the rest. When `count` is not set, it is
+ * the number of rows.
  *
  * @since 0.24.0
  * @status stable
@@ -34,19 +29,19 @@ declare const HelixHeadlessNotificationGroup_base: (new (...args: any[]) => impo
  *
  * @slot - The notifications in this group.
  * @slot actions - Beside the count, for a link to the rest of them.
- * @slot label - Replaces the group's name, for a heading that needs a mark in it.
+ * @slot label - Replaces the group's name, for a heading that includes an icon.
  *
- * @event {HelixBeforeCloseEvent} helix-before-close - Fired before the group folds, and cancelable.
- * @event {HelixBeforeOpenEvent} helix-before-open - Fired before the group unfolds. Cancelable: refusing it takes the decision and nothing moves.
+ * @event {HelixBeforeCloseEvent} helix-before-close - Fired before the group collapses. Cancelable.
+ * @event {HelixBeforeOpenEvent} helix-before-open - Fired before the group expands. Cancelable: cancel it to keep the group collapsed.
  *
  * @csspart actions - The trailing region of the header.
- * @csspart count - How many are in the group.
- * @csspart header - The label, the count and the action together.
+ * @csspart count - The number of notifications in the group.
+ * @csspart header - The label, the count, and the actions together.
  * @csspart items - The region holding the notifications.
- * @csspart label - What the group is called.
- * @csspart trigger - The control that collapses and expands, where collapsible.
+ * @csspart label - The group's name.
+ * @csspart trigger - The control that collapses and expands the group, when `collapsible` is set.
  *
- * @cssstate open - While the group shows every notification in it rather than the first.
+ * @cssstate open - The group shows all of its notifications.
  */
 export declare class HelixHeadlessNotificationGroup extends HelixHeadlessNotificationGroup_base {
     /**
@@ -73,7 +68,7 @@ export declare class HelixHeadlessNotificationGroup extends HelixHeadlessNotific
      */
     collapsible: boolean;
     /**
-     * How many notifications this group stands for.
+     * The number of notifications the group represents.
      *
      * **Not the number of rows, and that is the point.** A group saying five with
      * one row under it and a link to the rest is the ordinary shape of a feed that
@@ -82,14 +77,15 @@ export declare class HelixHeadlessNotificationGroup extends HelixHeadlessNotific
      */
     count?: number;
     /**
-     * What the group is called: a day, a subject, a person.
+     * The group's name, such as a day, a subject, or a person.
      *
      * The slot's fallback rather than its replacement, so a consumer who wants a
      * mark beside the name slots `label` and this goes unused.
      */
     label: string;
     /**
-     * What this is, for the feed above it to recognize without importing it.
+     * Marks this element as a notification group, so the feed can recognize it
+     * without importing its class.
      *
      * The same seam `Notification` uses: a root reads a child's markers rather
      * than its constructor, so the two tiers never have to agree about which class
@@ -98,7 +94,10 @@ export declare class HelixHeadlessNotificationGroup extends HelixHeadlessNotific
     readonly isNotificationGroup = true;
     /** The notifications written into this group, in the order they were given. */
     get items(): HelixHeadlessNotification[];
-    /** How many the group says it stands for, which is the count or the rows. */
+    /**
+     * The number of notifications the group represents: `count` when it is set,
+     * or the number of rows.
+     */
     get total(): number;
     /**
      * The same number where anything can know it, and nothing where nothing can.

package/dist/notifications/notification/notification.d.ts

@@ -3,32 +3,24 @@ import { nothing, type PropertyValues, type TemplateResult } from 'lit';
 import '../../format-date/index.js';
 declare const HelixHeadlessNotification_base: (new (...args: any[]) => import("@fusion.dev/helix-core").DismissibleElement) & typeof HelixElement;
 /**
- * @summary One thing that happened, which a reader may not have seen yet.
+ * @summary A single notification about something that happened, marked read or unread.
  *
  * @description
- * A notification is a toast that did not go away. `Toast` is deliberately the
- * opposite of this: a live region whose items carry a `duration` and whose root
- * never creates or destroys anything. What makes this its own family is the
- * state each item carries rather than the arrangement it sits in: read and
- * unread, a timestamp that has to stay correct, and an action a reader can take
- * later.
+ * A notification is a toast that stays. `Toast` is a live region whose items
+ * have a `duration`. A notification carries state instead: read or unread, a
+ * timestamp that stays correct, and an action you can take later.
  *
- * **The row is a label, a caption under it, and one trailing column that holds
- * either the time or the controls.** A feed is scanned rather than read, so the
- * thing that happened gets the first line on its own and everything qualifying
- * it goes under. The time and the controls occupy the same place because a
- * reader wants exactly one of them at a time: the time while they are scanning,
- * and what they can do about it once they have stopped on a row.
+ * The row has a label, a caption under it, and one trailing column. The label
+ * gets the first line on its own, so a feed is quick to scan. The trailing
+ * column shows either the time or the controls: the time while you scan, and
+ * the controls once you stop on a row.
  *
- * **The timestamp is `FormatDate`**, which is where the reading, the `<time
- * datetime>` and the shared timer now live. It was implemented here, and a
- * component that formats a date is not a fact about notifications: Chat wanted
- * the same thing and had its own copy of half of it.
+ * `FormatDate` renders the timestamp, including the readable text, the
+ * `<time datetime>` element, and the shared timer that keeps it current.
  *
- * **Read state is reported, not invented.** Marking something read is usually a
- * round trip, and a component that flips its own state and then hears the
- * request failed has told the reader something untrue. `helix-read` is
- * cancelable, and a `read` set by the consumer makes this element defer entirely.
+ * Read state is reported to you. Marking a notification read is usually a round
+ * trip to a server, so `helix-read` is cancelable, and when you set `read`
+ * yourself the element leaves it to you.
  *
  * @since 0.1.0
  * @status stable
@@ -36,35 +28,35 @@ declare const HelixHeadlessNotification_base: (new (...args: any[]) => import("@
  * @aliases Notification item, Inbox item
  * @documentation https://fusion.dev/helix/components/notifications
  *
- * @slot - What happened, in the consumer's own markup.
- * @slot actions - What a reader can do about it, under the words it is about. Drawn always
- * rather than on hover, because an action is the point of the row and not chrome around it.
- * @slot description - A second line qualifying it, quieter than the first. A bare
- * slot rather than a box, so an item without one pays nothing for it; style it
- * through `::slotted()`.
- * @slot detail - A block belonging to the row rather than a line about it: a quoted
- * comment, a status moving from one value to another, a preview. Unlike `description` nothing
- * here sets a size or an ink, because whatever fills it usually brings its own.
- * @slot dismiss - Replaces the glyph inside the dismiss control, which is drawn
- * only where the row is `dismissible`.
+ * @slot - What happened, in your own markup.
+ * @slot actions - Actions the user can take, shown under the text. They are always visible,
+ * because acting on the notification is the purpose of the row.
+ * @slot description - A second, quieter line with more detail. It is a bare slot
+ * with no wrapping box, so an item without a description costs nothing. Style it
+ * with `::slotted()`.
+ * @slot detail - A block of content in the row, such as a quoted comment, a status
+ * change from one value to another, or a preview. It sets no text size or color, because
+ * its content usually brings its own.
+ * @slot dismiss - Replaces the icon inside the dismiss control, which is drawn
+ * only when the row is `dismissible`.
  * @slot media - An avatar or icon identifying who or what it came from.
  *
- * @event {HelixDismissEvent} helix-dismiss - Fired when a reader asks to remove it, and cancelable.
- * @event {HelixReadEvent} helix-read - Fired when the item is marked read or unread, and cancelable.
+ * @event {HelixDismissEvent} helix-dismiss - Fired when the user dismisses the notification. Cancelable.
+ * @event {HelixReadEvent} helix-read - Fired when the notification is marked read or unread. Cancelable.
  *
  * @csspart actions - The trailing slot's box.
  * @csspart body - The label and the caption together.
- * @csspart controls - The actions and the dismiss, which replace the time.
- * @csspart dismiss - The control that removes it.
- * @csspart dismiss-mark - The glyph on that control, where none is slotted.
+ * @csspart controls - The actions and the dismiss control, shown in place of the time.
+ * @csspart dismiss - The control that dismisses the notification.
+ * @csspart dismiss-mark - The icon on the dismiss control, when no icon is slotted.
  * @csspart item - The whole notification.
  * @csspart label - What happened, on the first line.
  * @csspart media - The leading slot's box.
- * @csspart time - When it happened, read the way a person reads one.
+ * @csspart time - When it happened, formatted for people to read.
  * @csspart trailing - The column holding the time and the controls.
  *
  * @cssstate actions - While the actions slot holds something, so the words above make room for it.
- * @cssstate controls - While it can be dismissed, so the time makes way for the control under a pointer.
+ * @cssstate controls - The item can be dismissed, so the time gives way to the dismiss control under a pointer.
  * @cssstate read - While it has been read.
  */
 export declare class HelixHeadlessNotification extends HelixHeadlessNotification_base {
@@ -78,7 +70,7 @@ export declare class HelixHeadlessNotification extends HelixHeadlessNotification
      */
     at: string;
     /**
-     * State to open with, where nothing declared one.
+     * Whether the notification starts as read, used until `read` is set.
      */
     defaultRead: boolean;
     /**
@@ -88,7 +80,7 @@ export declare class HelixHeadlessNotification extends HelixHeadlessNotification
      */
     locale: string;
     /**
-     * Whether the reader has seen it.
+     * Whether the notification has been read.
      *
      * Set it and this element defers: a reader's click fires `helix-read` and
      * changes nothing until a new value arrives. `default-read` seeds a state
@@ -112,7 +104,8 @@ export declare class HelixHeadlessNotification extends HelixHeadlessNotification
     readonly isNotification = true;
     private readState;
     /**
-     * Asks to be marked read, and reports whether the request stood.
+     * Requests that the notification be marked read, and returns whether the
+     * change was applied.
      *
      * Public because a consumer's own control is as likely to ask as this
      * element's own markup is, and because a list marking everything read has to

package/dist/notifications/root/notifications-root.d.ts

@@ -4,25 +4,22 @@ import type { HelixHeadlessNotificationGroup } from '../group/notification-group
 import type { HelixHeadlessNotification } from '../notification/notification.js';
 declare const HelixHeadlessNotifications_base: (new (...args: any[]) => import("@fusion.dev/helix-core").CollectionElement) & typeof HelixElement;
 /**
- * @summary A feed a reader comes back to, made of notifications they may not have seen.
+ * @summary A feed of notifications, each marked read or unread.
  *
  * @description
- * **Slotted children rather than a data property.** A notification is a small
- * piece of somebody's own markup, with an avatar and a link and a button in it,
- * and there are tens of them rather than thousands, so writing them out lets an
- * item hold anything.
+ * Notifications are slotted children. Each one is your own markup, with an
+ * avatar, a link, or a button in it. Feeds usually hold tens of items, so
+ * writing them out lets an item hold anything.
  *
- * **This does not virtualize, and it cannot.** Windowing needs the list to own
- * the data, and here the consumer owns it: N notifications is N elements by
- * construction. A feed that really does hold thousands wants a data table with a
- * custom cell, and this component will not grow into one.
+ * The list does not virtualize. Windowing needs the list to own the data, and
+ * here you own it, so N notifications are N elements. For a feed of thousands,
+ * use a data table with a custom cell.
  *
- * **Read state is reported, never invented.** Marking read is usually a round
- * trip: this element asks its items and each item asks the consumer, so a
- * refused `helix-read` leaves everything alone and a consumer who owns `read`
- * sees nothing change until they say so. `unread` is derived from the items and
- * written to an attribute, so a stylesheet and a badge can both read it without
- * either of them counting.
+ * Read state is reported to you. Marking read goes from the root to the item
+ * and from the item to you, so a canceled `helix-read` changes nothing, and if
+ * you own `read`, nothing changes until you set it. `unread` is derived from
+ * the items and written to an attribute, so a stylesheet and a badge can both
+ * use it without counting.
  *
  * @since 0.1.0
  * @status stable
@@ -34,15 +31,15 @@ declare const HelixHeadlessNotifications_base: (new (...args: any[]) => import("
  * @slot footer - Below the list, for a link to everything.
  * @slot header - Above the list, for a title and the mark-all control.
  *
- * @event {HelixDismissEvent} helix-dismiss - A row asking to be removed, dispatched by the row and heard here because the feed is what a consumer holds. Cancelable: refusing it takes the decision and the row stays.
- * @event {HelixReadEvent} helix-read - Fired by an item, and by this element when everything is marked read. Cancelable.
+ * @event {HelixDismissEvent} helix-dismiss - Fired when the user dismisses a row. The row dispatches it, and you can listen for it on the feed. Cancelable: cancel it to keep the row.
+ * @event {HelixReadEvent} helix-read - Fired by an item when it is marked read or unread, and by the feed when everything is marked read. Cancelable.
  *
  * @csspart empty - Shown when there is nothing in the feed.
  * @csspart footer - The region below the list.
  * @csspart header - The region above the list.
  * @csspart list - The list itself.
- * @csspart live - The empty and loading lines again, in a region a screen reader hears when they change. Visually hidden in the styled tier.
- * @csspart loading - Shown while the feed is still on its way.
+ * @csspart live - A copy of the empty and loading messages, in a live region that screen readers announce when they change. Visually hidden in the styled tier.
+ * @csspart loading - Shown while the feed is loading.
  * @csspart mark-all - The control that marks everything read.
  *
  * @cssstate media - While a notification in the list holds something in its media slot, so every row keeps that column.
@@ -59,7 +56,7 @@ export declare class HelixHeadlessNotifications extends HelixHeadlessNotificatio
      */
     static shadowRootOptions: ShadowRootInit;
     /**
-     * Accessible name for the feed.
+     * The feed's name, read by screen readers.
      */
     label: string;
     /**
@@ -67,7 +64,7 @@ export declare class HelixHeadlessNotifications extends HelixHeadlessNotificatio
      */
     markAll: boolean;
     /**
-     * Label for that control.
+     * Label for the mark-all control.
      */
     markAllLabel: string;
     /**
@@ -102,7 +99,8 @@ export declare class HelixHeadlessNotifications extends HelixHeadlessNotificatio
      */
     get items(): HelixHeadlessNotification[];
     /**
-     * What the list slot is given: the rows and the groups, as written.
+     * The content assigned to the list slot: the rows and the groups, in the
+     * order they are written.
      *
      * Not `items`, which reaches through a group to the rows inside it. Assigning
      * those would lift them out of the group that is arranging them and hand the
@@ -118,7 +116,7 @@ export declare class HelixHeadlessNotifications extends HelixHeadlessNotificatio
      */
     get groups(): HelixHeadlessNotificationGroup[];
     /**
-     * Folds every group that can fold, and reports how many actually moved.
+     * Collapses every collapsible group, and returns how many changed.
      *
      * **A command, not a second place the state lives.** A group owns whether it
      * is folded; this asks all of them at once. The alternative, a property on the
@@ -141,7 +139,7 @@ export declare class HelixHeadlessNotifications extends HelixHeadlessNotificatio
      */
     foldEveryGroup(folded?: boolean): number;
     /**
-     * Marks every unread item read, and reports how many actually moved.
+     * Marks every unread item read, and returns how many changed.
      *
      * **Through each item's own request rather than by writing its property**,
      * which is what makes one refusal refuse one item: a consumer who owns some

package/dist/number-input/root/number-input-root.d.ts

@@ -2,34 +2,27 @@ import { AriaForwardController, HelixFormElement } from '@fusion.dev/helix-core'
 import { nothing, type PropertyValues, type TemplateResult } from 'lit';
 declare const HelixHeadlessNumberInput_base: (new (...args: any[]) => import("@fusion.dev/helix-core").MixinControllerValueInterface) & (new (...args: any[]) => import("@fusion.dev/helix-core").MixinFieldInterface) & typeof HelixFormElement;
 /**
- * @summary A number a reader types or steps to.
+ * @summary A field for a number, typed or changed with step buttons.
  *
  * @description
- * **A family rather than `Input`'s `type="number"`.** It renders two buttons,
- * binds four keys `Input` does not, and owns clamping and stepping, so it is an
- * alternative and not a variant.
+ * A separate family from `Input`'s `type="number"`. It renders two buttons,
+ * binds four keys `Input` does not, and handles clamping and stepping.
  *
- * **The field is `type="text"` with `inputmode="decimal"`, and that is a
- * measurement.** Asked of a real browser, `type=number` fails three ways this
- * control cannot live with:
+ * The field is `type="text"` with `inputmode="decimal"`. Tested in a real
+ * browser, `type="number"` fails in three ways:
+ * - Typing `12e` gives a `.value` of `""`, so the element cannot see what you
+ *   typed. A `type="text"` field keeps `"12e"`.
+ * - The mouse wheel over a focused field changes the value, for example from 5
+ *   to 4, when you only meant to scroll the page.
+ * - `selectionStart` is `null`, so the caret cannot be managed.
  *
- * ```
- * typed "12e" into type=number  → .value === ""
- * focused, wheeled over it      → 5 became 4
- * selectionStart on type=number → null
- * same keystrokes into type=text → .value === "12e"
- * ```
+ * `inputmode="decimal"` keeps the numeric keypad on phones.
  *
- * The first is fatal alone: the element cannot see what the reader typed. The
- * second changes a value because a page scrolled past. The third means the
- * caret cannot be managed at all. `inputmode` keeps the phone keypad, which is
- * the one thing `type=number` was giving.
- *
- * Validity is still the platform's, through `min`, `max` and `step` mirrored
+ * Validity still comes from the platform: `min`, `max`, and `step` are mirrored
  * onto the host's own `setValidity`.
  *
- * **Stepping is separate from typing**, so a reader mid-way through a number is
- * not corrected under their hands.
+ * Stepping is separate from typing, so a number is not corrected while you type
+ * it.
  *
  * @since 0.1.0
  * @status stable
@@ -37,31 +30,31 @@ declare const HelixHeadlessNumberInput_base: (new (...args: any[]) => import("@f
  * @aliases NumberField, Stepper, InputNumber
  * @documentation https://fusion.dev/helix/components/number-input
  *
- * @slot end - After it.
- * @slot start - Before the number, for a unit or an icon.
+ * @slot end - Content after the number, such as a unit.
+ * @slot start - Content before the number, such as a unit or an icon.
  *
- * @event {Event} change - Relayed from the field once the reader has finished.
- * @event {HelixBeforeChangeEvent} helix-before-change - Fired as the value changes, and cancelable.
- * @event {Event} input - Announced once the value has moved.
+ * @event {Event} change - The user finished changing the value. Relayed from the native field.
+ * @event {HelixBeforeChangeEvent} helix-before-change - The value is about to change. Cancelable: cancel it to keep the current value.
+ * @event {Event} input - The value changed.
  *
- * @csspart control - The field itself.
- * @csspart decrement - The control that steps down.
- * @csspart decrement-mark - The glyph on the step down control.
- * @csspart feedback - What is wrong with it.
- * @csspart field - The box holding everything.
- * @csspart hint - Help under the field, while nothing is wrong.
- * @csspart increment - The control that steps up.
- * @csspart increment-mark - The glyph on the step up control.
- * @csspart label - The name over the field, which is also the scrub grip.
+ * @csspart control - The input that holds the number.
+ * @csspart decrement - The button that steps the value down.
+ * @csspart decrement-mark - The icon on the step down button.
+ * @csspart feedback - The message that says what is wrong.
+ * @csspart field - The box that holds the whole control.
+ * @csspart hint - Help text under the field, shown while there is no feedback.
+ * @csspart increment - The button that steps the value up.
+ * @csspart increment-mark - The icon on the step up button.
+ * @csspart label - The label above the field. It is also the grip you drag when `scrub` is set.
  *
- * @cssstate invalid - While there is feedback to show: the platform's verdict, or the consumer's `feedback`.
+ * @cssstate invalid - The control has an error to show, from the browser's validation or from your `feedback`.
  */
 export declare class HelixHeadlessNumberInput extends HelixHeadlessNumberInput_base {
     protected readonly aria: AriaForwardController;
     /** Typed or dragged, so every edit is announced. See `announcesInput`. */
     protected readonly announcesInput = true;
     /**
-     * What the browser may autofill here, as one of the platform's own tokens.
+     * What the browser may autofill, as an HTML `autocomplete` token.
      *
      * Empty leaves the attribute off, which is the browser's default and is what
      * lets autofill work at all. Hardcoding `off` here is what stops a reader
@@ -70,7 +63,8 @@ export declare class HelixHeadlessNumberInput extends HelixHeadlessNumberInput_b
      */
     autocomplete: string;
     /**
-     * What a reader is told when the field holds something that is not a number.
+     * The message the browser shows when the field holds something that is not a
+     * number.
      *
      * **Every sentence a control raises in the browser's bubble is a property**,
      * named for the validity flag it reports, so a form in another language
@@ -79,15 +73,15 @@ export declare class HelixHeadlessNumberInput extends HelixHeadlessNumberInput_b
      */
     badInputMessage?: string;
     /**
-     * Accessible name for the control that steps down.
+     * The name of the step down button, read by screen readers.
      */
     decrementLabel: string;
     /**
-     * Accessible name for the control that steps up.
+     * The name of the step up button, read by screen readers.
      */
     incrementLabel: string;
     /**
-     * How far `PageUp` and `PageDown` move.
+     * How many steps `PageUp` and `PageDown` move.
      *
      * Ten steps, which is the convention every spinner on the platform follows,
      * and a property because ten of a step of `0.01` is a hundredth and rarely
@@ -95,13 +89,13 @@ export declare class HelixHeadlessNumberInput extends HelixHeadlessNumberInput_b
      */
     largeStep?: number;
     /**
-     * Largest value the reader may reach.
+     * The largest value allowed.
      *
      * Absent has no ceiling.
      */
     max?: number;
     /**
-     * Smallest value the reader may reach.
+     * The smallest value allowed.
      *
      * Absent has no floor.
      */
@@ -113,19 +107,21 @@ export declare class HelixHeadlessNumberInput extends HelixHeadlessNumberInput_b
      */
     placeholder: string;
     /**
-     * What a reader is told when the number is above `max`, with `{max}` filled in.
+     * The message the browser shows when the number is above `max`, with `{max}`
+     * filled in.
      */
     rangeOverflowMessage?: string;
     /**
-     * What a reader is told when the number is below `min`, with `{min}` filled in.
+     * The message the browser shows when the number is below `min`, with `{min}`
+     * filled in.
      */
     rangeUnderflowMessage?: string;
     /**
-     * Whether the field refuses input while still submitting its value.
+     * Prevents editing. The value is still submitted with the form.
      */
     readOnly: boolean;
     /**
-     * Whether a grip is shown that changes the value when it is dragged.
+     * 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,
      * because it changes what a press on the label does and a reader who drags
@@ -173,10 +169,10 @@ export declare class HelixHeadlessNumberInput extends HelixHeadlessNumberInput_b
      * refused step, or one pinned at a bound, finished nothing.
      */
     private land;
-    /** One step up, or `PageUp`'s larger one. */
+    /** Steps the value up, by `largeStep` steps when `large` is set. */
     stepUp(large?: boolean): void;
     /**
-     * Steps the value down, by `largeStep` when `large` is set.
+     * Steps the value down, by `largeStep` steps when `large` is set.
      *
      * The same path a press of the down arrow takes, so a consumer driving this
      * from their own control gets the clamping and the announcement rather than
@@ -278,7 +274,7 @@ export declare class HelixHeadlessNumberInput extends HelixHeadlessNumberInput_b
      * message is what a native spinner would have said.
      */
     private sync;
-    /** Puts the caret in the field, the way a label pointing at one would. */
+    /** Puts the cursor in the field. */
     focus(options?: FocusOptions): void;
     /** Selects the number, so typing replaces it. */
     select(): void;