@minimalstuff/ui 3.2.0 → 4.1.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

@@ -8,6 +8,7 @@ import { ReactElement } from 'react';
 import { ReactNode } from 'react';
 import { ReactPortal } from 'react';
 import { Ref } from 'react';
+import { RefObject } from 'react';
 import { StoreApi } from 'zustand';
 import { UseBoundStore } from 'zustand';
 
@@ -53,7 +54,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;
@@ -122,7 +122,7 @@ export declare interface CardProps {
     className?: string;
 }
 
-export declare function CharacterCount({ current, min, max, showMin, showMax, unstyled, className, }: Readonly<CharacterCountProps>): JSX.Element;
+export declare function CharacterCount({ current, min, max, showMin, showMax, unstyled, id, className, }: Readonly<CharacterCountProps>): JSX.Element;
 
 export declare interface CharacterCountProps {
     current: number;
@@ -131,28 +131,64 @@ 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, indeterminate, description, error, radius, unstyled, fullWidth, variant, className, wrapperClassName, checked, defaultChecked, onChange, id, 'aria-describedby': callerDescribedBy, ref, ...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;
+    /** Shows a dash instead of the checkmark and exposes the mixed state to assistive technology. */
+    indeterminate?: boolean;
     description?: string | React.ReactNode;
     error?: string;
     radius?: Radius;
     unstyled?: boolean;
+    fullWidth?: boolean;
+    variant?: 'inline' | 'card';
     className?: string;
     wrapperClassName?: string;
 }
 
+/** 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;
@@ -162,6 +198,7 @@ export declare interface ComboboxOption {
 export declare interface ComboboxProps {
     options: ComboboxOption[];
     label?: string | ReactNode;
+    'aria-label'?: string;
     error?: string;
     placeholder?: string;
     noResultsText?: string;
@@ -202,10 +239,16 @@ export declare type ConfirmModalResponse = boolean;
  * `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. */
@@ -215,6 +258,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). */
@@ -256,6 +301,7 @@ export declare type IconButtonProps = ComponentPropsWithRef<'button'> & {
     'aria-label': string;
     size?: ControlSize;
     children?: ReactNode;
+    tooltip?: IconButtonTooltip;
 } & IconButtonStyle;
 
 declare type IconButtonStyle = {
@@ -267,10 +313,28 @@ 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;
+/**
+ * Wraps the button in a `Tooltip`. `true` shows the `aria-label` at the
+ * default position, a position string moves it, and an object also allows
+ * custom `content`. When the tooltip repeats the `aria-label` it does not
+ * describe the button, so screen readers do not announce the name twice.
+ */
+export declare type IconButtonTooltip =
+	| boolean
+	| TooltipPosition
+	| IconButtonTooltipOptions;
+
+declare interface IconButtonTooltipOptions {
+    	position?: TooltipPosition;
+    	/** Defaults to the button's `aria-label`. */
+    	content?: ReactNode;
+}
+
+export declare function Input({ label, description, 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;
+    description?: string | ReactNode;
     error?: string;
     showCharCount?: boolean;
     minLength?: number;
@@ -295,20 +359,27 @@ 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` is made of
- * `MenuItem`s, optionally wrapped in `MenuGroup`s and split by
- * `MenuSeparator`s.
+ * 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`.
  *
- * Opening a `Modal` from a `MenuItem`'s `onClick` is 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`.
+ * 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;
 
@@ -432,9 +503,10 @@ export declare const Modal: Callable<ModalProps, void, {}>;
  * Declares `children` as the modal's pinned footer, wherever this is
  * rendered in the content tree — including inside a separate content
  * component, any number of levels below `Modal`'s own `children`. Renders
- * nothing itself; `Modal` places the actual footer in its own layout.
+ * nothing in place; the children are portaled into the modal's own footer
+ * slot, so they stay React children of this component.
  */
-export declare function ModalFooter({ children }: Readonly<ModalFooterProps>): null;
+export declare function ModalFooter({ children }: Readonly<ModalFooterProps>): ReactPortal | null;
 
 export declare interface ModalFooterProps {
     children: ReactNode;
@@ -448,23 +520,72 @@ export declare interface ModalProps {
     className?: string;
     dismissible?: boolean;
     closeLabel?: string;
+    /** `alertdialog` for urgent messages that need a response (describes the dialog by its content); pair with `dismissible={false}` when it must not be dismissed. */
+    role?: ModalRole;
+    /** Wins over the first-tabbable rule for where focus lands on open; may point at an element in the content or in a `ModalFooter`. */
+    initialFocusRef?: RefObject<HTMLElement | null>;
+    /** 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;
 
 declare type ModalRenderProp = ReactNode | ((close: () => void) => ReactNode);
 
+export declare type ModalRole = 'dialog' | 'alertdialog';
+
 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[];
@@ -485,7 +606,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, description, error, placeholder, radius, unstyled, className, wrapperClassName, value, defaultValue, onChange, id, 'aria-describedby': callerDescribedBy, ...props }: Readonly<SelectProps>): JSX.Element;
 
 export declare interface SelectOption {
     value: string;
@@ -495,6 +616,7 @@ export declare interface SelectOption {
 export declare interface SelectProps extends Omit<ComponentPropsWithRef<'select'>, 'children'> {
     options: SelectOption[];
     label?: string | ReactNode;
+    description?: string | ReactNode;
     error?: string;
     placeholder?: string;
     radius?: Radius;
@@ -543,13 +665,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;
 }
@@ -561,24 +684,35 @@ 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, description, 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;
+    description?: string | ReactNode;
     error?: string;
     showCharCount?: boolean;
     minLength?: number;
@@ -591,26 +725,63 @@ 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;
+export declare function ThemeToggle({ isTransitionEnabled, transitionDuration, transitionEasing, size, radius, variant, getAriaLabel, tooltip, }: Readonly<ThemeToggleProps>): JSX.Element;
 
 export declare interface ThemeToggleProps {
+    /**
+     * Animate the theme change with the View Transition API.
+     * Defaults to automatic: enabled, except on WebKitGTK where
+     * `startViewTransition` crashes the web process (2.54).
+     * `prefers-reduced-motion` is always respected.
+     */
     isTransitionEnabled?: boolean;
     transitionDuration?: number;
     transitionEasing?: string;
     size?: 'sm' | 'md' | 'lg';
     radius?: Radius;
     variant?: ButtonVariant;
-    getAriaLabel?: (theme: Theme_2) => string;
+    getAriaLabel?: (theme: Theme) => string;
+    tooltip?: IconButtonTooltip;
 }
 
-export declare function Tooltip({ content, children, position, showOnClick, temporaryContent, temporaryDuration, disabled, radius, onTemporaryShow, className, ref, }: Readonly<TooltipProps>): JSX.Element;
+/**
+ * A group of related controls with a single tab stop (WAI-ARIA toolbar).
+ * Tab enters the toolbar on the last focused item (the first enabled one
+ * initially); the arrow keys of the orientation (Left/Right horizontally,
+ * Up/Down vertically) move focus between items and wrap at the ends, Home and
+ * End jump to the first and last item, and disabled items are skipped. Arrow
+ * keys are left alone inside text fields. Requires `aria-label` or
+ * `aria-labelledby`.
+ */
+export declare function Toolbar(toolbarProps: Readonly<ToolbarProps>): JSX.Element;
+
+declare type ToolbarAccessibleName = {
+    'aria-label': string;
+    'aria-labelledby'?: undefined;
+} | {
+    'aria-labelledby': string;
+    'aria-label'?: undefined;
+};
+
+declare type ToolbarOrientation = 'horizontal' | 'vertical';
+
+export declare type ToolbarProps = Omit<ComponentPropsWithRef<'div'>, 'role' | 'aria-label' | 'aria-labelledby' | 'aria-orientation'> & {
+    orientation?: ToolbarOrientation;
+    unstyled?: boolean;
+} & ToolbarAccessibleName;
+
+/**
+ * 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, describeChild, portalContainer, ref, }: Readonly<TooltipProps>): JSX.Element;
 
 export declare type TooltipPosition = 'top' | 'bottom' | 'left' | 'right';
 
@@ -625,10 +796,76 @@ export declare interface TooltipProps {
     radius?: Radius;
     onTemporaryShow?: () => void;
     className?: string;
+    /**
+     * Whether the trigger is described by the tooltip (`aria-describedby`).
+     * `true` always describes, `false` never does. By default the trigger is
+     * described unless the tooltip text repeats its accessible name, which
+     * screen readers would otherwise announce twice.
+     */
+    describeChild?: boolean;
+    /**
+     * Where the tooltip is rendered. Defaults to the trigger's closest
+     * landmark or dialog (so it stays inside a landmark and inside an open
+     * modal), falling back to `document.body`. Transformed ancestors (such as the modal
+     * panel) can clip it; pass `portalContainer` to escape.
+     */
+    portalContainer?: HTMLElement | null;
     /** Attaches to the wrapper `<span>` around `children`, alongside `Tooltip`'s own internal ref. */
     ref?: Ref<HTMLSpanElement>;
 }
 
+export declare interface UILabels {
+    	/** Accessible name of the modal close button. */
+    	close: string;
+    	/** Confirm button of `ConfirmModal`. */
+    	confirm: string;
+    	/** Cancel button of `ConfirmModal`. */
+    	cancel: string;
+    	/** Empty state of `Combobox` and `MultiCombobox`. */
+    	noResults: string;
+    	/** Accessible name of the button clearing a selection. */
+    	clearSelection: string;
+    	/** Placeholder and accessible name of the `MultiCombobox` search field. */
+    	search: string;
+    	/** Visible text of the `MultiCombobox` clear button. */
+    	clear: string;
+    	/** Screen-reader suffix of a required `CheckboxOptions` group. */
+    	required: string;
+    	/** Accessible name of `ThemeToggle` for the current theme. */
+    	currentTheme: (theme: Theme) => string;
+    	/** `MultiCombobox` badge summarising the values that do not fit. */
+    	overflowCount: (hiddenCount: number) => string;
+    	/** `MultiCombobox` summary of the number of selected values. */
+    	selectedCount: (selectedCount: number) => string;
+    	/** `MultiCombobox` hint shown when the selection limit is reached. */
+    	maxSelectedHint: (maxSelectedValues: number) => string;
+}
+
+/**
+ * Provides default user-facing labels (close, confirm, no results...) to every
+ * component below it. Precedence: explicit prop > provider > English default.
+ *
+ * `Modal` and `ConfirmModal` render where `<ModalProvider />` is mounted, so
+ * mount `ModalProvider` inside `UIProvider` for them to receive the labels.
+ */
+export declare function UIProvider({ labels, announceFieldErrors, children, }: Readonly<UIProviderProps>): JSX.Element;
+
+export declare interface UIProviderProps {
+    /** Overrides the default labels. Nested providers merge over their parent. */
+    labels?: Partial<UILabels>;
+    /**
+     * Whether field errors are announced as they appear (`role="alert"`).
+     * Defaults to `true`; nested providers inherit the parent value unless set.
+     * Set it to `false` when the app announces errors itself (an error summary
+     * or focus on the first invalid field): it avoids several alerts firing at
+     * once on submit, and lets WebKitGTK re-read the error on focus, since it
+     * leaves `role="alert"` content out of the computed description. The error
+     * stays linked by `aria-describedby` either way.
+     */
+    announceFieldErrors?: boolean;
+    children: ReactNode;
+}
+
 export declare function useDisableHotkeysWhileMounted(): void;
 
 export declare const useGlobalHotkeysStore: UseBoundStore<StoreApi<GlobalHotkeysStore>>;
@@ -641,3 +878,10 @@ export declare const useThemeStore: UseBoundStore<StoreApi<ThemeStore>>;
 export declare const withClientOnly: <TProps extends object>(Component: React.ComponentType<TProps>) => React.ComponentType<TProps>;
 
 export { }
+
+
+
+declare module 'vitest' {
+	interface Assertion<T = unknown> extends AxeMatchers {}
+	interface AsymmetricMatchersContaining extends AxeMatchers {}
+}