haze-ui 1.26.0 → 1.28.0

package/dist/types/components/NumberInput/NumberInputCore.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 type NumberInputCoreProps = {
     value: number;
     onChange: (value: number) => void;
@@ -10,6 +10,8 @@ type NumberInputCoreProps = {
     step?: number;
     size?: 'sm' | 'md' | 'lg';
     className?: string;
+    /** Forwarded to the inner number `<input>` (not the wrapper div). */
+    ref?: Ref<HTMLInputElement>;
 } & Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'value' | 'onChange' | 'size'>;
-export default function NumberInputCore({ value, onChange, onNativeChange, min, max, step, size, className, ...rest }: NumberInputCoreProps): import("react").JSX.Element;
+export default function NumberInputCore({ value, onChange, onNativeChange, min, max, step, size, className, ref, ...rest }: NumberInputCoreProps): import("react").JSX.Element;
 export type { NumberInputCoreProps };

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

@@ -1,9 +1,13 @@
+import type { Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type OTPInputProps = {
     length?: number;
     value?: ControlOrValue<string>;
     onChange?: (value: string) => void;
     className?: string;
+    /** Forwarded to the first cell's `<input>` — the element form bridges
+     * and `ref.current.focus()` reach. */
+    ref?: Ref<HTMLInputElement>;
 };
-export default function OTPInput({ length, value: valueControl, onChange, className, }: OTPInputProps): import("react").JSX.Element;
+export default function OTPInput({ length, value: valueControl, onChange, className, ref, }: OTPInputProps): import("react").JSX.Element;
 export type { OTPInputProps };

package/dist/types/components/OTPInput/OTPInputCore.d.ts

@@ -1,8 +1,11 @@
+import type { Ref } from 'react';
 type OTPInputCoreProps = {
     length?: number;
     value: string;
     onChange: (value: string) => void;
     className?: string;
+    /** Forwarded to the first cell's `<input>`. */
+    ref?: Ref<HTMLInputElement>;
 };
-export default function OTPInputCore({ length, value, onChange, className, }: OTPInputCoreProps): import("react").JSX.Element;
+export default function OTPInputCore({ length, value, onChange, className, ref, }: OTPInputCoreProps): import("react").JSX.Element;
 export type { OTPInputCoreProps };

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

@@ -1,3 +1,4 @@
+import type { Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type PasswordInputProps = {
     value?: ControlOrValue<string>;
@@ -5,6 +6,9 @@ type PasswordInputProps = {
     placeholder?: string;
     disabled?: boolean;
     className?: string;
+    /** Forwarded to the inner password `<input>` (not the wrapper div) —
+     * the element form bridges and `ref.current.focus()` reach. */
+    ref?: Ref<HTMLInputElement>;
 };
-export default function PasswordInput({ value: valueControl, onChange, placeholder, disabled, className, }: PasswordInputProps): import("react").JSX.Element;
+export default function PasswordInput({ value: valueControl, onChange, placeholder, disabled, className, ref, }: PasswordInputProps): import("react").JSX.Element;
 export type { PasswordInputProps };

package/dist/types/components/PasswordInput/PasswordInputCore.d.ts

@@ -1,9 +1,12 @@
+import type { Ref } from 'react';
 type PasswordInputCoreProps = {
     value: string;
     onChange: (value: string) => void;
     placeholder?: string;
     disabled?: boolean;
     className?: string;
+    /** Forwarded to the inner password `<input>` (not the wrapper div). */
+    ref?: Ref<HTMLInputElement>;
 };
-export default function PasswordInputCore({ value, onChange, placeholder, disabled, className, }: PasswordInputCoreProps): import("react").JSX.Element;
+export default function PasswordInputCore({ value, onChange, placeholder, disabled, className, ref, }: PasswordInputCoreProps): import("react").JSX.Element;
 export type { PasswordInputCoreProps };

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

@@ -1,6 +1,36 @@
-import type { ReactNode } from 'react';
+import type { ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 import type { CollisionPadding } from '../../utils/collision';
+/**
+ * Imperative handle exposed through the React 19 `ref` prop (same API
+ * choice as VirtualList). `open`/`close` are state writes going through
+ * the same `useFloating` path as the trigger's own clicks — the popover
+ * visibility, animated exit and the toggle-echo reconciliation in the
+ * floating engine stay in charge; the handle never calls
+ * `showPopover`/`hidePopover` directly.
+ */
+type PopoverHandle = {
+    /** Show the popover, as if the trigger toggled it open. */
+    open: () => void;
+    /** Close the popover through the animated exit path. */
+    close: () => void;
+    /** Focus the trigger element. */
+    focusTrigger: () => void;
+};
+/**
+ * Semantic slot classes (AntD v6 `classNames` shape): consumer classes
+ * appended at the end of each part's class list (able to override
+ * component defaults). Popover has exactly two structural parts:
+ *
+ * - `trigger` — the clickable wrapper around `children`
+ * - `content` — the floating panel
+ */
+type PopoverClassNames = {
+    /** The trigger wrapper (the `role="button"` span around `children`). */
+    trigger?: string;
+    /** The floating panel. */
+    content?: string;
+};
 type PopoverProps = {
     content: ReactNode;
     open?: ControlOrValue<boolean>;
@@ -9,8 +39,16 @@ type PopoverProps = {
      * to all four edges, an object per edge.
      */
     collisionPadding?: CollisionPadding;
+    /**
+     * Semantic slot classes (AntD v6 `classNames` shape) — see
+     * {@link PopoverClassNames}. `classNames.content` lands after the
+     * panel's `className` prop; `classNames.trigger` has no default class
+     * to fight with. Omitting it changes nothing.
+     */
+    classNames?: PopoverClassNames;
     className?: string;
     children: ReactNode;
+    ref?: Ref<PopoverHandle>;
 };
-export default function Popover({ content, open: openControl, collisionPadding, className, children, }: PopoverProps): import("react").JSX.Element;
-export type { PopoverProps };
+export default function Popover({ content, open: openControl, collisionPadding, classNames, className, children, ref, }: PopoverProps): import("react").JSX.Element;
+export type { PopoverProps, PopoverHandle, PopoverClassNames };

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

@@ -1,2 +1,2 @@
 export { default as Popover } from './Popover';
-export type { PopoverProps } from './Popover';
+export type { PopoverProps, PopoverHandle, PopoverClassNames } from './Popover';

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

@@ -0,0 +1,46 @@
+import type { ComponentPropsWithoutRef } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+type PromptInputProps = {
+    /** Free-form draft text. */
+    value?: ControlOrValue<string>;
+    /** Value callback fired on every text edit (same value the control gets). */
+    onChange?: (value: string) => void;
+    /**
+     * Inline removable tags rendered before the text (context attachments
+     * for the prompt). They are never consumed by submit — removal is the
+     * only mutation the component performs.
+     */
+    tags?: ControlOrValue<string[]>;
+    /** Value callback fired when a tag is removed. */
+    onTagsChange?: (tags: string[]) => void;
+    /**
+     * Trigger characters that open the suggestion listbox while typing.
+     * Defaults to `['@']`. Inert without `getSuggestions`.
+     */
+    triggers?: string[];
+    /**
+     * Suggestions for the token at the caret: called with the trigger
+     * character and the text typed after it. Async responses are applied
+     * in request order — a stale response is discarded once a newer
+     * request has been issued.
+     */
+    getSuggestions?: (trigger: string, query: string) => string[] | Promise<string[]>;
+    /**
+     * Fired when the submit key is pressed with non-empty text; the draft
+     * clears afterwards (tags stay). Enter still commits a highlighted
+     * suggestion first while the listbox is open.
+     */
+    onSubmit?: () => void;
+    /**
+     * `'enter'` (default): Enter submits, Shift+Enter inserts a newline.
+     * `'mod-enter'`: only Ctrl/Cmd+Enter submits, plain Enter newlines.
+     */
+    submitKey?: 'enter' | 'mod-enter';
+    placeholder?: string;
+    disabled?: boolean;
+    /** Auto-grow cap in text rows; beyond it the textarea scrolls. */
+    maxRows?: number;
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'textarea'>, 'value' | 'onChange' | 'placeholder' | 'className' | 'style' | 'rows'>;
+export default function PromptInput({ value: valueControl, onChange, tags: tagsControl, onTagsChange, triggers, getSuggestions, onSubmit, submitKey, placeholder, disabled, maxRows, className, 'aria-label': ariaLabel, ...rest }: PromptInputProps): import("react").JSX.Element;
+export type { PromptInputProps };

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

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

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

@@ -1,8 +1,11 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 type RadioProps = {
     value: string;
+    /** Forwarded to the radio `<input>` (not the label wrapper) — form
+     * bridges and `ref.current.focus()` reach. */
+    ref?: Ref<HTMLInputElement>;
 } & Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'value' | 'name' | 'checked' | 'onChange'>;
-export default function Radio({ value, className, children, ...rest }: RadioProps & {
+export default function Radio({ value, className, children, ref, ...rest }: RadioProps & {
     children?: React.ReactNode;
 }): import("react").JSX.Element;
 export type { RadioProps };

package/dist/types/components/Radio/RadioGroup.d.ts

@@ -1,10 +1,16 @@
-import type { ReactNode } from 'react';
+import type { ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type RadioGroupProps = {
     value?: ControlOrValue<string>;
     name?: string;
     className?: string;
     children: ReactNode;
+    /**
+     * Forwarded to the group's focus target — the checked radio `<input>`
+     * (falling back to the first), matching where a browser Tab lands —
+     * so form bridges and `ref.current.focus()` reach the group.
+     */
+    ref?: Ref<HTMLInputElement>;
 };
-export default function RadioGroup({ value: valueControl, name, className, children, }: RadioGroupProps): import("react").JSX.Element;
+export default function RadioGroup({ value: valueControl, name, className, children, ref, }: RadioGroupProps): import("react").JSX.Element;
 export type { RadioGroupProps };

package/dist/types/components/Radio/RadioGroupCore.d.ts

@@ -1,10 +1,15 @@
-import type { ReactNode } from 'react';
+import type { ReactNode, Ref } from 'react';
 type RadioGroupCoreProps = {
     value: string;
     onChange: (value: string) => void;
     name?: string;
     className?: string;
     children: ReactNode;
+    /**
+     * Forwarded to the group's focus target — the checked radio `<input>`
+     * (falling back to the first), matching where a browser Tab lands.
+     */
+    ref?: Ref<HTMLInputElement>;
 };
-export default function RadioGroupCore({ value, onChange, name, className, children, }: RadioGroupCoreProps): import("react").JSX.Element;
+export default function RadioGroupCore({ value, onChange, name, className, children, ref, }: RadioGroupCoreProps): import("react").JSX.Element;
 export type { RadioGroupCoreProps };

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

@@ -1,3 +1,4 @@
+import type { Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type RatingProps = {
     value?: ControlOrValue<number>;
@@ -5,6 +6,12 @@ type RatingProps = {
     allowHalf?: boolean;
     onChange?: (value: number) => void;
     className?: string;
+    /**
+     * Forwarded to the group's focus target — the star that is the roving
+     * tab stop (the current rating, or the first star) — so form bridges
+     * and `ref.current.focus()` reach the group.
+     */
+    ref?: Ref<HTMLSpanElement>;
 };
-export default function Rating({ value: valueControl, count, allowHalf, onChange, className, }: RatingProps): import("react").JSX.Element;
+export default function Rating({ value: valueControl, count, allowHalf, onChange, className, ref, }: RatingProps): import("react").JSX.Element;
 export type { RatingProps };

package/dist/types/components/Rating/RatingCore.d.ts

@@ -1,9 +1,15 @@
+import type { Ref } from 'react';
 type RatingCoreProps = {
     value: number;
     onChange: (value: number) => void;
     count?: number;
     allowHalf?: boolean;
     className?: string;
+    /**
+     * Forwarded to the group's focus target — the star that is the roving
+     * tab stop (the current rating, or the first star).
+     */
+    ref?: Ref<HTMLSpanElement>;
 };
-export default function RatingCore({ value, onChange, count, allowHalf, className, }: RatingCoreProps): import("react").JSX.Element;
+export default function RatingCore({ value, onChange, count, allowHalf, className, ref, }: RatingCoreProps): import("react").JSX.Element;
 export type { RatingCoreProps };

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

@@ -1,2 +1,4 @@
 export { ResizableGroup, ResizablePanel, ResizableHandle } from './Resizable';
 export type { ResizableGroupProps, ResizablePanelProps, ResizableHandleProps } from './Resizable';
+export { ResizableGroup as SplitterGroup, ResizablePanel as SplitterPanel, ResizableHandle as SplitterHandle, } from './Resizable';
+export type { ResizableGroupProps as SplitterGroupProps, ResizablePanelProps as SplitterPanelProps, ResizableHandleProps as SplitterHandleProps, } from './Resizable';

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

@@ -1,3 +1,4 @@
+import type { Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 import type { SegmentedOption } from './SegmentedCore';
 type SegmentedProps = {
@@ -6,6 +7,12 @@ type SegmentedProps = {
     onChange?: (value: string) => void;
     size?: 'sm' | 'md' | 'lg';
     className?: string;
+    /**
+     * Forwarded to the group's focus target — the selected option's
+     * `<button>` (falling back to the first) — so form bridges and
+     * `ref.current.focus()` reach the group.
+     */
+    ref?: Ref<HTMLButtonElement>;
 };
-export default function Segmented({ options, value: valueControl, onChange, size, className, }: SegmentedProps): import("react").JSX.Element;
+export default function Segmented({ options, value: valueControl, onChange, size, className, ref, }: SegmentedProps): import("react").JSX.Element;
 export type { SegmentedProps, SegmentedOption };

package/dist/types/components/Segmented/SegmentedCore.d.ts

@@ -1,4 +1,4 @@
-import type { ReactNode } from 'react';
+import type { ReactNode, Ref } from 'react';
 type SegmentedOption = string | {
     value: string;
     label: ReactNode;
@@ -10,6 +10,11 @@ type SegmentedCoreProps = {
     onChange: (value: string) => void;
     size?: 'sm' | 'md' | 'lg';
     className?: string;
+    /**
+     * Forwarded to the group's focus target — the selected option's
+     * `<button>` (falling back to the first).
+     */
+    ref?: Ref<HTMLButtonElement>;
 };
-export default function SegmentedCore({ options, value, onChange, size, className, }: SegmentedCoreProps): import("react").JSX.Element;
+export default function SegmentedCore({ options, value, onChange, size, className, ref, }: SegmentedCoreProps): import("react").JSX.Element;
 export type { SegmentedCoreProps, SegmentedOption };

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

@@ -0,0 +1,16 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+type OptionGroupProps = {
+    /** Group heading. Renders as the native `<optgroup label>` in the
+     * single-select path and as a `role="group"` heading in the
+     * multiple/searchable listbox path. */
+    label: string;
+    children: ReactNode;
+} & Omit<ComponentPropsWithoutRef<'optgroup'>, 'label'>;
+/**
+ * Labels a cluster of options inside a Select. In single mode it is a
+ * plain native `<optgroup>`; the multiple/searchable floating listbox
+ * extracts the same structure and renders it as `role="group"` with a
+ * heading, keyboard navigation running continuously across groups.
+ */
+export default function OptionGroup({ label, children, ...rest }: OptionGroupProps): import("react").JSX.Element;
+export type { OptionGroupProps };

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

@@ -1,9 +1,83 @@
-import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
+import type { SelectVirtualizedConfig } from './SelectFloating';
 type SelectProps = {
-    value?: ControlOrValue<string>;
+    /** `string` in single mode, `string[]` when `multiple` is set. */
+    value?: ControlOrValue<string | string[]>;
+    /**
+     * Multiple selection mode (see SelectCoreProps.multiple). The
+     * uncontrolled empty value is `[]` in this mode, `''` otherwise.
+     */
+    multiple?: boolean;
+    /**
+     * Searchable single select (see SelectCoreProps.searchable): swaps
+     * the native `<select>` for the floating listbox with a panel-top
+     * search input — typing filters, ↑/↓ highlight, Enter picks, Escape
+     * closes. In multiple mode the same search input appears in the
+     * listbox panel instead.
+     */
+    searchable?: boolean;
+    /**
+     * Clear affordance (see SelectCoreProps.clearable): a pointer-only ×
+     * revealed on hover/focus-within empties the value (`[]` / `''`)
+     * without toggling the panel; Backspace is the keyboard parity path.
+     */
+    clearable?: boolean;
+    /**
+     * Async option state (see SelectCoreProps.loading): the floating
+     * panel's options area shows a Spinner with `aria-busy="true"` and
+     * suspends search filtering until it clears.
+     */
+    loading?: boolean;
+    /**
+     * Remote search (see SelectCoreProps.onSearch): with `onSearch` set,
+     * the floating panel stops filtering locally — options are entirely
+     * what the consumer passes as children — and every query transition
+     * of the panel's search input fires this callback (empty queries
+     * included, so the consumer can restore the full list; the reset on
+     * panel close reports `''` too). Pair with `loading` for the pending
+     * state; debouncing is the consumer's concern. Requires `searchable`
+     * (the only paths with a search input); the plain native single
+     * select has no query source and ignores it.
+     */
+    onSearch?: (query: string) => void;
+    /**
+     * Multiple mode only (see SelectCoreProps.maxTagCount): cap the
+     * rendered Chips; the overflow collapses into a `+N` badge whose
+     * `title` lists the hidden labels.
+     */
+    maxTagCount?: number;
+    /**
+     * Render the floating option list through VirtualList so long option
+     * lists mount only the visible window (plus overscan). Default
+     * (omitted/`false`) keeps the plain DOM path; single mode without
+     * `searchable` ignores it — the native `<select>` handles long lists
+     * natively.
+     */
+    virtualized?: boolean | SelectVirtualizedConfig;
+    /**
+     * Value callback for both modes: `string` in single mode, `string[]`
+     * when `multiple` is set — fired after the value updates. The native
+     * select `change` event stays available through `onChange` in single
+     * mode (the historical contract); the floating paths have no native
+     * event.
+     */
+    onValuesChange?: (value: string | string[]) => void;
+    /**
+     * Placeholder text for the floating triggers (falls back to the
+     * `select.placeholder` locale string). A native `<select>` has no
+     * placeholder attribute, so plain single mode consumes and drops it.
+     */
+    placeholder?: string;
     size?: 'sm' | 'md' | 'lg';
+    /**
+     * Forwarded to the focusable element — the native `<select>` in plain
+     * and clearable single mode, the trigger `<button>` when `multiple`
+     * or `searchable` render the floating engine. Form bridges and
+     * `ref.current.focus()` reach whichever mode renders.
+     */
+    ref?: Ref<HTMLSelectElement | HTMLButtonElement>;
     children: ReactNode;
-} & Omit<ComponentPropsWithoutRef<'select'>, 'value' | 'size'>;
-export default function Select({ value: valueControl, size, className, children, onChange, ...rest }: SelectProps): import("react").JSX.Element;
+} & 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 };

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

@@ -1,13 +1,86 @@
-import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
+import type { SelectVirtualizedConfig } from './SelectFloating';
 type SelectCoreProps = {
-    value: string;
-    onChange: (value: string) => void;
+    /** `string` in single mode, `string[]` when `multiple` is set. */
+    value: string | string[];
+    /** Notifies the next value: `string` in single mode, `string[]` when
+     * `multiple` is set. */
+    onChange: (value: string | string[]) => void;
     /** Native change event passthrough — invoked with the DOM event after
-     * `onChange`, so a spread can never override the controlled callback. */
+     * `onChange`, so a spread can never override the controlled callback.
+     * Single mode only; the floating paths have no native select element. */
     onNativeChange?: ComponentPropsWithoutRef<'select'>['onChange'];
+    /**
+     * Placeholder for the floating triggers (falls back to the
+     * `select.placeholder` locale string). A native `<select>` has no
+     * placeholder attribute, so the plain single mode consumes and drops
+     * it — single mode with `searchable` renders it like the multiple
+     * trigger does.
+     */
+    placeholder?: string;
+    /**
+     * Multiple selection mode: the native `<select>` is replaced by a
+     * button trigger rendering the selected values as removable Chips,
+     * opening a floating multi-select listbox. Default (`false`) keeps
+     * the native single-select path untouched.
+     */
+    multiple?: boolean;
+    /**
+     * Swap the single-mode native `<select>` for the floating listbox
+     * engine (the one `multiple` uses) with a search input at the top of
+     * the panel: typing filters the options, ↑/↓ move the highlight,
+     * Enter picks and closes, Escape closes. `multiple` ignores it — the
+     * multiple listbox gains the same search input instead. Default
+     * (`false`) keeps the native `<select>` untouched.
+     */
+    searchable?: boolean;
+    /**
+     * Show a pointer-only × clear affordance at the trigger's inline end
+     * while a value is selected (revealed on hover/focus-within; keyboard
+     * parity through Backspace on the trigger). Clicking it empties the
+     * value (`[]` / `''`) without toggling the panel. Works in every
+     * mode — on the plain single-select path the × overlays the select's
+     * caret slot instead of the floating trigger.
+     */
+    clearable?: boolean;
+    /**
+     * Async option state for the floating paths: the options area shows a
+     * Spinner with `aria-busy="true"` on the panel, and search filtering
+     * is suspended until loading finishes. The plain single-mode native
+     * `<select>` ignores it (a native select cannot render async state).
+     */
+    loading?: boolean;
+    /**
+     * Remote search for the floating paths (see SelectFloatingProps.onSearch):
+     * while set, local query filtering is suspended — options are entirely
+     * whatever arrives through `children` — and every query transition of
+     * the panel's search input is reported here, empty queries included
+     * (the consumer restores the full list). The plain single-mode native
+     * `<select>` path has no query source and ignores it.
+     */
+    onSearch?: (query: string) => void;
+    /**
+     * Multiple mode only: render at most this many value Chips in the
+     * trigger; the rest collapse into a `+N` badge whose `title` tooltip
+     * lists the overflow labels. Selection semantics are unchanged.
+     */
+    maxTagCount?: number;
     size?: 'sm' | 'md' | 'lg';
+    /**
+     * Render the floating option list through VirtualList so long option
+     * lists mount only the visible window (plus overscan). Default
+     * (omitted/`false`) keeps the plain DOM path; the plain single-mode
+     * native `<select>` ignores it — it handles long lists natively.
+     */
+    virtualized?: boolean | SelectVirtualizedConfig;
     children: ReactNode;
     className?: string;
-} & Omit<ComponentPropsWithoutRef<'select'>, 'value' | 'onChange' | 'size'>;
-export default function SelectCore({ value, onChange, onNativeChange, size, className, children, ...rest }: SelectCoreProps): import("react").JSX.Element;
+    /**
+     * Forwarded to the focusable element — the native `<select>` in plain
+     * and clearable single mode, the trigger `<button>` when `multiple`
+     * or `searchable` render the floating engine.
+     */
+    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 type { SelectCoreProps };

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

@@ -0,0 +1,94 @@
+import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { SelectEntryData } from './select-options';
+/** Metrics override for the `virtualized` option list of the floating
+ * Select paths (multiple, or single with `searchable`). */
+type SelectVirtualizedConfig = {
+    /**
+     * Row height in px of one option row. Defaults to 29 — the measured
+     * natural box of an option row: space-1 padding top+bottom (4+4) plus
+     * the taller of the text-sm line box (21px at leading-normal) and the
+     * 1.125rem visual checkbox (18px). Virtualization math needs it as a
+     * JS number; rows are stretched to fill it (`virtualRow`), so the two
+     * cannot drift apart.
+     */
+    itemHeight?: number;
+    /** Extra rows kept mounted above/below the visible window. Defaults
+     * to VirtualList's 5. */
+    overscan?: number;
+};
+type SelectFloatingProps = {
+    /**
+     * Current selection — `string[]` in multiple mode, `string` in single
+     * mode. A stray value of the other shape is normalized (empty
+     * selection / empty value) rather than crashing.
+     */
+    value: string | string[];
+    /**
+     * Notifies the next value: `string[]` in multiple mode, `string` in
+     * single mode — the single-mode option pick also closes the panel.
+     */
+    onChange: (value: string | string[]) => void;
+    /** Extracted <Option>/<option>/<OptionGroup> children of the owning
+     * Select, grouping structure preserved. */
+    entries: SelectEntryData[];
+    /** Multiple selection mode: chips in the trigger, toggling options,
+     * panel stays open across picks. Single mode closes on pick. */
+    multiple: boolean;
+    /** Falls back to the `select.placeholder` locale string. */
+    placeholder?: string;
+    size?: 'sm' | 'md' | 'lg';
+    /**
+     * Render a search input at the top of the panel that filters the
+     * options (case-insensitive substring over the label text). Typing
+     * filters and auto-highlights the first match; ↑/↓ move the
+     * highlight, Enter picks it, Escape closes. The input is focused
+     * when the panel opens.
+     */
+    searchable?: boolean;
+    /**
+     * Show a pointer-only × clear affordance at the trigger's inline end
+     * while a value is selected (revealed on hover/focus-within).
+     * Clicking it empties the value (`[]` / `''`) without toggling the
+     * panel and keeps focus on the trigger. Keyboard parity: Backspace on
+     * the single-mode trigger clears the value; multiple mode keeps
+     * Backspace removing the last chip.
+     */
+    clearable?: boolean;
+    /**
+     * Async option state: the options area shows a Spinner with
+     * `aria-busy="true"` on the panel instead of the list, and search
+     * filtering is skipped (an empty result while loading would be a
+     * lie). Keyboard navigation is inert until loading finishes.
+     */
+    loading?: boolean;
+    /**
+     * Remote search: while set, local query filtering is suspended — the
+     * panel renders exactly the options received through `entries`, and
+     * every query transition of the panel's search input is reported
+     * here instead: each keystroke, clearing the field, and the reset
+     * back to `''` when the panel closes (so the consumer can restore
+     * the full list before the next open). The consumer owns the
+     * options end to end; pair with `loading` for the pending state.
+     * Debouncing is the consumer's concern.
+     */
+    onSearch?: (query: string) => void;
+    /**
+     * Multiple mode only: render at most this many chips; the rest
+     * collapse into a `+N` badge whose `title` tooltip lists the
+     * overflow labels. Selection semantics are unchanged — the badge is
+     * presentational.
+     */
+    maxTagCount?: number;
+    /**
+     * Render the options list through VirtualList so thousand-option
+     * listboxes mount only the visible window (plus overscan) instead of
+     * the full DOM list. `false`/omitted (default) keeps the plain DOM
+     * path byte-for-byte; an object additionally customizes row metrics.
+     */
+    virtualized?: boolean | SelectVirtualizedConfig;
+    className?: string;
+    /** 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 type { SelectFloatingProps, SelectVirtualizedConfig };

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

@@ -4,3 +4,5 @@ export { default as SelectCore } from './SelectCore';
 export type { SelectCoreProps } from './SelectCore';
 export { default as Option } from './Option';
 export type { OptionProps } from './Option';
+export { default as OptionGroup } from './OptionGroup';
+export type { OptionGroupProps } from './OptionGroup';