haze-ui 1.28.0 → 1.30.0

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

@@ -0,0 +1,4 @@
+export { default } from './ConfigProvider';
+export type { ConfigProviderProps } from './ConfigProvider';
+export { useConfigDefaults } from './useConfigDefaults';
+export type { HazeConfig } from './ConfigContext';

package/dist/types/components/ConfigProvider/useConfigDefaults.d.ts

@@ -0,0 +1,28 @@
+import type { HazeConfig } from './ConfigContext';
+/**
+ * Reads one component's resolved defaults from the enclosing
+ * `ConfigProvider` chain. Returns a frozen empty object when no provider
+ * is mounted; callers fall through to their built-in defaults, so wiring
+ * a component never changes its provider-less behavior.
+ *
+ * ## Wiring a new component (the internal pattern)
+ *
+ * 1. Declare a section in `HazeConfig` (`ConfigContext.ts`) named after
+ *    the exported component:
+ *
+ *    ```ts
+ *    MyComponent?: { size?: 'sm' | 'md' | 'lg' };
+ *    ```
+ *
+ * 2. In the component, drop the destructuring default for each wired
+ *    prop and resolve three tiers — explicit prop, config, built-in:
+ *
+ *    ```ts
+ *    const config = useConfigDefaults('MyComponent');
+ *    const size = sizeProp ?? config.size ?? 'md';
+ *    ```
+ *
+ *    The built-in stays last so a missing provider renders exactly what
+ *    the component rendered before the wiring (byte-identical).
+ */
+export declare function useConfigDefaults<K extends keyof HazeConfig>(component: K): Readonly<NonNullable<HazeConfig[K]>>;

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

@@ -0,0 +1,20 @@
+import type { ComponentPropsWithoutRef } from 'react';
+type CountUpProps = {
+    /** Animation target — changes animate from the currently shown value. */
+    to: number;
+    /** Mount value; the first animation starts here (default 0). */
+    from?: number;
+    /** Animation length in milliseconds (default 1200). */
+    duration?: number;
+    /** Fraction digits kept by the default formatter (default 0). */
+    decimals?: number;
+    /** Value → display string. Default: cached `Intl.NumberFormat` with
+     * thousand grouping and `decimals` fraction digits. */
+    format?: (value: number) => string;
+    /** Animate on mount (default true). `false` renders `from` until the
+     * `to` prop changes. */
+    autostart?: boolean;
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'span'>, 'children'>;
+export default function CountUp({ to, from, duration, decimals, format, autostart, className, ...rest }: CountUpProps): import("react").JSX.Element;
+export type { CountUpProps };

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

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

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

@@ -1,26 +1,39 @@
 import type { Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
-import type { CalendarPickerMode } from '../Calendar/Calendar';
+import type { CalendarCellRender, CalendarPickerMode } from '../Calendar/Calendar';
 import type { DatepickerPreset } from './DatepickerCore';
 type DatepickerProps = {
     value?: ControlOrValue<string>;
     open?: ControlOrValue<boolean>;
-    /** Calendar granularity — 'date' (default), 'month', 'quarter' or
-     * 'year'. `value` serializes per mode: "YYYY-MM-DD", "YYYY-MM",
-     * "YYYY-Qn" or "YYYY". */
+    /** Calendar granularity — 'date' (default), an ISO week 'week',
+     * 'month', 'quarter' or 'year'. `value` serializes per mode:
+     * "YYYY-MM-DD", "YYYY-Www", "YYYY-MM", "YYYY-Qn" or "YYYY". */
     picker?: CalendarPickerMode;
     min?: string;
     max?: string;
     /** Disables individual dates on the calendar panel (see Calendar's
-     * `disabledDate`). */
+     * `disabledDate`) — day grid and header drill-down grids alike. */
     disabledDate?: (date: Date) => boolean;
     /** Shortcut rows at the top of the panel; clicking applies the
      * preset's value and closes the panel. */
     presets?: DatepickerPreset[];
-    /** Adds a time input (hour/minute) below the calendar; `value`
-     * serializes as `"YYYY-MM-DD HH:mm"` instead of `"YYYY-MM-DD"`
-     * (plain-date values stay accepted). Date granularity only. */
-    showTime?: boolean;
+    /** Adds a time input (hour/minute, or seconds with
+     * `{ seconds: true }`) below the calendar; `value` serializes as
+     * `"YYYY-MM-DD HH:mm"` / `"YYYY-MM-DD HH:mm:ss"` instead of
+     * `"YYYY-MM-DD"` (plain-date values stay accepted). Date granularity
+     * only. */
+    showTime?: boolean | {
+        seconds?: boolean;
+    };
+    /** Custom serialization for picks, replacing the built-in value
+     * format (see DatepickerCore's `format`). */
+    format?: (date: Date) => string;
+    /** Reads a custom-formatted value back into the calendar (see
+     * DatepickerCore's `parse`). */
+    parse?: (text: string) => Date | null;
+    /** Appends custom content inside the panel's picker cells (see
+     * Calendar's `cellRender`). */
+    cellRender?: CalendarCellRender;
     locale?: string;
     weekStartsOn?: 0 | 1;
     placeholder?: string;
@@ -29,5 +42,5 @@ type DatepickerProps = {
      * element form bridges and `ref.current.focus()` reach. */
     ref?: Ref<HTMLInputElement>;
 };
-export default function Datepicker({ value: valueControl, open: openControl, picker, min, max, disabledDate, presets, showTime, locale, weekStartsOn, placeholder, className, ref, }: DatepickerProps): import("react").JSX.Element;
+export default function Datepicker({ value: valueControl, open: openControl, picker, min, max, disabledDate, presets, showTime, format, parse, locale, weekStartsOn, cellRender, placeholder, className, ref, }: DatepickerProps): import("react").JSX.Element;
 export type { DatepickerProps };

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

@@ -1,12 +1,16 @@
 import type { Ref } from 'react';
-import type { CalendarPickerMode } from '../Calendar/Calendar';
+import type { CalendarCellRender, CalendarPickerMode } from '../Calendar/Calendar';
 /** One shortcut row at the top of the dropdown panel: clicking applies
  * `value` (serialized per `picker`) and closes the panel. */
 type DatepickerPreset = {
     /** Visible row copy. */
     label: string;
-    /** Applied value — "YYYY-MM-DD" (date), "YYYY-MM" (month), "YYYY-Qn"
-     * (quarter) or "YYYY" (year), matching `picker`. */
+    /**
+     * Applied value — "YYYY-MM-DD" (date), an ISO week "YYYY-Www" (week),
+     * "YYYY-MM" (month), "YYYY-Qn" (quarter) or "YYYY" (year), matching
+     * `picker`. With a custom `format`, presets carry the consumer's own
+     * serialization and pass through untouched.
+     */
     value: string;
 };
 type DatepickerCoreProps = {
@@ -20,22 +24,48 @@ type DatepickerCoreProps = {
     min?: string;
     max?: string;
     /** Disables individual dates on the panel's Calendar (see Calendar's
-     * `disabledDate`). */
+     * `disabledDate`). Applies to the day grid and the header drill-down
+     * grids alike. */
     disabledDate?: (date: Date) => boolean;
     /** Shortcut rows rendered above the calendar; clicking applies the
      * preset and closes the panel. */
     presets?: DatepickerPreset[];
-    /** Renders a time input (hour/minute) below the calendar; `value`
-     * serializes as `"YYYY-MM-DD HH:mm"`. Applies to the default date
-     * granularity only; without it the value keeps the plain
-     * `"YYYY-MM-DD"` format. */
-    showTime?: boolean;
+    /**
+     * Renders a time input below the calendar; `value` serializes as
+     * `"YYYY-MM-DD HH:mm"`, or with seconds as `"YYYY-MM-DD HH:mm:ss"`
+     * (`{ seconds: true }`). Applies to the default date granularity
+     * only; without it the value keeps the plain `"YYYY-MM-DD"` format
+     * (plain-date and minute-precision values stay accepted in seconds
+     * mode — the missing parts read as `00`).
+     */
+    showTime?: boolean | {
+        seconds?: boolean;
+    };
+    /**
+     * Custom serialization hook: when provided, picks serialize through
+     * it (`format(date-of-pick)`) instead of the built-in
+     * `"YYYY-MM-DD [HH:mm[:ss]]"` format, and the trigger input displays
+     * the resulting string verbatim. Pair with `parse` so a controlled
+     * value round-trips back into the calendar's anchor and highlight.
+     */
+    format?: (date: Date) => string;
+    /**
+     * Custom parse hook (the `format` counterpart): reads the value
+     * string back into a Date for the calendar's month view, day
+     * highlight and the time input. Returns `null` for text it does not
+     * recognize (the calendar then opens unanchored). The trigger stays
+     * readOnly — parsing serves controlled-value display, not typing.
+     */
+    parse?: (text: string) => Date | null;
     locale?: string;
     weekStartsOn?: 0 | 1;
     placeholder?: string;
     className?: string;
+    /** Appends custom content inside the panel's picker cells (see
+     * Calendar's `cellRender`). */
+    cellRender?: CalendarCellRender;
     /** Forwarded to the trigger `<input>` (not the wrapper div). */
     ref?: Ref<HTMLInputElement>;
 };
-export default function DatepickerCore({ value, onChange, open, onOpenChange, picker, min, max, disabledDate, presets, showTime, locale, weekStartsOn, placeholder, className, ref, }: DatepickerCoreProps): import("react").JSX.Element;
+export default function DatepickerCore({ value, onChange, open, onOpenChange, picker, min, max, disabledDate, presets, showTime, format, parse, locale, weekStartsOn, cellRender, placeholder, className, ref, }: DatepickerCoreProps): import("react").JSX.Element;
 export type { DatepickerCoreProps, DatepickerPreset };

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

@@ -3,25 +3,47 @@
  *
  * The combined value is the day-grid `"YYYY-MM-DD"` value (see
  * Calendar/date.ts — a local civil date, never a UTC timestamp) plus a
- * space and a 24-hour `"HH:mm"` time: `"2026-03-01 09:30"`. Without
- * `showTime` the value keeps the plain date format, and a plain date
- * stays a valid input with `showTime` on (the time then reads as
- * unset, defaulting to `00:00` on the next pick).
+ * space and a 24-hour time: `"YYYY-MM-DD HH:mm"`, or
+ * `"YYYY-MM-DD HH:mm:ss"` when `showTime` asks for seconds
+ * (`{ seconds: true }`). Without `showTime` the value keeps the plain
+ * date format, and a plain date stays a valid input with `showTime` on
+ * (the time then reads as unset, defaulting to midnight on the next
+ * pick).
  */
 /**
  * Split a value into its date and time parts. Accepts the combined
- * `"YYYY-MM-DD HH:mm"` form (returning both parts) and the bare
- * `"YYYY-MM-DD"` form (returning `time: null` — the backward-compatible
- * pure-date value). Returns `null` for anything that is not a real
- * calendar date, leaving the caller free to fall back to empty.
+ * `"YYYY-MM-DD HH:mm"` and `"YYYY-MM-DD HH:mm:ss"` forms (returning
+ * `time` in the same shape — with seconds only when the input had them)
+ * and the bare `"YYYY-MM-DD"` form (returning `time: null` — the
+ * backward-compatible pure-date value). Returns `null` for anything that
+ * is not a real calendar date, leaving the caller free to fall back to
+ * empty.
  */
 export declare function splitDateTimeValue(value: string): {
     date: string;
     time: string | null;
 } | null;
 /**
- * Combine a `"YYYY-MM-DD"` date and an `"HH:mm"` time into the
- * `"YYYY-MM-DD HH:mm"` value. Pure string join — both inputs are
- * expected in their already-serialized forms.
+ * Combine a `"YYYY-MM-DD"` date and an `"HH:mm"` / `"HH:mm:ss"` time
+ * into the combined value. Pure string join — both inputs are expected
+ * in their already-serialized forms.
  */
 export declare function formatDateTimeValue(date: string, time: string): string;
+/**
+ * Match a parsed time to the active precision: seconds mode pads a
+ * minute-only value with `:00`, minute mode drops stray seconds. Pure
+ * string math over the `"HH:mm"` / `"HH:mm:ss"` shapes.
+ */
+export declare function normalizeTime(time: string, seconds: boolean): string;
+/**
+ * Serialize a Date's wall-clock time as the `"HH:mm"` (or
+ * `"HH:mm:ss"` with `seconds`) string the combined value and the time
+ * input use. Inverse of {@link applyTimeToCivilDate} for the time part.
+ */
+export declare function timeOf(date: Date, seconds: boolean): string;
+/**
+ * Apply an `"HH:mm"` / `"HH:mm:ss"` string to a civil date's local
+ * wall clock, returning a new Date (the input is untouched). Feeds the
+ * consumer `format` hook, which serializes whole Date objects.
+ */
+export declare function applyTimeToCivilDate(date: Date, time: string): Date;

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

@@ -1,6 +1,7 @@
 import type { ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 import type { CollisionPadding } from '../../utils/collision';
+import type { MenuDataItem } from '../../utils/menuItems';
 /**
  * Imperative handle exposed through the React 19 `ref` prop (same API
  * choice as VirtualList). `open`/`close` run through the same
@@ -28,9 +29,18 @@ type DropdownMenuProps = {
      * to all four edges, an object per edge.
      */
     collisionPadding?: CollisionPadding;
-    children: ReactNode;
+    /**
+     * Data-driven alternative to composed children: plain items,
+     * checkboxes, radio groups, labeled groups, dividers and nested
+     * submenus, rendered through the same components the compound API
+     * uses. When passed, it replaces the children with a default `⋯`
+     * trigger plus the content built from the data.
+     */
+    items?: MenuDataItem[];
+    children?: ReactNode;
     className?: string;
     ref?: Ref<DropdownMenuHandle>;
 };
-export default function DropdownMenu({ open: openControl, onOpenChange, collisionPadding, children, className, ref, }: DropdownMenuProps): import("react").JSX.Element;
+export default function DropdownMenu({ open: openControl, onOpenChange, collisionPadding, items, children, className, ref, }: DropdownMenuProps): import("react").JSX.Element;
 export type { DropdownMenuProps, DropdownMenuHandle };
+export type { MenuDataItem as DropdownMenuDataItem };

package/dist/types/components/DropdownMenu/DropdownMenuCheckboxItem.d.ts

@@ -0,0 +1,26 @@
+import type { ReactNode } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+type DropdownMenuCheckboxItemProps = {
+    /** Whether the option is checked — controlled control or uncontrolled initial value. */
+    checked?: ControlOrValue<boolean>;
+    /** Fires on every toggle, whatever drove it (click, Enter, Space). */
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    /** Danger skin for destructive actions: danger-colored text and interaction states. */
+    danger?: boolean;
+    /** Inline-start icon slot; bare `svg` children are sized to 1em by the slot. */
+    icon?: ReactNode;
+    /** Inline-end shortcut hint (e.g. '⌘C'), muted and pushed to the item's end. */
+    kbdLabel?: ReactNode;
+    className?: string;
+    children: ReactNode;
+};
+/**
+ * A toggleable menu option (`role="menuitemcheckbox"`): click, Enter or
+ * Space flips `checked`; the state is controllable through the standard
+ * `ControlOrValue` prop. Toggling keeps the menu open — several options
+ * are typically flipped in one visit (unlike a plain item, which
+ * closes the menu on activation).
+ */
+export default function DropdownMenuCheckboxItem({ checked: checkedControl, onCheckedChange, disabled, danger, icon, kbdLabel, className, children, }: DropdownMenuCheckboxItemProps): import("react").JSX.Element;
+export type { DropdownMenuCheckboxItemProps };

package/dist/types/components/DropdownMenu/DropdownMenuGroup.d.ts

@@ -0,0 +1,16 @@
+import type { ReactNode } from 'react';
+type DropdownMenuGroupProps = {
+    /** Non-interactive heading naming the group (aria-labelledby). */
+    label: ReactNode;
+    className?: string;
+    /** The group's menu items. */
+    children: ReactNode;
+};
+/**
+ * A labeled, non-interactive section of menu items (`role="group"`
+ * named by its heading, the ARIA APG menu group shape). The heading is
+ * not a menu item: keyboard traversal, typeahead and the roving tab
+ * stop skip it entirely.
+ */
+export default function DropdownMenuGroup({ label, className, children, }: DropdownMenuGroupProps): import("react").JSX.Element;
+export type { DropdownMenuGroupProps };

package/dist/types/components/DropdownMenu/DropdownMenuItem.d.ts

@@ -3,7 +3,13 @@ type DropdownMenuItemProps = {
     children: ReactNode;
     onClick?: () => void;
     disabled?: boolean;
+    /** Danger skin for destructive actions: danger-colored text and interaction states. */
+    danger?: boolean;
+    /** Inline-start icon slot; bare `svg` children are sized to 1em by the slot. */
+    icon?: ReactNode;
+    /** Inline-end shortcut hint (e.g. '⌘C'), muted and pushed to the item's end. */
+    kbdLabel?: ReactNode;
     className?: string;
 };
-export default function DropdownMenuItem({ children, onClick, disabled, className }: DropdownMenuItemProps): import("react").JSX.Element;
+export default function DropdownMenuItem({ children, onClick, disabled, danger, icon, kbdLabel, className, }: DropdownMenuItemProps): import("react").JSX.Element;
 export type { DropdownMenuItemProps };

package/dist/types/components/DropdownMenu/DropdownMenuRadioGroup.d.ts

@@ -0,0 +1,21 @@
+import type { ReactNode } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+type DropdownMenuRadioGroupProps = {
+    /** Selected value — controlled control or uncontrolled initial value ('' = none). */
+    value?: ControlOrValue<string>;
+    /** Fires when the selection changes, whatever drove it (click, Enter, Space). */
+    onValueChange?: (value: string) => void;
+    /** Optional non-interactive heading naming the radio group (aria-labelledby). */
+    label?: ReactNode;
+    className?: string;
+    /** The group's `DropdownMenuRadioItem`s. */
+    children: ReactNode;
+};
+/**
+ * State container for a single-select cluster of
+ * `DropdownMenuRadioItem`s (`role="group"`): owns the selected value
+ * through the standard `ControlOrValue` prop and exposes it to the
+ * items.
+ */
+export default function DropdownMenuRadioGroup({ value, onValueChange, label, className, children, }: DropdownMenuRadioGroupProps): import("react").JSX.Element;
+export type { DropdownMenuRadioGroupProps };

package/dist/types/components/DropdownMenu/DropdownMenuRadioItem.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+type DropdownMenuRadioItemProps = {
+    /** Value this option selects in its DropdownMenuRadioGroup when activated. */
+    value: string;
+    disabled?: boolean;
+    /** Danger skin for destructive actions: danger-colored text and interaction states. */
+    danger?: boolean;
+    /** Inline-start icon slot; bare `svg` children are sized to 1em by the slot. */
+    icon?: ReactNode;
+    /** Inline-end shortcut hint (e.g. '⌘C'), muted and pushed to the item's end. */
+    kbdLabel?: ReactNode;
+    className?: string;
+    children: ReactNode;
+};
+/**
+ * One option of a DropdownMenuRadioGroup (`role="menuitemradio"`):
+ * activating it (click, Enter, Space) selects its `value` in the
+ * group — the previously selected sibling deselects. Selecting keeps
+ * the menu open. Must live inside a `DropdownMenuRadioGroup`.
+ */
+export default function DropdownMenuRadioItem({ value, disabled, danger, icon, kbdLabel, className, children, }: DropdownMenuRadioItemProps): import("react").JSX.Element;
+export type { DropdownMenuRadioItemProps };

package/dist/types/components/DropdownMenu/dropdown-menu-item-styles.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared slot and variant skins for the DropdownMenu family's item
+ * types (DropdownMenuItem, DropdownMenuCheckboxItem,
+ * DropdownMenuRadioItem). Merged after each item's base class so the
+ * overrides win on equal specificity.
+ */
+/**
+ * Danger skin for destructive actions: danger-colored text with a
+ * danger-subtle interaction background.
+ */
+export declare const dropdownMenuItemDanger: import("@linaria/core").LinariaClassName;
+/**
+ * Inline-start icon slot. The slot sizes bare `svg` children to 1em —
+ * an svg without intrinsic dimensions collapses to 0×0 inside flex.
+ */
+export declare const dropdownMenuItemIcon: import("@linaria/core").LinariaClassName;
+/**
+ * Inline-end shortcut hint (e.g. '⌘C'): muted, monospaced, pushed to
+ * the item's inline end.
+ */
+export declare const dropdownMenuItemKbd: import("@linaria/core").LinariaClassName;
+/**
+ * Fixed-size state indicator box (check/dot) for checkbox and radio
+ * items: reserves its square whether or not the glyph renders, so
+ * labels align across mixed items.
+ */
+export declare const dropdownMenuItemIndicator: import("@linaria/core").LinariaClassName;
+/** Group heading: muted, one step smaller than item text. Shared by DropdownMenuGroup and DropdownMenuRadioGroup's optional label. */
+export declare const dropdownMenuGroupLabel: import("@linaria/core").LinariaClassName;

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

@@ -2,14 +2,22 @@ export { default as DropdownMenu } from './DropdownMenu';
 export { default as DropdownMenuTrigger } from './DropdownMenuTrigger';
 export { default as DropdownMenuContent } from './DropdownMenuContent';
 export { default as DropdownMenuItem } from './DropdownMenuItem';
+export { default as DropdownMenuCheckboxItem } from './DropdownMenuCheckboxItem';
+export { default as DropdownMenuRadioGroup } from './DropdownMenuRadioGroup';
+export { default as DropdownMenuRadioItem } from './DropdownMenuRadioItem';
+export { default as DropdownMenuGroup } from './DropdownMenuGroup';
 export { default as DropdownMenuSeparator } from './DropdownMenuSeparator';
 export { default as DropdownMenuSub } from './DropdownMenuSub';
 export { default as DropdownMenuSubTrigger } from './DropdownMenuSubTrigger';
 export { default as DropdownMenuSubContent } from './DropdownMenuSubContent';
-export type { DropdownMenuProps, DropdownMenuHandle } from './DropdownMenu';
+export type { DropdownMenuProps, DropdownMenuHandle, DropdownMenuDataItem } from './DropdownMenu';
 export type { DropdownMenuTriggerProps } from './DropdownMenuTrigger';
 export type { DropdownMenuContentProps } from './DropdownMenuContent';
 export type { DropdownMenuItemProps } from './DropdownMenuItem';
+export type { DropdownMenuCheckboxItemProps } from './DropdownMenuCheckboxItem';
+export type { DropdownMenuRadioGroupProps } from './DropdownMenuRadioGroup';
+export type { DropdownMenuRadioItemProps } from './DropdownMenuRadioItem';
+export type { DropdownMenuGroupProps } from './DropdownMenuGroup';
 export type { DropdownMenuSeparatorProps } from './DropdownMenuSeparator';
 export type { DropdownMenuSubProps } from './DropdownMenuSub';
 export type { DropdownMenuSubTriggerProps } from './DropdownMenuSubTrigger';

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

@@ -0,0 +1,19 @@
+import type { ComponentPropsWithoutRef } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+type EllipsisProps = {
+    /** Full text to clamp; the tooltip and expand affordances reuse it. */
+    children: string;
+    /** Visible line budget before the ellipsis kicks in (default 1). */
+    lines?: number;
+    /** Reveal the full text in a library Tooltip while clamped. */
+    tooltip?: boolean;
+    /** Render an expand/collapse toggle once truncation is detected. */
+    expandable?: boolean;
+    /** Clamped/revealed state — pass a `useControl` triple to own it. */
+    expanded?: ControlOrValue<boolean>;
+    /** Fires with the next value on toggle-button activation. */
+    onExpandChange?: (expanded: boolean) => void;
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'span'>, 'children'>;
+export default function Ellipsis({ children, lines, tooltip, expandable, expanded: expandedControl, onExpandChange, className, ...rest }: EllipsisProps): import("react").JSX.Element;
+export type { EllipsisProps };

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

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

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

@@ -30,5 +30,6 @@ type FullscreenProps = {
  */
 export default function Fullscreen({ fullscreen: fullscreenControl, onChange, target, children, }: FullscreenProps): ReactElement<{
     onClick?: MouseEventEventHandler;
+    'data-slot'?: string;
 }, string | import("react").JSXElementConstructor<any>>;
 export type { FullscreenProps };

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

@@ -2,8 +2,15 @@ import type { ReactNode } from 'react';
 type GridProps = {
     columns?: number;
     gap?: number;
+    /**
+     * Enables a container-query context (`container-type: inline-size`) so
+     * GridItem `sm`/`md`/`lg` breakpoints respond to the grid's own width
+     * instead of the viewport. Defaults to false, which keeps the DOM exactly
+     * that of a plain grid.
+     */
+    responsive?: boolean;
     className?: string;
     children: ReactNode;
 };
-export default function Grid({ columns, gap, className, children, }: GridProps): import("react").JSX.Element;
+export default function Grid({ columns, gap, responsive, className, children, }: GridProps): import("react").JSX.Element;
 export type { GridProps };

package/dist/types/components/Grid/GridItem.d.ts

@@ -1,9 +1,32 @@
 import type { ReactNode } from 'react';
 type GridItemProps = {
+    /** Number of columns to span */
     span?: number;
+    /**
+     * Grid column start line. Preserved across breakpoints when combined with
+     * `sm`/`md`/`lg` — the container queries override only the span.
+     */
     start?: number;
+    /**
+     * Columns to span (1-12) once the grid container is at least 384px wide.
+     * Only takes effect inside a `responsive` Grid; without one the container
+     * query never matches and the item degrades to `span`.
+     */
+    sm?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+    /**
+     * Columns to span (1-12) once the grid container is at least 576px wide.
+     * Only takes effect inside a `responsive` Grid; without one the container
+     * query never matches and the item degrades to `span`.
+     */
+    md?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+    /**
+     * Columns to span (1-12) once the grid container is at least 768px wide.
+     * Only takes effect inside a `responsive` Grid; without one the container
+     * query never matches and the item degrades to `span`.
+     */
+    lg?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
     className?: string;
     children: ReactNode;
 };
-export default function GridItem({ span, start, className, children, }: GridItemProps): import("react").JSX.Element;
+export default function GridItem({ span, start, sm, md, lg, className, children, }: GridItemProps): import("react").JSX.Element;
 export type { GridItemProps };

package/dist/types/components/Grid/grid-item-styles.d.ts

@@ -0,0 +1,57 @@
+declare const spanClasses: {
+    readonly 1: import("@linaria/core").LinariaClassName;
+    readonly 2: import("@linaria/core").LinariaClassName;
+    readonly 3: import("@linaria/core").LinariaClassName;
+    readonly 4: import("@linaria/core").LinariaClassName;
+    readonly 5: import("@linaria/core").LinariaClassName;
+    readonly 6: import("@linaria/core").LinariaClassName;
+    readonly 7: import("@linaria/core").LinariaClassName;
+    readonly 8: import("@linaria/core").LinariaClassName;
+    readonly 9: import("@linaria/core").LinariaClassName;
+    readonly 10: import("@linaria/core").LinariaClassName;
+    readonly 11: import("@linaria/core").LinariaClassName;
+    readonly 12: import("@linaria/core").LinariaClassName;
+};
+declare const smSpans: {
+    readonly 1: import("@linaria/core").LinariaClassName;
+    readonly 2: import("@linaria/core").LinariaClassName;
+    readonly 3: import("@linaria/core").LinariaClassName;
+    readonly 4: import("@linaria/core").LinariaClassName;
+    readonly 5: import("@linaria/core").LinariaClassName;
+    readonly 6: import("@linaria/core").LinariaClassName;
+    readonly 7: import("@linaria/core").LinariaClassName;
+    readonly 8: import("@linaria/core").LinariaClassName;
+    readonly 9: import("@linaria/core").LinariaClassName;
+    readonly 10: import("@linaria/core").LinariaClassName;
+    readonly 11: import("@linaria/core").LinariaClassName;
+    readonly 12: import("@linaria/core").LinariaClassName;
+};
+declare const mdSpans: {
+    readonly 1: import("@linaria/core").LinariaClassName;
+    readonly 2: import("@linaria/core").LinariaClassName;
+    readonly 3: import("@linaria/core").LinariaClassName;
+    readonly 4: import("@linaria/core").LinariaClassName;
+    readonly 5: import("@linaria/core").LinariaClassName;
+    readonly 6: import("@linaria/core").LinariaClassName;
+    readonly 7: import("@linaria/core").LinariaClassName;
+    readonly 8: import("@linaria/core").LinariaClassName;
+    readonly 9: import("@linaria/core").LinariaClassName;
+    readonly 10: import("@linaria/core").LinariaClassName;
+    readonly 11: import("@linaria/core").LinariaClassName;
+    readonly 12: import("@linaria/core").LinariaClassName;
+};
+declare const lgSpans: {
+    readonly 1: import("@linaria/core").LinariaClassName;
+    readonly 2: import("@linaria/core").LinariaClassName;
+    readonly 3: import("@linaria/core").LinariaClassName;
+    readonly 4: import("@linaria/core").LinariaClassName;
+    readonly 5: import("@linaria/core").LinariaClassName;
+    readonly 6: import("@linaria/core").LinariaClassName;
+    readonly 7: import("@linaria/core").LinariaClassName;
+    readonly 8: import("@linaria/core").LinariaClassName;
+    readonly 9: import("@linaria/core").LinariaClassName;
+    readonly 10: import("@linaria/core").LinariaClassName;
+    readonly 11: import("@linaria/core").LinariaClassName;
+    readonly 12: import("@linaria/core").LinariaClassName;
+};
+export { lgSpans, mdSpans, smSpans, spanClasses };

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

@@ -45,5 +45,5 @@ type HoverCardProps = {
     /** The trigger — render a focusable element for keyboard access. */
     children: ReactNode;
 };
-export default function HoverCard({ content, openDelay, closeDelay, placement, open: openControl, collisionPadding, className, children, }: HoverCardProps): import("react").JSX.Element;
+export default function HoverCard({ content, openDelay: openDelayProp, closeDelay: closeDelayProp, placement, open: openControl, collisionPadding, className, children, }: HoverCardProps): import("react").JSX.Element;
 export type { HoverCardProps };

package/dist/types/components/LocaleProvider/ar-sa.d.ts

@@ -0,0 +1,22 @@
+import type { HazeStrings } from './locale';
+/**
+ * Modern Standard Arabic (ar-SA) copy for every user-visible literal
+ * in the library. Not auto-selected by `LocaleProvider`'s `locale`
+ * tag (only Chinese and Japanese variants resolve automatically) —
+ * mount it explicitly:
+ *
+ *   <LocaleProvider locale="ar-SA" strings={arSA}>
+ *
+ * Arabic is RTL: the provider chain derives direction 'rtl' from the
+ * tag (see utils/direction.ts), while the app keeps responsibility
+ * for writing `dir="rtl"` on the document. Temporal labels such as
+ * "previous"/"next" stay semantic — their visual mirroring is the
+ * layout's job, not the copy's.
+ *
+ * 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 arSA: HazeStrings;
+export { arSA };

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

@@ -0,0 +1,15 @@
+import type { HazeStrings } from './locale';
+/**
+ * German (de-DE) copy for every user-visible literal in the library.
+ * Not auto-selected by `LocaleProvider`'s `locale` tag (only Chinese
+ * and Japanese variants resolve automatically) — mount it explicitly:
+ *
+ *   <LocaleProvider locale="de-DE" strings={deDE}>
+ *
+ * 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 deDE: HazeStrings;
+export { deDE };