haze-ui 1.33.0 → 1.34.0

package/dist/types/components/Tabs/TabPanel.d.ts

@@ -4,5 +4,5 @@ type TabPanelProps = {
     className?: string;
     children: ReactNode;
 };
-export default function TabPanel({ value, className, children, }: TabPanelProps): import("react").JSX.Element;
+export default function TabPanel({ value, className, children, }: TabPanelProps): import("react").JSX.Element | null;
 export type { TabPanelProps };

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

@@ -1,8 +1,71 @@
-import type { ReactNode } from 'react';
+import type { ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
-import type { TabsClassNames } from './TabsContext';
+import type { TabsClassNames, TabsVariant, TabsAddable } from './TabsContext.js';
+import type { TabStatus } from './Tab.js';
+/**
+ * One tab of the data-driven `items` API on `<Tabs>`: the same affordances
+ * a compound `<Tab>` + `<TabPanel>` pair would declare, flattened into a
+ * record. `panel` is the tab's content — the panel always renders (even
+ * without `panel`) so the tab's `aria-controls` target never dangles.
+ */
+type TabData = {
+    value: string;
+    label: ReactNode;
+    icon?: ReactNode;
+    /** Inert tab: not clickable, not focusable, skipped by the roving
+     *  model — surfaced on the compound layer as Tab's `disabled`. */
+    disabled?: boolean;
+    /** Renders the × close affordance (purely visual on this path — the
+     *  notifying `onClose` lives on the compound `<Tab>`). */
+    closable?: boolean;
+    status?: TabStatus;
+    panel?: ReactNode;
+};
 type TabsProps = {
     value?: ControlOrValue<string>;
+    /**
+     * Visual skin of the whole strip, distributed through context:
+     * `line` (default — the classic underline strip, full-width
+     * separator), `card` (flat antd-style cards, the selected tab
+     * raising onto a bordered surface) or `pill` (the Segmented-style
+     * capsule). Omitting it keeps the line look byte-for-byte.
+     */
+    variant?: TabsVariant;
+    /**
+     * Data-driven mode: renders the `<TabList>` (one `<Tab>` per item)
+     * and every `<TabPanel>` for you — the strip keeps the full
+     * compound machinery (overflow folding, roving keyboard,
+     * ResizeObserver compression) because it is the same `<TabList>`
+     * path. Mutually exclusive with compound `children`; when both are
+     * given, `items` wins and a dev-time console.error explains the
+     * conflict.
+     */
+    items?: TabData[];
+    /**
+     * `false` (default) keeps inactive tab panels mounted and hidden
+     * (`display: none`) — panel state survives tab switches. `true`
+     * unmounts them instead: switching destroys the panel's internal
+     * state (inputs, scroll), trading keep-alive for a lighter DOM.
+     */
+    destroyInactiveTabPane?: boolean;
+    /**
+     * `false` (default) mounts every panel eagerly (hidden behind
+     * `display: none` when inactive). `true` defers each panel's first
+     * mount to its first activation — `items` and compound paths alike.
+     * After the first activation `destroyInactiveTabPane` takes over
+     * again: keep the panel alive and hidden (`false`) or unmount it on
+     * every switch away (`true`).
+     */
+    lazy?: boolean;
+    /**
+     * Renders the `+` button at the tail of the tab bar (outside the
+     * tablist, so the strip keeps owning nothing but tabs). A real
+     * button — a normal tab stop, Enter/Space activates. `onAdd` only
+     * notifies; growing the `items` array (or mounting another compound
+     * `<Tab>`) is the consumer's job. `addLabel` overrides the
+     * accessible name.
+     */
+    addable?: TabsAddable;
     /**
      * Semantic slot classes (AntD v6 `classNames` shape): declared once
      * here and distributed to every part through context — see
@@ -10,7 +73,15 @@ type TabsProps = {
      */
     classNames?: TabsClassNames;
     className?: string;
-    children: ReactNode;
+    /**
+     * Forwarded to the root wrapper `<div data-slot='tabs'>` — layout
+     * measurement and `ref.current.focus()`-style element access reach
+     * the family root (the strip and panels keep their own internal
+     * handles).
+     */
+    ref?: Ref<HTMLDivElement>;
+    /** Compound mode: `<TabList>` + `<TabPanel>`s. Omit when using `items`. */
+    children?: ReactNode;
 };
-export default function Tabs({ value: valueControl, classNames, className, children, }: TabsProps): import("react").JSX.Element;
-export type { TabsProps };
+export default function Tabs({ value: valueControl, variant, items, destroyInactiveTabPane, lazy, addable, classNames, className, ref, children, }: TabsProps): import("react").JSX.Element;
+export type { TabsProps, TabData };

package/dist/types/components/Tabs/TabsContext.d.ts

@@ -1,4 +1,24 @@
 import type { Dispatch, SetStateAction } from 'react';
+/**
+ * Visual skin of the strip, declared once on `<Tabs>` and distributed
+ * through context:
+ *
+ * - `line` — the classic underline strip (default, the long-standing look)
+ * - `card` — flat antd-style cards; the selected tab raises onto a
+ *   bordered surface, no strip separator
+ * - `pill` — the Segmented-style capsule: a muted trough with the
+ *   selected tab lifting onto the bg surface
+ */
+export type TabsVariant = 'line' | 'card' | 'pill';
+/**
+ * The strip-tail `+` affordance, declared once on `<Tabs>` — see
+ * `addable` there. `addLabel` overrides the button's accessible
+ * name (the i18n hook).
+ */
+export type TabsAddable = {
+    onAdd?: () => void;
+    addLabel?: string;
+};
 /**
  * Semantic slot classes (AntD v6 `classNames` shape) for the Tabs
  * family: declared once on the `<Tabs>` root and distributed to every
@@ -21,6 +41,21 @@ export type TabsClassNames = {
 type TabsContextValue = {
     value: string;
     setValue: Dispatch<SetStateAction<string>>;
+    /** Strip/tab visual variant — one declaration on `<Tabs>` skins
+     *  every part (the strip chrome, each tab, the overflow areas). */
+    variant: TabsVariant;
+    /** Unmount inactive tab panels instead of keeping them alive and
+     * hidden — see `destroyInactiveTabPane` on `<Tabs>`. */
+    destroyInactiveTabPane: boolean;
+    /** Defer each panel's first mount to its first activation — see
+     * `lazy` on `<Tabs>`. */
+    lazy: boolean;
+    /** Values that have been active at least once (seeded with the
+     *  initial value) — the lazy-mount ledger `TabPanel` consults
+     *  before mounting an inactive panel. */
+    activated: ReadonlySet<string>;
+    /** Renders the strip-tail `+` button when set (TabList reads it). */
+    addable: TabsAddable | undefined;
     classNames: TabsClassNames | undefined;
 };
 export declare const TabsProvider: import("react").Provider<TabsContextValue | undefined>;

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

@@ -1,11 +1,12 @@
-export { default as Tabs } from './Tabs';
-export type { TabsProps } from './Tabs';
-export type { TabsClassNames } from './TabsContext';
-export { default as TabList } from './TabList';
-export type { TabListProps } from './TabList';
-export { default as Tab } from './Tab';
-export type { TabProps, TabStatus } from './Tab';
-export { default as TabPanel } from './TabPanel';
-export type { TabPanelProps } from './TabPanel';
-export { default as SortableTabList } from './SortableTabList';
-export type { SortableTabListProps } from './SortableTabList';
+export { default as Tabs } from './Tabs.js';
+export type { TabsProps } from './Tabs.js';
+export type { TabsClassNames } from './TabsContext.js';
+export { default as TabList } from './TabList.js';
+export type { TabListProps } from './TabList.js';
+export { default as Tab } from './Tab.js';
+export type { TabProps, TabStatus } from './Tab.js';
+export { default as TabPanel } from './TabPanel.js';
+export type { TabPanelProps } from './TabPanel.js';
+export { default as SortableTabList } from './SortableTabList.js';
+export type { SortableTabListProps } from './SortableTabList.js';
+export { tabVariants, listVariants } from './tabs-styles.js';

package/dist/types/components/Tabs/tab-metas.d.ts

@@ -1,11 +1,25 @@
 import type { ReactNode } from 'react';
-import type { TabStatus } from './Tab';
+import type { TabStatus } from './Tab.js';
 export type TabMeta = {
     value: string;
     label: ReactNode;
     icon?: ReactNode;
     status?: TabStatus;
+    /** Carried into the overflow menu so a disabled tab is not
+     * selectable through the ⋯ radios either. */
+    disabled?: boolean;
 };
+/**
+ * The lazy-mount ledger: tab values that have been active at least
+ * once, seeded with the initial value. `<TabPanel>` consults it when
+ * `lazy` is set on `<Tabs>` — a panel that has never been active stays
+ * unmounted until its first activation. Recording happens in an effect
+ * (the newly active panel already mounts through `isActive`, so the
+ * one-commit lag is invisible). Lives here beside the metas collector
+ * so the component files keep a components-only export surface for
+ * react-refresh.
+ */
+export declare function useActivatedTabs(activeValue: string, enabled: boolean): ReadonlySet<string>;
 /**
  * `<Tab>` children in DOM order for the overflow menu: arrays and
  * Fragments flatten. Anything else between the tabs is left alone —

package/dist/types/components/Tabs/tabs-styles.d.ts

@@ -0,0 +1,10 @@
+import type { TabsVariant } from './TabsContext.js';
+/** Per-variant skin pair — `idle` rides every tab of the variant,
+ * `active` only the selected one (after the shared active floor). */
+export declare const tabVariants: Record<TabsVariant, {
+    idle: string;
+    active: string;
+}>;
+/** Per-variant strip chrome — the tabs carry the matching skins (see
+ * `tabVariants`). `variant` rides the Tabs context. */
+export declare const listVariants: Record<TabsVariant, string>;

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

@@ -1,11 +1,39 @@
-import type { ReactNode } from 'react';
-type TagProps = {
-    variant?: 'default' | 'primary' | 'success' | 'warning' | 'danger';
+import type { ComponentPropsWithRef, ElementType, ReactNode } from 'react';
+type TagOwnProps = {
+    /** Semantic status color. */
+    color?: 'default' | 'primary' | 'success' | 'warning' | 'danger' | 'info';
     size?: 'sm' | 'md';
     closable?: boolean;
     onClose?: () => void;
-    className?: string;
+    /**
+     * Accessible label for the remove button. Inlined default keeps Tag
+     * hook-free (RSC-safe: no useStrings); locale-aware callers pass
+     * their own string.
+     */
+    removeLabel?: string;
     children: ReactNode;
 };
-export default function Tag({ variant, size, closable, onClose, className, children, }: TagProps): import("react").JSX.Element;
-export type { TagProps };
+/**
+ * MUI-OverridableComponent-shaped polymorphism (Button's pattern): own
+ * props first, then the target element's props minus the colliding keys.
+ * The skin, `data-slot` and the remove button always land on/inside the
+ * rendered element — the same "wiring wins" precedence as Button's `as`.
+ * `ref` (and every native attribute) flows through to the rendered root.
+ */
+type TagProps<T extends ElementType = 'span'> = TagOwnProps & {
+    /**
+     * Render element. `'span'` (default) keeps the static tag; `'a'`
+     * renders a clickable tag link — `href`, `target`, `rel` and the
+     * rest of the anchor surface flow through, and the link shape resets
+     * the UA underline so the tag looks identical to the `span` form.
+     * Any component that forwards props to a DOM element works the same
+     * way (e.g. a router Link).
+     *
+     * Don't combine an interactive `as` with `closable`: the remove
+     * button would nest inside a link — invalid HTML and an SR/keyboard
+     * trap.
+     */
+    as?: T;
+} & Omit<ComponentPropsWithRef<T>, keyof TagOwnProps | 'as'>;
+export default function Tag<T extends ElementType = 'span'>({ color, size, closable, onClose, removeLabel, as, className, children, ...rest }: TagProps<T>): import("react").JSX.Element;
+export type { TagOwnProps, TagProps };

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

@@ -1,2 +1,3 @@
-export { default as Tag } from './Tag';
-export type { TagProps } from './Tag';
+export { default as Tag } from './Tag.js';
+export type { TagProps } from './Tag.js';
+export { colors as tagVariants, tagSizes } from './tag-styles.js';

package/dist/types/components/Tag/tag-styles.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared Tag skin — the base, color and size classes the `Tag`
+ * component wears. Living in their own module keeps the component file
+ * free of style internals (react-refresh boundary) and lets the
+ * colors/sizes maps ship as public constants (`tagVariants` /
+ * `tagSizes`, the shadcn `buttonVariants` precedent) for consumers
+ * composing custom elements with the same skin; split-css groups the
+ * emitted CSS into `haze-ui/css/tag.css` with them.
+ */
+export declare const base: import("@linaria/core").LinariaClassName;
+export declare const colors: {
+    readonly default: import("@linaria/core").LinariaClassName;
+    readonly primary: import("@linaria/core").LinariaClassName;
+    readonly success: import("@linaria/core").LinariaClassName;
+    readonly warning: import("@linaria/core").LinariaClassName;
+    readonly danger: import("@linaria/core").LinariaClassName;
+    readonly info: import("@linaria/core").LinariaClassName;
+};
+export declare const tagSizes: {
+    readonly sm: import("@linaria/core").LinariaClassName;
+    readonly md: import("@linaria/core").LinariaClassName;
+};
+/** The link shape (`as` set): anchors get a UA underline the tag skin
+ * never asked for — reset it (the color classes already own the ink;
+ * Button's `link` class does the same for its anchor shape). Applies to
+ * every explicit `as`, including router Links that render anchors. */
+export declare const linkShape: import("@linaria/core").LinariaClassName;
+export declare const closeBtn: import("@linaria/core").LinariaClassName;

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

@@ -1,5 +1,5 @@
 import type { ReactNode } from 'react';
-import { type TagGroupClassNames } from './TagGroup';
+import { type TagGroupClassNames } from './TagGroup.js';
 /**
  * Drag-and-drop reorderable variant of TagGroup — built on @dnd-kit
  * (a haze-ui dependency), so this module statically imports the dnd

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 { TagGroupClassNames, TagGroupProps } from './TagGroup';
-export type { TagGroupItemProps } from './TagGroupItem';
-export type { SortableTagGroupProps } from './SortableTagGroup';
+export { default as TagGroup } from './TagGroup.js';
+export { default as TagGroupItem } from './TagGroupItem.js';
+export { default as SortableTagGroup } from './SortableTagGroup.js';
+export type { TagGroupClassNames, TagGroupProps } from './TagGroup.js';
+export type { TagGroupItemProps } from './TagGroupItem.js';
+export type { SortableTagGroupProps } from './SortableTagGroup.js';

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

@@ -1,4 +1,4 @@
-import type { TagInputCoreProps } from './TagInputCore';
+import type { TagInputCoreProps } from './TagInputCore.js';
 /**
  * Props for `SortableTagInputCore` — the full `TagInputCoreProps` field
  * set (value/onChange/placeholder/maxTags/disabled/className/id/aria/ref)

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

@@ -7,6 +7,15 @@ type TagInputProps = {
     maxTags?: number;
     disabled?: boolean;
     className?: string;
+    /**
+     * Form field name: renders one hidden input per tag under the same
+     * name (native repeated-field semantics) so `<form action={fn}>` /
+     * `new FormData(form).getAll(name)` receive every tag — the inner
+     * text input never carries it (partial drafts would leak). An empty
+     * list submits nothing. react-f0rm `FormItem` usage never passes it,
+     * so both worlds coexist.
+     */
+    name?: string;
     /**
      * 字段 id（FormItem 桥生成）：必须挂到内部可聚焦的 input 上而非根
      * div，<label htmlFor> 与错误 span 的 aria 链路才能接到焦点元素——
@@ -21,5 +30,5 @@ type TagInputProps = {
      * element form bridges and `ref.current.focus()` reach. */
     ref?: Ref<HTMLInputElement>;
 };
-export default function TagInput({ value: valueControl, onChange, placeholder, maxTags, disabled, className, id, 'aria-invalid': ariaInvalid, 'aria-describedby': ariaDescribedby, ref, }: TagInputProps): import("react").JSX.Element;
+export default function TagInput({ value: valueControl, onChange, placeholder, maxTags, disabled, className, name, id, 'aria-invalid': ariaInvalid, 'aria-describedby': ariaDescribedby, ref, }: TagInputProps): import("react").JSX.Element;
 export type { TagInputProps };

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

@@ -1,8 +1,8 @@
-export { default as TagInput } from './TagInput';
-export type { TagInputProps } from './TagInput';
-export { default as TagInputCore } from './TagInputCore';
-export type { TagInputCoreProps } from './TagInputCore';
-export { default as SortableTagInput } from './SortableTagInput';
-export type { SortableTagInputProps } from './SortableTagInput';
-export { default as SortableTagInputCore } from './SortableTagInputCore';
-export type { SortableTagInputCoreProps } from './SortableTagInputCore';
+export { default as TagInput } from './TagInput.js';
+export type { TagInputProps } from './TagInput.js';
+export { default as TagInputCore } from './TagInputCore.js';
+export type { TagInputCoreProps } from './TagInputCore.js';
+export { default as SortableTagInput } from './SortableTagInput.js';
+export type { SortableTagInputProps } from './SortableTagInput.js';
+export { default as SortableTagInputCore } from './SortableTagInputCore.js';
+export type { SortableTagInputCoreProps } from './SortableTagInputCore.js';

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

@@ -1,4 +1,4 @@
-export { default as Textarea } from './Textarea';
-export type { TextareaProps } from './Textarea';
-export { default as TextareaCore } from './TextareaCore';
-export type { TextareaCoreProps } from './TextareaCore';
+export { default as Textarea } from './Textarea.js';
+export type { TextareaProps } from './Textarea.js';
+export { default as TextareaCore } from './TextareaCore.js';
+export type { TextareaCoreProps } from './TextareaCore.js';

package/dist/types/components/Textarea/textarea-styles.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared Textarea size skin — the per-size padding/typography classes
+ * the `TextareaCore` component wears (the `Textarea` sugar delegates to
+ * it). Sibling styles module per the react-refresh boundary convention
+ * (Input `input-styles` / NumberInput `number-input-styles` precedent);
+ * split-css groups the module with the Textarea family's css.
+ */
+export declare const sizes: {
+    readonly sm: import("@linaria/core").LinariaClassName;
+    readonly md: import("@linaria/core").LinariaClassName;
+    readonly lg: import("@linaria/core").LinariaClassName;
+};

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

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

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

@@ -0,0 +1,26 @@
+import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+import type { TimePickerFormat } from '../TimePicker/time.js';
+import type { TimeLabels, TimePlaceholder } from './TimeFieldCore.js';
+type TimeFieldProps = {
+    /** `"HH:mm"` / `"HH:mm:ss"` matching `format` (TimePicker's value
+     * semantics) or `''` when empty; commits fire only when every
+     * segment holds a value. */
+    value?: ControlOrValue<string>;
+    onChange?: (value: string) => void;
+    /** Column granularity and the value's serialization shape; defaults
+     * to `'HH:mm'` (no second segment), matching TimePicker. */
+    format?: TimePickerFormat;
+    /** 12-hour presentation with an AM/PM segment; the value stays
+     * 24-hour either way (10 PM serializes as `22:00`). */
+    use12Hours?: boolean;
+    disabled?: boolean;
+    placeholder?: TimePlaceholder;
+    labels?: TimeLabels;
+    className?: string;
+    /** Forwarded to the current tab-stop segment span — the element form
+     * bridges and `ref.current.focus()` reach. */
+    ref?: Ref<HTMLSpanElement>;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'onChange'>;
+export default function TimeField({ value: valueControl, onChange, format, use12Hours, disabled, placeholder, labels, className, ref, ...rest }: TimeFieldProps): import("react").JSX.Element;
+export type { TimeFieldProps };

package/dist/types/components/TimeField/TimeFieldCore.d.ts

@@ -0,0 +1,36 @@
+import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { TimePickerFormat } from '../TimePicker/time.js';
+/** Per-segment placeholder strings for the empty state. */
+type TimePlaceholder = {
+    hour?: string;
+    minute?: string;
+    second?: string;
+    dayPeriod?: string;
+};
+/** Accessible segment names, overriding the built-in English ones. */
+type TimeLabels = {
+    hour?: string;
+    minute?: string;
+    second?: string;
+    dayPeriod?: string;
+};
+type TimeFieldCoreProps = {
+    /** `"HH:mm"` / `"HH:mm:ss"` matching `format` (TimePicker's value
+     * semantics), or `''` when empty. */
+    value: string;
+    onChange: (value: string) => void;
+    /** Column granularity and the value's serialization shape; defaults
+     * to `'HH:mm'` (no second segment), matching TimePicker. */
+    format?: TimePickerFormat;
+    /** 12-hour presentation with an AM/PM segment; the value stays
+     * 24-hour either way (10 PM serializes as `22:00`). */
+    use12Hours?: boolean;
+    disabled?: boolean;
+    placeholder?: TimePlaceholder;
+    labels?: TimeLabels;
+    className?: string;
+    /** Forwarded to the current tab-stop segment span. */
+    ref?: Ref<HTMLSpanElement>;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'onChange'>;
+export default function TimeFieldCore({ value, onChange, format, use12Hours, disabled, placeholder, labels, className, ref, ...rest }: TimeFieldCoreProps): import("react").JSX.Element;
+export type { TimeFieldCoreProps, TimePlaceholder, TimeLabels };

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

@@ -0,0 +1,4 @@
+export { default as TimeField } from './TimeField.js';
+export type { TimeFieldProps } from './TimeField.js';
+export { default as TimeFieldCore } from './TimeFieldCore.js';
+export type { TimeFieldCoreProps, TimePlaceholder, TimeLabels } from './TimeFieldCore.js';

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

@@ -0,0 +1,58 @@
+import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+/**
+ * TimeGrid — a single-select grid of `'HH:mm'` time slots generated
+ * from a `from`..`to` window and a minute `step` (Mantine 8 TimeGrid
+ * precedent). The selection is controllable state
+ * (`ControlOrValue<string>` via useControl): pass a plain string for
+ * uncontrolled usage, a control or `value` + `onChange` for the
+ * controlled flow — `''` is the no-selection sentinel.
+ *
+ * Accessibility: an ARIA radio group — the root carries
+ * `role="radiogroup"` (name it with `aria-label`), every slot is a
+ * native `<button role="radio">` with `aria-checked`. Keyboard follows
+ * the roving-tabindex radio/grid hybrid: the selected slot (else the
+ * first enabled one) is the group's single tab stop; arrows move by
+ * slot (left/right) or by row (`columns`, up/down), Home/End jump the
+ * edges, and every move both focuses and selects — the radio pattern's
+ * arrow-checks semantics. Disabled slots are skipped and unreachable.
+ *
+ * Form participation mirrors Segmented: a `name` renders a hidden
+ * input bridge so `new FormData(form)` / server actions receive the
+ * selected `'HH:mm'`; `''` submits nothing.
+ */
+type TimeGridClassNames = {
+    /** The radiogroup root (`data-slot='time-grid'`). */
+    root?: string;
+    /** Every slot button (`data-slot='cell'`). */
+    cell?: string;
+};
+type TimeGridProps = {
+    /** Selected `'HH:mm'` slot — `ControlOrValue<string>`, `''` = none. */
+    value?: ControlOrValue<string>;
+    onChange?: (value: string) => void;
+    /** Window start, `'HH:mm'`; default '00:00'. */
+    from?: string;
+    /** Window end, `'HH:mm'`, inclusive when step-aligned; default '23:00'. */
+    to?: string;
+    /** Slot cadence in minutes; default 60. */
+    step?: number;
+    /** Slots rendered unselectable (skipped by the keyboard rover too). */
+    disabledValues?: readonly string[];
+    /** Slots per row in the grid; default 4. */
+    columns?: number;
+    /** Display text per slot (defaults to the `'HH:mm'` value). */
+    formatLabel?: (value: string) => string;
+    /**
+     * Form field name: renders a hidden input bridge next to the group
+     * so `<form action={fn}>` / `new FormData(form)` receive the selected
+     * slot. The `''` no-selection sentinel submits nothing.
+     */
+    name?: string;
+    classNames?: TimeGridClassNames;
+    className?: string;
+    /** Forwarded to the group's focus target — the selected slot's button (falling back to the first enabled one). */
+    ref?: Ref<HTMLButtonElement>;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'onChange'>;
+export default function TimeGrid({ value: valueControl, onChange, from, to, step, disabledValues, columns, formatLabel, name, classNames, className, style, ref, ...rest }: TimeGridProps): import("react").JSX.Element;
+export type { TimeGridProps, TimeGridClassNames };

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

@@ -0,0 +1,2 @@
+export { default as TimeGrid } from './TimeGrid.js';
+export type { TimeGridProps, TimeGridClassNames } from './TimeGrid.js';

package/dist/types/components/TimeGrid/time-grid-styles.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared TimeGrid skin — the slot-picker chrome (group grid and the
+ * per-slot button in its idle and selected states) the `TimeGrid`
+ * 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/time-grid.css`. The grid's column
+ * count is layout data (the `columns` prop) and rides the root as an
+ * inline `grid-template-columns`, not a class.
+ */
+export declare const timeGridBase: import("@linaria/core").LinariaClassName;
+export declare const timeGridButton: import("@linaria/core").LinariaClassName;
+/** The checked slot — must follow `timeGridButton` in the class list. */
+export declare const timeGridButtonSelected: import("@linaria/core").LinariaClassName;

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

@@ -1,6 +1,6 @@
 import type { ComponentPropsWithoutRef, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
-import type { TimeParts, TimePickerFormat } from './time';
+import type { TimeParts, TimePickerFormat } from './time.js';
 type TimePickerProps = {
     value?: ControlOrValue<string>;
     /** Panel visibility; defaults to the trigger's own toggle state. */

package/dist/types/components/TimePicker/TimePickerPanel.d.ts

@@ -1,5 +1,5 @@
 import type { ComponentPropsWithoutRef, Ref } from 'react';
-import type { TimeParts, TimePickerFormat } from './time';
+import type { TimeParts, TimePickerFormat } from './time.js';
 /**
  * One enabled/disabled decision for a candidate cell. The predicate is
  * evaluated against the currently selected parts for the other fields

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

@@ -1,5 +1,5 @@
-export { default as TimePicker } from './TimePicker';
-export type { TimePickerProps } from './TimePicker';
-export { default as TimePickerCore } from './TimePickerCore';
-export type { TimePickerCoreProps } from './TimePickerCore';
-export type { TimeParts, TimePickerFormat } from './time';
+export { default as TimePicker } from './TimePicker.js';
+export type { TimePickerProps } from './TimePicker.js';
+export { default as TimePickerCore } from './TimePickerCore.js';
+export type { TimePickerCoreProps } from './TimePickerCore.js';
+export type { TimeParts, TimePickerFormat } from './time.js';

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

@@ -1,2 +1,2 @@
-export { Timeline, TimelineItem } from './Timeline';
-export type { TimelineProps, TimelineItemProps } from './Timeline';
+export { Timeline, TimelineItem } from './Timeline.js';
+export type { TimelineProps, TimelineItemProps } from './Timeline.js';

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

@@ -1,5 +1,5 @@
 import type { ComponentPropsWithRef, ReactNode } from 'react';
-import type { ToastAction } from './ToastContext';
+import type { ToastAction } from './ToastContext.js';
 /**
  * Semantic slot classes (AntD v6 `classNames` shape) for the toast
  * family. Toasts are usually fired imperatively (`useToast()` /

package/dist/types/components/Toast/ToastContainer.d.ts

@@ -1,5 +1,5 @@
 import type { ReactNode } from 'react';
-import type { ToastClassNames } from './Toast';
+import type { ToastClassNames } from './Toast.js';
 type ToastPlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 type ToastContainerProps = {
     children: ReactNode;

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

@@ -1,7 +1,7 @@
-export { default as Toast } from './Toast';
-export type { ToastProps, ToastClassNames } from './Toast';
-export { default as ToastContainer } from './ToastContainer';
-export type { ToastContainerProps } from './ToastContainer';
-export { default as useToast } from './useToast';
-export { toast } from './toast-channel';
-export type { ToastAction, ToastOptions, ToastVariant } from './toast-channel';
+export { default as Toast } from './Toast.js';
+export type { ToastProps, ToastClassNames } from './Toast.js';
+export { default as ToastContainer } from './ToastContainer.js';
+export type { ToastContainerProps } from './ToastContainer.js';
+export { default as useToast } from './useToast.js';
+export { toast } from './toast-channel.js';
+export type { ToastAction, ToastOptions, ToastVariant } from './toast-channel.js';

package/dist/types/components/Toast/toast-channel.d.ts

@@ -1,5 +1,5 @@
 import type { ReactNode } from 'react';
-import type { ToastAction, ToastDeferredCopyKey, ToastItem, ToastUpdateOptions, ToastVariant } from './ToastContext';
+import type { ToastAction, ToastDeferredCopyKey, ToastItem, ToastUpdateOptions, ToastVariant } from './ToastContext.js';
 /** Options accepted by `toast()` — the same call shape `useToast()` takes. */
 type ToastOptions = {
     variant?: ToastVariant;

package/dist/types/components/Toast/useToast.d.ts

@@ -1,5 +1,5 @@
 import type { ReactNode } from 'react';
-import type { ToastOptions, ToastPromiseOptions, ToastUpdateOptions, ToastVariantOptions } from './toast-channel';
+import type { ToastOptions, ToastPromiseOptions, ToastUpdateOptions, ToastVariantOptions } from './toast-channel.js';
 /**
  * The `useToast()` return value: the toast trigger itself (returns the id,
  * usable with `update`) plus `loading`/`update`/`promise` — one-to-one