haze-ui 1.31.0 → 1.32.0

package/dist/types/components/ConfirmDialog/confirm.d.ts

@@ -0,0 +1,33 @@
+import type { ReactNode } from 'react';
+import type { ConfirmDialogProps } from './ConfirmDialog';
+/**
+ * Options for the imperative confirm — {@link ConfirmDialogProps} minus
+ * the wired callbacks (the promise carries the answer, so `onClose`/
+ * `onConfirm`/`onCancel` are derived paths, not inputs).
+ */
+type ConfirmOptions = Omit<ConfirmDialogProps, 'onClose' | 'onConfirm' | 'onCancel' | 'open' | 'children'> & {
+    /** Dialog body copy. */
+    children: ReactNode;
+    /** Fired when the user confirms (before the promise resolves). */
+    onConfirm?: () => void;
+    /** Fired when the user cancels or dismisses (before rejection). */
+    onCancel?: () => void;
+};
+/**
+ * Imperative promise-based confirm dialog, the AntD `Modal.confirm`
+ * shape: mounts a fresh ConfirmDialog into `document.body`, resolves
+ * with `true` on confirm, `false` on cancel/dismiss, and unmounts on
+ * settle. Safe to call outside React render (event handlers, async
+ * flows); not safe during SSR (no-op `false`, no mount).
+ *
+ * ```ts
+ * const ok = await confirm({ title: 'Discard draft?', children: '…', variant: 'danger' });
+ * if (ok) discard();
+ * ```
+ *
+ * Each call owns its own React root — multiple confirms stack (they
+ * open as sibling dialogs; the top layer negotiates them).
+ */
+declare function confirm(options: ConfirmOptions): Promise<boolean>;
+export { confirm };
+export type { ConfirmOptions };

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

@@ -1,2 +1,4 @@
 export { default as ConfirmDialog } from './ConfirmDialog';
 export type { ConfirmDialogProps } from './ConfirmDialog';
+export { confirm } from './confirm';
+export type { ConfirmOptions } from './confirm';

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

@@ -0,0 +1,36 @@
+import type { ControlOrValue } from 'react-use-control';
+import type { DatepickerPreset } from '../Datepicker/DatepickerCore';
+import type { CalendarCellRender } from '../Calendar/Calendar';
+import type { Ref } from 'react';
+/**
+ * Date+time picker (the Mantine DateTimePicker niche): a date calendar
+ * with a time field below it in one popover. This is a thin sugar over
+ * Datepicker — `picker` is fixed to `date` (date+time values are apples
+ * and day-granularity oranges for week/month/quarter/year modes) and
+ * `showTime` defaults to `true`; {@link showSeconds} flips it to the
+ * seconds-resolution form.
+ *
+ * Value serializes as `"YYYY-MM-DD HH:mm"` (or `"YYYY-MM-DD HH:mm:ss"`
+ * with `showSeconds`), matching Datepicker's showTime contract.
+ */
+type DateTimePickerProps = {
+    value?: ControlOrValue<string>;
+    open?: ControlOrValue<boolean>;
+    min?: string;
+    max?: string;
+    /** Disables individual dates on the calendar panel (day granularity). */
+    disabledDate?: (date: Date) => boolean;
+    /** Shortcut rows at the top of the panel. */
+    presets?: DatepickerPreset[];
+    /** Include seconds in the time field (value gains a `:ss` part). */
+    showSeconds?: boolean;
+    locale?: string;
+    weekStartsOn?: 0 | 1;
+    cellRender?: CalendarCellRender;
+    placeholder?: string;
+    className?: string;
+    /** Forwarded to the trigger `<input>`. */
+    ref?: Ref<HTMLInputElement>;
+};
+export default function DateTimePicker({ value: valueControl, open: openControl, min, max, disabledDate, presets, showSeconds, locale, weekStartsOn, cellRender, placeholder, className, ref, }: DateTimePickerProps): import("react").JSX.Element;
+export type { DateTimePickerProps };

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

@@ -0,0 +1,2 @@
+export { default as DateTimePicker } from './DateTimePicker';
+export type { DateTimePickerProps } from './DateTimePicker';

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

@@ -1,4 +1,4 @@
-import type { Ref } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 import type { CalendarCellRender, CalendarPickerMode } from '../Calendar/Calendar';
 import type { DatepickerPreset } from './DatepickerCore';
@@ -41,6 +41,6 @@ type DatepickerProps = {
     /** Forwarded to the trigger `<input>` (not the wrapper div) — the
      * element form bridges and `ref.current.focus()` reach. */
     ref?: Ref<HTMLInputElement>;
-};
-export default function Datepicker({ value: valueControl, open: openControl, picker, min, max, disabledDate, presets, showTime, format, parse, locale, weekStartsOn, cellRender, placeholder, className, ref, }: DatepickerProps): import("react").JSX.Element;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'onChange' | 'children'>;
+export default function Datepicker({ value: valueControl, open: openControl, picker, min, max, disabledDate, presets, showTime, format, parse, locale, weekStartsOn, cellRender, placeholder, className, ref, ...rest }: DatepickerProps): import("react").JSX.Element;
 export type { DatepickerProps };

package/dist/types/components/Datepicker/DatepickerCore.d.ts

@@ -1,4 +1,4 @@
-import type { Ref } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 import type { CalendarCellRender, CalendarPickerMode } from '../Calendar/Calendar';
 /** One shortcut row at the top of the dropdown panel: clicking applies
  * `value` (serialized per `picker`) and closes the panel. */
@@ -66,6 +66,6 @@ type DatepickerCoreProps = {
     cellRender?: CalendarCellRender;
     /** Forwarded to the trigger `<input>` (not the wrapper div). */
     ref?: Ref<HTMLInputElement>;
-};
-export default function DatepickerCore({ value, onChange, open, onOpenChange, picker, min, max, disabledDate, presets, showTime, format, parse, locale, weekStartsOn, cellRender, placeholder, className, ref, }: DatepickerCoreProps): import("react").JSX.Element;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'onChange' | 'children'>;
+export default function DatepickerCore({ value, onChange, open, onOpenChange, picker, min, max, disabledDate, presets, showTime, format, parse, locale, weekStartsOn, cellRender, placeholder, className, ref, ...rest }: DatepickerCoreProps): import("react").JSX.Element;
 export type { DatepickerCoreProps, DatepickerPreset };

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

@@ -18,6 +18,17 @@ type DrawerHandle = {
     /** Focus the element that held focus when the drawer last opened. */
     focusTrigger: () => void;
 };
+/**
+ * Semantic slot classes (AntD v6 `classNames` shape): keys land classes
+ * on Drawer's structural parts. Drawer renders a single `<dialog>` —
+ * `content` is that element's part (the placement class and any
+ * `className` land on the same node). A `classNames` prop set via
+ * ConfigProvider merges under the prop's keys.
+ */
+type DrawerClassNames = {
+    /** The `<dialog>` panel itself (data-slot='content'). */
+    content?: string;
+};
 type DrawerProps = {
     open?: ControlOrValue<boolean>;
     placement?: 'left' | 'right' | 'top' | 'bottom';
@@ -34,8 +45,10 @@ type DrawerProps = {
      */
     viewTransition?: boolean;
     className?: string;
+    /** Slot classes (see {@link DrawerClassNames}). */
+    classNames?: DrawerClassNames;
     children: ReactNode;
     ref?: Ref<DrawerHandle>;
 };
-export default function Drawer({ open: openControl, placement, onClose, viewTransition, className, children, ref, }: DrawerProps): import("react").JSX.Element;
-export type { DrawerProps, DrawerHandle };
+export default function Drawer({ open: openControl, placement, onClose, viewTransition, className, classNames, children, ref, }: DrawerProps): import("react").JSX.Element;
+export type { DrawerClassNames, DrawerProps, DrawerHandle };

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

@@ -1,2 +1,2 @@
 export { default as Drawer } from './Drawer';
-export type { DrawerProps, DrawerHandle } from './Drawer';
+export type { DrawerClassNames, DrawerProps, DrawerHandle } from './Drawer';

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

@@ -0,0 +1,16 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+/**
+ * A semantic `<fieldset>` + `<legend>` grouping for form sections —
+ * the native grouping HTML was made for, skinned. Screen readers name
+ * the group from the legend on focus entry into any control inside,
+ * which is the whole point over a bare div+heading.
+ */
+type FieldsetProps = {
+    /** The group's legend text/content — rendered inside `<legend>` so
+     * assistive tech names the whole group from it. */
+    legend?: ReactNode;
+    /** Disables every form control inside (native fieldset semantics). */
+    disabled?: boolean;
+} & Omit<ComponentPropsWithoutRef<'fieldset'>, 'disabled'>;
+export default function Fieldset({ legend: legendContent, disabled, className, children, ...rest }: FieldsetProps): import("react").JSX.Element;
+export type { FieldsetProps };

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

@@ -0,0 +1,2 @@
+export { default as Fieldset } from './Fieldset';
+export type { FieldsetProps } from './Fieldset';

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

@@ -0,0 +1,27 @@
+import type { ComponentPropsWithoutRef } from 'react';
+type HighlightProps = {
+    /** The text to scan. Rendering stays text-level: only matched
+     * substrings become `<mark>` children, everything else stays text
+     * nodes — no innerHTML, no injection surface. */
+    children: string;
+    /** One or more substrings to mark (empty strings are ignored). */
+    highlight: string | string[];
+    /**
+     * Case sensitivity of the match. Default `false` (the search-box
+     * convention: queries match regardless of letter case).
+     */
+    caseSensitive?: boolean;
+    /** Mark tone applied to every matched run. */
+    color?: 'warning' | 'primary' | 'success' | 'danger';
+} & Omit<ComponentPropsWithoutRef<'mark'>, 'children' | 'color'>;
+/**
+ * Highlights matching substrings inside a text run by wrapping them in
+ * {@link Mark} elements — the search-results affordance. Pure text in,
+ * text + marks out; non-string children are rejected by the type.
+ *
+ * Renders plain text (no wrapper DOM of its own): the outer container
+ * is a fragment and each match is a `<Mark data-slot="mark">`, so the
+ * data-slot namespace stays the shared `mark` slot.
+ */
+export default function Highlight({ children, highlight, caseSensitive, color, ...rest }: HighlightProps): import("react").JSX.Element;
+export type { HighlightProps };

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

@@ -0,0 +1,2 @@
+export { default as Highlight } from './Highlight';
+export type { HighlightProps } from './Highlight';

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

@@ -0,0 +1,24 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+/**
+ * Corner badge attached to a host element (avatar, icon button, tab) —
+ * the notification-dot affordance. Render without `label` for a plain
+ * dot; pass `label` for a count badge.
+ */
+type IndicatorProps = {
+    /**
+     * Badge content. Omitted (undefined / null, or render-empty values
+     * like false / '') renders a dot (a bare status marker); a value
+     * renders a count badge. Strings longer than `max`-formatted are the
+     * caller's concern (e.g. pass "99+").
+     */
+    label?: ReactNode;
+    /** Zero/out semantics: number 0 shows by default in badge mode. */
+    showZero?: boolean;
+    /** Badge tone. */
+    color?: 'primary' | 'danger' | 'success' | 'warning';
+    /** Corner placement of the badge. */
+    position?: 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
+    children: ReactNode;
+} & Omit<ComponentPropsWithoutRef<'span'>, 'color' | 'content'>;
+export default function Indicator({ label, showZero, color, position, className, children, ...rest }: IndicatorProps): import("react").JSX.Element;
+export type { IndicatorProps };

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

@@ -0,0 +1,2 @@
+export { default as Indicator } from './Indicator';
+export type { IndicatorProps } from './Indicator';

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

@@ -1,11 +1,17 @@
-import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type InputProps = {
     value?: ControlOrValue<string>;
     size?: 'sm' | 'md' | 'lg';
+    /** Content rendered inside the field at the leading edge (icon,
+     * currency glyph, …). See InputCore for the layout contract. */
+    leftSection?: ReactNode;
+    /** Same as `leftSection`, at the trailing edge — the conventional
+     * home of clear buttons and visibility toggles. */
+    rightSection?: ReactNode;
     /** Forwarded to the underlying `<input>` — the element form bridges
      * (react-f0rm `focusRef`), tests and `ref.current.focus()` reach. */
     ref?: Ref<HTMLInputElement>;
 } & Omit<ComponentPropsWithoutRef<'input'>, 'value' | 'size'>;
-export default function Input({ value: valueControl, size, className, onChange, ref, ...rest }: InputProps): import("react").JSX.Element;
+export default function Input({ value: valueControl, size, className, leftSection, rightSection, onChange, ref, ...rest }: InputProps): import("react").JSX.Element;
 export type { InputProps };

package/dist/types/components/Input/InputCore.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
 type InputCoreProps = {
     value: string;
     onChange: (value: string) => void;
@@ -8,8 +8,17 @@ type InputCoreProps = {
     onNativeChange?: ComponentPropsWithoutRef<'input'>['onChange'];
     size?: 'sm' | 'md' | 'lg';
     className?: string;
+    /** Content rendered inside the field, before the text — an icon, a
+     * currency glyph, a search marker. Layout sits in a flex row with the
+     * input; the field keeps its border and focus ring (the box stays
+     * one visual unit). Interactive children must re-enable pointer
+     * events themselves (see PasswordInput's visibility toggle). */
+    leftSection?: ReactNode;
+    /** Same as {@link InputCoreProps.leftSection}, at the trailing edge —
+     * the conventional home of clear buttons and visibility toggles. */
+    rightSection?: ReactNode;
     /** Forwarded to the `<input>` element. */
     ref?: Ref<HTMLInputElement>;
 } & Omit<ComponentPropsWithoutRef<'input'>, 'value' | 'onChange' | 'size'>;
-export default function InputCore({ value, onChange, onNativeChange, size, className, ref, ...rest }: InputCoreProps): import("react").JSX.Element;
+export default function InputCore({ value, onChange, onNativeChange, size, className, leftSection, rightSection, ref, ...rest }: InputCoreProps): import("react").JSX.Element;
 export type { InputCoreProps };

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

@@ -0,0 +1,25 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+/**
+ * Container-level loading state: dims the wrapped content and centers a
+ * spinner above it. The content stays in the tree and keeps its place
+ * in the focus order — deliberately, so focus survives the overlay
+ * (`aria-busy` on the wrapper is the AT channel, same as the Mantine
+ * equivalent). The veil blocks pointer and selection, but nothing here
+ * is modal: keyboard users can still reach the content. Consumers that
+ * need a full lock gate their own handlers on the same `visible` prop
+ * (or host the content in an `inert` subtree).
+ */
+type LoadingOverlayProps = {
+    /** Whether the overlay is shown. */
+    visible?: boolean;
+    /** Optional announcement text rendered inside a visually-paired label
+     * under the spinner for sighted context. */
+    label?: ReactNode;
+    /** Swap the default Spinner. */
+    loader?: ReactNode;
+    /** Spinner size (when the default loader is used). */
+    spinnerSize?: 'sm' | 'md' | 'lg';
+    children: ReactNode;
+} & ComponentPropsWithoutRef<'div'>;
+export default function LoadingOverlay({ visible, label, loader, spinnerSize, className, children, ...rest }: LoadingOverlayProps): import("react").JSX.Element;
+export type { LoadingOverlayProps };

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

@@ -0,0 +1,2 @@
+export { default as LoadingOverlay } from './LoadingOverlay';
+export type { LoadingOverlayProps } from './LoadingOverlay';

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

@@ -45,6 +45,10 @@ declare const defaultStrings: {
         create: string;
         noResults: string;
     };
+    spoiler: {
+        showMore: string;
+        showLess: string;
+    };
     command: {
         noResults: string;
     };

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

@@ -0,0 +1,12 @@
+import type { ComponentPropsWithoutRef } from 'react';
+type MarkProps = {
+    /** Highlight tone — maps to the semantic status tokens. */
+    color?: 'warning' | 'primary' | 'success' | 'danger';
+} & Omit<ComponentPropsWithoutRef<'mark'>, 'color'>;
+/**
+ * Text-level highlight — the semantic `<mark>` skinned with the status
+ * tokens. For search-result highlighting of arbitrary substrings use
+ * Highlight, which composes this element.
+ */
+export default function Mark({ color, className, ...rest }: MarkProps): import("react").JSX.Element;
+export type { MarkProps };

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

@@ -0,0 +1,2 @@
+export { default as Mark } from './Mark';
+export type { MarkProps } from './Mark';

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

@@ -1,5 +1,5 @@
-import type { ReactNode } from 'react';
-type MenuItemProps = {
+import type { ComponentPropsWithRef, ElementType, ReactNode } from 'react';
+type MenuItemOwnProps = {
     onSelect?: () => void;
     disabled?: boolean;
     /** Danger skin for destructive actions: danger-colored text and interaction states. */
@@ -11,5 +11,16 @@ type MenuItemProps = {
     className?: string;
     children: ReactNode;
 };
-export default function MenuItem({ onSelect, disabled, danger, icon, kbdLabel, className, children, }: MenuItemProps): import("react").JSX.Element;
-export type { MenuItemProps };
+/**
+ * Polymorphic like Button's `as`: the item skin and the menuitem wiring
+ * (role, roving tabIndex, disabled/aria handling) always land on the
+ * rendered element; the target's own props flow through. `as='a'`
+ * renders a navigation menuitem with link semantics (href).
+ */
+type MenuItemProps<T extends ElementType = 'button'> = MenuItemOwnProps & {
+    /** Render element — 'button' (default) or 'a' (or a router Link
+     * component forwarding props to an anchor). */
+    as?: T;
+} & Omit<ComponentPropsWithRef<T>, keyof MenuItemOwnProps | 'as'>;
+export default function MenuItem<T extends ElementType = 'button'>({ onSelect, disabled, danger, icon, kbdLabel, className, children, as, ...rest }: MenuItemProps<T>): import("react").JSX.Element;
+export type { MenuItemOwnProps, MenuItemProps };

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

@@ -0,0 +1,23 @@
+import type { ComponentPropsWithoutRef } from 'react';
+type NumberFormatterProps = {
+    /** The numeric value to render. */
+    value: number;
+    /** Intl.NumberFormat options minus locale. */
+    formatOptions?: Intl.NumberFormatOptions;
+    /** Explicit locale. Defaults to the runtime default (SSR-stable).
+     *
+     * Note: this formatter is RSC-safe (no hooks) and therefore does NOT
+     * read the LocaleProvider chain — pass `locale` explicitly inside a
+     * localized tree. */
+    locale?: string;
+    /** Text prepended/appended outside the formatted number. */
+    prefix?: string;
+    suffix?: string;
+} & Omit<ComponentPropsWithoutRef<'span'>, 'children' | 'prefix'>;
+/**
+ * Presentational number formatting — a thin, token-free numeric text
+ * node driven by Intl. Stat's display value is the styled display
+ * surface; this is the formatter for inline text ("共 12,345 条").
+ */
+export default function NumberFormatter({ value, formatOptions, locale, prefix, suffix, ...rest }: NumberFormatterProps): import("react").JSX.Element;
+export type { NumberFormatterProps };

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

@@ -0,0 +1,2 @@
+export { default as NumberFormatter } from './NumberFormatter';
+export type { NumberFormatterProps } from './NumberFormatter';

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

@@ -1,6 +1,24 @@
 import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 import type { SelectVirtualizedConfig } from './SelectFloating';
+/**
+ * Semantic slot classes (AntD v6 `classNames` shape), following the
+ * data-slot names: `trigger` is the focusable control (native `<select>`
+ * in plain mode, trigger `<button>` in floating modes); `content` is the
+ * floating panel; `option`, `clearButton`, `item`, `searchInput` cover
+ * the rest. Slots not rendered by the current mode are ignored. A
+ * ConfigProvider `Select.classNames` section merges under the prop.
+ */
+type SelectClassNames = {
+    trigger?: string;
+    content?: string;
+    option?: string;
+    clearButton?: string;
+    /** Selected-value chip in multiple mode (data-slot='item'). */
+    item?: string;
+    /** Panel-top filter input in searchable mode (data-slot='input'). */
+    searchInput?: string;
+};
 type SelectProps = {
     /** `string` in single mode, `string[]` when `multiple` is set. */
     value?: ControlOrValue<string | string[]>;
@@ -70,6 +88,9 @@ type SelectProps = {
      */
     placeholder?: string;
     size?: 'sm' | 'md' | 'lg';
+    /** Slot classes (see {@link SelectClassNames}); merged over any
+     * ConfigProvider `Select.classNames` section, per key. */
+    classNames?: SelectClassNames;
     /**
      * Forwarded to the focusable element — the native `<select>` in plain
      * and clearable single mode, the trigger `<button>` when `multiple`
@@ -79,5 +100,5 @@ type SelectProps = {
     ref?: Ref<HTMLSelectElement | HTMLButtonElement>;
     children: ReactNode;
 } & Omit<ComponentPropsWithoutRef<'select'>, 'value' | 'size' | 'multiple'>;
-export default function Select({ value: valueControl, multiple, searchable, clearable, loading, onSearch, maxTagCount, virtualized, size, className, children, onChange, onValuesChange, placeholder, ref, ...rest }: SelectProps): import("react").JSX.Element;
-export type { SelectProps };
+export default function Select({ value: valueControl, multiple, searchable, clearable, loading, onSearch, maxTagCount, virtualized, size, className, classNames, children, onChange, onValuesChange, placeholder, ref, ...rest }: SelectProps): import("react").JSX.Element;
+export type { SelectClassNames, SelectProps };

package/dist/types/components/Select/SelectCore.d.ts

@@ -1,5 +1,6 @@
 import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
 import type { SelectVirtualizedConfig } from './SelectFloating';
+import type { SelectClassNames } from './Select';
 type SelectCoreProps = {
     /** `string` in single mode, `string[]` when `multiple` is set. */
     value: string | string[];
@@ -75,6 +76,8 @@ type SelectCoreProps = {
     virtualized?: boolean | SelectVirtualizedConfig;
     children: ReactNode;
     className?: string;
+    /** Slot classes (see SelectProps.classNames in ./Select). */
+    classNames?: SelectClassNames;
     /**
      * Forwarded to the focusable element — the native `<select>` in plain
      * and clearable single mode, the trigger `<button>` when `multiple`
@@ -82,5 +85,5 @@ type SelectCoreProps = {
      */
     ref?: Ref<HTMLSelectElement | HTMLButtonElement>;
 } & Omit<ComponentPropsWithoutRef<'select'>, 'value' | 'onChange' | 'size' | 'multiple'>;
-export default function SelectCore({ value, onChange, onNativeChange, multiple, searchable, clearable, loading, onSearch, maxTagCount, size, virtualized, className, placeholder, children, ref, ...rest }: SelectCoreProps): import("react").JSX.Element;
+export default function SelectCore({ value, onChange, onNativeChange, multiple, searchable, clearable, loading, onSearch, maxTagCount, size, virtualized, className, classNames, placeholder, children, ref, ...rest }: SelectCoreProps): import("react").JSX.Element;
 export type { SelectCoreProps };

package/dist/types/components/Select/SelectFloating.d.ts

@@ -1,4 +1,5 @@
 import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { SelectClassNames } from './Select';
 import type { SelectEntryData } from './select-options';
 /** Metrics override for the `virtualized` option list of the floating
  * Select paths (multiple, or single with `searchable`). */
@@ -37,6 +38,10 @@ type SelectFloatingProps = {
     /** Falls back to the `select.placeholder` locale string. */
     placeholder?: string;
     size?: 'sm' | 'md' | 'lg';
+    /** Slot classes, following data-slot names (see SelectProps.classNames
+     * in ./Select; the Select wrapper merges its ConfigProvider section
+     * under this prop already). */
+    classNames?: SelectClassNames;
     /**
      * Render a search input at the top of the panel that filters the
      * options (case-insensitive substring over the label text). Typing
@@ -90,5 +95,5 @@ type SelectFloatingProps = {
     /** Forwarded to the trigger `<button>` element. */
     ref?: Ref<HTMLButtonElement>;
 } & Omit<ComponentPropsWithoutRef<'button'>, 'value' | 'onChange' | 'size' | 'type' | 'children'>;
-export default function SelectFloating({ value, onChange, entries, multiple, placeholder, searchable, clearable, loading, onSearch, maxTagCount, size, virtualized, className, ref, ...rest }: SelectFloatingProps): import("react").JSX.Element;
+export default function SelectFloating({ value, onChange, entries, multiple, placeholder, searchable, clearable, loading, onSearch, maxTagCount, size, virtualized, className, classNames, ref, ...rest }: SelectFloatingProps): import("react").JSX.Element;
 export type { SelectFloatingProps, SelectVirtualizedConfig };

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

@@ -1,5 +1,5 @@
 export { default as Select } from './Select';
-export type { SelectProps } from './Select';
+export type { SelectClassNames, SelectProps } from './Select';
 export { default as SelectCore } from './SelectCore';
 export type { SelectCoreProps } from './SelectCore';
 export { default as Option } from './Option';

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

@@ -0,0 +1,20 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+/**
+ * Collapsed-long-content gate ("show more / less"). The content box is
+ * height-capped while collapsed with a fade at the cut edge; the toggle
+ * button flips the state. Controllable via ControlOrValue<boolean>.
+ */
+type SpoilerProps = {
+    /** Collapsed/expanded state — see useControl (initial boolean). */
+    expanded?: ControlOrValue<boolean>;
+    /** Max height in px of the collapsed content preview. */
+    maxHeight?: number;
+    /** Toggle copy override (defaults to the spoiler locale strings). */
+    showLabel?: string;
+    hideLabel?: string;
+    children: ReactNode;
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children'>;
+export default function Spoiler({ expanded: expandedControl, maxHeight, showLabel, hideLabel, className, children, ...rest }: SpoilerProps): import("react").JSX.Element;
+export type { SpoilerProps };

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

@@ -0,0 +1,2 @@
+export { default as Spoiler } from './Spoiler';
+export type { SpoilerProps } from './Spoiler';

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

@@ -1,4 +1,5 @@
 import type { ReactNode } from 'react';
+import { type TagGroupClassNames } from './TagGroup';
 /**
  * Drag-and-drop reorderable variant of TagGroup — built on @dnd-kit
  * (a haze-ui dependency), so this module statically imports the dnd
@@ -10,6 +11,9 @@ import type { ReactNode } from 'react';
 type SortableTagGroupProps = {
     children: ReactNode;
     className?: string;
+    /** Slot classes — same contract as TagGroup's `classNames`; item-level
+     * keys are inherited by the TagGroupItem children. */
+    classNames?: TagGroupClassNames;
     /**
      * Receives `nextOrder` — the new sequence of original child indices —
      * after a completed drag. Reorder the children you pass accordingly;
@@ -17,5 +21,5 @@ type SortableTagGroupProps = {
      */
     onReorder?: (nextOrder: number[]) => void;
 };
-export default function SortableTagGroup({ children, className, onReorder, }: SortableTagGroupProps): import("react").JSX.Element;
+export default function SortableTagGroup({ children, className, classNames, onReorder, }: SortableTagGroupProps): import("react").JSX.Element;
 export type { SortableTagGroupProps };

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

@@ -1,10 +1,32 @@
 import type { ReactNode } from 'react';
+/** Item-level slot classes flow group → item without prop drilling.
+ * Default `undefined` — the same as no slot classes set anywhere. */
+declare const TagGroupItemClassNamesContext: import("react").Context<TagGroupClassNames | undefined>;
+/**
+ * Semantic slot classes for TagGroup (AntD v6 `classNames` shape; keys
+ * follow the data-slot names). `item`/`removeButton` forward onto every
+ * TagGroupItem child through context, so row-level skins are set once
+ * on the group. A ConfigProvider `TagGroup.classNames` section merges
+ * under the prop, per key.
+ */
+type TagGroupClassNames = {
+    /** The group wrapper (data-slot='tag-group'). */
+    root?: string;
+    /** Every item's chip span (data-slot='tag-group-item'). */
+    item?: string;
+    /** Every item's remove button (data-slot='remove-button'). */
+    removeButton?: string;
+};
 type TagGroupProps = {
     children: ReactNode;
     className?: string;
+    /** Slot classes (see {@link TagGroupClassNames}); item-level keys are
+     * inherited by the TagGroupItem children. */
+    classNames?: TagGroupClassNames;
 };
 /** Plain non-draggable tag row. For drag-and-drop reordering use
  * 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 };
+export default function TagGroup({ children, className, classNames }: TagGroupProps): import("react").JSX.Element;
+export { TagGroupItemClassNamesContext };
+export type { TagGroupClassNames, TagGroupProps };

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

@@ -1,6 +1,6 @@
 export { default as TagGroup } from './TagGroup';
 export { default as TagGroupItem } from './TagGroupItem';
 export { default as SortableTagGroup } from './SortableTagGroup';
-export type { TagGroupProps } from './TagGroup';
+export type { TagGroupClassNames, TagGroupProps } from './TagGroup';
 export type { TagGroupItemProps } from './TagGroupItem';
 export type { SortableTagGroupProps } from './SortableTagGroup';

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

@@ -0,0 +1,4 @@
+import type { ComponentPropsWithoutRef } from 'react';
+type VisuallyHiddenProps = ComponentPropsWithoutRef<'span'>;
+export default function VisuallyHidden({ className, ...rest }: VisuallyHiddenProps): import("react").JSX.Element;
+export type { VisuallyHiddenProps };

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

@@ -0,0 +1,2 @@
+export { default as VisuallyHidden } from './VisuallyHidden';
+export type { VisuallyHiddenProps } from './VisuallyHidden';

package/dist/types/headless/index.d.ts

@@ -17,6 +17,7 @@
  * major version. The primitives still evolve alongside the library's
  * own components, within that contract.
  */
+import { useBusyPressable } from '../hooks/useBusyPressable';
 import { useClickOutside } from '../hooks/useClickOutside';
 import { hotkey, useHotkeys } from '../hooks/useHotkeys';
 import { useInView } from '../hooks/useInView';
@@ -378,6 +379,14 @@ export type { UseInViewOptions } from '../hooks/useInView';
  * get a stable `false` instead of a throw.
  */
 export { useMediaQuery };
+/**
+ * Props bag for a pressable that can enter a busy/loading state —
+ * `disabled` forced while busy, `aria-busy` mirrored. The behavior
+ * half of `Button`'s/`ButtonLink`'s `loading` prop, for consumers
+ * composing their own trigger. Anchors translate `disabled` to
+ * `aria-disabled` (see ButtonLink).
+ */
+export { useBusyPressable };
 /**
  * The value from the previous render; `undefined` on the first.
  * Compared by identity per render — no deep equality.