haze-ui 1.30.0 → 1.32.0

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

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithRef, ElementType, ReactNode } from 'react';
 /**
  * Component-level tokens: Button can be rethemed per-component by setting
  * `--haze-button-*` custom properties on `:root` or any ancestor —
@@ -6,10 +6,55 @@ import type { ComponentPropsWithoutRef } from 'react';
  * `--haze-button-radius` (fallbacks and usage documented in ./styles).
  * ButtonLink and Toggle wear the same skin and follow along.
  */
-type ButtonProps = {
+type ButtonOwnProps = {
     variant?: 'solid' | 'outline' | 'ghost';
     size?: 'sm' | 'md' | 'lg';
     square?: boolean;
-} & Omit<ComponentPropsWithoutRef<'button'>, 'type'>;
-export default function Button({ variant, size: sizeProp, square, className, ...rest }: ButtonProps): import("react").JSX.Element;
-export type { ButtonProps };
+    /**
+     * Busy state: swaps the label ink for a spinner (the button keeps its
+     * width — the label still sizes the cell, just transparent), forces
+     * `disabled` so click/Enter/submit are blocked at the platform level,
+     * and sets `aria-busy`. Pass an object to replace the default spinner
+     * (`icon`) or the announced label text (`text` — visually replaces
+     * the children while busy, e.g. "Saving…").
+     *
+     * On anchors/custom components (`as`) there is no native `disabled`:
+     * busy reports `aria-disabled`/`aria-busy` and the skin drops pointer
+     * events, but keyboard users can still focus — pass `tabIndex={-1}`
+     * yourself to fully lock a busy link.
+     */
+    loading?: boolean | {
+        icon?: ReactNode;
+        text?: ReactNode;
+    };
+};
+/**
+ * MUI-OverridableComponent-shaped polymorphism: own props first, then
+ * the target element's props minus the colliding keys. The wiring
+ * (classes, data-slot, aria, type gating) always lands on the rendered
+ * element — the same "wiring wins" precedence as FormItem's `as`.
+ */
+type ButtonProps<T extends ElementType = 'button'> = ButtonOwnProps & {
+    /**
+     * Render element. `'button'` (default) renders a native button;
+     * `'a'` renders an anchor wearing the button skin — link semantics
+     * (`href`, ⌘/middle-click, crawlers) without a ButtonLink import.
+     * Any component works the same way (e.g. a router Link) as long as it
+     * forwards props and ref to a DOM element.
+     *
+     * Element-specific defaults are gated: `type='button'` is only set on
+     * the native-button shape, so anchors never carry the attribute.
+     */
+    as?: T;
+} & Omit<ComponentPropsWithRef<T>, keyof ButtonOwnProps | 'as' | 'type'>;
+/**
+ * DOM contract: idle buttons render their `children` bare —
+ * byte-identical to the pre-`loading` DOM (no wrapper). Only a busy
+ * render wraps them in `<span data-slot='label'>` (transparent ink
+ * keeps sizing the control) and adds
+ * `<span data-slot='indicator' aria-hidden>` next to it; both unmount
+ * when the busy phase lifts. `button > *` selectors keep working for
+ * idle buttons; children remount across a busy toggle.
+ */
+export default function Button<T extends ElementType = 'button'>({ variant, size: sizeProp, square, loading: loadingProp, as, className, children, disabled: disabledProp, ...rest }: ButtonProps<T>): import("react").JSX.Element;
+export type { ButtonOwnProps, ButtonProps };

package/dist/types/components/Button/ButtonLink.d.ts

@@ -1,34 +1,46 @@
-import type { ComponentPropsWithoutRef } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
 /**
  * A real `<a>` with the full Button appearance — for navigation that
- * must look like a button. Rendering `as={Button}` puts `href` on a
- * `<button>` (an invalid attribute: no ⌘/middle-click, no crawlable
- * link); ButtonLink keeps the anchor semantics and wears Button's skin
- * (same `variant`/`size`/`square` props, same focus/disabled visual
- * states).
+ * must look like a button.
  *
- * Extends the native `<a>` attributes — everything not listed below is
- * spread onto the anchor, so routers composing their own `Link` through
- * an `as` prop can inject `href`, `onClick`, `target`, `rel` and
- * friends (NavLink-style).
+ * @deprecated Use `<Button as='a'>` instead — same skin, same anchor
+ * semantics, and the wiring is shared with Button (single code path per
+ * family). ButtonLink remains as a deprecated alias and will be removed
+ * in the next major.
  *
  * Anchors have no `disabled` attribute: report the state with
  * `aria-disabled` (and `tabIndex={-1}` to drop it from the focus
- * order) — ButtonLink styles `aria-disabled` exactly like Button's
+ * order) — the skin styles `aria-disabled` exactly like Button's
  * `:disabled`.
  *
- * Component-level theming tokens (`--haze-button-*`) apply here too —
- * this anchor wears the exact same skin as Button (see ./styles).
+ * Migration note (1.4 minor): since Button learned `as`, ButtonLink
+ * delegates rendering to Button. Idle anchors keep the flat DOM (no
+ * wrapper); only a busy render wraps the children in
+ * `<span data-slot='label'>` and adds
+ * `<span data-slot='indicator' aria-hidden>`. Props stay
+ * contract-equal: `variant` still defaults to `'solid'` (the Button
+ * tier never read config) and `size` still reads the `ButtonLink`
+ * config section first.
  */
 type ButtonLinkProps = {
     variant?: 'solid' | 'outline' | 'ghost';
     size?: 'sm' | 'md' | 'lg';
     square?: boolean;
+    /** Busy state — same visual contract as Button's `loading`. */
+    loading?: boolean | {
+        icon?: ReactNode;
+        text?: ReactNode;
+    };
 } & ComponentPropsWithoutRef<'a'>;
-declare const _default: import("react").ForwardRefExoticComponent<{
+declare const ButtonLink: import("react").ForwardRefExoticComponent<{
     variant?: "solid" | "outline" | "ghost";
     size?: "sm" | "md" | "lg";
     square?: boolean;
+    /** Busy state — same visual contract as Button's `loading`. */
+    loading?: boolean | {
+        icon?: ReactNode;
+        text?: ReactNode;
+    };
 } & Omit<import("react").DetailedHTMLProps<import("react").AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & import("react").RefAttributes<HTMLAnchorElement>>;
-export default _default;
+export default ButtonLink;
 export type { ButtonLinkProps };

package/dist/types/components/Button/styles.d.ts

@@ -44,3 +44,37 @@ export declare const squareSizes: {
     readonly md: import("@linaria/core").LinariaClassName;
     readonly lg: import("@linaria/core").LinariaClassName;
 };
+/**
+ * Layout conduit for the button's children during a busy render. The
+ * span only mounts while busy (idle buttons spread children directly
+ * under the row, byte-identical to the pre-`loading` DOM); it exists so
+ * the children can be gridded against the indicator. This class
+ * replicates the parent flex context (same gap, same alignment) inside
+ * the shared grid cell.
+ */
+export declare const label: import("@linaria/core").LinariaClassName;
+/**
+ * Anchor reset for the button skin worn by an `<a>` (Button `as='a'`
+ * and ButtonLink): anchors bring a UA underline; a button-looking link
+ * resets it (variants already own the color).
+ *
+ * Anchor-shaped disabled: Button's :disabled has no meaning on an `<a>`,
+ * so the state is driven by `aria-disabled` (callers pair it with
+ * tabIndex={-1} to drop the link from the focus order). Busy anchors
+ * skip the opacity dim — like Button's busy state they should look
+ * active, not dead — while keeping click suppression.
+ */
+export declare const link: import("@linaria/core").LinariaClassName;
+/**
+ * Busy state (Button `loading`). Grid stacking keeps the busy swap
+ * width-stable: the label span and the indicator span share
+ * grid-area 1/1 (gap is inert across a shared cell), so the widest of
+ * the two drives the cell and the label box keeps sizing the control.
+ * `color: transparent` hides the label's ink without removing it from
+ * the accessibility tree — visibility: hidden would strip the button's
+ * accessible name mid-request. The indicator sits on top, centered.
+ *
+ * cursor: progress reads "working" instead of the base's not-allowed
+ * (the control is temporarily unavailable, not forbidden).
+ */
+export declare const loading: import("@linaria/core").LinariaClassName;

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

@@ -27,6 +27,16 @@ type ComboboxOptionData = {
      */
     group?: string;
 };
+/**
+ * Semantic slot classes for Combobox (keys follow the data-slot names;
+ * see the `classNames` prop on {@link ComboboxProps}).
+ */
+type ComboboxClassNames = {
+    root?: string;
+    input?: string;
+    item?: string;
+    empty?: string;
+};
 type ComboboxProps = {
     /**
      * `string` in single mode, `string[]` when `multiple` is set. The
@@ -111,6 +121,14 @@ type ComboboxProps = {
      */
     virtualized?: boolean | ComboboxVirtualizedConfig;
     className?: string;
+    /**
+     * Slot classes (AntD v6 `classNames` shape), following the data-slot
+     * names: `root` (the positioning wrapper), `input` (the combobox
+     * field), `item` (each option row), `empty` (the no-match state
+     * block). A ConfigProvider `Combobox.classNames` section merges under
+     * the prop, per key.
+     */
+    classNames?: ComboboxClassNames;
     /**
      * Forwarded to the combobox `<input>` — the focusable field in both
      * single and multiple mode (multiple mode's chip box wraps it but is
@@ -119,5 +137,5 @@ type ComboboxProps = {
      */
     ref?: Ref<HTMLInputElement>;
 };
-export default function Combobox({ value: valueControl, open: openControl, options, multiple, onValuesChange, creatable, onCreate, onSearch, loading, empty, highlightMatches, maxHeight, placeholder, virtualThreshold, virtualized: virtualizedProp, className, ref, }: ComboboxProps): import("react").JSX.Element;
-export type { ComboboxProps, ComboboxVirtualizedConfig, ComboboxOptionData };
+export default function Combobox({ value: valueControl, open: openControl, options, multiple, onValuesChange, creatable, onCreate, onSearch, loading, empty, highlightMatches, maxHeight, placeholder, virtualThreshold, virtualized: virtualizedProp, className, classNames, ref, }: ComboboxProps): import("react").JSX.Element;
+export type { ComboboxClassNames, ComboboxProps, ComboboxVirtualizedConfig, ComboboxOptionData };

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

@@ -1,5 +1,5 @@
 export { default as Combobox } from './Combobox';
-export type { ComboboxProps, ComboboxVirtualizedConfig, ComboboxOptionData } from './Combobox';
+export type { ComboboxClassNames, ComboboxProps, ComboboxVirtualizedConfig, ComboboxOptionData } from './Combobox';
 export { default as ComboboxOption } from './ComboboxOption';
 export type { ComboboxOptionProps } from './ComboboxOption';
 export { default as ComboboxGroup } from './ComboboxGroup';

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

@@ -1,3 +1,7 @@
+import type { DrawerClassNames } from '../Drawer/Drawer';
+import type { SelectClassNames } from '../Select/Select';
+import type { ComboboxClassNames } from '../Combobox/Combobox';
+import type { TagGroupClassNames } from '../TagGroup/TagGroup';
 import type { ToastPlacement } from '../Toast/ToastContainer';
 /**
  * Component default overrides, keyed by the exported component name —
@@ -48,6 +52,22 @@ type HazeConfig = {
          */
         closeDelay?: number;
     };
+    /** `Drawer` slot classes — merged under an explicit `classNames` prop. */
+    Drawer?: {
+        classNames?: DrawerClassNames;
+    };
+    /** `Select` slot classes — merged under an explicit `classNames` prop. */
+    Select?: {
+        classNames?: SelectClassNames;
+    };
+    /** `Combobox` slot classes — merged under an explicit `classNames` prop. */
+    Combobox?: {
+        classNames?: ComboboxClassNames;
+    };
+    /** `TagGroup` slot classes — merged under an explicit `classNames` prop. */
+    TagGroup?: {
+        classNames?: TagGroupClassNames;
+    };
 };
 /**
  * The fully merged config visible below a `ConfigProvider`. The

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

@@ -6,7 +6,7 @@ type ConfirmDialogProps = {
     onConfirm?: () => void;
     onCancel?: () => void;
     title?: ReactNode;
-    children: ReactNode;
+    children?: ReactNode;
     confirmText?: string;
     cancelText?: string;
     variant?: 'default' | 'danger';

package/dist/types/components/ConfirmDialog/confirm.d.ts

@@ -0,0 +1,33 @@
+import type { ReactNode } from 'react';
+import type { ConfirmDialogProps } from './ConfirmDialog';
+/**
+ * Options for the imperative confirm — {@link ConfirmDialogProps} minus
+ * the wired callbacks (the promise carries the answer, so `onClose`/
+ * `onConfirm`/`onCancel` are derived paths, not inputs).
+ */
+type ConfirmOptions = Omit<ConfirmDialogProps, 'onClose' | 'onConfirm' | 'onCancel' | 'open' | 'children'> & {
+    /** Dialog body copy. */
+    children: ReactNode;
+    /** Fired when the user confirms (before the promise resolves). */
+    onConfirm?: () => void;
+    /** Fired when the user cancels or dismisses (before rejection). */
+    onCancel?: () => void;
+};
+/**
+ * Imperative promise-based confirm dialog, the AntD `Modal.confirm`
+ * shape: mounts a fresh ConfirmDialog into `document.body`, resolves
+ * with `true` on confirm, `false` on cancel/dismiss, and unmounts on
+ * settle. Safe to call outside React render (event handlers, async
+ * flows); not safe during SSR (no-op `false`, no mount).
+ *
+ * ```ts
+ * const ok = await confirm({ title: 'Discard draft?', children: '…', variant: 'danger' });
+ * if (ok) discard();
+ * ```
+ *
+ * Each call owns its own React root — multiple confirms stack (they
+ * open as sibling dialogs; the top layer negotiates them).
+ */
+declare function confirm(options: ConfirmOptions): Promise<boolean>;
+export { confirm };
+export type { ConfirmOptions };

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

@@ -1,2 +1,4 @@
 export { default as ConfirmDialog } from './ConfirmDialog';
 export type { ConfirmDialogProps } from './ConfirmDialog';
+export { confirm } from './confirm';
+export type { ConfirmOptions } from './confirm';

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

@@ -1,7 +1,16 @@
 import type { ReactNode } from 'react';
 type ConversationListProps = {
     children: ReactNode;
+    /**
+     * Infinite-scroll trigger on the list's scrollport: fired when the
+     * scroll position comes within 200px of the end. Entering the zone
+     * fires once; staying inside does not re-fire; scrolling back out
+     * re-arms, and growth of the rendered children re-arms too, so a
+     * still-short list chains straight into the next page. Typical use:
+     * append the next page of conversations. Ignored when not provided.
+     */
+    onLoadMore?: () => void;
     className?: string;
 };
-export default function ConversationList({ children, className }: ConversationListProps): import("react").JSX.Element;
+export default function ConversationList({ children, onLoadMore, className }: ConversationListProps): import("react").JSX.Element;
 export type { ConversationListProps };

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

@@ -0,0 +1,36 @@
+import type { ControlOrValue } from 'react-use-control';
+import type { DatepickerPreset } from '../Datepicker/DatepickerCore';
+import type { CalendarCellRender } from '../Calendar/Calendar';
+import type { Ref } from 'react';
+/**
+ * Date+time picker (the Mantine DateTimePicker niche): a date calendar
+ * with a time field below it in one popover. This is a thin sugar over
+ * Datepicker — `picker` is fixed to `date` (date+time values are apples
+ * and day-granularity oranges for week/month/quarter/year modes) and
+ * `showTime` defaults to `true`; {@link showSeconds} flips it to the
+ * seconds-resolution form.
+ *
+ * Value serializes as `"YYYY-MM-DD HH:mm"` (or `"YYYY-MM-DD HH:mm:ss"`
+ * with `showSeconds`), matching Datepicker's showTime contract.
+ */
+type DateTimePickerProps = {
+    value?: ControlOrValue<string>;
+    open?: ControlOrValue<boolean>;
+    min?: string;
+    max?: string;
+    /** Disables individual dates on the calendar panel (day granularity). */
+    disabledDate?: (date: Date) => boolean;
+    /** Shortcut rows at the top of the panel. */
+    presets?: DatepickerPreset[];
+    /** Include seconds in the time field (value gains a `:ss` part). */
+    showSeconds?: boolean;
+    locale?: string;
+    weekStartsOn?: 0 | 1;
+    cellRender?: CalendarCellRender;
+    placeholder?: string;
+    className?: string;
+    /** Forwarded to the trigger `<input>`. */
+    ref?: Ref<HTMLInputElement>;
+};
+export default function DateTimePicker({ value: valueControl, open: openControl, min, max, disabledDate, presets, showSeconds, locale, weekStartsOn, cellRender, placeholder, className, ref, }: DateTimePickerProps): import("react").JSX.Element;
+export type { DateTimePickerProps };

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

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

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

@@ -1,4 +1,4 @@
-import type { Ref } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 import type { CalendarCellRender, CalendarPickerMode } from '../Calendar/Calendar';
 import type { DatepickerPreset } from './DatepickerCore';
@@ -41,6 +41,6 @@ type DatepickerProps = {
     /** 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, picker, min, max, disabledDate, presets, showTime, format, parse, locale, weekStartsOn, cellRender, placeholder, className, ref, }: DatepickerProps): import("react").JSX.Element;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'onChange' | 'children'>;
+export default function Datepicker({ value: valueControl, open: openControl, picker, min, max, disabledDate, presets, showTime, format, parse, locale, weekStartsOn, cellRender, placeholder, className, ref, ...rest }: DatepickerProps): import("react").JSX.Element;
 export type { DatepickerProps };

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

@@ -1,4 +1,4 @@
-import type { Ref } from 'react';
+import type { ComponentPropsWithoutRef, Ref } from 'react';
 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. */
@@ -66,6 +66,6 @@ type DatepickerCoreProps = {
     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, format, parse, locale, weekStartsOn, cellRender, placeholder, className, ref, }: DatepickerCoreProps): import("react").JSX.Element;
+} & Omit<ComponentPropsWithoutRef<'div'>, 'onChange' | 'children'>;
+export default function DatepickerCore({ value, onChange, open, onOpenChange, picker, min, max, disabledDate, presets, showTime, format, parse, locale, weekStartsOn, cellRender, placeholder, className, ref, ...rest }: DatepickerCoreProps): import("react").JSX.Element;
 export type { DatepickerCoreProps, DatepickerPreset };

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

@@ -18,6 +18,17 @@ type DrawerHandle = {
     /** Focus the element that held focus when the drawer last opened. */
     focusTrigger: () => void;
 };
+/**
+ * Semantic slot classes (AntD v6 `classNames` shape): keys land classes
+ * on Drawer's structural parts. Drawer renders a single `<dialog>` —
+ * `content` is that element's part (the placement class and any
+ * `className` land on the same node). A `classNames` prop set via
+ * ConfigProvider merges under the prop's keys.
+ */
+type DrawerClassNames = {
+    /** The `<dialog>` panel itself (data-slot='content'). */
+    content?: string;
+};
 type DrawerProps = {
     open?: ControlOrValue<boolean>;
     placement?: 'left' | 'right' | 'top' | 'bottom';
@@ -34,8 +45,10 @@ type DrawerProps = {
      */
     viewTransition?: boolean;
     className?: string;
+    /** Slot classes (see {@link DrawerClassNames}). */
+    classNames?: DrawerClassNames;
     children: ReactNode;
     ref?: Ref<DrawerHandle>;
 };
-export default function Drawer({ open: openControl, placement, onClose, viewTransition, className, children, ref, }: DrawerProps): import("react").JSX.Element;
-export type { DrawerProps, DrawerHandle };
+export default function Drawer({ open: openControl, placement, onClose, viewTransition, className, classNames, children, ref, }: DrawerProps): import("react").JSX.Element;
+export type { DrawerClassNames, DrawerProps, DrawerHandle };

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

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

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

@@ -0,0 +1,16 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+/**
+ * A semantic `<fieldset>` + `<legend>` grouping for form sections —
+ * the native grouping HTML was made for, skinned. Screen readers name
+ * the group from the legend on focus entry into any control inside,
+ * which is the whole point over a bare div+heading.
+ */
+type FieldsetProps = {
+    /** The group's legend text/content — rendered inside `<legend>` so
+     * assistive tech names the whole group from it. */
+    legend?: ReactNode;
+    /** Disables every form control inside (native fieldset semantics). */
+    disabled?: boolean;
+} & Omit<ComponentPropsWithoutRef<'fieldset'>, 'disabled'>;
+export default function Fieldset({ legend: legendContent, disabled, className, children, ...rest }: FieldsetProps): import("react").JSX.Element;
+export type { FieldsetProps };

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

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

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

@@ -0,0 +1,27 @@
+import type { ComponentPropsWithoutRef } from 'react';
+type HighlightProps = {
+    /** The text to scan. Rendering stays text-level: only matched
+     * substrings become `<mark>` children, everything else stays text
+     * nodes — no innerHTML, no injection surface. */
+    children: string;
+    /** One or more substrings to mark (empty strings are ignored). */
+    highlight: string | string[];
+    /**
+     * Case sensitivity of the match. Default `false` (the search-box
+     * convention: queries match regardless of letter case).
+     */
+    caseSensitive?: boolean;
+    /** Mark tone applied to every matched run. */
+    color?: 'warning' | 'primary' | 'success' | 'danger';
+} & Omit<ComponentPropsWithoutRef<'mark'>, 'children' | 'color'>;
+/**
+ * Highlights matching substrings inside a text run by wrapping them in
+ * {@link Mark} elements — the search-results affordance. Pure text in,
+ * text + marks out; non-string children are rejected by the type.
+ *
+ * Renders plain text (no wrapper DOM of its own): the outer container
+ * is a fragment and each match is a `<Mark data-slot="mark">`, so the
+ * data-slot namespace stays the shared `mark` slot.
+ */
+export default function Highlight({ children, highlight, caseSensitive, color, ...rest }: HighlightProps): import("react").JSX.Element;
+export type { HighlightProps };

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

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

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

@@ -0,0 +1,24 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+/**
+ * Corner badge attached to a host element (avatar, icon button, tab) —
+ * the notification-dot affordance. Render without `label` for a plain
+ * dot; pass `label` for a count badge.
+ */
+type IndicatorProps = {
+    /**
+     * Badge content. Omitted (undefined / null, or render-empty values
+     * like false / '') renders a dot (a bare status marker); a value
+     * renders a count badge. Strings longer than `max`-formatted are the
+     * caller's concern (e.g. pass "99+").
+     */
+    label?: ReactNode;
+    /** Zero/out semantics: number 0 shows by default in badge mode. */
+    showZero?: boolean;
+    /** Badge tone. */
+    color?: 'primary' | 'danger' | 'success' | 'warning';
+    /** Corner placement of the badge. */
+    position?: 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
+    children: ReactNode;
+} & Omit<ComponentPropsWithoutRef<'span'>, 'color' | 'content'>;
+export default function Indicator({ label, showZero, color, position, className, children, ...rest }: IndicatorProps): import("react").JSX.Element;
+export type { IndicatorProps };

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

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

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

@@ -1,11 +1,17 @@
-import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
 import type { ControlOrValue } from 'react-use-control';
 type InputProps = {
     value?: ControlOrValue<string>;
     size?: 'sm' | 'md' | 'lg';
+    /** Content rendered inside the field at the leading edge (icon,
+     * currency glyph, …). See InputCore for the layout contract. */
+    leftSection?: ReactNode;
+    /** Same as `leftSection`, at the trailing edge — the conventional
+     * home of clear buttons and visibility toggles. */
+    rightSection?: ReactNode;
     /** Forwarded to the underlying `<input>` — the element form bridges
      * (react-f0rm `focusRef`), tests and `ref.current.focus()` reach. */
     ref?: Ref<HTMLInputElement>;
 } & Omit<ComponentPropsWithoutRef<'input'>, 'value' | 'size'>;
-export default function Input({ value: valueControl, size, className, onChange, ref, ...rest }: InputProps): import("react").JSX.Element;
+export default function Input({ value: valueControl, size, className, leftSection, rightSection, onChange, ref, ...rest }: InputProps): import("react").JSX.Element;
 export type { InputProps };

package/dist/types/components/Input/InputCore.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentPropsWithoutRef, Ref } from 'react';
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
 type InputCoreProps = {
     value: string;
     onChange: (value: string) => void;
@@ -8,8 +8,17 @@ type InputCoreProps = {
     onNativeChange?: ComponentPropsWithoutRef<'input'>['onChange'];
     size?: 'sm' | 'md' | 'lg';
     className?: string;
+    /** Content rendered inside the field, before the text — an icon, a
+     * currency glyph, a search marker. Layout sits in a flex row with the
+     * input; the field keeps its border and focus ring (the box stays
+     * one visual unit). Interactive children must re-enable pointer
+     * events themselves (see PasswordInput's visibility toggle). */
+    leftSection?: ReactNode;
+    /** Same as {@link InputCoreProps.leftSection}, at the trailing edge —
+     * the conventional home of clear buttons and visibility toggles. */
+    rightSection?: ReactNode;
     /** Forwarded to the `<input>` element. */
     ref?: Ref<HTMLInputElement>;
 } & Omit<ComponentPropsWithoutRef<'input'>, 'value' | 'onChange' | 'size'>;
-export default function InputCore({ value, onChange, onNativeChange, size, className, ref, ...rest }: InputCoreProps): import("react").JSX.Element;
+export default function InputCore({ value, onChange, onNativeChange, size, className, leftSection, rightSection, ref, ...rest }: InputCoreProps): import("react").JSX.Element;
 export type { InputCoreProps };

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

@@ -3,6 +3,15 @@ type ListProps = {
     variant?: 'unordered' | 'ordered' | 'none';
     className?: string;
     children: ReactNode;
+    /**
+     * Explicit load-more area rendered as the final list item. Zero
+     * policy: the consumer decides what appears — a "Load more" button, a
+     * skeleton, a spinner. Pair it with whatever triggers the next page:
+     * the consumer's own scroll logic (e.g. VirtualList `onEndReached`
+     * driving the data) or a plain button inside the slot; the slot itself
+     * has no behavior.
+     */
+    loadMore?: ReactNode;
 };
-export default function List({ variant, className, children, }: ListProps): import("react").JSX.Element;
+export default function List({ variant, className, children, loadMore, }: ListProps): import("react").JSX.Element;
 export type { ListProps };

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

@@ -0,0 +1,25 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+/**
+ * Container-level loading state: dims the wrapped content and centers a
+ * spinner above it. The content stays in the tree and keeps its place
+ * in the focus order — deliberately, so focus survives the overlay
+ * (`aria-busy` on the wrapper is the AT channel, same as the Mantine
+ * equivalent). The veil blocks pointer and selection, but nothing here
+ * is modal: keyboard users can still reach the content. Consumers that
+ * need a full lock gate their own handlers on the same `visible` prop
+ * (or host the content in an `inert` subtree).
+ */
+type LoadingOverlayProps = {
+    /** Whether the overlay is shown. */
+    visible?: boolean;
+    /** Optional announcement text rendered inside a visually-paired label
+     * under the spinner for sighted context. */
+    label?: ReactNode;
+    /** Swap the default Spinner. */
+    loader?: ReactNode;
+    /** Spinner size (when the default loader is used). */
+    spinnerSize?: 'sm' | 'md' | 'lg';
+    children: ReactNode;
+} & ComponentPropsWithoutRef<'div'>;
+export default function LoadingOverlay({ visible, label, loader, spinnerSize, className, children, ...rest }: LoadingOverlayProps): import("react").JSX.Element;
+export type { LoadingOverlayProps };

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

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

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

@@ -45,6 +45,10 @@ declare const defaultStrings: {
         create: string;
         noResults: string;
     };
+    spoiler: {
+        showMore: string;
+        showLess: string;
+    };
     command: {
         noResults: string;
     };
@@ -232,6 +236,13 @@ declare const defaultStrings: {
     streamingText: {
         generating: string;
     };
+    tabs: {
+        close: string;
+        moreTabs: string;
+        statusDirty: string;
+        statusError: string;
+        statusSyncing: string;
+    };
     tag: {
         remove: string;
     };