haze-ui 1.26.0 → 1.28.0

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

@@ -0,0 +1,34 @@
+import type { ReactElement, MouseEvent } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+import type { FullscreenTarget } from '../../hooks/useFullscreen';
+type MouseEventEventHandler = (event: MouseEvent<HTMLElement>) => void;
+type FullscreenProps = {
+    /** Whether the target should be fullscreen — control or plain initial value. */
+    fullscreen?: ControlOrValue<boolean>;
+    /** Fires whenever the actual fullscreen state changes (toggle, Esc, …). */
+    onChange?: (fullscreen: boolean) => void;
+    /** Element (or ref) to fullscreen; defaults to the document element. */
+    target?: FullscreenTarget;
+    /** The trigger — its click toggles fullscreen. */
+    children: ReactElement<{
+        onClick?: MouseEventEventHandler;
+    }>;
+};
+/**
+ * Wrap-mode fullscreen: the single child becomes the trigger.
+ *
+ * ```tsx
+ * <Fullscreen target={boxRef}>
+ *   <Button>Maximize</Button>
+ * </Fullscreen>
+ * ```
+ *
+ * The desired state (`fullscreen`) and the browser's actual state are
+ * reconciled both ways: prop writes request/exit the API, and browser-side
+ * changes (including the Esc shortcut) write back and fire `onChange`.
+ * Without the Fullscreen API the trigger stays inert instead of throwing.
+ */
+export default function Fullscreen({ fullscreen: fullscreenControl, onChange, target, children, }: FullscreenProps): ReactElement<{
+    onClick?: MouseEventEventHandler;
+}, string | import("react").JSXElementConstructor<any>>;
+export type { FullscreenProps };

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

@@ -0,0 +1,3 @@
+export { default as Fullscreen } from './Fullscreen';
+export type { FullscreenProps } from './Fullscreen';
+export type { FullscreenTarget, UseFullscreenHandle } from '../../hooks/useFullscreen';

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

@@ -1,11 +1,26 @@
-import type { CSSProperties, ReactNode } from 'react';
+import type { ComponentPropsWithoutRef, CSSProperties, ReactNode } from 'react';
+/**
+ * Preview overlay configuration: absent/false disables the preview; each
+ * flag opts out of one control (default enabled), mirroring antd's
+ * PreviewOperations config.
+ */
+type ImagePreviewConfig = {
+    zoom?: boolean;
+    rotate?: boolean;
+};
 type ImageProps = {
     src: string;
     alt: string;
     fallback?: ReactNode;
     aspectRatio?: string;
     objectFit?: CSSProperties['objectFit'];
-    className?: string;
-};
-export default function Image({ src, alt, fallback, aspectRatio, objectFit, className, }: ImageProps): import("react").JSX.Element;
-export type { ImageProps };
+    /**
+     * Enable the fullscreen click-to-preview overlay (default `false` —
+     * rendering and behavior are unchanged). `true` turns on every control;
+     * an object opts out per control: `zoom: false` drops the zoom
+     * buttons, wheel zoom and drag pan, `rotate: false` the rotate button.
+     */
+    preview?: boolean | ImagePreviewConfig;
+} & Omit<ComponentPropsWithoutRef<'img'>, 'src' | 'alt'>;
+export default function Image({ src, alt, fallback, aspectRatio, objectFit, preview, className, style, onClick, onError, ...rest }: ImageProps): import("react").JSX.Element;
+export type { ImageProps, ImagePreviewConfig };

package/dist/types/components/Image/ImagePreview.d.ts

@@ -0,0 +1,13 @@
+import type { ControlOrValue } from 'react-use-control';
+type ImagePreviewProps = {
+    src: string;
+    alt: string;
+    /** Shared open state — Image passes its control so both ends drive it. */
+    open?: ControlOrValue<boolean>;
+    /** Zoom buttons, wheel zoom and drag pan are available (default true). */
+    zoom?: boolean;
+    /** The rotate control is available (default true). */
+    rotate?: boolean;
+};
+export default function ImagePreview({ src, alt, open: openControl, zoom, rotate, }: ImagePreviewProps): import("react").JSX.Element;
+export type { ImagePreviewProps };

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

@@ -1,2 +1,2 @@
 export { default as Image } from './Image';
-export type { ImageProps } from './Image';
+export type { ImageProps, ImagePreviewConfig } from './Image';

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

@@ -0,0 +1,29 @@
+import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+type InlineCompletionProps = {
+    /** The remaining completion, rendered as ghost text after `value`. */
+    suggestion?: string;
+    value?: ControlOrValue<string>;
+    /** Fired after the suggestion has been accepted into `value` (Tab). */
+    onAccept?: () => void;
+    /** Fired when the active suggestion is dismissed (Escape). */
+    onDismiss?: () => void;
+    /** Render a `<textarea>` host instead of a single-line `<input>`. */
+    multiline?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    /** Screen-reader hint, announced while a suggestion is active.
+     * Default from `inlineCompletion.hint` in the locale packs. */
+    hint?: string;
+    /** Visible rows of the `multiline` host. */
+    rows?: number;
+    /** Native change event passthrough — stays a native handler (Input
+     * sugar contract); the value itself leaves through the `value` control. */
+    onChange?: ComponentPropsWithoutRef<'input'>['onChange'];
+    className?: string;
+    /** Forwarded to the host input/textarea — form bridges and
+     * `ref.current.focus()` reach the focusable element, not the wrapper. */
+    ref?: Ref<HTMLInputElement | HTMLTextAreaElement>;
+} & Omit<ComponentPropsWithoutRef<'input'>, 'value' | 'onChange' | 'size' | 'defaultValue'>;
+export default function InlineCompletion({ suggestion, value: valueControl, onAccept, onDismiss, multiline, placeholder, disabled, hint, rows, className, ref, onChange, onFocus, onBlur, onKeyDown, 'aria-describedby': ariaDescribedby, ...rest }: InlineCompletionProps): import("react").JSX.Element;
+export type { InlineCompletionProps };

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

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

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

@@ -1,8 +1,11 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type InputProps = {
     value?: ControlOrValue<string>;
     size?: 'sm' | 'md' | 'lg';
+    /** 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, ...rest }: InputProps): import("react").JSX.Element;
+export default function Input({ value: valueControl, size, className, 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 } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 type InputCoreProps = {
     value: string;
     onChange: (value: string) => void;
@@ -8,6 +8,8 @@ type InputCoreProps = {
     onNativeChange?: ComponentPropsWithoutRef<'input'>['onChange'];
     size?: 'sm' | 'md' | 'lg';
     className?: string;
+    /** Forwarded to the `<input>` element. */
+    ref?: Ref<HTMLInputElement>;
 } & Omit<ComponentPropsWithoutRef<'input'>, 'value' | 'onChange' | 'size'>;
-export default function InputCore({ value, onChange, onNativeChange, size, className, ...rest }: InputCoreProps): import("react").JSX.Element;
+export default function InputCore({ value, onChange, onNativeChange, size, className, ref, ...rest }: InputCoreProps): import("react").JSX.Element;
 export type { InputCoreProps };

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

@@ -0,0 +1,26 @@
+import type { ComponentPropsWithoutRef } from 'react';
+type MoreLabelFn = (count: number) => string;
+type JsonViewProps = {
+    /** The value to render — any JSON shape (or plain JS value). */
+    data: unknown;
+    /**
+     * Nodes at `depth >= defaultExpandedDepth` start collapsed (the root
+     * is depth 0). Default `Infinity` — everything expanded. Collapsed
+     * state is internal UI state; toggling a node never needs a parent.
+     */
+    defaultExpandedDepth?: number;
+    /** Opt in to the corner copy button (pretty-printed `data`). */
+    copyable?: boolean;
+    /**
+     * Accessible label for the copy button. Default from
+     * `jsonView.copy` in the locale packs.
+     */
+    copyLabel?: string;
+    /**
+     * Formats the "+N more" hint on truncated collections. Default
+     * derives from `jsonView.more` in the locale packs.
+     */
+    moreLabel?: MoreLabelFn;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children'>;
+export default function JsonView({ data, defaultExpandedDepth, copyable, copyLabel, moreLabel, className, ...rest }: JsonViewProps): import("react").JSX.Element;
+export type { JsonViewProps, MoreLabelFn };

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

@@ -0,0 +1,2 @@
+export { default as JsonView } from './JsonView';
+export type { JsonViewProps, MoreLabelFn } from './JsonView';

package/dist/types/components/JsonView/json-view-utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shape tags for the JSON tree renderer. `other` covers non-JSON JS
+ * values (functions, symbols, bigint, Date, RegExp) rendered as leaf
+ * text — robustness for hand-built `data`, since JSON.parse output only
+ * ever produces the first seven kinds.
+ */
+export type JsonValueKind = 'string' | 'number' | 'boolean' | 'null' | 'undefined' | 'array' | 'object' | 'other';
+export declare function getJsonValueKind(value: unknown): JsonValueKind;
+/** Entries of a branch node: `Object.entries` pairs for objects, index
+ * keys for arrays. Leaves (and empty branches) yield `[]`. */
+export declare function jsonEntries(value: unknown): [string, unknown][];
+/** Collections beyond this many entries render only their head plus a
+ * "+N more" hint, keeping huge API payloads cheap to render. */
+export declare const JSON_VIEW_MAX_ENTRIES = 100;
+export type SlicedEntries = {
+    visible: [string, unknown][];
+    hiddenCount: number;
+};
+export declare function sliceEntries(entries: [string, unknown][], max: number): SlicedEntries;
+/** Leaf display text. Strings round-trip through JSON.stringify so the
+ * quotes and any escapes render exactly as they would serialized. */
+export declare function formatJsonLeaf(value: unknown, kind: JsonValueKind): string;

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

@@ -1,3 +1,4 @@
+import type { Direction } from '../../utils/direction';
 import type { HazeStrings } from './locale';
 /** String overrides keyed by component; every level is optional. */
 type HazeStringsOverrides = {
@@ -11,6 +12,14 @@ type HazeStringsOverrides = {
 type LocaleContextValue = {
     /** BCP 47 tag; `useStrings` resolves it to a built-in string pack. */
     locale?: string;
+    /**
+     * Declared writing direction: an explicit `direction` prop on some
+     * provider in the chain, else derived from the resolved locale.
+     * `undefined` only when no provider is mounted. Note this is declared
+     * intent — layout truth stays the DOM's `[dir]` resolution (see
+     * `utils/direction.ts`).
+     */
+    direction?: Direction;
     strings?: HazeStringsOverrides;
     parent?: LocaleContextValue;
 };

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

@@ -9,8 +9,19 @@ type LocaleProviderProps = {
      * of the selected pack.
      */
     locale?: string;
+    /**
+     * Declared writing direction of the subtree. Takes precedence over
+     * everything the chain would otherwise derive: an explicit value on
+     * an outer provider survives inner providers that only narrow the
+     * locale. When nobody declares one, the direction is derived from
+     * the resolved locale (Arabic, Hebrew, Persian, … → 'rtl'). The
+     * provider never writes a `dir` attribute — setting the document's
+     * direction is the app's job; this value only informs library
+     * logic that cannot read the DOM (`useDirection`).
+     */
+    direction?: 'ltr' | 'rtl';
     strings?: HazeStringsOverrides;
     children: ReactNode;
 };
-export default function LocaleProvider({ locale, strings, children, }: LocaleProviderProps): import("react").JSX.Element;
+export default function LocaleProvider({ locale, direction, strings, children, }: LocaleProviderProps): import("react").JSX.Element;
 export type { LocaleProviderProps };

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

@@ -5,3 +5,6 @@ export type { HazeStringsOverrides } from './LocaleContext';
 export { defaultStrings, enUS } from './locale';
 export type { HazeStrings } from './locale';
 export { zhCN } from './zh-cn';
+export { jaJP } from './ja-jp';
+export { createStrings } from './strings';
+export type { DeepPartial } from './strings';

package/dist/types/components/LocaleProvider/ja-jp.d.ts

@@ -0,0 +1,13 @@
+import type { HazeStrings } from './locale';
+/**
+ * Japanese (ja-JP) copy for every user-visible literal in the library.
+ * `LocaleProvider` selects this pack automatically for Japanese BCP 47
+ * tags ('ja', 'ja-JP', 'ja_JP', …).
+ *
+ * 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 jaJP: HazeStrings;
+export { jaJP };

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

@@ -29,10 +29,25 @@ declare const defaultStrings: {
         previousMonth: string;
         nextMonth: string;
         today: string;
+        selectMonth: string;
+        selectQuarter: string;
+        selectYear: string;
+        previousYear: string;
+        nextYear: string;
+        previousDecade: string;
+        nextDecade: string;
+        weekNumber: string;
     };
     cascader: {
         expand: string;
     };
+    combobox: {
+        create: string;
+        noResults: string;
+    };
+    command: {
+        noResults: string;
+    };
     sidebar: {
         toggle: string;
         expand: string;
@@ -60,6 +75,11 @@ declare const defaultStrings: {
         nextSlide: string;
         goToSlide: string;
     };
+    chat: {
+        newMessages: string;
+        stopGeneration: string;
+        copy: string;
+    };
     chatInput: {
         placeholder: string;
         send: string;
@@ -83,6 +103,22 @@ declare const defaultStrings: {
     dateRangePicker: {
         startDate: string;
         endDate: string;
+        presetToday: string;
+        presetYesterday: string;
+        presetLast7Days: string;
+        presetLast30Days: string;
+        presetThisMonth: string;
+        presetLastMonth: string;
+    };
+    datepicker: {
+        time: string;
+    };
+    dataTable: {
+        selectAll: string;
+        filterPlaceholder: string;
+    };
+    diffViewer: {
+        header: string;
     };
     empty: {
         description: string;
@@ -90,9 +126,30 @@ declare const defaultStrings: {
     fileInput: {
         label: string;
     };
+    filePreview: {
+        remove: string;
+        retry: string;
+        uploading: string;
+        uploaded: string;
+        error: string;
+    };
+    image: {
+        zoomIn: string;
+        zoomOut: string;
+        reset: string;
+        rotate: string;
+        close: string;
+    };
     inlineEdit: {
         placeholder: string;
     };
+    inlineCompletion: {
+        hint: string;
+    };
+    jsonView: {
+        copy: string;
+        more: string;
+    };
     logViewer: {
         all: string;
         noLogs: string;
@@ -123,13 +180,39 @@ declare const defaultStrings: {
     progress: {
         label: string;
     };
+    promptInput: {
+        label: string;
+        removeTag: string;
+        noMatch: string;
+        loading: string;
+    };
     rating: {
         star: string;
         stars: string;
     };
+    signature: {
+        clear: string;
+        undo: string;
+        unsupported: string;
+    };
+    select: {
+        placeholder: string;
+        listboxLabel: string;
+        clear: string;
+        searchLabel: string;
+        searchPlaceholder: string;
+        noMatch: string;
+        loading: string;
+        moreTags: string;
+    };
     spinner: {
         loading: string;
     };
+    sources: {
+        label: string;
+        expand: string;
+        collapse: string;
+    };
     tag: {
         remove: string;
     };
@@ -145,6 +228,12 @@ declare const defaultStrings: {
     thinkingIndicator: {
         text: string;
     };
+    toast: {
+        loading: string;
+        success: string;
+        error: string;
+        close: string;
+    };
     tokenCounter: {
         label: string;
     };
@@ -165,9 +254,20 @@ declare const defaultStrings: {
     tree: {
         expand: string;
         collapse: string;
+        loadError: string;
+        retry: string;
+        noMatch: string;
     };
     upload: {
         hint: string;
+        clickHint: string;
+        label: string;
+        retry: string;
+        cancel: string;
+        remove: string;
+        uploading: string;
+        success: string;
+        error: string;
     };
 };
 export type HazeStrings = typeof defaultStrings;

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

@@ -0,0 +1,28 @@
+import type { HazeStrings } from './locale';
+/**
+ * Recursive partial of a strings pack: every level is optional down to
+ * the leaf messages, so an override names exactly the copy it rewords.
+ * For the pack topology (section → message) this is structurally the
+ * provider's `HazeStringsOverrides`; the recursive form keeps it valid
+ * if a section ever grows nested groups.
+ */
+type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+/**
+ * Deep-merges a partial override onto a base string pack, returning a
+ * complete `HazeStrings`. Consumers can derive a customized pack —
+ * "zh-CN with our terminology", "English with brand copy" — without
+ * forking the entire literal set: sections and keys the override does
+ * not name keep the base copy verbatim.
+ *
+ * Neither input is mutated and every section of the result is a fresh
+ * object, so the returned pack is safe to mutate or layer further.
+ * Built on the provider chain instead, a bare partial passed as
+ * `strings` achieves the same layering per component; `createStrings`
+ * is for when you need the resolved pack as a value (sharing it
+ * across providers, persisting it, or translating it wholesale).
+ */
+declare function createStrings(base: HazeStrings, overrides: DeepPartial<HazeStrings>): HazeStrings;
+export { createStrings };
+export type { DeepPartial };

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

@@ -0,0 +1,34 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+/**
+ * Masonry ("Pinterest-style") column layout: children flow into N
+ * equal-width columns and stack independently, so a tall card never
+ * stretches a row of short ones.
+ *
+ * Unlike `Grid` — a uniform two-dimensional grid where cells share row
+ * alignment and each item occupies a rect of equal-height rows —
+ * Masonry aligns items to the *column* only. Nothing is row-aligned:
+ * each column is an independent flex stack.
+ *
+ * Column assignment happens in JS, not CSS multicolumn, for one reason:
+ * CSS `columns` fill vertically (column 1 top-to-bottom, then column 2),
+ * scrambling the reading order of a list. The JS pass distributes
+ * children greedily to the currently-shortest column **in source
+ * order**, so `items[0], items[1], items[2]` read left-to-right as
+ * expected. It is estimation-based (all children assumed equally tall,
+ * which degenerates to round-robin) and never measures the DOM; see
+ * ./masonry-distribute for the height-oracle upgrade path
+ * (`ResizeObserver` per item) — the distribution function already
+ * accepts per-item heights, only the measurement wiring is future work.
+ */
+type MasonryProps = {
+    /** Number of equal-width columns (≥ 1). Responsive breakpoints are a
+     * follow-up; wrap in a container query or render a different
+     * `columns` per breakpoint for now. */
+    columns?: number;
+    /** Vertical and horizontal gutter, as a `--haze-space-*` scale index
+     * (Grid's `gap` convention; default `4` = `--haze-space-4`). */
+    gap?: number;
+    children: ReactNode;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children'>;
+export default function Masonry({ columns, gap, children, className, ...rest }: MasonryProps): import("react").JSX.Element;
+export type { MasonryProps };

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

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

package/dist/types/components/Masonry/masonry-distribute.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Greedy shortest-column distribution for `Masonry`.
+ *
+ * Children are visited in source order (row-major reading preserved:
+ * item `i` lands in column `i % columns` when every estimate is equal,
+ * which is the default) and each is appended to the currently shortest
+ * column — the classic "pack the shortest stack" heuristic that keeps
+ * column heights balanced as estimates diverge.
+ *
+ * This is the estimation-based simplified pass: the height oracle
+ * defaults to a constant, so distribution is stable, SSR-safe and free
+ * of measurement. Feeding real heights (e.g. from a `ResizeObserver`
+ * over mounted items) is a drop-in extension of the same function —
+ * the component documents that upgrade path.
+ */
+export declare function distributeIndices(count: number, columns: number, estimateHeight?: (index: number) => number): number[][];

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

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 import type { MentionsOption } from './MentionsCore';
 type MentionsProps = {
@@ -12,6 +12,9 @@ type MentionsProps = {
     trigger?: string;
     placeholder?: string;
     className?: string;
+    /** Forwarded to the underlying `<textarea>` — the element form bridges
+     * and `ref.current.focus()` reach. */
+    ref?: Ref<HTMLTextAreaElement>;
 } & Omit<ComponentPropsWithoutRef<'textarea'>, 'value' | 'onChange' | 'placeholder' | 'className' | 'style'>;
-export default function Mentions({ value: valueControl, onChange, ...rest }: MentionsProps): import("react").JSX.Element;
+export default function Mentions({ value: valueControl, onChange, ref, ...rest }: MentionsProps): import("react").JSX.Element;
 export type { MentionsProps };

package/dist/types/components/Mentions/MentionsCore.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 export type MentionsOption = {
     /** Text inserted after the trigger character when picked. */
     value: string;
@@ -16,6 +16,8 @@ type MentionsCoreProps = {
     trigger?: string;
     placeholder?: string;
     className?: string;
+    /** Forwarded to the `<textarea>` element. */
+    ref?: Ref<HTMLTextAreaElement>;
 } & Omit<ComponentPropsWithoutRef<'textarea'>, 'value' | 'onChange' | 'placeholder' | 'className' | 'style'>;
-export default function MentionsCore({ value, onChange, options, trigger, placeholder, className, 'aria-label': ariaLabel, ...rest }: MentionsCoreProps): import("react").JSX.Element;
+export default function MentionsCore({ value, onChange, options, trigger, placeholder, className, 'aria-label': ariaLabel, ref, ...rest }: MentionsCoreProps): import("react").JSX.Element;
 export type { MentionsCoreProps };

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

@@ -0,0 +1,18 @@
+import type { ReactNode } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+type MenuSubProps = {
+    /** Whether the submenu is open — controlled control or uncontrolled initial value. */
+    open?: ControlOrValue<boolean>;
+    /** Fires on every open transition, whatever drove it (keyboard, hover, click, light dismiss). */
+    onOpenChange?: (open: boolean) => void;
+    className?: string;
+    /** `<MenuSubTrigger>` followed by `<MenuSubContent>`. */
+    children: ReactNode;
+};
+/**
+ * State container for a nested submenu inside a Menu. Wraps a
+ * MenuSubTrigger + MenuSubContent pair; the open state is controllable
+ * through the standard `ControlOrValue` prop.
+ */
+export default function MenuSub({ open, onOpenChange, className, children, }: MenuSubProps): import("react").JSX.Element;
+export type { MenuSubProps };

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

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+type MenuSubContentProps = {
+    className?: string;
+    children: ReactNode;
+};
+/**
+ * The panel of a MenuSub submenu. Resident like the Menu panel itself
+ * (hidden through the floating lifecycle while closed); keyboard focus
+ * is contained to this level — Escape closes only this submenu.
+ */
+export default function MenuSubContent({ className, children, }: MenuSubContentProps): import("react").JSX.Element;
+export type { MenuSubContentProps };

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

@@ -0,0 +1,14 @@
+import type { ReactNode } from 'react';
+type MenuSubTriggerProps = {
+    disabled?: boolean;
+    className?: string;
+    children: ReactNode;
+};
+/**
+ * The menuitem that opens a MenuSub submenu: hover opens it after a
+ * short intent delay, click toggles, and the inline-end arrow (ArrowRight
+ * in LTR, ArrowLeft under `dir="rtl"`) opens it with focus on its first
+ * item.
+ */
+export default function MenuSubTrigger({ disabled, className, children, }: MenuSubTriggerProps): import("react").JSX.Element;
+export type { MenuSubTriggerProps };

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

@@ -3,3 +3,9 @@ export type { MenuProps } from './Menu';
 export { default as MenuItem } from './MenuItem';
 export type { MenuItemProps } from './MenuItem';
 export { default as MenuDivider } from './MenuDivider';
+export { default as MenuSub } from './MenuSub';
+export type { MenuSubProps } from './MenuSub';
+export { default as MenuSubTrigger } from './MenuSubTrigger';
+export type { MenuSubTriggerProps } from './MenuSubTrigger';
+export { default as MenuSubContent } from './MenuSubContent';
+export type { MenuSubContentProps } from './MenuSubContent';

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

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type NumberInputProps = {
     value?: ControlOrValue<number>;
@@ -6,6 +6,9 @@ type NumberInputProps = {
     max?: number;
     step?: number;
     size?: 'sm' | 'md' | 'lg';
+    /** Forwarded to the inner number `<input>` (not the wrapper div) —
+     * the element form bridges and `ref.current.focus()` reach. */
+    ref?: Ref<HTMLInputElement>;
 } & Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'value' | 'size'>;
-export default function NumberInput({ value: valueControl, min, max, step, size, className, onChange, ...rest }: NumberInputProps): import("react").JSX.Element;
+export default function NumberInput({ value: valueControl, min, max, step, size, className, onChange, ref, ...rest }: NumberInputProps): import("react").JSX.Element;
 export type { NumberInputProps };