haze-ui 1.26.0 → 1.28.0

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

@@ -1,13 +1,33 @@
+import type { Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
+import type { 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". */
+    picker?: CalendarPickerMode;
     min?: string;
     max?: string;
+    /** Disables individual dates on the calendar panel (see Calendar's
+     * `disabledDate`). */
+    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;
     locale?: string;
     weekStartsOn?: 0 | 1;
     placeholder?: string;
     className?: string;
+    /** Forwarded to the trigger `<input>` (not the wrapper div) — the
+     * element form bridges and `ref.current.focus()` reach. */
+    ref?: Ref<HTMLInputElement>;
 };
-export default function Datepicker({ value: valueControl, open: openControl, min, max, locale, weekStartsOn, placeholder, className, }: DatepickerProps): import("react").JSX.Element;
+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 type { DatepickerProps };

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

@@ -1,14 +1,41 @@
+import type { Ref } from 'react';
+import type { 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`. */
+    value: string;
+};
 type DatepickerCoreProps = {
     value: string;
     onChange: (value: string) => void;
     open: boolean;
     onOpenChange: (open: boolean) => void;
+    /** Calendar granularity; forwarded to the panel's Calendar and
+     * followed by `value`/`onChange` serialization. */
+    picker?: CalendarPickerMode;
     min?: string;
     max?: string;
+    /** Disables individual dates on the panel's Calendar (see Calendar's
+     * `disabledDate`). */
+    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;
     locale?: string;
     weekStartsOn?: 0 | 1;
     placeholder?: string;
     className?: string;
+    /** Forwarded to the trigger `<input>` (not the wrapper div). */
+    ref?: Ref<HTMLInputElement>;
 };
-export default function DatepickerCore({ value, onChange, open, onOpenChange, min, max, locale, weekStartsOn, placeholder, className, }: DatepickerCoreProps): import("react").JSX.Element;
-export type { DatepickerCoreProps };
+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 type { DatepickerCoreProps, DatepickerPreset };

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

@@ -0,0 +1,27 @@
+/**
+ * Serialization helpers for Datepicker's `showTime` mode.
+ *
+ * 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).
+ */
+/**
+ * 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.
+ */
+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.
+ */
+export declare function formatDateTimeValue(date: string, time: string): string;

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

@@ -1,4 +1,4 @@
 export { default as Datepicker } from './Datepicker';
 export type { DatepickerProps } from './Datepicker';
 export { default as DatepickerCore } from './DatepickerCore';
-export type { DatepickerCoreProps } from './DatepickerCore';
+export type { DatepickerCoreProps, DatepickerPreset } from './DatepickerCore';

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

@@ -0,0 +1,30 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+/**
+ * One key→value pair. `span` is measured in description columns
+ * (label+value pairs per row), matching AntD: `span: 2` stretches the
+ * value across a second column pair on the same row.
+ */
+type DescriptionsItem = {
+    /** Stable identity for the pair within `items`. */
+    key: string;
+    /** The term (`<dt>`). */
+    label: ReactNode;
+    /** The description (`<dd>`). */
+    children: ReactNode;
+    /** Columns the item occupies; clamped to `columns`. Default 1. */
+    span?: number;
+};
+type DescriptionsProps = {
+    /** Ordered pairs to display — the list is data-driven (no children). */
+    items: DescriptionsItem[];
+    /** Description columns (label+value pairs per row). Default 3. */
+    columns?: number;
+    /** Bordered variant: full grid lines plus a shaded label column. */
+    bordered?: boolean;
+    /** Cell padding density. Default 'md'. */
+    size?: 'sm' | 'md';
+    /** Heading rendered above the list (outside the `<dl>`). */
+    title?: ReactNode;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children' | 'title'>;
+export default function Descriptions({ items, columns, bordered, size, title, className, style, ...rest }: DescriptionsProps): import("react").JSX.Element;
+export type { DescriptionsProps, DescriptionsItem };

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

@@ -0,0 +1,2 @@
+export { default as Descriptions } from './Descriptions';
+export type { DescriptionsProps, DescriptionsItem } from './Descriptions';

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

@@ -1,5 +1,50 @@
-import type { ReactNode } from 'react';
+import type { ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
+/**
+ * Imperative handle exposed through the React 19 `ref` prop (same API
+ * choice as VirtualList). `open`/`close` are state writes going through
+ * the same control path as every other open transition, so the animated
+ * exit → native `close` event remains the single `onClose` exit — a
+ * handle close never double-fires the callback.
+ */
+type DialogHandle = {
+    /** Show the dialog (`showModal` + initial focus, as if `open` flipped true). */
+    open: () => void;
+    /**
+     * Close the dialog through the animated exit; `onClose` fires exactly
+     * once, via the native close event — never synchronously here.
+     */
+    close: () => void;
+    /** Focus the element that held focus when the dialog last opened. */
+    focusTrigger: () => void;
+};
+/**
+ * Semantic slot classes (AntD v6 `classNames` 形态)：键名对应 Dialog 的
+ * 结构部位，消费者类名追加在部位节点 x-class 数组末尾（可覆盖组件
+ * 默认样式）。Dialog 的面板就是 `<dialog>` 元素本身、遮罩是它的
+ * `::backdrop` 伪元素（无法挂类），因此只有这两个真实部位：
+ *
+ * - `root` — `<dialog>` 面板元素
+ * - `header` — `title` prop 渲染出的 `<h2>` 标题（不传 title 时不存在）
+ */
+type DialogClassNames = {
+    /** `<dialog>` 面板元素（含内边距/圆角/阴影的盒子）。 */
+    root?: string;
+    /** 标题 `<h2>`；仅在传 `title` prop 时渲染。 */
+    header?: string;
+};
+/**
+ * Component-level tokens: Dialog can be rethemed per-component by setting
+ * `--haze-dialog-*` custom properties on `:root` or any ancestor. The
+ * library never defines them — the stylesheet only carries fallback
+ * chains, so unset variables keep the shipped look:
+ *
+ * - `--haze-dialog-width` — panel max-width (fallback `480px`)
+ * - `--haze-dialog-radius` — panel corner radius (fallback `--haze-radius-xl`)
+ * - `--haze-dialog-padding` — panel body padding (fallback `--haze-space-6`)
+ * - `--haze-dialog-title-gap` — gap between title and body (fallback `--haze-space-4`)
+ * - `--haze-dialog-title-font-size` — title text size (fallback `--haze-text-lg`)
+ */
 type DialogProps = {
     open?: ControlOrValue<boolean>;
     onClose?: () => void;
@@ -9,8 +54,28 @@ type DialogProps = {
      * 可访问名默认为空）。不传时不生成空关联。
      */
     title?: ReactNode;
+    /**
+     * 开/关状态翻转是否包进 View Transitions API（默认 `false`，行为与
+     * 不传完全一致）。开启后每次显隐翻转都运行在
+     * `document.startViewTransition(() => flushSync(...))` 里（React 官方
+     * 要求的同步 DOM 更新模式），页面获得原生过渡；命令式 handle、
+     * Esc、背景点击等路径共用同一出口。引擎不支持
+     * `startViewTransition` 或用户偏好 `prefers-reduced-motion: reduce`
+     * 时自动退化为直接翻转。过渡外观由消费方的 `::view-transition-*`
+     * 样式定义，组件自身的进退场动画照常运行在新快照内。
+     */
+    viewTransition?: boolean;
+    /**
+     * 语义槽位类名（AntD v6 `classNames` 形态）：按键把消费者类落到
+     * Dialog 的结构部位（见 {@link DialogClassNames}）。槽位类追加在
+     * 部位节点类列表末尾，可与根节点 `className` 并用（`className`
+     * 同样落在 `<dialog>` 上，`classNames.root` 在其后）。不传时渲染
+     * 输出零变化。
+     */
+    classNames?: DialogClassNames;
     className?: string;
     children: ReactNode;
+    ref?: Ref<DialogHandle>;
 };
-export default function Dialog({ open: openControl, onClose, title, className, children, }: DialogProps): import("react").JSX.Element;
-export type { DialogProps };
+export default function Dialog({ open: openControl, onClose, title, viewTransition, classNames, className, children, ref, }: DialogProps): import("react").JSX.Element;
+export type { DialogProps, DialogHandle, DialogClassNames };

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

@@ -1,2 +1,2 @@
 export { default as Dialog } from './Dialog';
-export type { DialogProps } from './Dialog';
+export type { DialogProps, DialogHandle, DialogClassNames } from './Dialog';

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

@@ -1,11 +1,41 @@
-import type { ReactNode } from 'react';
+import type { ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
+/**
+ * Imperative handle exposed through the React 19 `ref` prop (same API
+ * choice as VirtualList). `open`/`close` are state writes going through
+ * the same control path as every other open transition, so the animated
+ * exit → native `close` event remains the single `onClose` exit — a
+ * handle close never double-fires the callback.
+ */
+type DrawerHandle = {
+    /** Show the drawer (`showModal` + initial focus, as if `open` flipped true). */
+    open: () => void;
+    /**
+     * Close the drawer through the animated exit; `onClose` fires exactly
+     * once, via the native close event — never synchronously here.
+     */
+    close: () => void;
+    /** Focus the element that held focus when the drawer last opened. */
+    focusTrigger: () => void;
+};
 type DrawerProps = {
     open?: ControlOrValue<boolean>;
     placement?: 'left' | 'right' | 'top' | 'bottom';
     onClose?: () => void;
+    /**
+     * 开/关状态翻转是否包进 View Transitions API（默认 `false`，行为与
+     * 不传完全一致）。开启后每次显隐翻转都运行在
+     * `document.startViewTransition(() => flushSync(...))` 里（React 官方
+     * 要求的同步 DOM 更新模式），页面获得原生过渡；命令式 handle、
+     * Esc、背景点击等路径共用同一出口。引擎不支持
+     * `startViewTransition` 或用户偏好 `prefers-reduced-motion: reduce`
+     * 时自动退化为直接翻转。过渡外观由消费方的 `::view-transition-*`
+     * 样式定义，组件自身的进退场动画照常运行在新快照内。
+     */
+    viewTransition?: boolean;
     className?: string;
     children: ReactNode;
+    ref?: Ref<DrawerHandle>;
 };
-export default function Drawer({ open: openControl, placement, onClose, className, children, }: DrawerProps): import("react").JSX.Element;
-export type { DrawerProps };
+export default function Drawer({ open: openControl, placement, onClose, viewTransition, className, children, ref, }: DrawerProps): import("react").JSX.Element;
+export type { DrawerProps, DrawerHandle };

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

@@ -1,2 +1,2 @@
 export { default as Drawer } from './Drawer';
-export type { DrawerProps } from './Drawer';
+export type { DrawerProps, DrawerHandle } from './Drawer';

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

@@ -1,6 +1,25 @@
-import type { ReactNode } from 'react';
+import type { ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 import type { CollisionPadding } from '../../utils/collision';
+/**
+ * Imperative handle exposed through the React 19 `ref` prop (same API
+ * choice as VirtualList). `open`/`close` run through the same
+ * `handleSetOpen` the trigger and items use — `onOpenChange` fires, and
+ * the floating engine's popover visibility, animated exit and
+ * toggle-echo reconciliation stay in charge; the handle never calls
+ * `showPopover`/`hidePopover` directly.
+ */
+type DropdownMenuHandle = {
+    /** Show the menu, as if the trigger toggled it open (`onOpenChange(true)`). */
+    open: () => void;
+    /**
+     * Close the menu through the animated exit path
+     * (`onOpenChange(false)`).
+     */
+    close: () => void;
+    /** Focus the trigger element. */
+    focusTrigger: () => void;
+};
 type DropdownMenuProps = {
     open?: ControlOrValue<boolean>;
     onOpenChange?: (open: boolean) => void;
@@ -11,6 +30,7 @@ type DropdownMenuProps = {
     collisionPadding?: CollisionPadding;
     children: ReactNode;
     className?: string;
+    ref?: Ref<DropdownMenuHandle>;
 };
-export default function DropdownMenu({ open: openControl, onOpenChange, collisionPadding, children, className, }: DropdownMenuProps): import("react").JSX.Element;
-export type { DropdownMenuProps };
+export default function DropdownMenu({ open: openControl, onOpenChange, collisionPadding, children, className, ref, }: DropdownMenuProps): import("react").JSX.Element;
+export type { DropdownMenuProps, DropdownMenuHandle };

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

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

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

@@ -0,0 +1,13 @@
+import type { ReactNode } from 'react';
+type DropdownMenuSubContentProps = {
+    className?: string;
+    children: ReactNode;
+};
+/**
+ * The panel of a DropdownMenuSub submenu. Unmounts once closed, like
+ * DropdownMenuContent (the animated exit keeps it mounted through the
+ * fade); keyboard focus is contained to this level — Escape closes only
+ * this submenu.
+ */
+export default function DropdownMenuSubContent({ className, children, }: DropdownMenuSubContentProps): import("react").JSX.Element | null;
+export type { DropdownMenuSubContentProps };

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

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

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

@@ -3,8 +3,14 @@ export { default as DropdownMenuTrigger } from './DropdownMenuTrigger';
 export { default as DropdownMenuContent } from './DropdownMenuContent';
 export { default as DropdownMenuItem } from './DropdownMenuItem';
 export { default as DropdownMenuSeparator } from './DropdownMenuSeparator';
-export type { DropdownMenuProps } from './DropdownMenu';
+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 { DropdownMenuTriggerProps } from './DropdownMenuTrigger';
 export type { DropdownMenuContentProps } from './DropdownMenuContent';
 export type { DropdownMenuItemProps } from './DropdownMenuItem';
 export type { DropdownMenuSeparatorProps } from './DropdownMenuSeparator';
+export type { DropdownMenuSubProps } from './DropdownMenuSub';
+export type { DropdownMenuSubTriggerProps } from './DropdownMenuSubTrigger';
+export type { DropdownMenuSubContentProps } from './DropdownMenuSubContent';

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

@@ -0,0 +1,35 @@
+import type { ComponentPropsWithoutRef } from 'react';
+/** The attached file's descriptor — name plus optional metadata. */
+type FilePreviewFile = {
+    name: string;
+    /** Size in bytes; formatted via KB/MB when present. */
+    size?: number;
+    /** MIME type; `image/*` with a `url` renders a thumbnail. */
+    type?: string;
+    url?: string;
+};
+type FilePreviewStatus = 'uploading' | 'uploaded' | 'error';
+type FilePreviewProps = {
+    file: FilePreviewFile;
+    /** Lifecycle of the attachment; drives progress, status text, retry. */
+    status?: FilePreviewStatus;
+    /** 0–100 upload progress, clamped; shown while `status` is `uploading`. */
+    progress?: number;
+    /** Rendering the remove action; only shown when provided. */
+    onRemove?: () => void;
+    /** Rendering the retry action; only shown in the `error` status. */
+    onRetry?: () => void;
+    /** Remove button label. Default from `filePreview.remove`. */
+    removeLabel?: string;
+    /** Retry button label. Default from `filePreview.retry`. */
+    retryLabel?: string;
+    /** Status text while `status` is `uploading`. Default from `filePreview.uploading`. */
+    uploadingLabel?: string;
+    /** Status text once `status` is `uploaded`. Default from `filePreview.uploaded`. */
+    uploadedLabel?: string;
+    /** Status text when `status` is `error`. Default from `filePreview.error`. */
+    errorLabel?: string;
+    className?: string;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children'>;
+export default function FilePreview({ file, status, progress, onRemove, onRetry, removeLabel, retryLabel, uploadingLabel, uploadedLabel, errorLabel, className, ...rest }: FilePreviewProps): import("react").JSX.Element;
+export type { FilePreviewProps, FilePreviewFile, FilePreviewStatus };

package/dist/types/components/FilePreview/file-preview-format.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Pure formatting helpers for FilePreview. Component-prefixed basename
+ * (`file-preview-*`): Linaria slug collisions are a non-issue in a
+ * class-free module, but the naming rule keeps sibling files greppable
+ * and future-proofs a later style split.
+ */
+/**
+ * Human-readable byte size: `B` below 1 KiB, then the largest fitting
+ * binary unit (`KB`/`MB`/`GB`/`TB`) with 2 significant decimals
+ * (`512 B`, `1.00 KB`, `1.50 MB`). Non-finite or negative input (and
+ * `undefined`) yields an empty string so callers can skip the meta chip.
+ */
+declare function formatFileSize(bytes?: number): string;
+/**
+ * Uppercase extension of a file name for the type badge (`report.pdf` →
+ * `PDF`). Leading-dot files (` .vimrc`), extension-less names and a
+ * trailing dot return an empty string (no badge).
+ */
+declare function getFileExtension(name: string): string;
+export { formatFileSize, getFileExtension };

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

@@ -0,0 +1,2 @@
+export { default as FilePreview } from './FilePreview';
+export type { FilePreviewProps, FilePreviewFile, FilePreviewStatus } from './FilePreview';

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

@@ -0,0 +1,43 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+/**
+ * A floating action button pinned to the inline-end / block-end screen
+ * corner — the "primary action" affordance material design popularized.
+ * General-purpose: any global action (create, chat, share…). For the
+ * specific "scroll back up" action keep `BackToTop`, which owns its own
+ * scroll-watching logic.
+ *
+ * Pass `href` to render a real anchor (navigation keeps ⌘/middle-click
+ * and crawlability — the ButtonLink rationale); without it a
+ * `<button type='button'>` is rendered and the rest of the native
+ * attributes spread through.
+ *
+ * `variant` follows Button's `solid | outline | ghost` semantics over
+ * the same color tokens; only the elevation (FAB shadow) is
+ * FloatButton-specific. The default icon is a plus glyph — `icon`
+ * replaces it (give a custom `svg` explicit width/height, or wrap it in
+ * `Icon`).
+ *
+ * Standalone use fixes the button to the corner via logical insets
+ * (RTL-safe; `--haze-float-button-offset` re-themes the gap). Inside a
+ * `FloatButtonGroup` the button drops its own anchor and joins the
+ * group's expandable menu.
+ *
+ * An icon-only FloatButton has no accessible name — pass `aria-label`
+ * (it spreads through like any native attribute) or a `description`.
+ */
+type FloatButtonProps = {
+    /** Icon slot; defaults to a plus glyph. Purely decorative (hidden
+     * from AT) — the accessible name comes from `description` or
+     * `aria-label`. */
+    icon?: ReactNode;
+    /** Text beside the icon (pill-shaped button); doubles as the
+     * accessible name. */
+    description?: ReactNode;
+    shape?: 'circle' | 'square';
+    /** Button-aligned color variant over the same tokens. */
+    variant?: 'solid' | 'outline' | 'ghost';
+    /** Render an anchor navigating to this URL instead of a button. */
+    href?: string;
+} & Omit<ComponentPropsWithoutRef<'button'>, 'type'> & Omit<ComponentPropsWithoutRef<'a'>, 'children' | 'type'>;
+export default function FloatButton({ icon, description, shape, variant, href, className, onClick, ...rest }: FloatButtonProps): import("react").JSX.Element;
+export type { FloatButtonProps };

package/dist/types/components/FloatButton/FloatButtonGroup.d.ts

@@ -0,0 +1,33 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+import type { ControlOrValue } from 'react-use-control';
+/**
+ * A `FloatButton` whose trigger expands a stack of `FloatButton`
+ * children — the classic FAB menu. The trigger owns the fixed anchor
+ * (`--haze-float-button-offset`), rotates its plus into an × as the menu
+ * opens, and reports the state through `aria-expanded` /
+ * `aria-controls`. Activating a child button dismisses the menu (the
+ * child's own `onClick` runs first); Escape closes it too.
+ *
+ * `open` follows the controllable-state contract: a control drives it
+ * live, a plain boolean is the uncontrolled initial value.
+ */
+type FloatButtonGroupProps = {
+    /** Expanded state; a Control drives it live, a plain boolean is the
+     * uncontrolled initial value. */
+    open?: ControlOrValue<boolean>;
+    /** Fires whenever the expanded state changes through user
+     * interaction — trigger toggle, child activation or Escape. */
+    onOpenChange?: (open: boolean) => void;
+    /** Icon of the trigger button; defaults to a plus glyph (rotates 45°
+     * into an × while open). */
+    icon?: ReactNode;
+    /** Text beside the trigger icon; doubles as its accessible name. */
+    description?: ReactNode;
+    shape?: 'circle' | 'square';
+    /** Button-aligned color variant over the same tokens. */
+    variant?: 'solid' | 'outline' | 'ghost';
+    /** `FloatButton` items revealed by the trigger. */
+    children: ReactNode;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'children'>;
+export default function FloatButtonGroup({ open: openControl, onOpenChange, icon, description, shape, variant, children, className, onKeyDown, ...rest }: FloatButtonGroupProps): import("react").JSX.Element;
+export type { FloatButtonGroupProps };

package/dist/types/components/FloatButton/float-button-context.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Provided by `FloatButtonGroup`. A `FloatButton` inside a group drops
+ * its own fixed anchor (the group owns the anchor) and closes the menu
+ * after its action runs (AntD behavior).
+ */
+export type FloatButtonGroupContextValue = {
+    /** Request the group menu to close. */
+    closeMenu: () => void;
+};
+export declare const FloatButtonGroupContext: import("react").Context<FloatButtonGroupContextValue | undefined>;
+export declare function useFloatButtonGroup(): FloatButtonGroupContextValue | undefined;

package/dist/types/components/FloatButton/float-button-glyphs.d.ts

@@ -0,0 +1,3 @@
+/** Default FloatButton glyph — a plus that reads as an × once the group
+ * trigger rotates it 45° (see `iconOpen` in ./float-button-styles). */
+export declare function PlusGlyph(): import("react").JSX.Element;

package/dist/types/components/FloatButton/float-button-styles.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Shared FloatButton skin — the button face both `FloatButton` and the
+ * `FloatButtonGroup` trigger wear, plus the fixed anchor and the
+ * expand/collapse menu mechanics. Split into its own module (with the
+ * `float-button-` basename Linaria hashes class names from) so component
+ * files stay free of style internals and no two siblings ever collide on
+ * the `haze-styles__*` slug.
+ *
+ * ## Component-level tokens
+ *
+ * The skin exposes component-scoped custom properties for per-component
+ * theming. The library never *defines* them — every usage below is a
+ * fallback chain, so the shipped look is the fallback until a consumer
+ * sets the variable on `:root` or any ancestor (plain CSS inheritance):
+ *
+ * - `--haze-float-button-size` — button size (fallback `2.5rem`)
+ * - `--haze-float-button-offset` — screen-edge gap of the fixed anchor
+ *   (fallback `--haze-space-6`); the safe-area inset is always added on
+ *   top for the block-end edge
+ * - `--haze-float-button-radius` — `square` shape radius
+ *   (fallback `--haze-radius-lg`)
+ *
+ * ## Button semantics
+ *
+ * `variant` mirrors Button's `solid | outline | ghost` family and reads
+ * the same color tokens, so a FloatButton re-themes together with
+ * Buttons — only the elevation (FAB shadow) is FloatButton-specific.
+ */
+export declare const fab: import("@linaria/core").LinariaClassName;
+export declare const shapes: {
+    readonly circle: import("@linaria/core").LinariaClassName;
+    readonly square: import("@linaria/core").LinariaClassName;
+};
+export declare const variants: {
+    readonly solid: import("@linaria/core").LinariaClassName;
+    readonly outline: import("@linaria/core").LinariaClassName;
+    readonly ghost: import("@linaria/core").LinariaClassName;
+};
+/**
+ * Fixed screen anchor — logical insets keep the placement RTL-safe
+ * (inline-end flips with direction). Only the block-end edge carries the
+ * physical safe-area env, which has no logical counterpart but matches
+ * block-end in every horizontal writing mode.
+ */
+export declare const anchored: import("@linaria/core").LinariaClassName;
+export declare const groupAnchor: import("@linaria/core").LinariaClassName;
+/**
+ * Expand/collapse list of grouped buttons. The outer grid animates its
+ * single row track 1fr↔0fr (no content-height knowledge needed); the
+ * structural inner wrapper clips while shrinking. `visibility` keeps
+ * collapsed items out of the tab order, delayed on close so the collapse
+ * animation finishes first and immediate on open.
+ */
+export declare const menuList: import("@linaria/core").LinariaClassName;
+export declare const iconBox: import("@linaria/core").LinariaClassName;
+/** Plus rotates into an × as the group opens (AntD behavior). */
+export declare const iconOpen: import("@linaria/core").LinariaClassName;
+export declare const descBox: import("@linaria/core").LinariaClassName;

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

@@ -0,0 +1,4 @@
+export { default as FloatButton } from './FloatButton';
+export type { FloatButtonProps } from './FloatButton';
+export { default as FloatButtonGroup } from './FloatButtonGroup';
+export type { FloatButtonGroupProps } from './FloatButtonGroup';