@minimalstuff/ui 3.1.0 → 4.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sonny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import { Callable } from 'react-call';
 import { ComponentPropsWithRef } from 'react';
-import { HTMLAttributeAnchorTarget } from 'react';
+import type { HTMLAttributeAnchorTarget } from 'react';
 import { JSX } from 'react';
 import { JSXElementConstructor } from 'react';
-import { MouseEvent as MouseEvent_2 } from 'react';
+import type { MouseEvent as MouseEvent_2 } from 'react';
 import { ReactElement } from 'react';
 import { ReactNode } from 'react';
 import { ReactPortal } from 'react';
@@ -11,6 +11,34 @@ import { Ref } from 'react';
 import { StoreApi } from 'zustand';
 import { UseBoundStore } from 'zustand';
 
+/**
+ * The picture of a person, or the initial of `name` when there is none.
+ * Labelled with the full `name` so screen readers announce the person rather
+ * than a stray letter; the `<img>` itself stays out of the accessibility
+ * tree to avoid announcing it twice.
+ *
+ * A `src` that fails to load falls back to the initial — remote avatars go
+ * missing (deleted accounts, rate limits), and a broken-image glyph in a
+ * circle looks like a bug. Pointing `src` at a different URL retries.
+ *
+ * A missing name is the caller's call to make: this renders whatever `name`
+ * starts with, and an empty circle for a blank string, rather than inventing
+ * a placeholder identity.
+ */
+export declare function Avatar({ name, src, size, color, radius, unstyled, className, }: Readonly<AvatarProps>): JSX.Element;
+
+export declare interface AvatarProps {
+    name: string;
+    src?: string;
+    size?: AvatarSize;
+    color?: ButtonColor;
+    radius?: Radius;
+    unstyled?: boolean;
+    className?: string;
+}
+
+export declare type AvatarSize = ControlSize;
+
 export declare const Badge: ({ children, color, variant, size, radius, className, ...props }: Readonly<BadgeProps>) => JSX.Element;
 
 export declare interface BadgeProps extends ComponentPropsWithRef<'span'> {
@@ -25,7 +53,6 @@ export declare type BadgeSize = ControlSize;
 
 export declare type BadgeVariant = 'solid' | 'outline' | 'subtle';
 
-/** Chrome shared by every text-entry control (Input, Textarea, Select, Combobox). */
 export declare const BASE_INPUT_STYLES = "w-full border border-gray-300 dark:border-gray-600 bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 placeholder-gray-500 dark:placeholder-gray-400 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent transition-all duration-200 disabled:opacity-50 disabled:cursor-not-allowed";
 
 export declare function Button(buttonProps: Readonly<ButtonProps>): JSX.Element;
@@ -36,6 +63,7 @@ declare type ButtonColor =
 	| 'danger'
 	| 'success'
 	| 'warning';
+export { ButtonColor as AvatarColor }
 export { ButtonColor as BadgeColor }
 export { ButtonColor }
 
@@ -60,7 +88,40 @@ declare type ButtonStyle = {
 
 export declare type ButtonVariant = 'solid' | 'outline' | 'ghost' | 'subtle';
 
-export declare function CharacterCount({ current, min, max, showMin, showMax, unstyled, className, }: Readonly<CharacterCountProps>): JSX.Element;
+/**
+ * A section container: surface, border, radius, padding. Pass `title` (plus
+ * optionally `description` and `actions`, which sit opposite the title) to
+ * get the standard header, or omit all three and lay the section out inside
+ * `children` yourself.
+ *
+ * A titled card is also a labelled `region`, so screen reader users can jump
+ * between sections by name — worth it on a settings page stacking seven of
+ * them. Untitled cards stay plain `div`s rather than adding nameless
+ * landmarks. Set `headingLevel` when the card sits under an existing heading:
+ * the default `h2` is right at the top level of a page and wrong nested.
+ *
+ * `unstyled` strips the surface, border, radius and padding; the header
+ * markup stays, since that is structure rather than skin.
+ */
+export declare function Card({ children, title, description, actions, headingLevel, padding, radius, unstyled, className, }: Readonly<CardProps>): JSX.Element;
+
+export declare type CardHeadingLevel = 2 | 3 | 4;
+
+export declare type CardPadding = 'none' | 'sm' | 'md' | 'lg';
+
+export declare interface CardProps {
+    children: ReactNode;
+    title?: ReactNode;
+    description?: ReactNode;
+    actions?: ReactNode;
+    headingLevel?: CardHeadingLevel;
+    padding?: CardPadding;
+    radius?: Radius;
+    unstyled?: boolean;
+    className?: string;
+}
+
+export declare function CharacterCount({ current, min, max, showMin, showMax, unstyled, id, className, }: Readonly<CharacterCountProps>): JSX.Element;
 
 export declare interface CharacterCountProps {
     current: number;
@@ -69,10 +130,33 @@ export declare interface CharacterCountProps {
     showMin?: boolean;
     showMax?: boolean;
     unstyled?: boolean;
+    id?: string;
     className?: string;
 }
 
-export declare function Checkbox({ label, description, error, radius, unstyled, className, wrapperClassName, checked, defaultChecked, onChange, id, ...props }: Readonly<CheckboxProps>): JSX.Element;
+export declare function Checkbox({ label, description, error, radius, unstyled, fullWidth, variant, className, wrapperClassName, checked, defaultChecked, onChange, id, 'aria-describedby': callerDescribedBy, ...props }: Readonly<CheckboxProps>): JSX.Element;
+
+export declare type CheckboxOption = ChoiceOption;
+
+export declare function CheckboxOptions({ options, orientation, values, defaultValues, onChange, name: nameProp, label, error, required, requiredLabel, disabled, radius, unstyled, className, wrapperClassName, id, 'aria-describedby': callerDescribedBy, ...props }: Readonly<CheckboxOptionsProps>): JSX.Element;
+
+export declare interface CheckboxOptionsProps extends Omit<ComponentPropsWithRef<'fieldset'>, 'onChange'> {
+    options: string[] | CheckboxOption[];
+    orientation?: 'vertical' | 'horizontal';
+    values?: readonly string[];
+    defaultValues?: readonly string[];
+    onChange?: (values: readonly string[]) => void;
+    name?: string;
+    label?: string | React.ReactNode;
+    error?: string;
+    required?: boolean;
+    requiredLabel?: string;
+    radius?: Radius;
+    unstyled?: boolean;
+    className?: string;
+    wrapperClassName?: string;
+    id?: string;
+}
 
 export declare interface CheckboxProps extends Omit<ComponentPropsWithRef<'input'>, 'type' | 'className'> {
     label?: string | React.ReactNode;
@@ -80,17 +164,28 @@ export declare interface CheckboxProps extends Omit<ComponentPropsWithRef<'input
     error?: string;
     radius?: Radius;
     unstyled?: boolean;
+    fullWidth?: boolean;
+    variant?: 'inline' | 'card';
     className?: string;
     wrapperClassName?: string;
 }
 
-export declare function ClientOnly({ children, fallback }: Readonly<ClientOnlyProps>): string | number | bigint | boolean | Iterable< ReactNode> | Promise<string | number | bigint | boolean | ReactPortal | ReactElement<unknown, string | JSXElementConstructor<any>> | Iterable< ReactNode> | null | undefined> | JSX.Element | null;
+/** One choice in a `RadioOptions` or `CheckboxOptions` list. */
+export declare interface ChoiceOption {
+    	value: string;
+    	label: string;
+    	description?: string;
+    	icon?: string;
+    	disabled?: boolean;
+}
+
+export declare function ClientOnly({ children, fallback }: Readonly<ClientOnlyProps>): string | number | bigint | boolean | JSX.Element | Iterable< ReactNode> | Promise<string | number | bigint | boolean | ReactPortal | ReactElement<unknown, string | JSXElementConstructor<any>> | Iterable< ReactNode> | null | undefined> | null;
 
 export declare interface ClientOnlyProps extends React.PropsWithChildren {
     fallback?: React.ReactNode;
 }
 
-export declare function Combobox({ options, label, error, placeholder, noResultsText, clearLabel, radius, unstyled, disabled, required, className, wrapperClassName, value, defaultValue, onChange, id, }: Readonly<ComboboxProps>): JSX.Element;
+export declare function Combobox({ options, label, 'aria-label': ariaLabel, error, placeholder, noResultsText, clearLabel, radius, unstyled, disabled, required, className, wrapperClassName, value, defaultValue, onChange, id, }: Readonly<ComboboxProps>): JSX.Element;
 
 export declare interface ComboboxOption {
     value: string;
@@ -100,6 +195,7 @@ export declare interface ComboboxOption {
 export declare interface ComboboxProps {
     options: ComboboxOption[];
     label?: string | ReactNode;
+    'aria-label'?: string;
     error?: string;
     placeholder?: string;
     noResultsText?: string;
@@ -135,15 +231,21 @@ export declare interface ConfirmModalProps {
 export declare type ConfirmModalResponse = boolean;
 
 /**
- * Wraps `children` (the right-click target area) and opens `items`, a list
- * of `MenuItem` elements as direct children (see `MenuItem`'s own doc
- * comment), at the cursor position. Right-click again elsewhere on the
- * wrapped area to reposition it.
+ * Wraps `children` (the right-click target area) and opens `items` — made
+ * of `MenuItem`s, optionally wrapped in `MenuGroup`s and split by
+ * `MenuSeparator`s — at the cursor position. Right-click again elsewhere on
+ * the wrapped area to reposition it.
+ *
+ * Keyboard-only users reach it via Shift+F10 or the Menu key instead of a
+ * right-click, but only once the wrapped area (or something inside it) can
+ * hold focus — give `children` a focusable element, or a `tabIndex={0}` plus
+ * a `role` and `aria-label` on the wrapper itself, or Shift+F10 has nothing
+ * to fire on. See `context_menu.stories.tsx`'s `Default` story.
  *
  * For a menu anchored to a specific button (e.g. a kebab icon) instead of a
  * right-click, use `Menu`.
  */
-export declare function ContextMenu({ children, items, radius, className, ref, }: Readonly<ContextMenuProps>): JSX.Element;
+export declare function ContextMenu({ children, items, radius, className, ref, 'aria-label': ariaLabel, }: Readonly<ContextMenuProps>): JSX.Element;
 
 export declare interface ContextMenuProps {
     /** The area that opens the menu on right-click. */
@@ -153,6 +255,8 @@ export declare interface ContextMenuProps {
     radius?: Radius;
     className?: string;
     ref?: Ref<HTMLDivElement>;
+    /** Names the menu for assistive tech, since there is no trigger element to label it from. */
+    'aria-label'?: string;
 }
 
 /** The size scale every inline control shares (Button, IconButton, Badge, Kbd). */
@@ -205,7 +309,7 @@ declare type IconButtonStyle = {
     radius?: Radius;
 };
 
-export declare function Input({ label, error, showCharCount, minLength, maxLength, radius, unstyled, className, wrapperClassName, value, defaultValue, onChange, id, ...props }: Readonly<InputProps>): JSX.Element;
+export declare function Input({ label, error, showCharCount, minLength, maxLength, radius, unstyled, className, wrapperClassName, value, defaultValue, onChange, id, 'aria-describedby': callerDescribedBy, ...props }: Readonly<InputProps>): JSX.Element;
 
 export declare interface InputProps extends ComponentPropsWithRef<'input'> {
     label?: string | ReactNode;
@@ -233,23 +337,63 @@ export declare type KbdSize = ControlSize;
 
 /**
  * A dropdown anchored to `trigger` (e.g. a kebab `IconButton`): click to
- * open, click again/click outside/Escape to close. `children` must be
- * `MenuItem` elements as direct children (see `MenuItem`'s own doc comment)
- * for keyboard nav and close-on-select to work.
+ * open, click again/click outside/Escape to close, or ArrowDown/ArrowUp on
+ * the closed trigger to open focused on the first/last item respectively.
+ * `children` is made of `MenuItem`s, optionally wrapped in `MenuGroup`s and
+ * split by `MenuSeparator`s.
  *
  * For "right-click anywhere on this area" instead of a specific trigger
  * button, use `ContextMenu`.
+ *
+ * Safe to nest inside a `Modal`: Escape on the open menu calls
+ * `event.preventDefault()` before closing it (see `MenuSurface`), so the
+ * modal's own Escape handler — which ignores an already-`defaultPrevented`
+ * event — leaves the dialog open and only the menu closes.
+ *
+ * Opening a `Modal` from a `MenuItem`'s `onClick` is also safe: the menu
+ * returns focus to `trigger` synchronously during the click, then the modal
+ * mounts a render later and takes focus from there. That ordering is what
+ * makes the modal record `trigger` as its restore target, so focus lands
+ * back on the trigger when the modal closes. The menu panel outlives the
+ * click by one exit animation, but the modal sits above it and owns Escape
+ * (a document listener), so the fading panel is inert. See
+ * `menu_with_modal.test.tsx`.
  */
 export declare function Menu({ trigger, children, side, align, radius, className, ref, }: Readonly<MenuProps>): JSX.Element;
 
 export declare type MenuAlign = 'start' | 'center' | 'end';
 
 /**
- * A row inside a `Menu` or `ContextMenu`. Must be a direct child of one of
- * those (or of a `<>` fragment passed as their `children`/`items`): arrow
- * key navigation and close-on-select both rely on `role="menuitem"` being a
- * direct descendant. Wrapping items in another element (e.g. a `<div>` for
- * a labeled section) will render fine but breaks both.
+ * A named group of `MenuItem`s inside a `Menu` or `ContextMenu`. Where
+ * `MenuSeparator` cuts, this one names — and unlike a bare title sitting
+ * next to the items, `role="group"` plus `aria-labelledby` actually tells
+ * assistive tech which items the name covers.
+ *
+ * Wrapping items is safe: the enclosing menu collects `[role="menuitem"]`
+ * across all its descendants, so keyboard navigation still walks into the
+ * group, and close-on-select travels through React context rather than the
+ * DOM tree.
+ *
+ * `className` styles the label — the only part of the group that carries any
+ * skin. `wrapperClassName` styles the `role="group"` element around both the
+ * label and the items.
+ */
+export declare function MenuGroup({ label, children, unstyled, className, wrapperClassName, }: Readonly<MenuGroupProps>): JSX.Element;
+
+export declare interface MenuGroupProps {
+    label: ReactNode;
+    children: ReactNode;
+    unstyled?: boolean;
+    className?: string;
+    wrapperClassName?: string;
+}
+
+/**
+ * A row inside a `Menu` or `ContextMenu`, at any depth: the menu collects
+ * `[role="menuitem"]`/`[role="menuitemradio"]` across all its descendants
+ * for keyboard navigation, and close-on-select travels through React
+ * context rather than the DOM tree. `MenuGroup` relies on that to wrap the
+ * items it names.
  *
  * Renders either a `<button>` (pass `onClick`) or a native `<a>` (pass
  * `href`, plus optional `target`/`rel`); the two are mutually exclusive.
@@ -263,27 +407,45 @@ export declare type MenuAlign = 'start' | 'center' | 'end';
 export declare function MenuItem(menuItemProps: Readonly<MenuItemProps>): JSX.Element;
 
 declare type MenuItemBaseProps = {
-    icon?: string;
-    danger?: boolean;
-    disabled?: boolean;
-    children: ReactNode;
-    className?: string;
+    	icon?: string;
+    	/**
+     	 * Content pinned to the end of the row, dimmed by default — a `Kbd`, the
+     	 * current value of a setting. Keep it inert: the whole row is already the
+     	 * control, so anything focusable or separately clickable in here breaks
+     	 * both the menu's keyboard navigation and its `menuitem` semantics.
+     	 *
+     	 * It sits inside the row, so it is part of what the row announces:
+     	 * "Theme, Dark" for a value, "Shortcuts, Command K" for a shortcut. That
+     	 * is usually what you want; pass already-hidden content if it is not.
+     	 */
+    	trailing?: ReactNode;
+    	danger?: boolean;
+    	disabled?: boolean;
+    	children: ReactNode;
+    	className?: string;
 };
 
 export declare type MenuItemButtonProps = MenuItemBaseProps & {
-    onClick: (event: MouseEvent_2<HTMLButtonElement>) => void;
-    href?: never;
-    target?: never;
-    rel?: never;
-    ref?: Ref<HTMLButtonElement>;
+    	onClick: (event: MouseEvent_2<HTMLButtonElement>) => void;
+    	/**
+     	 * Turns the item into one option of a choice: it reports as
+     	 * `menuitemradio`, carries `aria-checked`, and shows a check mark when
+     	 * true. Leave it out for plain actions — an unset `selected` is not the
+     	 * same as `false`, which reads as "an option, currently not the one".
+     	 */
+    	selected?: boolean;
+    	href?: never;
+    	target?: never;
+    	rel?: never;
+    	ref?: Ref<HTMLButtonElement>;
 };
 
 export declare type MenuItemLinkProps = MenuItemBaseProps & {
-    href: string;
-    target?: HTMLAttributeAnchorTarget;
-    rel?: string;
-    onClick?: never;
-    ref?: Ref<HTMLAnchorElement>;
+    	href: string;
+    	target?: HTMLAttributeAnchorTarget;
+    	rel?: string;
+    	onClick?: never;
+    	ref?: Ref<HTMLAnchorElement>;
 };
 
 export declare type MenuItemProps = MenuItemButtonProps | MenuItemLinkProps;
@@ -299,6 +461,18 @@ export declare interface MenuProps {
     ref?: Ref<HTMLSpanElement>;
 }
 
+/**
+ * A divider between groups of `MenuItem`s inside a `Menu` or `ContextMenu`.
+ * Carries `role="separator"` (never `menuitem`), so the surrounding menu's
+ * arrow key navigation skips it: only focusable items take part.
+ */
+export declare const MenuSeparator: ({ unstyled, className, }: Readonly<MenuSeparatorProps>) => JSX.Element;
+
+export declare interface MenuSeparatorProps {
+    unstyled?: boolean;
+    className?: string;
+}
+
 export declare type MenuSide = 'top' | 'bottom' | 'left' | 'right';
 
 export declare const Modal: Callable<ModalProps, void, {}>;
@@ -323,6 +497,8 @@ export declare interface ModalProps {
     className?: string;
     dismissible?: boolean;
     closeLabel?: string;
+    /** Names the dialog when there is no `title`; ignored when `title` is set since the title labels it. */
+    'aria-label'?: string;
 }
 
 export declare function ModalProvider(): JSX.Element;
@@ -331,15 +507,56 @@ declare type ModalRenderProp = ReactNode | ((close: () => void) => ReactNode);
 
 export declare type ModalSize = 'sm' | 'md' | 'lg' | 'xl';
 
-export declare interface RadioOption {
+/**
+ * Multi-select combobox: a trigger button showing the selected options as
+ * pills opens a searchable dropdown of checkbox-style options. Selecting an
+ * option never closes the dropdown, unlike the single-select `Combobox`.
+ */
+export declare function MultiCombobox({ options, label, 'aria-label': ariaLabel, error, placeholder, searchPlaceholder, noResultsText, clearLabel, clearText, maxSelectedValues, isOptionDisabled, maxDisplayedValues, formatOverflowCount, formatSelectedCount, formatMaxSelectedHint, radius, unstyled, disabled, required, className, wrapperClassName, values, defaultValues, onChange, onDropdownClose, id, }: Readonly<MultiComboboxProps>): ReactElement;
+
+export declare interface MultiComboboxOption {
     value: string;
     label: string;
-    description?: string;
-    icon?: string;
+}
+
+export declare interface MultiComboboxProps {
+    options: readonly MultiComboboxOption[];
+    label?: string | ReactNode;
+    'aria-label'?: string;
+    error?: string;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    noResultsText?: string;
+    clearLabel?: string;
+    clearText?: string;
+    maxSelectedValues?: number;
+    isOptionDisabled?: (optionValue: string, selectedValues: readonly string[]) => boolean;
+    maxDisplayedValues?: number;
+    formatOverflowCount?: (hiddenCount: number) => string;
+    formatSelectedCount?: (selectedCount: number) => string;
+    formatMaxSelectedHint?: (maxSelectedValues: number) => string;
+    radius?: Radius;
+    unstyled?: boolean;
     disabled?: boolean;
+    required?: boolean;
+    className?: string;
+    wrapperClassName?: string;
+    values?: readonly string[];
+    defaultValues?: readonly string[];
+    onChange?: (values: readonly string[]) => void;
+    /**
+     * Fires with the final selection whenever the user is done editing:
+     * when the dropdown closes (Escape, outside click, focus leaving the
+     * wrapper), and when the selection is cleared from the trigger's X
+     * button while the dropdown is closed.
+     */
+    onDropdownClose?: (values: readonly string[]) => void;
+    id?: string;
 }
 
-export declare function RadioOptions({ options, orientation, value, defaultValue, onChange, name: nameProp, label, error, required, disabled, radius, unstyled, className, wrapperClassName, id, ...props }: Readonly<RadioOptionsProps>): JSX.Element;
+export declare type RadioOption = ChoiceOption;
+
+export declare function RadioOptions({ options, orientation, value, defaultValue, onChange, name: nameProp, label, error, required, disabled, radius, unstyled, className, wrapperClassName, id, 'aria-describedby': callerDescribedBy, ...props }: Readonly<RadioOptionsProps>): JSX.Element;
 
 export declare interface RadioOptionsProps extends Omit<ComponentPropsWithRef<'fieldset'>, 'onChange'> {
     options: string[] | RadioOption[];
@@ -360,7 +577,7 @@ export declare interface RadioOptionsProps extends Omit<ComponentPropsWithRef<'f
 
 declare type Radius = 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
 
-export declare function Select({ options, label, error, placeholder, radius, unstyled, className, wrapperClassName, value, defaultValue, onChange, id, ...props }: Readonly<SelectProps>): JSX.Element;
+export declare function Select({ options, label, error, placeholder, radius, unstyled, className, wrapperClassName, value, defaultValue, onChange, id, 'aria-describedby': callerDescribedBy, ...props }: Readonly<SelectProps>): JSX.Element;
 
 export declare interface SelectOption {
     value: string;
@@ -418,13 +635,14 @@ export declare function splitIntoHighlightSegments(
     	return segments;
 }
 
-export declare function Switch({ label, description, error, unstyled, className, wrapperClassName, checked, defaultChecked, onChange, id, ...props }: Readonly<SwitchProps>): JSX.Element;
+export declare function Switch({ label, description, error, unstyled, fullWidth, className, wrapperClassName, checked, defaultChecked, onChange, id, 'aria-describedby': callerDescribedBy, ...props }: Readonly<SwitchProps>): JSX.Element;
 
 export declare interface SwitchProps extends Omit<ComponentPropsWithRef<'input'>, 'type' | 'className'> {
     label?: string | ReactNode;
     description?: string | ReactNode;
     error?: string;
     unstyled?: boolean;
+    fullWidth?: boolean;
     className?: string;
     wrapperClassName?: string;
 }
@@ -436,21 +654,31 @@ export declare interface TabItem {
     icon?: string;
 }
 
-export declare function Tabs({ items, value, defaultIndex, radius, unstyled, className, tabListClassName, panelClassName, onChange, }: Readonly<TabsProps>): JSX.Element;
+export declare function Tabs({ items, value, defaultIndex, variant, size, radius, fullWidth, unstyled, animated, className, tabListClassName, panelClassName, onChange, }: Readonly<TabsProps>): JSX.Element;
 
 export declare interface TabsProps {
     items: TabItem[];
     value?: number;
     defaultIndex?: number;
+    variant?: TabsVariant;
+    size?: ControlSize;
+    /**
+     * Only visibly rounds the `segmented` variant's track and tabs. The `line`
+     * variant has no filled surface to round, so radius is a no-op there.
+     */
     radius?: Radius;
+    fullWidth?: boolean;
     unstyled?: boolean;
+    animated?: boolean;
     className?: string;
     tabListClassName?: string;
     panelClassName?: string;
     onChange?: (index: number) => void;
 }
 
-export declare function Textarea({ label, error, showCharCount, minLength, maxLength, radius, unstyled, className, wrapperClassName, value, defaultValue, onChange, id, ...props }: Readonly<TextareaProps>): JSX.Element;
+export declare type TabsVariant = 'line' | 'segmented';
+
+export declare function Textarea({ label, error, showCharCount, minLength, maxLength, radius, unstyled, className, wrapperClassName, value, defaultValue, onChange, id, 'aria-describedby': callerDescribedBy, ...props }: Readonly<TextareaProps>): JSX.Element;
 
 export declare interface TextareaProps extends ComponentPropsWithRef<'textarea'> {
     label?: string | ReactNode;
@@ -466,11 +694,9 @@ export declare interface TextareaProps extends ComponentPropsWithRef<'textarea'>
 
 export declare type Theme = 'light' | 'dark' | 'system';
 
-declare type Theme_2 = 'light' | 'dark' | 'system';
-
 declare interface ThemeStore {
-    theme: Theme_2;
-    setTheme: (theme: Theme_2) => void;
+    theme: Theme;
+    setTheme: (theme: Theme) => void;
 }
 
 export declare function ThemeToggle({ isTransitionEnabled, transitionDuration, transitionEasing, size, radius, variant, getAriaLabel, }: Readonly<ThemeToggleProps>): JSX.Element;
@@ -482,9 +708,15 @@ export declare interface ThemeToggleProps {
     size?: 'sm' | 'md' | 'lg';
     radius?: Radius;
     variant?: ButtonVariant;
-    getAriaLabel?: (theme: Theme_2) => string;
+    getAriaLabel?: (theme: Theme) => string;
 }
 
+/**
+ * The trigger (`children`) must be focusable, otherwise the tooltip is
+ * unreachable by keyboard. Shows on hover and focus; Escape dismisses it.
+ * `temporaryContent` is announced to screen readers through a polite status
+ * region.
+ */
 export declare function Tooltip({ content, children, position, showOnClick, temporaryContent, temporaryDuration, disabled, radius, onTemporaryShow, className, ref, }: Readonly<TooltipProps>): JSX.Element;
 
 export declare type TooltipPosition = 'top' | 'bottom' | 'left' | 'right';