haze-ui 1.28.0 → 1.30.0

package/dist/types/components/LocaleProvider/es-es.d.ts

@@ -0,0 +1,15 @@
+import type { HazeStrings } from './locale';
+/**
+ * Spanish (es-ES) copy for every user-visible literal in the library.
+ * Not auto-selected by `LocaleProvider`'s `locale` tag (only Chinese
+ * and Japanese variants resolve automatically) — mount it explicitly:
+ *
+ *   <LocaleProvider locale="es-ES" strings={esES}>
+ *
+ * Keys mirror `defaultStrings` 1:1 — the `HazeStrings` annotation
+ * fails the build when either pack drifts out of sync. `{name}`
+ * placeholders must survive translation verbatim; they are expanded
+ * by `formatString` at runtime.
+ */
+declare const esES: HazeStrings;
+export { esES };

package/dist/types/components/LocaleProvider/fr-fr.d.ts

@@ -0,0 +1,15 @@
+import type { HazeStrings } from './locale';
+/**
+ * French (fr-FR) copy for every user-visible literal in the library.
+ * Not auto-selected by `LocaleProvider`'s `locale` tag (only Chinese
+ * and Japanese variants resolve automatically) — mount it explicitly:
+ *
+ *   <LocaleProvider locale="fr-FR" strings={frFR}>
+ *
+ * Keys mirror `defaultStrings` 1:1 — the `HazeStrings` annotation
+ * fails the build when either pack drifts out of sync. `{name}`
+ * placeholders must survive translation verbatim; they are expanded
+ * by `formatString` at runtime.
+ */
+declare const frFR: HazeStrings;
+export { frFR };

package/dist/types/components/LocaleProvider/index.d.ts

@@ -6,5 +6,13 @@ export { defaultStrings, enUS } from './locale';
 export type { HazeStrings } from './locale';
 export { zhCN } from './zh-cn';
 export { jaJP } from './ja-jp';
+export { deDE } from './de-de';
+export { frFR } from './fr-fr';
+export { esES } from './es-es';
+export { itIT } from './it-it';
+export { ptBR } from './pt-br';
+export { ruRU } from './ru-ru';
+export { koKR } from './ko-kr';
+export { arSA } from './ar-sa';
 export { createStrings } from './strings';
 export type { DeepPartial } from './strings';

package/dist/types/components/LocaleProvider/it-it.d.ts

@@ -0,0 +1,15 @@
+import type { HazeStrings } from './locale';
+/**
+ * Italian (it-IT) copy for every user-visible literal in the library.
+ * Not auto-selected by `LocaleProvider`'s `locale` tag (only Chinese
+ * and Japanese variants resolve automatically) — mount it explicitly:
+ *
+ *   <LocaleProvider locale="it-IT" strings={itIT}>
+ *
+ * Keys mirror `defaultStrings` 1:1 — the `HazeStrings` annotation
+ * fails the build when either pack drifts out of sync. `{name}`
+ * placeholders must survive translation verbatim; they are expanded
+ * by `formatString` at runtime.
+ */
+declare const itIT: HazeStrings;
+export { itIT };

package/dist/types/components/LocaleProvider/ko-kr.d.ts

@@ -0,0 +1,15 @@
+import type { HazeStrings } from './locale';
+/**
+ * Korean (ko-KR) copy for every user-visible literal in the library.
+ * Not auto-selected by `LocaleProvider`'s `locale` tag (only Chinese
+ * and Japanese variants resolve automatically) — mount it explicitly:
+ *
+ *   <LocaleProvider locale="ko-KR" strings={koKR}>
+ *
+ * Keys mirror `defaultStrings` 1:1 — the `HazeStrings` annotation
+ * fails the build when either pack drifts out of sync. `{name}`
+ * placeholders must survive translation verbatim; they are expanded
+ * by `formatString` at runtime.
+ */
+declare const koKR: HazeStrings;
+export { koKR };

package/dist/types/components/LocaleProvider/locale.d.ts

@@ -95,6 +95,11 @@ declare const defaultStrings: {
     colorPicker: {
         pickColor: string;
         hexColor: string;
+        saturationBrightness: string;
+        hue: string;
+        alpha: string;
+        presetsLabel: string;
+        recentColors: string;
     };
     confirmDialog: {
         confirm: string;
@@ -123,6 +128,10 @@ declare const defaultStrings: {
     empty: {
         description: string;
     };
+    ellipsis: {
+        expand: string;
+        collapse: string;
+    };
     fileInput: {
         label: string;
     };
@@ -171,6 +180,13 @@ declare const defaultStrings: {
     pagination: {
         previous: string;
         next: string;
+        sizeLabel: string;
+        sizeOption: string;
+        jumperLabel: string;
+        jumperPrefix: string;
+        jumperSuffix: string;
+        ellipsisBackward: string;
+        ellipsisForward: string;
     };
     passwordInput: {
         label: string;
@@ -213,6 +229,9 @@ declare const defaultStrings: {
         expand: string;
         collapse: string;
     };
+    streamingText: {
+        generating: string;
+    };
     tag: {
         remove: string;
     };
@@ -228,6 +247,15 @@ declare const defaultStrings: {
     thinkingIndicator: {
         text: string;
     };
+    timePicker: {
+        now: string;
+        hour: string;
+        minute: string;
+        second: string;
+        period: string;
+        am: string;
+        pm: string;
+    };
     toast: {
         loading: string;
         success: string;
@@ -258,6 +286,13 @@ declare const defaultStrings: {
         retry: string;
         noMatch: string;
     };
+    treeSelect: {
+        placeholder: string;
+        searchLabel: string;
+        searchPlaceholder: string;
+        clear: string;
+        moreTags: string;
+    };
     upload: {
         hint: string;
         clickHint: string;

package/dist/types/components/LocaleProvider/pt-br.d.ts

@@ -0,0 +1,16 @@
+import type { HazeStrings } from './locale';
+/**
+ * Brazilian Portuguese (pt-BR) copy for every user-visible literal in
+ * the library. Not auto-selected by `LocaleProvider`'s `locale` tag
+ * (only Chinese and Japanese variants resolve automatically) — mount
+ * it explicitly:
+ *
+ *   <LocaleProvider locale="pt-BR" strings={ptBR}>
+ *
+ * Keys mirror `defaultStrings` 1:1 — the `HazeStrings` annotation
+ * fails the build when either pack drifts out of sync. `{name}`
+ * placeholders must survive translation verbatim; they are expanded
+ * by `formatString` at runtime.
+ */
+declare const ptBR: HazeStrings;
+export { ptBR };

package/dist/types/components/LocaleProvider/ru-ru.d.ts

@@ -0,0 +1,15 @@
+import type { HazeStrings } from './locale';
+/**
+ * Russian (ru-RU) copy for every user-visible literal in the library.
+ * Not auto-selected by `LocaleProvider`'s `locale` tag (only Chinese
+ * and Japanese variants resolve automatically) — mount it explicitly:
+ *
+ *   <LocaleProvider locale="ru-RU" strings={ruRU}>
+ *
+ * Keys mirror `defaultStrings` 1:1 — the `HazeStrings` annotation
+ * fails the build when either pack drifts out of sync. `{name}`
+ * placeholders must survive translation verbatim; they are expanded
+ * by `formatString` at runtime.
+ */
+declare const ruRU: HazeStrings;
+export { ruRU };

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

@@ -1,10 +1,19 @@
 import type { ReactNode } from 'react';
 import type { ControlOrValue } from 'react-use-control';
+import type { MenuDataItem } from '../../utils/menuItems';
 type MenuProps = {
     open?: ControlOrValue<boolean>;
     trigger?: ReactNode;
+    /**
+     * Data-driven alternative to composed children: plain items,
+     * checkboxes, radio groups, labeled groups, dividers and nested
+     * submenus, rendered through the same components the compound API
+     * uses. When passed, it replaces the panel's children.
+     */
+    items?: MenuDataItem[];
     className?: string;
-    children: ReactNode;
+    children?: ReactNode;
 };
-export default function Menu({ open: openControl, trigger, className, children, }: MenuProps): import("react").JSX.Element;
+export default function Menu({ open: openControl, trigger, items, className, children, }: MenuProps): import("react").JSX.Element;
 export type { MenuProps };
+export type { MenuDataItem };

package/dist/types/components/Menu/MenuCheckboxItem.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+type MenuCheckboxItemProps = {
+    /** Whether the option is checked — controlled control or uncontrolled initial value. */
+    checked?: ControlOrValue<boolean>;
+    /** Fires on every toggle, whatever drove it (click, Enter, Space). */
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    /** Danger skin for destructive actions: danger-colored text and interaction states. */
+    danger?: boolean;
+    /** Inline-start icon slot; bare `svg` children are sized to 1em by the slot. */
+    icon?: ReactNode;
+    /** Inline-end shortcut hint (e.g. '⌘C'), muted and pushed to the item's end. */
+    kbdLabel?: ReactNode;
+    className?: string;
+    children: ReactNode;
+};
+/**
+ * A toggleable menu option (`role="menuitemcheckbox"`): click, Enter or
+ * Space flips `checked`; the state is controllable through the standard
+ * `ControlOrValue` prop. Unlike a plain item, toggling does not close
+ * the menu — several options are typically flipped in one visit.
+ */
+export default function MenuCheckboxItem({ checked: checkedControl, onCheckedChange, disabled, danger, icon, kbdLabel, className, children, }: MenuCheckboxItemProps): import("react").JSX.Element;
+export type { MenuCheckboxItemProps };

package/dist/types/components/Menu/MenuGroup.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+type MenuGroupProps = {
+    /** Non-interactive heading naming the group (aria-labelledby). */
+    label: ReactNode;
+    className?: string;
+    /** The group's menu items. */
+    children: ReactNode;
+};
+/**
+ * A labeled, non-interactive section of menu items (`role="group"`
+ * named by its heading, the ARIA APG menu group shape). The heading is
+ * not a menu item: keyboard traversal, typeahead and the roving tab
+ * stop skip it entirely.
+ */
+export default function MenuGroup({ label, className, children }: MenuGroupProps): import("react").JSX.Element;
+export type { MenuGroupProps };

package/dist/types/components/Menu/MenuItem.d.ts

@@ -2,8 +2,14 @@ import type { ReactNode } from 'react';
 type MenuItemProps = {
     onSelect?: () => void;
     disabled?: boolean;
+    /** Danger skin for destructive actions: danger-colored text and interaction states. */
+    danger?: boolean;
+    /** Inline-start icon slot; bare `svg` children are sized to 1em by the slot. */
+    icon?: ReactNode;
+    /** Inline-end shortcut hint (e.g. '⌘C'), muted and pushed to the item's end. */
+    kbdLabel?: ReactNode;
     className?: string;
     children: ReactNode;
 };
-export default function MenuItem({ onSelect, disabled, className, children, }: MenuItemProps): import("react").JSX.Element;
+export default function MenuItem({ onSelect, disabled, danger, icon, kbdLabel, className, children, }: MenuItemProps): import("react").JSX.Element;
 export type { MenuItemProps };

package/dist/types/components/Menu/MenuRadioGroup.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+type MenuRadioGroupProps = {
+    /** Selected value — controlled control or uncontrolled initial value ('' = none). */
+    value?: ControlOrValue<string>;
+    /** Fires when the selection changes, whatever drove it (click, Enter, Space). */
+    onValueChange?: (value: string) => void;
+    /** Optional non-interactive heading naming the radio group (aria-labelledby). */
+    label?: ReactNode;
+    className?: string;
+    /** The group's `MenuRadioItem`s. */
+    children: ReactNode;
+};
+/**
+ * State container for a single-select cluster of `MenuRadioItem`s
+ * (`role="group"`): owns the selected value through the standard
+ * `ControlOrValue` prop and exposes it to the items.
+ */
+export default function MenuRadioGroup({ value, onValueChange, label, className, children, }: MenuRadioGroupProps): import("react").JSX.Element;
+export type { MenuRadioGroupProps };

package/dist/types/components/Menu/MenuRadioItem.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+type MenuRadioItemProps = {
+    /** Value this option selects in its MenuRadioGroup when activated. */
+    value: string;
+    disabled?: boolean;
+    /** Danger skin for destructive actions: danger-colored text and interaction states. */
+    danger?: boolean;
+    /** Inline-start icon slot; bare `svg` children are sized to 1em by the slot. */
+    icon?: ReactNode;
+    /** Inline-end shortcut hint (e.g. '⌘C'), muted and pushed to the item's end. */
+    kbdLabel?: ReactNode;
+    className?: string;
+    children: ReactNode;
+};
+/**
+ * One option of a MenuRadioGroup (`role="menuitemradio"`): activating
+ * it (click, Enter, Space) selects its `value` in the group — the
+ * previously selected sibling deselects. Must live inside a
+ * `MenuRadioGroup`.
+ */
+export default function MenuRadioItem({ value, disabled, danger, icon, kbdLabel, className, children, }: MenuRadioItemProps): import("react").JSX.Element;
+export type { MenuRadioItemProps };

package/dist/types/components/Menu/index.d.ts

@@ -1,7 +1,15 @@
 export { default as Menu } from './Menu';
-export type { MenuProps } from './Menu';
+export type { MenuProps, MenuDataItem } from './Menu';
 export { default as MenuItem } from './MenuItem';
 export type { MenuItemProps } from './MenuItem';
+export { default as MenuCheckboxItem } from './MenuCheckboxItem';
+export type { MenuCheckboxItemProps } from './MenuCheckboxItem';
+export { default as MenuRadioGroup } from './MenuRadioGroup';
+export type { MenuRadioGroupProps } from './MenuRadioGroup';
+export { default as MenuRadioItem } from './MenuRadioItem';
+export type { MenuRadioItemProps } from './MenuRadioItem';
+export { default as MenuGroup } from './MenuGroup';
+export type { MenuGroupProps } from './MenuGroup';
 export { default as MenuDivider } from './MenuDivider';
 export { default as MenuSub } from './MenuSub';
 export type { MenuSubProps } from './MenuSub';

package/dist/types/components/Menu/menu-item-styles.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared slot and variant skins for the Menu family's item types
+ * (MenuItem, MenuCheckboxItem, MenuRadioItem). Merged after each item's
+ * base class so the overrides win on equal specificity.
+ */
+/**
+ * Danger skin for destructive actions: danger-colored text with a
+ * danger-subtle interaction background.
+ */
+export declare const menuItemDanger: import("@linaria/core").LinariaClassName;
+/**
+ * Inline-start icon slot. The slot sizes bare `svg` children to 1em —
+ * an svg without intrinsic dimensions collapses to 0×0 inside flex.
+ */
+export declare const menuItemIcon: import("@linaria/core").LinariaClassName;
+/**
+ * Inline-end shortcut hint (e.g. '⌘C'): muted, monospaced, pushed to
+ * the item's inline end.
+ */
+export declare const menuItemKbd: import("@linaria/core").LinariaClassName;
+/**
+ * Fixed-size state indicator box (check/dot) for checkbox and radio
+ * items: reserves its square whether or not the glyph renders, so
+ * labels align across mixed items.
+ */
+export declare const menuItemIndicator: import("@linaria/core").LinariaClassName;
+/** Group heading: muted, one step smaller than item text. Shared by MenuGroup and MenuRadioGroup's optional label. */
+export declare const menuGroupLabel: import("@linaria/core").LinariaClassName;

package/dist/types/components/NavigationBar/NavLink.d.ts

@@ -37,6 +37,6 @@ declare const _default: import("react").ForwardRefExoticComponent<{
      */
     onClick?: (event: MouseEvent<HTMLAnchorElement>) => void;
     className?: string;
-} & Omit<Omit<import("react").DetailedHTMLProps<import("react").AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref">, "className" | "children" | "onClick" | "href"> & import("react").RefAttributes<HTMLAnchorElement>>;
+} & Omit<Omit<import("react").DetailedHTMLProps<import("react").AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref">, "children" | "className" | "onClick" | "href"> & import("react").RefAttributes<HTMLAnchorElement>>;
 export default _default;
 export type { NavLinkProps };

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

@@ -1,11 +1,25 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type PaginationProps = {
     page?: ControlOrValue<number>;
     total: number;
-    pageSize?: number;
+    pageSize?: ControlOrValue<number>;
+    /** Page sizes offered by the size changer (`showSizeChanger`). */
+    pageSizeOptions?: number[];
+    /** Renders a page-size select; changing it resets to page 1. */
+    showSizeChanger?: boolean;
+    /** Renders a "Go to [input]" control that jumps on Enter (clamped). */
+    showQuickJumper?: boolean;
+    /** Renders a summary of `total` and the current page's item range. */
+    showTotal?: (total: number, range: [number, number]) => ReactNode;
+    /** Minimal mode: a page input plus prev/next instead of the page list. */
+    simple?: boolean;
+    /** Turns the ellipsis markers into buttons jumping ±5 pages (clamped). */
+    ellipsisJump?: boolean;
+    /** Value callback fired for every page jump and page-size change. */
+    onPageChange?: (page: number, pageSize: number) => void;
     size?: 'sm' | 'md' | 'lg';
     className?: string;
 } & Omit<ComponentPropsWithoutRef<'nav'>, 'onChange'>;
-export default function Pagination({ page: pageControl, total, pageSize, size, className, ...rest }: PaginationProps): import("react").JSX.Element;
+export default function Pagination({ page: pageControl, total, pageSize: pageSizeControl, pageSizeOptions, showSizeChanger, showQuickJumper, showTotal, simple, ellipsisJump, onPageChange, size, className, ...rest }: PaginationProps): import("react").JSX.Element;
 export type { PaginationProps };

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

@@ -0,0 +1,33 @@
+import type { ComponentPropsWithoutRef } from 'react';
+type QRCodeLevel = 'L' | 'M' | 'Q' | 'H';
+type QRCodeProps = {
+    /** Text or URL to encode. Must be non-empty. */
+    value: string;
+    /** Rendered edge length in px. Default 128. */
+    size?: number;
+    /** QR error correction level. Default 'M'. */
+    level?: QRCodeLevel;
+    /** Whether to wrap the code in a bordered, padded frame. Default true. */
+    bordered?: boolean;
+    /**
+     * Fill of the dark modules. Any CSS color string — defaults to the text
+     * token, so it follows the theme.
+     */
+    modulesColor?: string;
+    /**
+     * Fill of the light background. Any CSS color string — defaults to the
+     * bg token, so it follows the theme.
+     */
+    bgColor?: string;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children'>;
+/**
+ * QR code rendered as a single crisp SVG path over the `qrcode`
+ * dependency (statically imported, SortableTagGroup-style: the dist
+ * contract test pins the reference surface so qrcode only enters this
+ * module's import graph). The svg is the semantic image: `role="img"` with
+ * the encoded `value` as its accessible name, so screen readers announce
+ * what the code contains; the wrapper div receives the native `...rest`
+ * (e.g. `aria-hidden` on it silences the whole graphic).
+ */
+export default function QRCode({ value, size, level, bordered, modulesColor, bgColor, className, ...rest }: QRCodeProps): import("react").JSX.Element;
+export type { QRCodeProps, QRCodeLevel };

package/dist/types/components/QRCode/index.d.ts

@@ -0,0 +1,2 @@
+export { default as QRCode } from './QRCode';
+export type { QRCodeProps, QRCodeLevel } from './QRCode';

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

@@ -0,0 +1,16 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+type ResultStatus = 'success' | 'error' | 'info' | 'warning' | '403' | '404' | '500';
+type ResultProps = {
+    /** Determines the default illustration. Default 'info'. */
+    status?: ResultStatus;
+    /** Custom illustration replacing the status default. */
+    icon?: ReactNode;
+    /** Primary statement, rendered semibold at `--haze-text-xl`. */
+    title?: ReactNode;
+    /** Secondary explanation below the title. */
+    subTitle?: ReactNode;
+    /** Action area (buttons, links) below the content. */
+    extra?: ReactNode;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'title'>;
+export default function Result({ status, icon, title, subTitle, extra, className, ...rest }: ResultProps): import("react").JSX.Element;
+export type { ResultProps, ResultStatus };

package/dist/types/components/Result/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Result } from './Result';
+export type { ResultProps, ResultStatus } from './Result';

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

@@ -49,7 +49,7 @@ export declare const SidebarItem: import("react").ForwardRefExoticComponent<{
      */
     onClick?: (event: MouseEvent<HTMLAnchorElement>) => void;
     className?: string;
-} & Omit<Omit<import("react").DetailedHTMLProps<import("react").AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref">, "className" | "children" | "onClick"> & import("react").RefAttributes<HTMLAnchorElement>>;
+} & Omit<Omit<import("react").DetailedHTMLProps<import("react").AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref">, "children" | "className" | "onClick"> & import("react").RefAttributes<HTMLAnchorElement>>;
 type SidebarFooterProps = {
     children: ReactNode;
     className?: string;

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

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type SliderProps = {
     /** `number` in single mode, `[low, high]` when `range` is set. */
@@ -22,11 +22,33 @@ type SliderProps = {
      * identically named sliders are ambiguous — prefer the tuple).
      */
     'aria-label'?: string | [string, string];
+    /**
+     * Value bubble over the active thumb while dragging or focused
+     * (see SliderCoreProps.tooltip). Opt-in; in single mode it wraps the
+     * input in a positioning span (the input keeps `className`).
+     */
+    tooltip?: boolean;
+    /** Bubble content formatter (see SliderCoreProps.tooltipFormatter). */
+    tooltipFormatter?: (value: number) => ReactNode;
+    /**
+     * Tick labels under the track, clickable onto the nearest thumb
+     * (see SliderCoreProps.marks).
+     */
+    marks?: Record<number, ReactNode>;
+    /**
+     * Vertical orientation, bottom-to-top (see SliderCoreProps.vertical).
+     */
+    vertical?: boolean;
+    /**
+     * `null` restricts the selectable values to the `marks` keys
+     * (see SliderCoreProps.step); a number forwards to the native input.
+     */
+    step?: number | null;
     /**
      * Forwarded to the `<input type='range'>` — the only input in single
      * mode, the low thumb (first tab stop) in range mode.
      */
     ref?: Ref<HTMLInputElement>;
-} & Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'value' | 'aria-label'>;
+} & Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'value' | 'aria-label' | 'step'>;
 export default function Slider({ value: valueControl, range, className, onChange, onValuesChange, ref, ...rest }: SliderProps): import("react").JSX.Element;
 export type { SliderProps };

package/dist/types/components/Slider/SliderCore.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
 type SliderCoreProps = {
     /** `number` in single mode, `[low, high]` when `range` is set. An
      * inverted tuple renders normalized (low ≤ high). */
@@ -21,6 +21,44 @@ type SliderCoreProps = {
      * pointer input.
      */
     range?: boolean;
+    /**
+     * Shows a value bubble over the active thumb while it is being
+     * dragged (pointerdown until pointerup) or focused. Opt-in: without
+     * it nothing extra renders. The bubble is visual only
+     * (`aria-hidden`) — the native input keeps exposing the value, so
+     * `aria-valuetext` semantics are untouched. In range mode each thumb
+     * carries its own bubble.
+     */
+    tooltip?: boolean;
+    /** Formats the bubble content (both modes); defaults to the raw
+     * number. */
+    tooltipFormatter?: (value: number) => ReactNode;
+    /**
+     * Tick labels rendered under the track (beside it when `vertical`).
+     * Clicking a label commits that value to the nearest thumb (ties go
+     * to the low thumb; a value past the other thumb still snaps against
+     * it instead of crossing). Combine with `step={null}` to restrict
+     * the selectable values to the mark keys.
+     */
+    marks?: Record<number, ReactNode>;
+    /**
+     * Vertical orientation (bottom-to-top) via the modern
+     * `writing-mode: vertical-lr; direction: rtl` slider recipe
+     * (Chromium 119+ / Firefox 120+ / Safari 17.4+; older engines keep
+     * rendering horizontally). Keyboard behavior stays native — the
+     * RTL arrow mirroring only applies to horizontal sliders. The track
+     * length defaults to `calc(var(--haze-space-16) * 2)`; override it
+     * by setting `--haze-slider-track` on the slider or an ancestor.
+     */
+    vertical?: boolean;
+    /**
+     * Pass `null` (with `marks`) to make the marks the only selectable
+     * values: the native inputs receive `step='any'` and every change —
+     * drag, click or keyboard — snaps to the nearest mark key. A number
+     * is forwarded to the native inputs as-is; omitted keeps the native
+     * default.
+     */
+    step?: number | null;
     className?: string;
     /**
      * Single mode: forwarded to the input untouched. Range mode: a
@@ -35,6 +73,6 @@ type SliderCoreProps = {
      * mode, the low thumb (first tab stop) in range mode.
      */
     ref?: Ref<HTMLInputElement>;
-} & Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'value' | 'onChange' | 'aria-label'>;
-export default function SliderCore({ value, onChange, onNativeChange, range, className, onKeyDown, 'aria-label': ariaLabel, ref, ...rest }: SliderCoreProps): import("react").JSX.Element;
+} & Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'value' | 'onChange' | 'aria-label' | 'step'>;
+export default function SliderCore({ value, onChange, onNativeChange, range, className, onKeyDown, 'aria-label': ariaLabel, tooltip, tooltipFormatter, marks, vertical, step, onPointerDown, onFocus, onBlur, ref, ...rest }: SliderCoreProps): import("react").JSX.Element;
 export type { SliderCoreProps };

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

@@ -1,9 +1,16 @@
 type StreamingTextProps = {
     text: string;
     speed?: number;
+    /**
+     * How often (ms) the screen-reader live region picks up a new snapshot
+     * of the streamed text. Everything streamed in between stays silent:
+     * announcing per character would restart the reader's utterance on
+     * every tick, so the throttle is the point, not an optimization.
+     */
+    announceInterval?: number;
     onComplete?: () => void;
     showCursor?: boolean;
     className?: string;
 };
-export default function StreamingText({ text, speed, onComplete, showCursor, className, }: StreamingTextProps): import("react").JSX.Element;
+export default function StreamingText({ text, speed, announceInterval, onComplete, showCursor, className, }: StreamingTextProps): import("react").JSX.Element;
 export type { StreamingTextProps };

package/dist/types/components/TagGroup/SortableTagGroup.d.ts

@@ -1,8 +1,9 @@
 import type { ReactNode } from 'react';
 /**
  * Drag-and-drop reorderable variant of TagGroup — built on @dnd-kit
- * (optional peers), so this module statically imports the dnd runtime;
- * the plain TagGroup stays free of it. Each chip becomes draggable;
+ * (a haze-ui dependency), so this module statically imports the dnd
+ * runtime; the plain TagGroup stays free of it. Each chip becomes
+ * draggable;
  * keyboard: focus a chip, Space lifts, arrows move, Space drops, Escape
  * cancels.
  */

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

@@ -4,7 +4,7 @@ type TagGroupProps = {
     className?: string;
 };
 /** Plain non-draggable tag row. For drag-and-drop reordering use
- * SortableTagGroup (which statically imports the dnd-kit optional peers);
+ * SortableTagGroup (which statically imports the @dnd-kit runtime);
  * this base component stays free of the dnd runtime. */
 export default function TagGroup({ children, className }: TagGroupProps): import("react").JSX.Element;
 export type { TagGroupProps };

package/dist/types/components/TagInput/SortableTagInput.d.ts

@@ -23,9 +23,8 @@ type SortableTagInputProps = {
 };
 /**
  * Controllable-state sugar over `SortableTagInputCore`: drag-and-drop tag
- * reordering built on the @dnd-kit optional peers — install
- * `@dnd-kit/core`, `@dnd-kit/sortable` and `@dnd-kit/utilities` to use
- * it (the plain `TagInput` never touches them). Reorders leave through
+ * reordering built on the @dnd-kit dependency (the plain `TagInput` never
+ * touches it). Reorders leave through
  * `onChange` with the new array — the same single exit as add/remove.
  * Keyboard: focus a tag's label, Space lifts, arrows move, Space drops,
  * Escape cancels.