haze-ui 1.29.0 → 1.30.0

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

@@ -1,11 +1,25 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type PaginationProps = {
     page?: ControlOrValue<number>;
     total: number;
-    pageSize?: number;
+    pageSize?: ControlOrValue<number>;
+    /** Page sizes offered by the size changer (`showSizeChanger`). */
+    pageSizeOptions?: number[];
+    /** Renders a page-size select; changing it resets to page 1. */
+    showSizeChanger?: boolean;
+    /** Renders a "Go to [input]" control that jumps on Enter (clamped). */
+    showQuickJumper?: boolean;
+    /** Renders a summary of `total` and the current page's item range. */
+    showTotal?: (total: number, range: [number, number]) => ReactNode;
+    /** Minimal mode: a page input plus prev/next instead of the page list. */
+    simple?: boolean;
+    /** Turns the ellipsis markers into buttons jumping ±5 pages (clamped). */
+    ellipsisJump?: boolean;
+    /** Value callback fired for every page jump and page-size change. */
+    onPageChange?: (page: number, pageSize: number) => void;
     size?: 'sm' | 'md' | 'lg';
     className?: string;
 } & Omit<ComponentPropsWithoutRef<'nav'>, 'onChange'>;
-export default function Pagination({ page: pageControl, total, pageSize, size, className, ...rest }: PaginationProps): import("react").JSX.Element;
+export default function Pagination({ page: pageControl, total, pageSize: pageSizeControl, pageSizeOptions, showSizeChanger, showQuickJumper, showTotal, simple, ellipsisJump, onPageChange, size, className, ...rest }: PaginationProps): import("react").JSX.Element;
 export type { PaginationProps };

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

@@ -49,7 +49,7 @@ export declare const SidebarItem: import("react").ForwardRefExoticComponent<{
      */
     onClick?: (event: MouseEvent<HTMLAnchorElement>) => void;
     className?: string;
-} & Omit<Omit<import("react").DetailedHTMLProps<import("react").AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref">, "className" | "children" | "onClick"> & import("react").RefAttributes<HTMLAnchorElement>>;
+} & Omit<Omit<import("react").DetailedHTMLProps<import("react").AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref">, "children" | "className" | "onClick"> & import("react").RefAttributes<HTMLAnchorElement>>;
 type SidebarFooterProps = {
     children: ReactNode;
     className?: string;

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

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type SliderProps = {
     /** `number` in single mode, `[low, high]` when `range` is set. */
@@ -22,11 +22,33 @@ type SliderProps = {
      * identically named sliders are ambiguous — prefer the tuple).
      */
     'aria-label'?: string | [string, string];
+    /**
+     * Value bubble over the active thumb while dragging or focused
+     * (see SliderCoreProps.tooltip). Opt-in; in single mode it wraps the
+     * input in a positioning span (the input keeps `className`).
+     */
+    tooltip?: boolean;
+    /** Bubble content formatter (see SliderCoreProps.tooltipFormatter). */
+    tooltipFormatter?: (value: number) => ReactNode;
+    /**
+     * Tick labels under the track, clickable onto the nearest thumb
+     * (see SliderCoreProps.marks).
+     */
+    marks?: Record<number, ReactNode>;
+    /**
+     * Vertical orientation, bottom-to-top (see SliderCoreProps.vertical).
+     */
+    vertical?: boolean;
+    /**
+     * `null` restricts the selectable values to the `marks` keys
+     * (see SliderCoreProps.step); a number forwards to the native input.
+     */
+    step?: number | null;
     /**
      * Forwarded to the `<input type='range'>` — the only input in single
      * mode, the low thumb (first tab stop) in range mode.
      */
     ref?: Ref<HTMLInputElement>;
-} & Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'value' | 'aria-label'>;
+} & Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'value' | 'aria-label' | 'step'>;
 export default function Slider({ value: valueControl, range, className, onChange, onValuesChange, ref, ...rest }: SliderProps): import("react").JSX.Element;
 export type { SliderProps };

package/dist/types/components/Slider/SliderCore.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
 type SliderCoreProps = {
     /** `number` in single mode, `[low, high]` when `range` is set. An
      * inverted tuple renders normalized (low ≤ high). */
@@ -21,6 +21,44 @@ type SliderCoreProps = {
      * pointer input.
      */
     range?: boolean;
+    /**
+     * Shows a value bubble over the active thumb while it is being
+     * dragged (pointerdown until pointerup) or focused. Opt-in: without
+     * it nothing extra renders. The bubble is visual only
+     * (`aria-hidden`) — the native input keeps exposing the value, so
+     * `aria-valuetext` semantics are untouched. In range mode each thumb
+     * carries its own bubble.
+     */
+    tooltip?: boolean;
+    /** Formats the bubble content (both modes); defaults to the raw
+     * number. */
+    tooltipFormatter?: (value: number) => ReactNode;
+    /**
+     * Tick labels rendered under the track (beside it when `vertical`).
+     * Clicking a label commits that value to the nearest thumb (ties go
+     * to the low thumb; a value past the other thumb still snaps against
+     * it instead of crossing). Combine with `step={null}` to restrict
+     * the selectable values to the mark keys.
+     */
+    marks?: Record<number, ReactNode>;
+    /**
+     * Vertical orientation (bottom-to-top) via the modern
+     * `writing-mode: vertical-lr; direction: rtl` slider recipe
+     * (Chromium 119+ / Firefox 120+ / Safari 17.4+; older engines keep
+     * rendering horizontally). Keyboard behavior stays native — the
+     * RTL arrow mirroring only applies to horizontal sliders. The track
+     * length defaults to `calc(var(--haze-space-16) * 2)`; override it
+     * by setting `--haze-slider-track` on the slider or an ancestor.
+     */
+    vertical?: boolean;
+    /**
+     * Pass `null` (with `marks`) to make the marks the only selectable
+     * values: the native inputs receive `step='any'` and every change —
+     * drag, click or keyboard — snaps to the nearest mark key. A number
+     * is forwarded to the native inputs as-is; omitted keeps the native
+     * default.
+     */
+    step?: number | null;
     className?: string;
     /**
      * Single mode: forwarded to the input untouched. Range mode: a
@@ -35,6 +73,6 @@ type SliderCoreProps = {
      * mode, the low thumb (first tab stop) in range mode.
      */
     ref?: Ref<HTMLInputElement>;
-} & Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'value' | 'onChange' | 'aria-label'>;
-export default function SliderCore({ value, onChange, onNativeChange, range, className, onKeyDown, 'aria-label': ariaLabel, ref, ...rest }: SliderCoreProps): import("react").JSX.Element;
+} & Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'value' | 'onChange' | 'aria-label' | 'step'>;
+export default function SliderCore({ value, onChange, onNativeChange, range, className, onKeyDown, 'aria-label': ariaLabel, tooltip, tooltipFormatter, marks, vertical, step, onPointerDown, onFocus, onBlur, ref, ...rest }: SliderCoreProps): import("react").JSX.Element;
 export type { SliderCoreProps };

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

@@ -1,9 +1,16 @@
 type StreamingTextProps = {
     text: string;
     speed?: number;
+    /**
+     * How often (ms) the screen-reader live region picks up a new snapshot
+     * of the streamed text. Everything streamed in between stays silent:
+     * announcing per character would restart the reader's utterance on
+     * every tick, so the throttle is the point, not an optimization.
+     */
+    announceInterval?: number;
     onComplete?: () => void;
     showCursor?: boolean;
     className?: string;
 };
-export default function StreamingText({ text, speed, onComplete, showCursor, className, }: StreamingTextProps): import("react").JSX.Element;
+export default function StreamingText({ text, speed, announceInterval, onComplete, showCursor, className, }: StreamingTextProps): import("react").JSX.Element;
 export type { StreamingTextProps };

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

@@ -1,13 +1,45 @@
 import type { ComponentPropsWithoutRef, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
+import type { TimeParts, TimePickerFormat } from './time';
 type TimePickerProps = {
     value?: ControlOrValue<string>;
+    /** Panel visibility; defaults to the trigger's own toggle state. */
+    open?: ControlOrValue<boolean>;
     onChange?: (value: string) => void;
+    /**
+     * Column granularity and the value's serialization shape. The panel
+     * shows hour/minute columns for `'HH:mm'` (default) and adds a second
+     * column for `'HH:mm:ss'`; `value` always serializes to match.
+     */
+    format?: TimePickerFormat;
+    /** Hour column step — only multiples of it are offered. Default 1. */
+    hourStep?: number;
+    /** Minute column step — only multiples of it are offered. Default 1. */
+    minuteStep?: number;
+    /** Second column step — only multiples of it are offered. Default 1. */
+    secondStep?: number;
+    /**
+     * Presents a 12-hour clock column plus an AM/PM column. The value
+     * stays 24-hour `"HH:mm[:ss]"` either way (12:34 AM is `00:34`).
+     */
+    use12Hours?: boolean;
+    /**
+     * Disables candidate times on the panel's columns: return `true` to
+     * make that cell unselectable (muted + not clickable). Each candidate
+     * is judged against the currently selected parts of the other
+     * fields, so a disabled hour re-evaluates as minutes change.
+     */
+    disabledTime?: (parts: TimeParts) => boolean;
+    /**
+     * Falls back to the bare native `<input type="time">` form
+     * (TimePickerCore) — the panel props above do not apply to it.
+     */
+    native?: boolean;
     placeholder?: string;
     className?: string;
-    /** Forwarded to the underlying `<input>` — the element form bridges
-     * and `ref.current.focus()` reach. */
+    /** Forwarded to the trigger `<input>` — the element form bridges and
+     * `ref.current.focus()` reach. */
     ref?: Ref<HTMLInputElement>;
-} & Omit<ComponentPropsWithoutRef<'input'>, 'value' | 'onChange' | 'type' | 'placeholder'>;
-export default function TimePicker({ value: valueControl, onChange, placeholder, className, ref, ...rest }: TimePickerProps): import("react").JSX.Element;
+} & Omit<ComponentPropsWithoutRef<'input'>, 'value' | 'onChange' | 'type' | 'placeholder' | 'defaultValue'>;
+export default function TimePicker({ value: valueControl, open: openControl, onChange, format, hourStep, minuteStep, secondStep, use12Hours, disabledTime, native, placeholder, className, ref, ...rest }: TimePickerProps): import("react").JSX.Element;
 export type { TimePickerProps };

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

@@ -0,0 +1,26 @@
+import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { TimeParts, TimePickerFormat } from './time';
+/**
+ * One enabled/disabled decision for a candidate cell. The predicate is
+ * evaluated against the currently selected parts for the other fields
+ * (see `disabledTime` on TimePickerProps).
+ */
+type TimePredicate = (parts: TimeParts) => boolean;
+type TimePickerPanelProps = {
+    value: string;
+    onChange: (value: string) => void;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    format: TimePickerFormat;
+    hourStep: number;
+    minuteStep: number;
+    secondStep: number;
+    use12Hours: boolean;
+    disabledTime?: TimePredicate;
+    placeholder?: string;
+    className?: string;
+    /** Forwarded to the trigger `<input>` — focus bridges reach it. */
+    ref?: Ref<HTMLInputElement>;
+} & Omit<ComponentPropsWithoutRef<'input'>, 'value' | 'onChange' | 'type' | 'placeholder' | 'defaultValue'>;
+export default function TimePickerPanel({ value, onChange, open, onOpenChange, format, hourStep, minuteStep, secondStep, use12Hours, disabledTime, placeholder, className, onKeyDown: consumerKeyDown, ref, ...rest }: TimePickerPanelProps): import("react").JSX.Element;
+export {};

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

@@ -2,3 +2,4 @@ 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';

package/dist/types/components/TimePicker/time-picker-styles.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Linaria classes for the TimePicker panel form (TimePicker.tsx /
+ * TimePickerPanel.tsx). Lives in a sibling file — component files only
+ * export components and types (react-refresh/only-export-components).
+ */
+export declare const wrapper: import("@linaria/core").LinariaClassName;
+/** Readonly trigger input (Datepicker's trigger look). */
+export declare const trigger: import("@linaria/core").LinariaClassName;
+/** Panel visual skin applied on every rendering tier. */
+export declare const panel: import("@linaria/core").LinariaClassName;
+export declare const columns: import("@linaria/core").LinariaClassName;
+/**
+ * One column frame: fixed height (7 option rows), the highlight band
+ * behind the center row, and the scrolling list on top of it. The band
+ * is where a committed selection scrolls to, so it stays put while the
+ * list moves under it.
+ */
+export declare const columnWrap: import("@linaria/core").LinariaClassName;
+/**
+ * The scrolling option list. Padding of three rows lets the first and
+ * last options center in the band like every other row. Positioned
+ * above the wrap's ::before band.
+ */
+export declare const columnList: import("@linaria/core").LinariaClassName;
+export declare const columnOption: import("@linaria/core").LinariaClassName;
+export declare const columnOptionSelected: import("@linaria/core").LinariaClassName;
+export declare const columnOptionDisabled: import("@linaria/core").LinariaClassName;
+/** Panel footer: the "Now" action row. */
+export declare const footer: import("@linaria/core").LinariaClassName;
+export declare const nowButton: import("@linaria/core").LinariaClassName;

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

@@ -0,0 +1,49 @@
+/**
+ * Time-of-day value helpers for the TimePicker panel form.
+ *
+ * The value is a 24-hour `"HH:mm"` / `"HH:mm:ss"` string (per `format`,
+ * always zero-padded). With `use12Hours` the columns present a 12-hour
+ * clock plus an AM/PM column, but serialization stays 24-hour — `12:34`
+ * is midday, `00:34` (12:34 AM) is half past midnight.
+ */
+/** 24-hour time-of-day, the serialization coordinate of every form. */
+export type TimeParts = {
+    hour: number;
+    minute: number;
+    second: number;
+};
+/** Column granularity and the value's serialization shape. */
+export type TimePickerFormat = 'HH:mm' | 'HH:mm:ss';
+/**
+ * Parse a `"HH:mm"`/`"HH:mm:ss"` value into 24-hour parts. A missing
+ * second field reads as `0`. Returns `null` for empty or impossible
+ * times (`"25:00"`, `"12:61"`) so the caller can treat it as "unset".
+ */
+export declare function parseTimeValue(value: string): TimeParts | null;
+/** Serialize 24-hour parts per `format`, zero-padded. */
+export declare function formatTimeValue(parts: TimeParts, format: TimePickerFormat): string;
+/** 24-hour hour → 12-hour clock hour: 0→12, 13→1, 12→12. */
+export declare function to12Hour(hour: number): number;
+/** 12-hour clock hour + period → 24-hour hour: (12, AM)→0, (12, PM)→12. */
+export declare function from12Hour(hour12: number, pm: boolean): number;
+/**
+ * The values of one step grid: multiples of `step` from 0 through `max`
+ * inclusive (`max` itself lands on the grid only when divisible).
+ */
+export declare function stepValues(max: number, step: number): number[];
+/**
+ * The 12-hour column's display order — 12 first, then 1 through 11
+ * (AntD's order) — filtered to the `step` grid. `12` sits on the grid
+ * whenever `step` divides 12 or 0, matching the 24-hour grid's 0/12.
+ */
+export declare function hour12Values(step: number): number[];
+/**
+ * Next enabled value walking from `from` by `±step` around the
+ * `0..max` ring (negative `step` walks down). Skips candidates
+ * rejected by `isEnabled`; after a full lap without a hit returns
+ * `null` (every grid value is disabled — caller keeps the current
+ * value). A `step` of 0 is treated as 1.
+ */
+export declare function stepValue(from: number, step: number, max: number, isEnabled: (value: number) => boolean): number | null;
+/** Two-digit, zero-padded column label (`0` → `"00"`). */
+export declare function pad2(value: number): string;

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

@@ -1,4 +1,5 @@
 import type { ComponentPropsWithRef, ReactNode } from 'react';
+import type { ToastAction } from './ToastContext';
 /**
  * Semantic slot classes (AntD v6 `classNames` shape) for the toast
  * family. Toasts are usually fired imperatively (`useToast()` /
@@ -18,21 +19,33 @@ type ToastClassNames = {
     item?: string;
     /** The body wrapper around the toast content. */
     content?: string;
+    /** The action button (only rendered for toasts carrying an action). */
+    action?: string;
+    /** The bold title line (only rendered for toasts carrying a title). */
+    title?: string;
     /** The dismiss × button. */
     close?: string;
 };
 type ToastProps = {
-    variant?: 'info' | 'success' | 'warning' | 'danger';
+    variant?: 'info' | 'success' | 'warning' | 'danger' | 'loading';
+    /**
+     * Action button rendered right of the content and left of the dismiss
+     * × — a real focusable button (see {@link ToastAction}). `close`
+     * defaults to `true`: the toast dismisses right after `onClick` runs.
+     */
+    action?: ToastAction;
+    /** Bold first line rendered above the content. */
+    title?: ReactNode;
     onClose: () => void;
     duration: number;
     children: ReactNode;
     /**
      * Semantic slot classes (AntD v6 `classNames` shape) — see
-     * {@link ToastClassNames}. Only `item`/`content`/`close` apply to a
-     * directly rendered toast; `viewport` is a `ToastContainer` part.
-     * Omitting it changes nothing.
+     * {@link ToastClassNames}. Only `item`/`content`/`action`/`title`/
+     * `close` apply to a directly rendered toast; `viewport` is a
+     * `ToastContainer` part. Omitting it changes nothing.
      */
     classNames?: ToastClassNames;
-} & Omit<ComponentPropsWithRef<'div'>, 'children' | 'onClose'>;
-export default function Toast({ variant, onClose, duration, children, classNames, className, ...rest }: ToastProps): import("react").JSX.Element;
+} & Omit<ComponentPropsWithRef<'div'>, 'children' | 'onClose' | 'title'>;
+export default function Toast({ variant, action, title, onClose, duration, children, classNames, className, ...rest }: ToastProps): import("react").JSX.Element;
 export type { ToastProps, ToastClassNames };

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

@@ -23,5 +23,5 @@ export declare const toastPlacements: {
     readonly 'bottom-left': import("@linaria/core").LinariaClassName;
     readonly 'bottom-right': import("@linaria/core").LinariaClassName;
 };
-export default function ToastContainer({ children, maxCount, placement, classNames, }: ToastContainerProps): import("react").JSX.Element;
+export default function ToastContainer({ children, maxCount: maxCountProp, placement: placementProp, classNames, }: ToastContainerProps): import("react").JSX.Element;
 export type { ToastContainerProps, ToastPlacement };

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

@@ -1,10 +1,26 @@
 import type { ReactNode } from 'react';
-type ToastVariant = 'info' | 'success' | 'warning' | 'danger';
+type ToastVariant = 'info' | 'success' | 'warning' | 'danger' | 'loading';
+/**
+ * Action button carried by a toast: rendered right of the content and
+ * left of the dismiss ×, as a real focusable `<button>`.
+ */
+type ToastAction = {
+    /** Button label. */
+    label: ReactNode;
+    /** Runs when the action button is activated. */
+    onClick: () => void;
+    /** Dismiss the toast right after `onClick` runs. Default `true`. */
+    close?: boolean;
+};
 type ToastItem = {
     id: number;
     variant: ToastVariant;
     content: ReactNode;
     duration: number;
+    /** Action button — omitted renders no button. */
+    action?: ToastAction;
+    /** Bold first line rendered above the content. */
+    title?: ReactNode;
 };
 /**
  * Patch accepted by `toast.update(id, patch)` and `useToast().update(id,
@@ -19,6 +35,10 @@ type ToastUpdateOptions = {
     /** New auto-dismiss budget in ms. Changing it re-arms the countdown
      * from the full value; leaving it out keeps the running countdown. */
     duration?: number;
+    /** Replacement (or first) action button. */
+    action?: ToastAction;
+    /** Replacement (or first) title line. */
+    title?: ReactNode;
 };
 /** The `toast.promise` phases whose default copy lives in the locale pack. */
 type ToastDeferredCopyKey = 'loading' | 'success' | 'error';
@@ -53,4 +73,4 @@ type ToastContextValue = {
 export declare const ToastProvider: import("react").Provider<ToastContextValue | undefined>;
 export declare function useToastContext(): ToastContextValue;
 export { applyToastPatch, deferredCopyKey, deferredToastCopy, };
-export type { ToastDeferredCopy, ToastDeferredCopyKey, ToastItem, ToastContextValue, ToastUpdateOptions, ToastVariant, };
+export type { ToastAction, ToastDeferredCopy, ToastDeferredCopyKey, ToastItem, ToastContextValue, ToastUpdateOptions, ToastVariant, };

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

@@ -4,4 +4,4 @@ export { default as ToastContainer } from './ToastContainer';
 export type { ToastContainerProps } from './ToastContainer';
 export { default as useToast } from './useToast';
 export { toast } from './toast';
-export type { ToastOptions, ToastVariant } from './toast';
+export type { ToastAction, ToastOptions, ToastVariant } from './toast';

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

@@ -1,9 +1,14 @@
 import type { ReactNode } from 'react';
-import type { ToastDeferredCopyKey, ToastItem, ToastUpdateOptions, ToastVariant } from './ToastContext';
+import type { ToastAction, ToastDeferredCopyKey, ToastItem, ToastUpdateOptions, ToastVariant } from './ToastContext';
 /** Options accepted by `toast()` — the same call shape `useToast()` takes. */
 type ToastOptions = {
     variant?: ToastVariant;
     duration?: number;
+    /** Action button rendered right of the content (left of the dismiss ×);
+     * `close` defaults to `true` — the toast dismisses after `onClick`. */
+    action?: ToastAction;
+    /** Bold first line rendered above the content. */
+    title?: ReactNode;
 };
 /** Options accepted by the variant sugar methods (`toast.success()` …). */
 type ToastVariantOptions = Omit<ToastOptions, 'variant'>;
@@ -42,10 +47,10 @@ export declare function nextToastId(): number;
  * Returns the toast id, usable with `toast.dismiss(id)` and
  * `toast.update(id, patch)`.
  *
- * Mirrors the `useToast()` call shape (content + `{variant, duration}`,
- * defaulting to `info` / 3000ms). With no container mounted the toast is
- * silently queued (never throws) and replayed when a `ToastContainer`
- * mounts.
+ * Mirrors the `useToast()` call shape (content + `{variant, duration,
+ * action, title}`, defaulting to `info` / 3000ms). With no container
+ * mounted the toast is silently queued (never throws) and replayed when
+ * a `ToastContainer` mounts.
  */
 declare function toast(content: ReactNode, options?: ToastOptions): number;
 declare namespace toast {
@@ -53,20 +58,21 @@ declare namespace toast {
     var success: (content: ReactNode, options?: ToastVariantOptions) => number;
     var warning: (content: ReactNode, options?: ToastVariantOptions) => number;
     var danger: (content: ReactNode, options?: ToastVariantOptions) => number;
+    var loading: (content: ReactNode, options?: ToastVariantOptions) => number;
     var dismiss: (id?: number) => void;
     var update: (id: number, patch: ToastUpdateOptions) => void;
     var promise: <T>(p: Promise<T>, options?: ToastPromiseOptions<T>) => Promise<T>;
 }
 /**
- * Shared engine behind `toast.promise` and `useToast().promise`: fires the
- * loading toast through `show` (persistent — duration 0), then patches it
- * in place when the promise settles, so the toast never remounts and its
- * animations never replay. Returns the original promise untouched:
- * rejections keep propagating to the caller's `await`/`catch`, and a
- * loading toast dismissed before settling is simply not found by the
- * update — it never resurrects.
+ * Shared engine behind `toast.promise` and `useToast().promise`: fires
+ * the loading toast through `showLoading` (spinner icon, persistent —
+ * duration 0), then patches it in place when the promise settles, so the
+ * toast never remounts and its animations never replay. Returns the
+ * original promise untouched: rejections keep propagating to the
+ * caller's `await`/`catch`, and a loading toast dismissed before
+ * settling is simply not found by the update — it never resurrects.
  */
-export declare function driveToastPromise<T>(show: (content: ReactNode, options?: ToastOptions) => number, updateById: (id: number, patch: ToastUpdateOptions) => void, promise: Promise<T>, options?: ToastPromiseOptions<T>): Promise<T>;
+export declare function driveToastPromise<T>(showLoading: (content: ReactNode) => number, updateById: (id: number, patch: ToastUpdateOptions) => void, promise: Promise<T>, options?: ToastPromiseOptions<T>): Promise<T>;
 /**
  * Called from `ToastContainer`'s mount effect. The first subscriber also
  * replays everything queued before any container existed, in call order;
@@ -74,4 +80,4 @@ export declare function driveToastPromise<T>(show: (content: ReactNode, options?
  */
 export declare function subscribeToastChannel(channel: ToastChannel): () => void;
 export { toast };
-export type { ToastDeferredCopyKey, ToastOptions, ToastPhaseContent, ToastPromiseOptions, ToastUpdateOptions, ToastVariant, ToastVariantOptions, };
+export type { ToastAction, ToastDeferredCopyKey, ToastOptions, ToastPhaseContent, ToastPromiseOptions, ToastUpdateOptions, ToastVariant, ToastVariantOptions, };

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

@@ -1,13 +1,23 @@
 import type { ReactNode } from 'react';
-import type { ToastOptions, ToastPromiseOptions, ToastUpdateOptions } from './toast';
+import type { ToastOptions, ToastPromiseOptions, ToastUpdateOptions, ToastVariantOptions } from './toast';
 /**
  * The `useToast()` return value: the toast trigger itself (returns the id,
- * usable with `update`) plus `update` and `promise` — one-to-one with the
- * module-level `toast` API, but routed through the enclosing container's
- * context instead of the first-mounted channel subscriber.
+ * usable with `update`) plus `loading`/`update`/`promise` — one-to-one
+ * with the module-level `toast` API, but routed through the enclosing
+ * container's context instead of the first-mounted channel subscriber.
  */
 type ShowToast = {
     (content: ReactNode, options?: ToastOptions): number;
+    /** Info toast — see `toast.info`. */
+    info: (content: ReactNode, options?: ToastVariantOptions) => number;
+    /** Success toast — see `toast.success`. */
+    success: (content: ReactNode, options?: ToastVariantOptions) => number;
+    /** Warning toast — see `toast.warning`. */
+    warning: (content: ReactNode, options?: ToastVariantOptions) => number;
+    /** Danger toast — see `toast.danger`. */
+    danger: (content: ReactNode, options?: ToastVariantOptions) => number;
+    /** Loading toast with the spinner icon — see `toast.loading`. */
+    loading: (content: ReactNode, options?: ToastVariantOptions) => number;
     /** Patches a toast in place — see `toast.update`. */
     update: (id: number, patch: ToastUpdateOptions) => void;
     /** Loading → success/danger lifecycle — see `toast.promise`. */

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

@@ -12,5 +12,5 @@ type TooltipProps = {
     className?: string;
     children: ReactNode;
 };
-export default function Tooltip({ content, position, delay, open: openControl, collisionPadding, className, children, }: TooltipProps): import("react").JSX.Element;
+export default function Tooltip({ content, position, delay: delayProp, open: openControl, collisionPadding, className, children, }: TooltipProps): import("react").JSX.Element;
 export type { TooltipProps };

package/dist/types/components/Tree/SortableTree.d.ts

@@ -0,0 +1,38 @@
+import type { SortableTreeMoveInfo } from './sortable-tree-utils';
+import type { TreeProps } from './types';
+/**
+ * Props for `SortableTree` — the full `TreeProps` field set (the tree
+ * keeps all of its expand/select/check/keyboard/virtual behavior) plus
+ * the drag contract. The internal injection seams are hidden: drag
+ * reordering owns them.
+ */
+export type SortableTreeProps = {
+    /**
+     * Reports a completed drag: the dragged `key` should become the child
+     * at `index` of `parentKey` (`null` = root level), computed after
+     * removing the node from its old spot — splice it right in. Update
+     * `treeData` accordingly (controlled, one-way — the same philosophy as
+     * `SortableTagGroup`); without a handler a drop only animates back to
+     * the source position. The node's whole subtree travels with it.
+     */
+    onMove?: (info: SortableTreeMoveInfo) => void;
+    /**
+     * `false` (default): the whole row is the drag activator — an 8px
+     * pointer move threshold keeps clicks, expands and checks untouched.
+     * `true`: only the leading grip icon starts pointer drags; keyboard
+     * drags (Space lifts on the focused row) work either way.
+     */
+    dragHandle?: boolean;
+} & Omit<TreeProps, 'rowWrap' | 'keyboardNavigation'>;
+/**
+ * Drag-and-drop reorderable variant of Tree — built on the @dnd-kit
+ * dependency (the plain `Tree` never touches it): same-level reorders
+ * and cross-parent moves, the dragged node's whole subtree follows, and
+ * keyboard sortable works with Space / arrows / Space / Escape on the
+ * focused row. Dropping onto a row inserts right after it, so a drop on
+ * a child of another parent reparents; nodes never drop into their own
+ * subtree. All tree state stays controlled — `onMove` reports
+ * `{ key, parentKey, index }` and the consumer updates `treeData`.
+ */
+export default function SortableTree({ treeData, disabled, dragHandle, titleRender, searchValue, expandedKeys, onExpand, onMove, className, ...rest }: SortableTreeProps): import("react").JSX.Element;
+export type { SortableTreeMoveInfo };

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

@@ -1,3 +1,3 @@
 import type { TreeProps, TreeVirtualizedConfig } from './types';
-export default function Tree({ treeData, multiple, checkable, checkStrictly, selectable, disabled, blockNode, showLine, showIcon, switcherIcon, loadingIcon, titleRender, iconRender, virtualized, loadData, searchValue, expandedKeys: expandedKeysControl, selectedKeys: selectedKeysControl, checkedKeys: checkedKeysControl, className, onExpand, onSelect, onCheck, }: TreeProps): import("react").JSX.Element;
+export default function Tree({ treeData, multiple, checkable, checkStrictly, selectable, disabled, blockNode, showLine, showIcon, switcherIcon, loadingIcon, titleRender, iconRender, virtualized, loadData, searchValue, rowWrap, keyboardNavigation, expandedKeys: expandedKeysControl, selectedKeys: selectedKeysControl, checkedKeys: checkedKeysControl, className, onExpand, onSelect, onCheck, }: TreeProps): import("react").JSX.Element;
 export type { TreeProps, TreeVirtualizedConfig };

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

@@ -1,2 +1,4 @@
 export { default as Tree } from './Tree';
+export { default as SortableTree } from './SortableTree';
 export type { TreeProps, TreeNodeData } from './types';
+export type { SortableTreeProps, SortableTreeMoveInfo } from './SortableTree';

package/dist/types/components/Tree/sortable-tree-styles.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Linaria classes for SortableTree — sibling file per the repo convention
+ * (sortable-tree- prefix keeps the class slug distinct from every other
+ * *-styles.ts, the tag-group-styles precedent). The classes land in the
+ * `tree` css family automatically (same component directory).
+ */
+/**
+ * The sortable node wrapper around every treeitem (the element that
+ * carries useSortable's ref). `position: relative` anchors the dragging
+ * row's z-index stack; the inline transform/transition (from
+ * sortableItemStyle) animates the drag and the snap-back.
+ */
+export declare const row: import("@linaria/core").LinariaClassName;
+/**
+ * Whole-row drag affordance (`dragHandle: false`): the wrapper grabs the
+ * pointer for PointerSensor (touch-action: none) and shows the grab
+ * cursor — the treeitem's own `cursor: pointer` is inherited over so the
+ * row reads as draggable while the switcher/checkbox keep their cursors.
+ * Clicks still work: PointerSensor's 8px distance constraint keeps plain
+ * taps from ever starting a drag.
+ */
+export declare const rowDraggable: import("@linaria/core").LinariaClassName;
+/** The dragged row stacks above its siblings while it flies. */
+export declare const rowDragging: import("@linaria/core").LinariaClassName;
+/**
+ * Rows inside the dragged subtree dim while their ancestor flies — the
+ * subtree follows as one block, so its rows are never drop targets.
+ */
+export declare const rowInSubtree: import("@linaria/core").LinariaClassName;
+/**
+ * The drag grip (`dragHandle: true`): pointer-activated only and hidden
+ * from the accessibility tree — keyboard drags stay on the treeitem row
+ * (Space lifts, arrows move, Space drops), keeping the tree's single
+ * roving tab stop intact.
+ */
+export declare const grip: import("@linaria/core").LinariaClassName;