haze-ui 1.33.0 → 1.34.0

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

@@ -104,6 +104,13 @@ declare const defaultStrings: {
         alpha: string;
         presetsLabel: string;
         recentColors: string;
+        solid: string;
+        gradient: string;
+        angle: string;
+        stopColor: string;
+        stopPosition: string;
+        addStop: string;
+        removeStop: string;
     };
     confirmDialog: {
         confirm: string;
@@ -136,6 +143,10 @@ declare const defaultStrings: {
         expand: string;
         collapse: string;
     };
+    errorBoundary: {
+        title: string;
+        reset: string;
+    };
     fileInput: {
         label: string;
     };
@@ -152,6 +163,10 @@ declare const defaultStrings: {
         reset: string;
         rotate: string;
         close: string;
+        prevImage: string;
+        nextImage: string;
+        counter: string;
+        thumbnail: string;
     };
     inlineEdit: {
         placeholder: string;
@@ -197,6 +212,11 @@ declare const defaultStrings: {
         show: string;
         hide: string;
     };
+    phoneInput: {
+        placeholder: string;
+        countryLabel: string;
+        invalid: string;
+    };
     progress: {
         label: string;
     };

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

@@ -1,4 +1,4 @@
-import type { HazeStrings } from './locale';
+import type { HazeStrings } from './locale.js';
 /**
  * Brazilian Portuguese (pt-BR) copy for every user-visible literal in
  * the library. Not auto-selected by `LocaleProvider`'s `locale` tag

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

@@ -1,4 +1,4 @@
-import type { HazeStrings } from './locale';
+import type { HazeStrings } from './locale.js';
 /**
  * Russian (ru-RU) copy for every user-visible literal in the library.
  * Not auto-selected by `LocaleProvider`'s `locale` tag (only Chinese

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

@@ -1,4 +1,4 @@
-import type { HazeStrings } from './locale';
+import type { HazeStrings } from './locale.js';
 /**
  * Recursive partial of a strings pack: every level is optional down to
  * the leaf messages, so an override names exactly the copy it rewords.

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

@@ -1,4 +1,4 @@
-import type { HazeStrings } from './locale';
+import type { HazeStrings } from './locale.js';
 /**
  * Resolved copy for one component: the section of the built-in pack
  * selected by the provider chain's effective `locale`, layered with

package/dist/types/components/LocaleProvider/zh-cn.d.ts

@@ -1,4 +1,4 @@
-import type { HazeStrings } from './locale';
+import type { HazeStrings } from './locale.js';
 /**
  * Simplified Chinese (zh-CN) copy for every user-visible literal in
  * the library. `LocaleProvider` selects this pack automatically for

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

@@ -1,2 +1,2 @@
-export { default as LogViewer } from './LogViewer';
-export type { LogViewerProps, LogEntry, LogLevel } from './LogViewer';
+export { default as LogViewer } from './LogViewer.js';
+export type { LogViewerProps, LogEntry, LogLevel } from './LogViewer.js';

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

@@ -1,7 +1,7 @@
 import type { ComponentPropsWithoutRef } from 'react';
 type MarkProps = {
-    /** Highlight tone — maps to the semantic status tokens. */
-    color?: 'warning' | 'primary' | 'success' | 'danger';
+    /** Semantic highlight color — maps to the status tokens. */
+    color?: 'default' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
 } & Omit<ComponentPropsWithoutRef<'mark'>, 'color'>;
 /**
  * Text-level highlight — the semantic `<mark>` skinned with the status

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

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

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

@@ -1,2 +1,2 @@
-export { default as MarkdownRenderer } from './MarkdownRenderer';
-export type { MarkdownRendererProps } from './MarkdownRenderer';
+export { default as MarkdownRenderer } from './MarkdownRenderer.js';
+export type { MarkdownRendererProps } from './MarkdownRenderer.js';

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

@@ -0,0 +1,20 @@
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+type MaskedInputProps = {
+    /** Masked display value (`'(123) 456'`); `onChange` fires with the
+     * masked string too — extract the raw content with `unmask`. */
+    value?: ControlOrValue<string>;
+    /** See {@link MaskedInputCoreProps.mask}. */
+    mask: string;
+    size?: 'sm' | 'md' | 'lg';
+    /** See {@link InputCoreProps.leftSection}. */
+    leftSection?: ReactNode;
+    /** See {@link InputCoreProps.rightSection}. */
+    rightSection?: ReactNode;
+    /** Forwarded to the underlying `<input>` — the element form bridges,
+     * tests and `ref.current.focus()` reach. */
+    ref?: Ref<HTMLInputElement>;
+} & Omit<ComponentPropsWithoutRef<'input'>, 'value' | 'size'>;
+/** Input-skinned masked text field — `useControl` sugar over `MaskedInputCore`. */
+export default function MaskedInput({ value: valueControl, mask, size, className, leftSection, rightSection, onChange, ref, ...rest }: MaskedInputProps): import("react").JSX.Element;
+export type { MaskedInputProps };

package/dist/types/components/MaskedInput/MaskedInputCore.d.ts

@@ -0,0 +1,33 @@
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
+type MaskedInputCoreProps = {
+    value: string;
+    onChange: (value: string) => void;
+    /** Native change event passthrough — invoked with the DOM event after
+     * `onChange`, so a spread can never override the controlled callback. */
+    onNativeChange?: ComponentPropsWithoutRef<'input'>['onChange'];
+    /** Mask pattern: `9` digit, `a` letter, `A` letter uppercased, `*`
+     * alphanumeric, any other char a literal, `\\` escapes the next one.
+     * Changing it re-formats the current slot content under the new
+     * pattern. */
+    mask: string;
+    size?: 'sm' | 'md' | 'lg';
+    /** See {@link InputCoreProps.leftSection}. */
+    leftSection?: ReactNode;
+    /** See {@link InputCoreProps.rightSection}. */
+    rightSection?: ReactNode;
+    className?: string;
+    /** Forwarded to the underlying `<input>` — the element form bridges,
+     * tests and `ref.current.focus()` reach. */
+    ref?: Ref<HTMLInputElement>;
+} & Omit<ComponentPropsWithoutRef<'input'>, 'value' | 'onChange' | 'size'>;
+/**
+ * Headless masked text input — the value engine over `InputCore`'s
+ * skin. Every edit is diffed against the committed value and applied
+ * through the pure `applyEdit` engine: rejected input restores the DOM
+ * imperatively (a controlled React input only snaps back on the next
+ * render, and a rejected edit triggers none), accepted edits commit
+ * the masked value and place the caret after the edited character in
+ * the same tick, so jsdom and browsers agree on `selectionStart`.
+ */
+export default function MaskedInputCore({ value, onChange, onNativeChange, mask, size, className, leftSection, rightSection, onKeyDown, onKeyUp, ref, ...rest }: MaskedInputCoreProps): import("react").JSX.Element;
+export type { MaskedInputCoreProps };

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

@@ -0,0 +1,6 @@
+export { default as MaskedInput } from './MaskedInput.js';
+export type { MaskedInputProps } from './MaskedInput.js';
+export { default as MaskedInputCore } from './MaskedInputCore.js';
+export type { MaskedInputCoreProps } from './MaskedInputCore.js';
+export { unmask, formatMask, parseMask, applyEdit } from './mask.js';
+export type { MaskToken, MaskEdit, MaskEditDirection } from './mask.js';

package/dist/types/components/MaskedInput/mask.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Pure mask engine for MaskedInput — parsing, formatting and edit
+ * application are plain functions so the caret algebra is testable
+ * without a DOM.
+ *
+ * Mask syntax: `9` digit, `a` letter, `A` letter (uppercased on
+ * accept), `*` alphanumeric. Any other character is a literal;
+ * `\\` escapes the character after it (a literal `9` is written `\\9`).
+ *
+ * Values are *progressive*: literals render only while a filled slot
+ * still follows them, so a half-typed `(999) 999-9999` field holds
+ * `'(123'`, not `'(123) ____'` — the value string is always exactly
+ * what the user has committed.
+ */
+/** The pattern token kinds; everything else in a mask is a literal. */
+type MaskKind = '9' | 'a' | 'A' | '*';
+export type MaskToken = {
+    type: 'literal';
+    char: string;
+} | {
+    type: 'slot';
+    kind: MaskKind;
+};
+/**
+ * Outcome of applying a browser edit to a masked value. `reject` means
+ * the engine ignored the edit entirely (e.g. a letter into a digit
+ * slot) and the caret should be restored to `caret`; `skip` keeps the
+ * value but moves the caret (typing a literal the mask itself
+ * supplies jumps over it); `edit` produces the next masked value with
+ * the caret placed after the edited character.
+ */
+export type MaskEdit = {
+    type: 'reject';
+    caret: number;
+} | {
+    type: 'skip';
+    caret: number;
+} | {
+    type: 'edit';
+    value: string;
+    caret: number;
+};
+/** Which delete key produced an edit, when the Core could observe it. */
+export type MaskEditDirection = 'backward' | 'forward' | null;
+/** Tokenizes a mask pattern; a trailing lone `\\` is a literal backslash. */
+export declare function parseMask(mask: string): MaskToken[];
+/**
+ * Formats raw slot content into its masked display string. Chars that
+ * do not fit their slot kind are dropped, so formatting a foreign
+ * string (a value set from outside, content from an older mask)
+ * converges to the nearest legal rendering.
+ */
+export declare function formatMask(content: string, mask: string): string;
+/**
+ * Extracts the raw slot content of a masked value — the inverse of
+ * {@link formatMask}. Literals are skipped where present (progressive
+ * values may lack their trailing ones); whatever char sits at a slot
+ * position is taken as that slot's content.
+ */
+export declare function unmask(value: string, mask: string): string;
+/**
+ * Applies one browser edit to a masked value.
+ *
+ * `prev` is the committed masked value, `raw` the string now sitting
+ * in the DOM after the browser applied the user's edit, `caret` the
+ * DOM caret (`selectionStart`) after that edit, and `direction` the
+ * delete key behind a pure-literal deletion (Backspace deletes the
+ * nearest preceding slot char — the react-input-mask convention —
+ * while Delete/Cut restore untouched).
+ *
+ * Inserted chars that fit the next slot are accepted in order (a paste
+ * of several chars fills several slots); chars equal to an upcoming
+ * mask literal skip over it; anything else is dropped as noise. The
+ * returned caret lands after the last edited character.
+ */
+export declare function applyEdit(prev: string, raw: string, caret: number, mask: string, direction?: MaskEditDirection): MaskEdit;
+export {};

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

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

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

@@ -1,6 +1,6 @@
 import type { ComponentPropsWithoutRef, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
-import type { MentionsOption } from './MentionsCore';
+import type { MentionsOption } from './MentionsCore.js';
 type MentionsProps = {
     value?: ControlOrValue<string>;
     onChange?: (value: string) => void;

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

@@ -1,4 +1,4 @@
-export { default as Mentions } from './Mentions';
-export type { MentionsProps } from './Mentions';
-export { default as MentionsCore } from './MentionsCore';
-export type { MentionsCoreProps, MentionsOption } from './MentionsCore';
+export { default as Mentions } from './Mentions.js';
+export type { MentionsProps } from './Mentions.js';
+export { default as MentionsCore } from './MentionsCore.js';
+export type { MentionsCoreProps, MentionsOption } from './MentionsCore.js';

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

@@ -1,6 +1,7 @@
-import type { ReactNode } from 'react';
+import type { ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
-import type { MenuDataItem } from '../../utils/menuItems';
+import type { MenuDataItem } from '../../utils/menuItems.js';
+import type { MenuClassNames } from './MenuContext.js';
 type MenuProps = {
     open?: ControlOrValue<boolean>;
     trigger?: ReactNode;
@@ -11,9 +12,47 @@ type MenuProps = {
      * uses. When passed, it replaces the panel's children.
      */
     items?: MenuDataItem[];
+    /**
+     * Opt-in: render the data-driven `items` list through VirtualList so
+     * thousand-entry menus mount only the visible window (plus overscan)
+     * instead of the full DOM list. `false`/omitted keeps the plain DOM
+     * path byte-for-byte. The keyboard model follows the data — arrows,
+     * Home/End and typeahead reach rows outside the window by scrolling
+     * them in (`scrollToIndex`) and focusing them after the commit.
+     *
+     * Scope (correctness first — fixed-height rows only):
+     * - requires the `items` data API; composed `children` cannot be
+     *   windowed and render through the plain path (dev-only error);
+     * - `group` entries keep their plain path too — group/radio-group
+     *   semantics need the DOM wrapper a windowed row cannot provide
+     *   (dev-only error);
+     * - every remaining entry is a fixed-height row (`item`, `checkbox`,
+     *   `divider`, `sub`); variable-height content is not supported.
+     *   Submenus render as single rows whose panels are plain DOM, so
+     *   nested levels keep full keyboard/typeahead behavior.
+     */
+    virtualized?: boolean;
+    /**
+     * Semantic slot classes (AntD v6 `classNames` shape): declared once
+     * here and distributed to every family part through context (see
+     * {@link MenuClassNames}). Slot classes are appended at the end of
+     * each part's class list; per-part `className` props still land after
+     * the slot class. Not passing it renders identical output. A
+     * ConfigProvider `Menu.classNames` section merges under the prop,
+     * per key.
+     */
+    classNames?: MenuClassNames;
     className?: string;
     children?: ReactNode;
+    /**
+     * Forwarded to the family's root wrapper `<div>`
+     * (`data-slot='menu'`) — the container holding both the trigger area
+     * and the floating panel. The panel itself is a native popover with
+     * its own DOM; reach it through `classNames.panel` styling or panel
+     * queries (`role="menu"`), not this ref.
+     */
+    ref?: Ref<HTMLDivElement>;
 };
-export default function Menu({ open: openControl, trigger, items, className, children, }: MenuProps): import("react").JSX.Element;
+export default function Menu({ open: openControl, trigger, items, virtualized, classNames, className, children, ref, }: MenuProps): import("react").JSX.Element;
 export type { MenuProps };
 export type { MenuDataItem };

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

@@ -0,0 +1,39 @@
+/**
+ * Semantic slot classes (AntD v6 `classNames` shape) for the Menu
+ * family: declared once on `<Menu>` and distributed to every part
+ * through context — one record themes the trigger, the panel and every
+ * item kind while the sub-components stay prop-light. Consumer classes
+ * are appended at the end of each part's class list (able to override
+ * component defaults); per-part `className` props remain for one-off
+ * tweaks and still land after the slot class.
+ */
+export type MenuClassNames = {
+    /** The wrapper `<div>` (`data-slot='menu'`) `<Menu>` renders. */
+    root?: string;
+    /** The trigger area `<span>` (`data-slot='trigger'`). */
+    trigger?: string;
+    /** The floating panel (`role="menu"`, `data-slot='content'`). */
+    panel?: string;
+    /** Every `<MenuItem>` (`data-slot='menu-item'`) — plain and `danger`. */
+    item?: string;
+    /** Every `<MenuCheckboxItem>` (`data-slot='menu-checkbox-item'`). */
+    checkboxItem?: string;
+    /** Every `<MenuRadioItem>` (`data-slot='menu-radio-item'`). */
+    radioItem?: string;
+    /** Group wrappers: `<MenuGroup>` and `<MenuRadioGroup>`
+     *  (`data-slot='group'`). */
+    group?: string;
+    /** Every `<MenuDivider>` (`data-slot='separator'`). */
+    divider?: string;
+    /** Every `<MenuSub>` wrapper (`data-slot='menu-sub'`). */
+    sub?: string;
+    /** Every `<MenuSubTrigger>` (`data-slot='menu-sub-trigger'`). */
+    subTrigger?: string;
+    /** Every `<MenuSubContent>` panel (`role="menu"`). */
+    subContent?: string;
+};
+export declare const MenuClassNamesProvider: import("react").Provider<MenuClassNames | undefined>;
+/** The slot record declared on the nearest `<Menu>`; `undefined`
+ *  outside one. Decorative only — never throws, so items rendered in
+ *  any other host keep working. */
+export declare function useMenuClassNames(): MenuClassNames | undefined;

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

@@ -1,19 +1,20 @@
-export { default as Menu } from './Menu';
-export type { MenuProps, MenuDataItem } from './Menu';
-export { default as MenuItem } from './MenuItem';
-export type { MenuItemProps } from './MenuItem';
-export { default as MenuCheckboxItem } from './MenuCheckboxItem';
-export type { MenuCheckboxItemProps } from './MenuCheckboxItem';
-export { default as MenuRadioGroup } from './MenuRadioGroup';
-export type { MenuRadioGroupProps } from './MenuRadioGroup';
-export { default as MenuRadioItem } from './MenuRadioItem';
-export type { MenuRadioItemProps } from './MenuRadioItem';
-export { default as MenuGroup } from './MenuGroup';
-export type { MenuGroupProps } from './MenuGroup';
-export { default as MenuDivider } from './MenuDivider';
-export { default as MenuSub } from './MenuSub';
-export type { MenuSubProps } from './MenuSub';
-export { default as MenuSubTrigger } from './MenuSubTrigger';
-export type { MenuSubTriggerProps } from './MenuSubTrigger';
-export { default as MenuSubContent } from './MenuSubContent';
-export type { MenuSubContentProps } from './MenuSubContent';
+export { default as Menu } from './Menu.js';
+export type { MenuProps, MenuDataItem } from './Menu.js';
+export type { MenuClassNames } from './MenuContext.js';
+export { default as MenuItem } from './MenuItem.js';
+export type { MenuItemProps } from './MenuItem.js';
+export { default as MenuCheckboxItem } from './MenuCheckboxItem.js';
+export type { MenuCheckboxItemProps } from './MenuCheckboxItem.js';
+export { default as MenuRadioGroup } from './MenuRadioGroup.js';
+export type { MenuRadioGroupProps } from './MenuRadioGroup.js';
+export { default as MenuRadioItem } from './MenuRadioItem.js';
+export type { MenuRadioItemProps } from './MenuRadioItem.js';
+export { default as MenuGroup } from './MenuGroup.js';
+export type { MenuGroupProps } from './MenuGroup.js';
+export { default as MenuDivider } from './MenuDivider.js';
+export { default as MenuSub } from './MenuSub.js';
+export type { MenuSubProps } from './MenuSub.js';
+export { default as MenuSubTrigger } from './MenuSubTrigger.js';
+export type { MenuSubTriggerProps } from './MenuSubTrigger.js';
+export { default as MenuSubContent } from './MenuSubContent.js';
+export type { MenuSubContentProps } from './MenuSubContent.js';

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

@@ -0,0 +1,72 @@
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
+/** One threshold band: at `at` (and above, until the next threshold)
+ * the meter wears `color`. */
+type MeterThreshold = {
+    /** Lower bound of the band, in the same units as `value`/`min`/`max`. */
+    at: number;
+    /** Band color. Omitted keeps the default primary ink (a band that
+     * only re-splits the scale without recoloring). */
+    color?: MeterTone;
+};
+/** The resolved band color — the same six-value semantic axis the
+ * display family exposes as its `color` prop. `primary` when no
+ * threshold band contains the value (or the matching band omitted
+ * its color). */
+type MeterTone = 'default' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
+/** Semantic slot classes for Meter (AntD v6 `classNames` shape; keys
+ * follow the data-slot names). */
+type MeterClassNames = {
+    /** The gauge root (data-slot='meter', role='meter'). */
+    root?: string;
+    /** The label/value header row (data-slot='header'). */
+    header?: string;
+    /** The visible label (data-slot='label'). */
+    label?: string;
+    /** The numeric readout (data-slot='value'). */
+    value?: string;
+    /** The track (data-slot='track'). */
+    track?: string;
+    /** The filled bar (data-slot='bar'). */
+    bar?: string;
+};
+type MeterOwnProps = {
+    /** Current reading, in the same units as `min`/`max` (clamped into
+     * range for both the bar width and `aria-valuenow`). */
+    value: number;
+    /** Lower bound of the scale. Defaults to 0. */
+    min?: number;
+    /** Upper bound of the scale. Defaults to 100. */
+    max?: number;
+    /** Threshold bands coloring the gauge; see {@link MeterThreshold}.
+     * Order is irrelevant — bands are resolved by their `at` bound. */
+    thresholds?: MeterThreshold[];
+    /** Visible label rendered above the gauge and wired to the meter
+     * element via `aria-labelledby` (any ReactNode names the meter). */
+    label?: ReactNode;
+    /** Render the current reading right-aligned in the header row. */
+    showValue?: boolean;
+    /** Track height; the same three steps as Progress. */
+    size?: 'sm' | 'md' | 'lg';
+    /** Slot classes (see {@link MeterClassNames}). */
+    classNames?: MeterClassNames;
+};
+type MeterProps = MeterOwnProps & {
+    className?: string;
+    /** Forwarded to the root element (data-slot='meter'). */
+    ref?: Ref<HTMLDivElement>;
+} & Omit<ComponentPropsWithoutRef<'div'>, keyof MeterOwnProps | 'className' | 'children'>;
+/**
+ * Read-only semantic gauge (React Aria / HeroUI Meter semantics):
+ * a scalar reading on a min–max scale, exposed as `role='meter'` with
+ * `aria-valuenow`/`aria-valuemin`/`aria-valuemax`. Unlike Progress
+ * (task completion) a Meter is a live measurement — CPU load, storage
+ * quota, signal strength — and its `thresholds` bands recolor the
+ * gauge as the value crosses each bound.
+ *
+ * The meter element is the root itself, so a `label` prop wires
+ * `aria-labelledby` to the visible label span; without one, pass
+ * `aria-label` (or any native naming attribute) straight through the
+ * rest props.
+ */
+export default function Meter({ value, min, max, thresholds, label, showValue, size, classNames, className, ref, ...rest }: MeterProps): import("react").JSX.Element;
+export type { MeterClassNames, MeterOwnProps, MeterProps, MeterThreshold, MeterTone };

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

@@ -0,0 +1,3 @@
+export { default as Meter } from './Meter.js';
+export type { MeterProps, MeterOwnProps, MeterClassNames, MeterThreshold, MeterTone, } from './Meter.js';
+export { trackSizes } from './meter-styles.js';

package/dist/types/components/Meter/meter-styles.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared Meter skin — the labeled gauge chrome (root, header row with
+ * label/value, track and bar classes) the `Meter` component wears.
+ * Living in its own module keeps the component file free of style
+ * internals (react-refresh boundary); split-css groups the emitted CSS
+ * into `haze-ui/css/meter.css` with them.
+ *
+ * ## Threshold coloring
+ *
+ * The resolved color rides a `data-color` attribute on the root, track
+ * and bar; the track washes with the color's `-subtle` token while the
+ * bar inks the full color — attribute selectors (not per-color classes)
+ * so consumers can retarget bands with plain `[data-color]` CSS.
+ */
+export declare const root: import("@linaria/core").LinariaClassName;
+export declare const header: import("@linaria/core").LinariaClassName;
+export declare const label: import("@linaria/core").LinariaClassName;
+export declare const value: import("@linaria/core").LinariaClassName;
+export declare const track: import("@linaria/core").LinariaClassName;
+export declare const trackSizes: {
+    readonly sm: import("@linaria/core").LinariaClassName;
+    readonly md: import("@linaria/core").LinariaClassName;
+    readonly lg: import("@linaria/core").LinariaClassName;
+};
+export declare const bar: import("@linaria/core").LinariaClassName;

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

@@ -1,2 +1,2 @@
-export { default as ModelPicker } from './ModelPicker';
-export type { ModelPickerProps, ModelOption } from './ModelPicker';
+export { default as ModelPicker } from './ModelPicker.js';
+export type { ModelPickerProps, ModelOption } from './ModelPicker.js';

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

@@ -1,4 +1,4 @@
-export { default as NavigationBar } from './NavigationBar';
-export { default as NavLink } from './NavLink';
-export type { NavigationBarProps } from './NavigationBar';
-export type { NavLinkProps } from './NavLink';
+export { default as NavigationBar } from './NavigationBar.js';
+export { default as NavLink } from './NavLink.js';
+export type { NavigationBarProps } from './NavigationBar.js';
+export type { NavLinkProps } from './NavLink.js';

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

@@ -0,0 +1,47 @@
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+import type { NavigationMenuClassNames } from './NavigationMenuContext.js';
+type NavigationMenuProps = {
+    /**
+     * The item whose panel is open (its `value`), or `null` when every
+     * panel is closed. Accepts a control (fully controlled) or a plain
+     * value (the uncontrolled default). Uncontrolled menus drive the
+     * value themselves from hover/focus/click; controlled ones still
+     * raise every intent through `onActiveValueChange` — the parent
+     * decides what lands.
+     */
+    activeValue?: ControlOrValue<string | null>;
+    /** Notified on every active-item change, including the null close. */
+    onActiveValueChange?: (value: string | null) => void;
+    /**
+     * Hover dwell (ms) before the FIRST panel opens — moving the pointer
+     * across the bar should not flash panels open. Switching between
+     * panels while one is already open skips this delay entirely.
+     */
+    intentDelay?: number;
+    /**
+     * Pointer grace (ms) after the pointer leaves a trigger or panel —
+     * the diagonal travel to the panel body must not close it. Any
+     * re-enter (trigger or panel) cancels the countdown.
+     */
+    graceDelay?: number;
+    /**
+     * `false` (default) sizes each panel to its content (mega-menu grids,
+     * link columns). `true` stretches the panel to its trigger's inline
+     * size instead (dropdown-like menus under their trigger).
+     */
+    stretchToTrigger?: boolean;
+    /**
+     * Semantic slot classes (AntD v6 `classNames` shape) — see
+     * {@link NavigationMenuClassNames}. Declared once here, distributed
+     * to every part through context.
+     */
+    classNames?: NavigationMenuClassNames;
+    className?: string;
+    /** Forwarded to the root `<nav>` — element access for measurement. */
+    ref?: Ref<HTMLElement>;
+    /** `<NavigationMenuList>` (usually exactly one). */
+    children?: ReactNode;
+} & Omit<ComponentPropsWithoutRef<'nav'>, 'className' | 'children' | 'ref'>;
+export default function NavigationMenu({ activeValue: activeValueControl, onActiveValueChange, intentDelay, graceDelay, stretchToTrigger, classNames, className, ref, children, ...rest }: NavigationMenuProps): import("react").JSX.Element;
+export type { NavigationMenuProps };

package/dist/types/components/NavigationMenu/NavigationMenuContent.d.ts

@@ -0,0 +1,16 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+type NavigationMenuContentProps = {
+    className?: string;
+    /** Any ReactNode: link columns, card grids, plain lists. */
+    children?: ReactNode;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'className' | 'children'>;
+/**
+ * The item's floating panel: anchored under its trigger through the
+ * shared floating engine (native popover + anchor positioning tiers,
+ * JS-positioned fallback), opened only while the item is the menu's
+ * active one. Entering the panel cancels the close grace; leaving arms
+ * it again — unless focus rests inside (a keyboard user reading the
+ * panel keeps it).
+ */
+export default function NavigationMenuContent({ className, children, ...rest }: NavigationMenuContentProps): import("react").JSX.Element;
+export type { NavigationMenuContentProps };