@alsha-research/picaso-ui 0.0.2 → 0.0.13

package/dist/index.d.cts

@@ -32,7 +32,41 @@ type AccordionContentProps = {
 };
 declare function AccordionContent({ children }: AccordionContentProps): React.JSX.Element;
 
-interface BaseProps {
+type Intent = "primary" | "success" | "warning" | "error" | "default";
+interface AlertProps {
+    /** Optional. Bold first line. */
+    title?: React.ReactNode;
+    /** Optional. Message text. */
+    children?: React.ReactNode;
+    /** Optional. Defaults to "primary". */
+    intent?: Intent;
+    /** Optional. "soft" = tinted, "solid" = strong filled bar (good for announcements). Defaults to "soft". */
+    appearance?: "soft" | "solid";
+    /** Optional. Full-width page banner: no rounded corners and no side borders. Defaults to false. */
+    banner?: boolean;
+    /** Optional. Custom icon, or false to hide the icon. Defaults to an icon matching the intent. */
+    icon?: JSX.Element | false;
+    /** Optional. Buttons or links shown at the end (or under the text on small screens). */
+    actions?: React.ReactNode;
+    /** Optional. Show a close button. Defaults to false. */
+    dismissible?: boolean;
+    /** Optional. Called when the close button is pressed. */
+    onDismiss?: () => void;
+    /** Optional. Controlled visibility. When omitted, the alert hides itself after dismiss. */
+    open?: boolean;
+    /** Optional. Center the content (usual for banners). Defaults to false. */
+    centered?: boolean;
+    /** Optional. Override the ARIA role. Errors and warnings default to "alert", others to "status". */
+    role?: "alert" | "status" | "region";
+    className?: string;
+    id?: string;
+}
+declare const Alert: {
+    ({ title, children, intent, appearance, banner, icon, actions, dismissible, onDismiss, open, centered, role, className, id, }: AlertProps): React.JSX.Element | null;
+    displayName: string;
+};
+
+interface BaseProps$1 {
     type: "image" | "icon" | "text";
     size?: "sm" | "md" | "lg";
     className?: string;
@@ -46,16 +80,16 @@ interface BaseProps {
     statusIcon?: JSX.Element;
     statusPosition?: "top-right" | "top-left" | "bottom-right" | "bottom-left";
 }
-interface ImageProps extends BaseProps {
+interface ImageProps extends BaseProps$1 {
     type: "image";
     src: string;
     alt?: string;
 }
-interface IconProps extends BaseProps {
+interface IconProps extends BaseProps$1 {
     type: "icon";
     icon: JSX.Element;
 }
-interface TextProps extends BaseProps {
+interface TextProps extends BaseProps$1 {
     type: "text";
     text: string;
 }
@@ -71,6 +105,36 @@ interface AvatarGroupProps {
 }
 declare const AvatarGroup: React.ForwardRefExoticComponent<AvatarGroupProps & React.RefAttributes<HTMLDivElement>>;
 
+interface BadgeProps {
+    /** Optional. Element the badge is attached to (icon, avatar, button…). Omit for a standalone badge. */
+    children?: React.ReactNode;
+    /** Optional. Number or short text shown in the badge. */
+    content?: number | string;
+    /** Optional. Show a small dot instead of content. Defaults to false. */
+    dot?: boolean;
+    /** Optional. Numbers above this show as "max+" (e.g. 99+). Defaults to 99. */
+    max?: number;
+    /** Optional. Show the badge when content is 0. Defaults to false. */
+    showZero?: boolean;
+    /** Optional. Hide the badge without unmounting it. */
+    invisible?: boolean;
+    /** Optional. Defaults to "error". */
+    intent?: "primary" | "error" | "success" | "warning" | "default";
+    /** Optional. Defaults to "md". */
+    size?: "sm" | "md";
+    /** Optional. Corner of the child where the badge sits. Defaults to "top-right". */
+    placement?: "top-right" | "top-left" | "bottom-right" | "bottom-left";
+    /** Optional. Pulsing ring, useful for a dot that needs attention. Defaults to false. */
+    pulse?: boolean;
+    /** Optional. Text for screen readers, e.g. "3 unread messages". Defaults to the content. */
+    label?: string;
+    className?: string;
+}
+declare const Badge: {
+    ({ children, content, dot, max, showZero, invisible, intent, size, placement, pulse, label, className, }: BadgeProps): React.JSX.Element | null;
+    displayName: string;
+};
+
 type BreadcrumbsProps = {
     children: React.ReactNode;
     separator?: React.ReactNode;
@@ -102,8 +166,8 @@ interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantPr
     loadingIndicator?: ReactNode;
 }
 declare const buttonVariants: (props?: ({
-    variant?: "link" | "filled" | "outlined" | "soft" | "ghost" | null | undefined;
-    intent?: "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "primary" | "success" | "error" | "warning" | "default" | "bluegray" | "bluelight" | "rose" | "primary-outlined" | "success-outlined" | "error-outlined" | "warning-outlined" | "default-outlined" | "blue-outlined" | "bluegray-outlined" | "bluelight-outlined" | "indigo-outlined" | "purple-outlined" | "violet-outlined" | "pink-outlined" | "rose-outlined" | "orange-outlined" | null | undefined;
+    variant?: "link" | "soft" | "filled" | "outlined" | "ghost" | null | undefined;
+    intent?: "primary" | "success" | "warning" | "error" | "default" | "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "bluegray" | "bluelight" | "rose" | "primary-outlined" | "success-outlined" | "error-outlined" | "warning-outlined" | "default-outlined" | "blue-outlined" | "bluegray-outlined" | "bluelight-outlined" | "indigo-outlined" | "purple-outlined" | "violet-outlined" | "pink-outlined" | "rose-outlined" | "orange-outlined" | null | undefined;
     size?: "sm" | "md" | "lg" | "xs" | "xl" | null | undefined;
     iconOnly?: boolean | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
@@ -165,7 +229,7 @@ declare const Calendar: {
 
 declare const calloutVariants: (props?: ({
     variant?: "filled" | "outlined" | null | undefined;
-    intent?: "primary" | "success" | "error" | "warning" | "default" | null | undefined;
+    intent?: "primary" | "success" | "warning" | "error" | "default" | null | undefined;
     size?: "sm" | "md" | "lg" | "xs" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface CalloutProps extends VariantProps<typeof calloutVariants> {
@@ -214,7 +278,7 @@ declare const CardFooter: React.FC<CardFooterProps>;
 
 declare const checkboxVariant: (props?: ({
     size?: "sm" | "lg" | "xl" | null | undefined;
-    intent?: "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "primary" | "success" | "error" | "warning" | "default" | "bluegray" | "bluelight" | "rose" | null | undefined;
+    intent?: "primary" | "success" | "warning" | "error" | "default" | "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "bluegray" | "bluelight" | "rose" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface CheckboxProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof checkboxVariant> {
     size?: "sm" | "lg" | "xl";
@@ -229,8 +293,8 @@ interface ChipProps extends HTMLAttributes<HTMLSpanElement>, VariantProps<typeof
     endIcon?: JSX.Element;
 }
 declare const chipVariants: (props?: ({
-    variant?: "outlined" | "soft" | "solid" | null | undefined;
-    intent?: "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "primary" | "success" | "error" | "warning" | "default" | "bluegray" | "bluelight" | "rose" | null | undefined;
+    variant?: "soft" | "solid" | "outlined" | null | undefined;
+    intent?: "primary" | "success" | "warning" | "error" | "default" | "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "bluegray" | "bluelight" | "rose" | null | undefined;
     size?: "sm" | "md" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 declare const Chip: ({ children, className, size, variant, intent, dot, dotColor, startIcon, endIcon, ...rest }: ChipProps) => React.JSX.Element;
@@ -244,6 +308,103 @@ interface CircularProgressBarProps {
 }
 declare const CircularProgressBar: ({ percentage, size, strokeWidth, text, textClassName, }: CircularProgressBarProps) => React.JSX.Element;
 
+interface SelectOption {
+    label: string;
+    value: string | number;
+    /** Optional. Unselectable and skipped by the keyboard. */
+    disabled?: boolean;
+    /** Optional. Secondary line under the label. */
+    description?: string;
+    /** Optional. Icon shown before the label. */
+    icon?: JSX.Element;
+}
+interface SelectGroup {
+    label: string;
+    options: SelectOption[];
+}
+interface SelectProps {
+    /** Flat options, or groups of options. */
+    options: (SelectOption | SelectGroup)[];
+    /** Controlled value. Use null for "nothing selected". */
+    value?: string | number | null;
+    /** Uncontrolled initial value. */
+    defaultValue?: string | number | null;
+    /** Called with the new value (null when cleared) and its option. */
+    onChange?: (value: string | number | null, option: SelectOption | null) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    error?: boolean;
+    /** Optional. "sm" = 320px, "lg" = 313px, default = full width (same as Input). */
+    size?: "sm" | "lg";
+    /** Optional. Open the list above or below. Defaults to "bottom". */
+    placement?: "bottom" | "top";
+    /** Optional. Show a clear button when a value is selected. Defaults to false. */
+    clearable?: boolean;
+    /** Optional. Max height of the list in px. Defaults to 264. */
+    maxHeight?: number;
+    /** Optional. Text shown when options is empty. */
+    emptyText?: string;
+    id?: string;
+    /** Optional. Adds a hidden input for native forms. */
+    name?: string;
+    className?: string;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+}
+declare const Select: {
+    ({ options, value, defaultValue, onChange, placeholder, disabled, error, size, placement, clearable, maxHeight, emptyText, id, name, className, "aria-label": ariaLabel, "aria-describedby": ariaDescribedby, }: SelectProps): React.JSX.Element;
+    displayName: string;
+};
+
+type ComboboxOption = SelectOption;
+type ComboboxGroup = SelectGroup;
+interface ComboboxProps {
+    /** Flat options, or groups of options. */
+    options: (ComboboxOption | ComboboxGroup)[];
+    /** Controlled value. Use null for "nothing selected". */
+    value?: string | number | null;
+    /** Uncontrolled initial value. */
+    defaultValue?: string | number | null;
+    /** Called with the new value (null when cleared) and its option. */
+    onChange?: (value: string | number | null, option: ComboboxOption | null) => void;
+    /** Optional. Called whenever the user types. Use it to fetch options from a server. */
+    onInputChange?: (query: string) => void;
+    /**
+     * Optional. Custom matcher, or false to turn off client-side filtering
+     * (when you filter on the server). Defaults to a case-insensitive "contains" match on the label.
+     */
+    filter?: ((option: ComboboxOption, query: string) => boolean) | false;
+    /** Optional. Shows a "Loading…" row. */
+    loading?: boolean;
+    /** Optional. Offer a "Create …" row when the typed text matches no option. */
+    allowCreate?: boolean;
+    /** Optional. Called when the user chooses the "Create …" row. Add the option and set the value yourself. */
+    onCreate?: (label: string) => void;
+    placeholder?: string;
+    /** Optional. Text shown when nothing matches. */
+    emptyText?: string;
+    disabled?: boolean;
+    error?: boolean;
+    /** Optional. "sm" = 320px, "lg" = 313px, default = full width (same as Input). */
+    size?: "sm" | "lg";
+    /** Optional. Open the list above or below. Defaults to "bottom". */
+    placement?: "bottom" | "top";
+    /** Optional. Show a clear button when a value is selected. Defaults to true. */
+    clearable?: boolean;
+    /** Optional. Max height of the list in px. Defaults to 264. */
+    maxHeight?: number;
+    id?: string;
+    /** Optional. Adds a hidden input for native forms. */
+    name?: string;
+    className?: string;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+}
+declare const Combobox: {
+    ({ options, value, defaultValue, onChange, onInputChange, filter, loading, allowCreate, onCreate, placeholder, emptyText, disabled, error, size, placement, clearable, maxHeight, id, name, className, "aria-label": ariaLabel, "aria-describedby": ariaDescribedby, }: ComboboxProps): React.JSX.Element;
+    displayName: string;
+};
+
 declare const SHADES: readonly [25, 50, 100, 200, 300, 400, 500, 600, 700, 800, 900];
 declare const PALETTE: {
     readonly primary: {
@@ -474,6 +635,1316 @@ declare const DateRangePicker: {
     displayName: string;
 };
 
+interface ContextMenuProps {
+    children: React.ReactNode;
+    /** Optional. Called when the menu opens or closes. */
+    onOpenChange?: (open: boolean) => void;
+    /** Optional. Turn the custom menu off so the browser's own context menu shows. */
+    disabled?: boolean;
+}
+declare const ContextMenu: ({ children, onOpenChange, disabled }: ContextMenuProps) => React.JSX.Element;
+interface ContextMenuTriggerProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    /** Optional. Press-and-hold time in ms that opens the menu on touch screens. Defaults to 600. */
+    longPressMs?: number;
+}
+declare const ContextMenuTrigger: ({ children, className, longPressMs, onContextMenu, onKeyDown, onPointerDown, onPointerMove, onPointerUp, onPointerCancel, ...rest }: ContextMenuTriggerProps) => React.JSX.Element;
+interface ContextMenuContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    "aria-label"?: string;
+}
+declare const ContextMenuContent: ({ children, className, style, ...rest }: ContextMenuContentProps) => React.ReactPortal | null;
+interface BaseItemProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    /** Optional. Icon shown before the label. */
+    icon?: JSX.Element;
+    /** Optional. Shortcut hint shown at the end, such as "Ctrl+C". Display only. */
+    shortcut?: string;
+    disabled?: boolean;
+    /** Optional. Use "danger" for destructive actions. */
+    intent?: "default" | "danger";
+    /** Optional. Close the menu after selecting. Defaults to true for items, false for checkbox items. */
+    closeOnSelect?: boolean;
+}
+interface ContextMenuItemProps extends BaseItemProps {
+    /** Called when the item is chosen by click, Enter or Space. */
+    onSelect?: () => void;
+}
+declare const ContextMenuItem: ({ children, icon, shortcut, disabled, intent, closeOnSelect, onSelect, className, ...rest }: ContextMenuItemProps) => React.JSX.Element;
+interface ContextMenuCheckboxItemProps extends BaseItemProps {
+    checked: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+}
+declare const ContextMenuCheckboxItem: ({ children, checked, onCheckedChange, icon, shortcut, disabled, intent, closeOnSelect, className, ...rest }: ContextMenuCheckboxItemProps) => React.JSX.Element;
+declare const ContextMenuLabel: ({ children, className, ...rest }: React.HTMLAttributes<HTMLDivElement>) => React.JSX.Element;
+declare const ContextMenuSeparator: ({ className, ...rest }: React.HTMLAttributes<HTMLDivElement>) => React.JSX.Element;
+declare const ContextMenuSub: ({ children }: {
+    children: React.ReactNode;
+}) => React.JSX.Element;
+declare const ContextMenuSubTrigger: ({ children, icon, disabled, className, ...rest }: Omit<BaseItemProps, "shortcut" | "intent" | "closeOnSelect">) => React.JSX.Element;
+declare const ContextMenuSubContent: ({ children, className, style, ...rest }: ContextMenuContentProps) => React.ReactPortal | null;
+
+interface CommandItem {
+    /** Unique id for the command. */
+    id: string;
+    /** Text shown and searched. */
+    label: string;
+    /** Optional. Secondary text shown under the label and searched too. */
+    description?: string;
+    /** Optional. Icon shown before the label. */
+    icon?: JSX.Element;
+    /** Optional. Shortcut hint shown at the end, such as "Ctrl+N". Display only. */
+    shortcut?: string;
+    /** Optional. Extra words that should match this command in search. */
+    keywords?: string[];
+    disabled?: boolean;
+    /** Called when the command is chosen. */
+    onSelect?: () => void;
+}
+interface CommandGroup {
+    /** Optional. Heading shown above the group. */
+    heading?: string;
+    items: CommandItem[];
+}
+interface CommandPaletteProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The commands, organised in groups. */
+    groups: CommandGroup[];
+    /** Optional. Placeholder in the search field. Defaults to "Search commands…". */
+    placeholder?: string;
+    /** Optional. Message when nothing matches. Defaults to "No results found." */
+    emptyMessage?: string;
+    /** Optional. Accessible name for the dialog. Defaults to "Command palette". */
+    "aria-label"?: string;
+    /** Optional. Global key combo that toggles the palette, such as "mod+k" (mod = Ctrl on Windows/Linux, Cmd on Mac). */
+    hotkey?: string;
+    /** Optional. Close after a command is chosen. Defaults to true. */
+    closeOnSelect?: boolean;
+    /** Optional. Replace the built-in search. Return true to keep the item. */
+    filter?: (item: CommandItem, query: string) => boolean;
+    /** Optional. Class name for the panel. */
+    className?: string;
+}
+declare const CommandPalette: ({ open, onOpenChange, groups, placeholder, emptyMessage, "aria-label": ariaLabel, hotkey, closeOnSelect, filter, className, }: CommandPaletteProps) => React.ReactPortal | null;
+
+interface MenubarProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    /** Accessible name for the menu bar. */
+    "aria-label"?: string;
+}
+declare const Menubar: ({ children, className, ...rest }: MenubarProps) => React.JSX.Element;
+declare const MenubarMenu: ({ children }: {
+    children: React.ReactNode;
+}) => React.JSX.Element;
+interface MenubarTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    children: React.ReactNode;
+}
+declare const MenubarTrigger: ({ children, className, onClick, onKeyDown, onMouseEnter, ...rest }: MenubarTriggerProps) => React.JSX.Element;
+interface MenubarContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    "aria-label"?: string;
+}
+declare const MenubarContent: ({ children, className, style, ...rest }: MenubarContentProps) => React.ReactPortal | null;
+interface BaseProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    /** Optional. Icon shown before the label. */
+    icon?: JSX.Element;
+    /** Optional. Shortcut hint, display only. */
+    shortcut?: string;
+    disabled?: boolean;
+    /** Optional. Use "danger" for destructive actions. */
+    intent?: "default" | "danger";
+    /** Optional. Close the menu after selecting. Defaults to true for items, false for checkbox items. */
+    closeOnSelect?: boolean;
+}
+interface MenubarItemProps extends BaseProps {
+    /** Called when the item is chosen by click, Enter or Space. */
+    onSelect?: () => void;
+}
+declare const MenubarItem: ({ children, icon, shortcut, disabled, intent, closeOnSelect, onSelect, className, ...rest }: MenubarItemProps) => React.JSX.Element;
+interface MenubarCheckboxItemProps extends BaseProps {
+    checked: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+}
+declare const MenubarCheckboxItem: ({ children, checked, onCheckedChange, icon, shortcut, disabled, intent, closeOnSelect, className, ...rest }: MenubarCheckboxItemProps) => React.JSX.Element;
+declare const MenubarLabel: ({ children, className, ...rest }: React.HTMLAttributes<HTMLDivElement>) => React.JSX.Element;
+declare const MenubarSeparator: ({ className, ...rest }: React.HTMLAttributes<HTMLDivElement>) => React.JSX.Element;
+declare const MenubarSub: ({ children }: {
+    children: React.ReactNode;
+}) => React.JSX.Element;
+declare const MenubarSubTrigger: ({ children, icon, disabled, className, ...rest }: Omit<BaseProps, "shortcut" | "intent" | "closeOnSelect">) => React.JSX.Element;
+declare const MenubarSubContent: ({ children, className, style, ...rest }: MenubarContentProps) => React.ReactPortal | null;
+
+interface NavbarItem {
+    /** Unique id. */
+    id: string;
+    label: string;
+    /** Optional. Link target. Items without an href render as buttons. */
+    href?: string;
+    /** Optional. Icon shown before the label. */
+    icon?: JSX.Element;
+    /** Optional. Marks the current page (adds aria-current="page"). */
+    active?: boolean;
+    disabled?: boolean;
+    /** Optional. Called when the item is clicked. */
+    onClick?: (e: React.MouseEvent) => void;
+}
+interface NavbarLinkRenderProps {
+    href: string;
+    className: string;
+    children: React.ReactNode;
+    onClick?: (e: React.MouseEvent) => void;
+    "aria-current"?: "page";
+}
+interface NavbarProps extends Omit<React.HTMLAttributes<HTMLElement>, "children"> {
+    /** Optional. Logo or product name shown at the start. */
+    brand?: React.ReactNode;
+    /** Optional. Navigation links. */
+    items?: NavbarItem[];
+    /** Optional. Content at the end, such as buttons, a search field or an avatar. */
+    actions?: React.ReactNode;
+    /** Optional. Extra content in the middle, between the links and the actions. */
+    children?: React.ReactNode;
+    /** Optional. Visual style. Defaults to "default". */
+    variant?: "default" | "transparent" | "primary";
+    /** Optional. Stick to the top of the page while scrolling. Defaults to false. */
+    sticky?: boolean;
+    /** Optional. Show a bottom border. Defaults to true. */
+    bordered?: boolean;
+    /** Optional. Width at which the links collapse into a menu button. Defaults to "md". */
+    collapseBelow?: "sm" | "md" | "lg";
+    /** Optional. Maximum content width. Defaults to "7xl". */
+    maxWidth?: "3xl" | "5xl" | "7xl" | "full";
+    /** Optional. Accessible name for the navigation. Defaults to "Main". */
+    "aria-label"?: string;
+    /** Optional. Render links with your router's Link component, for example Next.js Link. */
+    renderLink?: (props: NavbarLinkRenderProps) => React.ReactNode;
+}
+declare const Navbar: ({ brand, items, actions, children, variant, sticky, bordered, collapseBelow, maxWidth, "aria-label": ariaLabel, renderLink, className, ...rest }: NavbarProps) => React.JSX.Element;
+
+type TimelineStatus = "completed" | "current" | "upcoming" | "error";
+interface TimelineItem {
+    /** Unique id. */
+    id: string;
+    /** Short heading for the event. */
+    title: React.ReactNode;
+    /** Optional. Supporting text under the title. */
+    description?: React.ReactNode;
+    /** Optional. Date or time label, such as "2 hours ago". */
+    time?: string;
+    /** Optional. Machine-readable date for the time element, such as "2026-11-05". */
+    dateTime?: string;
+    /** Optional. Replaces the default marker (check, cross or dot). */
+    icon?: JSX.Element;
+    /** Optional. Controls the marker colour. Defaults to "completed". */
+    status?: TimelineStatus;
+    /** Optional. Extra content below the description, such as a card or attachment. */
+    content?: React.ReactNode;
+}
+interface TimelineProps extends Omit<React.OlHTMLAttributes<HTMLOListElement>, "children"> {
+    items: TimelineItem[];
+    /** Optional. Layout direction. Defaults to "vertical". */
+    orientation?: "vertical" | "horizontal";
+    /** Optional. Marker size. Defaults to "md". */
+    size?: "sm" | "md";
+    /** Optional. Put the time on the left of the marker in vertical layouts. Defaults to false. */
+    timeOnSide?: boolean;
+    /** Optional. Accessible name for the list. */
+    "aria-label"?: string;
+}
+declare const Timeline: ({ items, orientation, size, timeOnSide, className, ...rest }: TimelineProps) => React.JSX.Element;
+
+interface CarouselProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange" | "children"> {
+    /** The slides. Each child becomes one slide. */
+    children: React.ReactNode;
+    /** Optional. Controlled index of the first visible slide. */
+    index?: number;
+    /** Optional. Starting index when uncontrolled. Defaults to 0. */
+    defaultIndex?: number;
+    /** Optional. Called when the visible slide changes. */
+    onIndexChange?: (index: number) => void;
+    /** Optional. Slides visible at once. Defaults to 1. */
+    slidesPerView?: 1 | 2 | 3 | 4;
+    /** Optional. Space between slides in pixels. Defaults to 16. */
+    gap?: number;
+    /** Optional. Wrap from the last slide to the first and back. Defaults to false. */
+    loop?: boolean;
+    /** Optional. Show previous and next buttons. Defaults to true. */
+    arrows?: boolean;
+    /** Optional. Show dot indicators. Defaults to true. */
+    dots?: boolean;
+    /** Optional. Milliseconds between automatic slides. 0 turns autoplay off. Defaults to 0. */
+    autoplay?: number;
+    /** Optional. Allow dragging or swiping. Defaults to true. */
+    swipe?: boolean;
+    /** Optional. Accessible name for the carousel. Defaults to "Carousel". */
+    "aria-label"?: string;
+    /** Optional. Class name for the sliding area. */
+    viewportClassName?: string;
+}
+declare const Carousel: ({ children, index: controlled, defaultIndex, onIndexChange, slidesPerView, gap, loop, arrows, dots, autoplay, swipe, "aria-label": ariaLabel, className, viewportClassName, ...rest }: CarouselProps) => React.JSX.Element;
+
+interface GalleryImage {
+    /** Full size image URL. */
+    src: string;
+    /** Text description of the image. Use "" only for purely decorative images. */
+    alt: string;
+    /** Optional. Smaller image used in the grid and thumbnail strip. Defaults to src. */
+    thumbnail?: string;
+    /** Optional. Caption shown in the lightbox. */
+    caption?: React.ReactNode;
+}
+interface LightboxProps {
+    images: GalleryImage[];
+    open: boolean;
+    /** Index of the image being shown. */
+    index: number;
+    /** Called when the user moves to another image. */
+    onIndexChange: (index: number) => void;
+    /** Called when the lightbox should close. */
+    onClose: () => void;
+    /** Optional. Wrap around at the first and last image. Defaults to false. */
+    loop?: boolean;
+    /** Optional. Show the thumbnail strip. Defaults to true. */
+    showThumbnails?: boolean;
+    /** Optional. Show the zoom button. Defaults to true. */
+    zoom?: boolean;
+    /** Optional. Accessible name for the dialog. Defaults to "Image viewer". */
+    "aria-label"?: string;
+}
+declare const Lightbox: ({ images, open, index, onIndexChange, onClose, loop, showThumbnails, zoom, "aria-label": ariaLabel, }: LightboxProps) => React.ReactPortal | null;
+interface ImageGalleryProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    images: GalleryImage[];
+    /** Optional. Number of columns on wide screens. Defaults to 3. */
+    columns?: 2 | 3 | 4 | 5;
+    /** Optional. Shape of each thumbnail. Defaults to "square". */
+    aspect?: "square" | "video" | "portrait";
+    /** Optional. Open images in a lightbox when clicked. Defaults to true. */
+    lightbox?: boolean;
+    /** Optional. Wrap around in the lightbox. Defaults to false. */
+    loop?: boolean;
+    /** Optional. Show thumbnails in the lightbox. Defaults to true. */
+    showThumbnails?: boolean;
+    /** Optional. Called when a thumbnail is clicked. */
+    onImageClick?: (index: number) => void;
+}
+declare const ImageGallery: ({ images, columns, aspect, lightbox, loop, showThumbnails, onImageClick, className, ...rest }: ImageGalleryProps) => React.JSX.Element;
+
+interface EmptyStateProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title"> {
+    /** Short heading, such as "No results found". */
+    title: React.ReactNode;
+    /** Optional. Supporting text that explains why it is empty and what to do next. */
+    description?: React.ReactNode;
+    /** Optional. Icon or illustration shown above the title. */
+    icon?: JSX.Element;
+    /** Optional. Main action, such as a Button. */
+    action?: React.ReactNode;
+    /** Optional. Secondary action shown next to the main one. */
+    secondaryAction?: React.ReactNode;
+    /** Optional. Spacing and text size. Defaults to "md". */
+    size?: "sm" | "md" | "lg";
+    /** Optional. "plain" has no frame, "dashed" draws a dashed border, "card" a solid bordered card. Defaults to "plain". */
+    variant?: "plain" | "dashed" | "card";
+    /** Optional. Heading element to use so the page outline stays correct. Defaults to "h3". */
+    headingLevel?: "h2" | "h3" | "h4" | "h5" | "h6" | "p";
+}
+declare const EmptyState: ({ title, description, icon, action, secondaryAction, size, variant, headingLevel: Heading, className, ...rest }: EmptyStateProps) => React.JSX.Element;
+
+type SortDirection = "asc" | "desc";
+interface DataGridSort {
+    columnId: string;
+    direction: SortDirection;
+}
+interface DataGridColumn<T> {
+    /** Unique column id. */
+    id: string;
+    /** Column heading. Use a string so the filter box gets a good accessible name. */
+    header: string;
+    /** Optional. Property name or function that reads the cell value from a row. Defaults to the id. */
+    accessor?: keyof T | ((row: T) => unknown);
+    /** Optional. Custom cell renderer. */
+    cell?: (value: unknown, row: T) => React.ReactNode;
+    /** Optional. Let people sort by this column. Defaults to false. */
+    sortable?: boolean;
+    /** Optional. Show a filter box for this column when columnFilters is on. Defaults to true. */
+    filterable?: boolean;
+    /** Optional. Custom sort comparison for this column. */
+    sortFn?: (a: T, b: T) => number;
+    /** Optional. Custom filter test. Return true to keep the row. */
+    filterFn?: (value: unknown, query: string, row: T) => boolean;
+    /** Optional. Column width, such as "120px" or "20%". */
+    width?: string;
+    /** Optional. Text alignment. Defaults to "left". */
+    align?: "left" | "center" | "right";
+}
+interface DataGridProps<T> {
+    data: T[];
+    columns: DataGridColumn<T>[];
+    /** Optional. Returns a stable unique id for a row. Defaults to row.id, then the row index. */
+    getRowId?: (row: T, index: number) => string;
+    /** Optional. Row selection: "none", "single" (radio) or "multiple" (checkboxes). Defaults to "none". */
+    selectionMode?: "none" | "single" | "multiple";
+    /** Optional. Controlled selected row ids. */
+    selectedIds?: string[];
+    /** Optional. Initially selected row ids when uncontrolled. */
+    defaultSelectedIds?: string[];
+    /** Optional. Called when the selection changes. */
+    onSelectionChange?: (ids: string[]) => void;
+    /** Optional. Controlled sort. Use null for no sort. */
+    sort?: DataGridSort | null;
+    /** Optional. Initial sort when uncontrolled. */
+    defaultSort?: DataGridSort | null;
+    /** Optional. Called when the sort changes. */
+    onSortChange?: (sort: DataGridSort | null) => void;
+    /** Optional. Rows per page. 0 shows every row without pagination. Defaults to 0. */
+    pageSize?: number;
+    /** Optional. Show a search box that filters all columns. Defaults to false. */
+    searchable?: boolean;
+    /** Optional. Show a filter box under each sortable/filterable heading. Defaults to false. */
+    columnFilters?: boolean;
+    /** Optional. Message when there are no rows. Defaults to "No data". */
+    emptyMessage?: React.ReactNode;
+    /** Optional. Shows a loading state. */
+    loading?: boolean;
+    /** Optional. Alternate row backgrounds. */
+    striped?: boolean;
+    /** Optional. Row height. Defaults to "comfortable". */
+    density?: "compact" | "comfortable";
+    /** Optional. Keep the header visible while the body scrolls. Needs maxHeight. */
+    stickyHeader?: boolean;
+    /** Optional. Maximum height of the scrolling area, such as "400px". */
+    maxHeight?: string;
+    /** Optional. Called when a row is clicked. */
+    onRowClick?: (row: T) => void;
+    /** Optional. Extra content in the toolbar, such as buttons. */
+    toolbar?: React.ReactNode;
+    /** Accessible name for the table. */
+    "aria-label": string;
+    className?: string;
+}
+declare function DataGrid<T>({ data, columns, getRowId, selectionMode, selectedIds, defaultSelectedIds, onSelectionChange, sort: sortProp, defaultSort, onSortChange, pageSize, searchable, columnFilters, emptyMessage, loading, striped, density, stickyHeader, maxHeight, onRowClick, toolbar, "aria-label": ariaLabel, className, }: DataGridProps<T>): React.JSX.Element;
+
+interface ActiveFilter {
+    /** Unique id for the filter. */
+    id: string;
+    /** Name of the filter, such as "Status". */
+    label: string;
+    /** Optional. Chosen value, such as "Active". Shown as "Status: Active". */
+    value?: string;
+}
+interface TableToolbarProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Optional. Current search text. Pass with onSearchChange to show the search box. */
+    searchValue?: string;
+    /** Optional. Called with the new search text (after debounceMs, if set). */
+    onSearchChange?: (value: string) => void;
+    /** Optional. Placeholder in the search box. Defaults to "Search…". */
+    searchPlaceholder?: string;
+    /** Optional. Wait this many milliseconds after typing before calling onSearchChange. Defaults to 0. */
+    debounceMs?: number;
+    /** Optional. Filter controls, such as Select or Dropdown components. */
+    filters?: React.ReactNode;
+    /** Optional. Filters currently applied, shown as removable chips. */
+    activeFilters?: ActiveFilter[];
+    /** Optional. Called when a chip's remove button is used. */
+    onRemoveFilter?: (id: string) => void;
+    /** Optional. Called by "Clear all". The button shows when there is search text or more than one filter. */
+    onClearAll?: () => void;
+    /** Optional. Number of rows after filtering. Shown and announced to screen readers. */
+    resultCount?: number;
+    /** Optional. Word for the results. Defaults to "results". Use the plural. */
+    resultLabel?: string;
+    /** Optional. Content on the right, such as Export or Add buttons. */
+    actions?: React.ReactNode;
+    /** Optional. Number of selected rows. When above 0 the toolbar switches to bulk mode. */
+    selectedCount?: number;
+    /** Optional. Actions for the selected rows, shown in bulk mode. */
+    bulkActions?: React.ReactNode;
+    /** Optional. Called by the Clear selection button in bulk mode. */
+    onClearSelection?: () => void;
+    /** Optional. Accessible name for the search and filter group. Defaults to "Filter table". */
+    "aria-label"?: string;
+}
+declare const TableToolbar: ({ searchValue, onSearchChange, searchPlaceholder, debounceMs, filters, activeFilters, onRemoveFilter, onClearAll, resultCount, resultLabel, actions, selectedCount, bulkActions, onClearSelection, "aria-label": ariaLabel, className, ...rest }: TableToolbarProps) => React.JSX.Element;
+
+type FieldValidator = (value: any, values: Record<string, any>) => string | undefined | null | false;
+/** Ready-made validators to pass to FormField's `validate` prop. Combine them with `compose`. */
+declare const validators: {
+    required: (message?: string) => FieldValidator;
+    email: (message?: string) => FieldValidator;
+    minLength: (n: number, message?: string) => FieldValidator;
+    maxLength: (n: number, message?: string) => FieldValidator;
+    pattern: (re: RegExp, message?: string) => FieldValidator;
+    min: (n: number, message?: string) => FieldValidator;
+    max: (n: number, message?: string) => FieldValidator;
+    matches: (otherField: string, message?: string) => FieldValidator;
+};
+/** Run validators in order and return the first error message. */
+declare const compose: (...fns: FieldValidator[]) => FieldValidator;
+type FormErrors = Record<string, string | undefined>;
+interface FormState<V extends Record<string, any> = Record<string, any>> {
+    values: V;
+    /** All current errors, whether or not they are shown yet. */
+    errors: FormErrors;
+    touched: Record<string, boolean>;
+    isSubmitting: boolean;
+    /** True when there are no errors at all. */
+    isValid: boolean;
+    /** True when any value differs from the initial values. */
+    isDirty: boolean;
+    submitCount: number;
+    setValue: (name: string, value: any) => void;
+    setValues: (patch: Partial<V>) => void;
+    setTouched: (name: string, touched?: boolean) => void;
+    /** Restore the initial values and clear touched, submit count and any submit error. */
+    reset: (values?: V) => void;
+}
+/** Read form state and helpers from anywhere inside a <Form>. */
+declare function useFormContext<V extends Record<string, any> = Record<string, any>>(): FormState<V>;
+interface FormProps<V extends Record<string, any> = Record<string, any>> extends Omit<React.FormHTMLAttributes<HTMLFormElement>, "onSubmit" | "children"> {
+    /** Starting values, keyed by field name. */
+    initialValues: V;
+    /** Called with the values when the form is valid. May be async; a thrown error is shown as a form error. */
+    onSubmit: (values: V) => void | Promise<void>;
+    /** Optional. Form-level validation, for rules that involve several fields. Return an object of messages keyed by field name. */
+    validate?: (values: V) => FormErrors | undefined;
+    /** Optional. When field errors appear: after the field loses focus ("blur"), as soon as it changes ("change"), or only after a submit attempt ("submit"). Defaults to "blur". */
+    validateOn?: "blur" | "change" | "submit";
+    /** Optional. Show a summary of errors at the top after a failed submit. Defaults to true. */
+    errorSummary?: boolean;
+    /** Optional. Heading of the error summary. Defaults to "Please fix the following". */
+    errorSummaryTitle?: string;
+    /** Form contents, or a function that receives the form state. */
+    children: React.ReactNode | ((state: FormState<V>) => React.ReactNode);
+}
+declare function Form<V extends Record<string, any> = Record<string, any>>({ initialValues, onSubmit, validate, validateOn, errorSummary, errorSummaryTitle, children, className, ...rest }: FormProps<V>): React.JSX.Element;
+interface FieldControlProps {
+    id: string;
+    name: string;
+    value: any;
+    checked?: boolean;
+    onChange: (eventOrValue: any) => void;
+    onBlur: () => void;
+    "aria-invalid": true | undefined;
+    "aria-required": true | undefined;
+    "aria-describedby": string | undefined;
+}
+interface FormFieldProps {
+    /** Key of this field in the form values. */
+    name: string;
+    /** Label shown above the control. */
+    label: string;
+    /** Optional. Help text shown under the label. */
+    description?: React.ReactNode;
+    /** Optional. Mark the field as required. Pass a string to set the error message. */
+    required?: boolean | string;
+    /** Optional. Validation for this field. Return an error message, or nothing when valid. Combine rules with compose(). */
+    validate?: FieldValidator;
+    /** Optional. Use "checked" for checkbox and switch controls so their boolean value is passed as `checked`. Defaults to "value". */
+    valueProp?: "value" | "checked";
+    /** Optional. Hide the label visually but keep it for screen readers. */
+    hideLabel?: boolean;
+    className?: string;
+    /** The control. A function receives the props to spread onto it plus `error` text and `invalid`. A plain element receives the props directly. */
+    children: React.ReactElement | ((control: FieldControlProps & {
+        error?: string;
+        invalid: boolean;
+    }) => React.ReactNode);
+}
+declare const FormField: ({ name, label, description, required, validate, valueProp, hideLabel, className, children }: FormFieldProps) => React.JSX.Element;
+
+interface NumberInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange" | "size" | "min" | "max" | "step" | "type" | "prefix"> {
+    /** Controlled value. Use null (or an empty string) for empty. */
+    value?: number | null | "";
+    /** Optional. Starting value when uncontrolled. */
+    defaultValue?: number | null;
+    /** Called with the new number, or null when the field is empty. Fires while typing and when the buttons are used. */
+    onChange?: (value: number | null) => void;
+    /** Optional. Smallest allowed value. */
+    min?: number;
+    /** Optional. Largest allowed value. */
+    max?: number;
+    /** Optional. Amount added or removed by the buttons and arrow keys. Defaults to 1. */
+    step?: number;
+    /** Optional. Digits shown after the decimal point. Values are rounded to this. Defaults to 0. */
+    precision?: number;
+    /** Optional. Where to put the +/- buttons: on both "sides", "stacked" at the end, or "none". Defaults to "sides". */
+    controls?: "sides" | "stacked" | "none";
+    /** Optional. Text or icon before the number, such as "$". */
+    prefix?: React.ReactNode;
+    /** Optional. Text after the number, such as "kg" or "%". */
+    suffix?: React.ReactNode;
+    /** Optional. Field height. Defaults to "lg". */
+    size?: "sm" | "lg";
+    /** Optional. Show the error style. */
+    error?: boolean;
+    /** Optional. Turns the field off. */
+    disabled?: boolean;
+    /** Optional. Make it read-only. */
+    readOnly?: boolean;
+    /** Optional. Class name for the outer wrapper. */
+    className?: string;
+}
+declare const NumberInput: React.ForwardRefExoticComponent<NumberInputProps & React.RefAttributes<HTMLInputElement>>;
+
+interface PasswordStrength {
+    /** 0 (empty) to 4 (strong). */
+    score: 0 | 1 | 2 | 3 | 4;
+    label: "" | "Weak" | "Fair" | "Good" | "Strong";
+    /** The rules and whether each is met. */
+    checks: {
+        id: string;
+        label: string;
+        met: boolean;
+    }[];
+}
+/** Score a password from 0 to 4 and list which rules it meets. Exported so you can reuse it in validation. */
+declare const getPasswordStrength: (password: string) => PasswordStrength;
+interface PasswordInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size" | "prefix"> {
+    /** Optional. Field height. Defaults to "lg". */
+    size?: "sm" | "lg";
+    /** Optional. Show the error style. */
+    error?: boolean;
+    /** Optional. Show a lock icon at the start. Defaults to false. */
+    showLockIcon?: boolean;
+    /** Optional. Controlled visibility of the password. */
+    visible?: boolean;
+    /** Optional. Start with the password shown. Defaults to false. */
+    defaultVisible?: boolean;
+    /** Optional. Called when the password is shown or hidden. */
+    onVisibleChange?: (visible: boolean) => void;
+    /** Optional. Show a strength meter under the field. Use when people create a password. Defaults to false. */
+    showStrength?: boolean;
+    /** Optional. Show the list of rules under the meter. Needs showStrength. Defaults to false. */
+    showRequirements?: boolean;
+    /** Optional. Warn when Caps Lock is on while typing. Defaults to true. */
+    capsLockWarning?: boolean;
+    /** Optional. Class name for the outer wrapper. */
+    className?: string;
+}
+declare const PasswordInput: React.ForwardRefExoticComponent<PasswordInputProps & React.RefAttributes<HTMLInputElement>>;
+
+interface SearchInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size" | "value" | "defaultValue" | "onChange" | "prefix"> {
+    /** Controlled search text. */
+    value?: string;
+    /** Optional. Starting text when uncontrolled. */
+    defaultValue?: string;
+    /** Called with the new text on every keystroke and when the text is cleared. */
+    onChange?: (value: string) => void;
+    /** Optional. Called when the person presses Enter, clears the box, or (with debounceMs) pauses typing. */
+    onSearch?: (value: string) => void;
+    /** Optional. Wait this many milliseconds after typing stops, then call onSearch. 0 means only Enter and clear call it. Defaults to 0. */
+    debounceMs?: number;
+    /** Optional. Show a spinner while results load. */
+    loading?: boolean;
+    /** Optional. Show the clear button when there is text. Defaults to true. */
+    clearable?: boolean;
+    /** Optional. Global key that focuses the field, such as "/" or "k". Ignored while typing in another field. */
+    hotkey?: string;
+    /** Optional. Field height. Defaults to "lg". */
+    size?: "sm" | "lg";
+    /** Optional. Show the error style. */
+    error?: boolean;
+    /** Optional. Class name for the outer wrapper. */
+    className?: string;
+}
+declare const SearchInput: React.ForwardRefExoticComponent<SearchInputProps & React.RefAttributes<HTMLInputElement>>;
+
+/** Strip everything except a small set of safe formatting tags. Use it before rendering saved editor HTML elsewhere. */
+declare const sanitizeHtml: (html: string) => string;
+type RichTextToolbarItem = "bold" | "italic" | "underline" | "strike" | "style" | "bulletList" | "numberList" | "quote" | "link" | "undo" | "redo" | "clear" | "|";
+interface RichTextEditorProps {
+    /** Controlled content as HTML. */
+    value?: string;
+    /** Optional. Starting HTML when uncontrolled. */
+    defaultValue?: string;
+    /** Called with the new HTML, or an empty string when there is no text. The HTML only contains safe formatting tags. */
+    onChange?: (html: string) => void;
+    /** Optional. Hint shown while empty. */
+    placeholder?: string;
+    /** Optional. Which tools to show, in order. Use "|" for a divider. Defaults to all. */
+    toolbar?: RichTextToolbarItem[];
+    /** Optional. Smallest height of the writing area, in pixels. Defaults to 140. */
+    minHeight?: number;
+    /** Optional. Largest height before the area scrolls, in pixels. */
+    maxHeight?: number;
+    /** Optional. Stop typing after this many characters and show a counter. */
+    maxLength?: number;
+    /** Optional. Show the error style. */
+    error?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    /** Optional. Called when the editor loses focus. */
+    onBlur?: () => void;
+    /** Optional. id of the writing area, so a label can point to it. */
+    id?: string;
+    name?: string;
+    /** Accessible name when there is no visible label. */
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+    "aria-invalid"?: boolean;
+    "aria-required"?: boolean;
+    className?: string;
+}
+declare const RichTextEditor: ({ value, defaultValue, onChange, placeholder, toolbar, minHeight, maxHeight, maxLength, error, disabled, readOnly, onBlur, id: idProp, name, className, ...aria }: RichTextEditorProps) => React.JSX.Element;
+
+interface CodeBlockProps extends Omit<React.HTMLAttributes<HTMLElement>, "children" | "title" | "onCopy"> {
+    /** The code to show. */
+    code: string;
+    /** Optional. Language for colouring: js, jsx, ts, tsx, json, css, html, bash, python. Other values show plain text. */
+    language?: string;
+    /** Optional. File name or heading shown above the code. Defaults to the language name. */
+    title?: React.ReactNode;
+    /** Optional. Show line numbers. Defaults to false. */
+    showLineNumbers?: boolean;
+    /** Optional. First line number. Defaults to 1. */
+    startLine?: number;
+    /** Optional. Lines to highlight, as numbers or a string such as "1,3-5". Numbers follow startLine. */
+    highlightLines?: number[] | string;
+    /** Optional. Wrap long lines instead of scrolling sideways. Defaults to false. */
+    wrap?: boolean;
+    /** Optional. Show a button that toggles wrapping. Defaults to false. */
+    wrapToggle?: boolean;
+    /** Optional. Show the copy button. Defaults to true. */
+    copyable?: boolean;
+    /** Optional. Called after the code is copied. */
+    onCodeCopy?: (code: string) => void;
+    /** Optional. Maximum height before the code scrolls, such as "320px". */
+    maxHeight?: string;
+    /** Optional. Colour scheme. Defaults to "dark". */
+    theme?: "dark" | "light";
+    /** Optional. Colour the code. Set false for plain text. Defaults to true. */
+    highlight?: boolean;
+}
+declare const CodeBlock: ({ code, language, title, showLineNumbers, startLine, highlightLines, wrap: wrapProp, wrapToggle, copyable, onCodeCopy, maxHeight, theme, highlight, className, ...rest }: CodeBlockProps) => React.JSX.Element;
+
+interface KbdProps extends Omit<React.HTMLAttributes<HTMLElement>, "children"> {
+    /** A single key, such as "K", "Enter" or "mod". Friendly names are converted: mod, cmd, ctrl, alt, shift, enter, esc, tab, space, up, down, left, right. */
+    children?: React.ReactNode;
+    /** Optional. A shortcut as a list of keys, such as ["mod", "K"]. Use this instead of children. */
+    keys?: string[];
+    /** Optional. Text between the keys of a shortcut. Defaults to "+". Use "" for none. */
+    separator?: string;
+    /** Optional. Show symbols (⌘ ⇧ ⌥) on Mac and words on other systems. Set false to always show words. Defaults to true. */
+    platformAware?: boolean;
+    /** Optional. Key size. Defaults to "md". */
+    size?: "sm" | "md" | "lg";
+    /** Optional. Look of the keys. "default" is a raised key, "outlined" a flat border, "subtle" a plain grey chip. Defaults to "default". */
+    variant?: "default" | "outlined" | "subtle";
+}
+declare const Kbd: ({ children, keys, separator, platformAware, size, variant, className, ...rest }: KbdProps) => React.JSX.Element;
+
+interface LinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "color"> {
+    /** Where the link goes. Without an href (and not disabled) a button that looks like a link is rendered. */
+    href?: string;
+    /** Optional. Colour of the link. "inherit" uses the surrounding text colour. Defaults to "primary". */
+    variant?: "primary" | "neutral" | "inherit";
+    /** Optional. When the underline shows. Keep "always" inside paragraphs so links do not rely on colour alone. Defaults to "always". */
+    underline?: "always" | "hover" | "none";
+    /** Optional. Text size. "inherit" matches the surrounding text. Defaults to "inherit". */
+    size?: "sm" | "md" | "lg" | "inherit";
+    /** Optional. Opens in a new tab with safe rel values, shows an icon and tells screen readers. Defaults to false. */
+    external?: boolean;
+    /** Optional. Show the arrow icon on external links. Defaults to true. */
+    showExternalIcon?: boolean;
+    /** Optional. Marks the link to the page you are on (aria-current="page") and makes it bolder. */
+    current?: boolean;
+    /** Optional. Turns the link off. It stays visible but cannot be used. */
+    disabled?: boolean;
+    /** Optional. Icon before the text. */
+    startIcon?: JSX.Element;
+    /** Optional. Icon after the text. */
+    endIcon?: JSX.Element;
+    /** Optional. Component to render instead of a plain anchor, such as Next.js Link or React Router Link. It receives the same props. */
+    component?: React.ElementType;
+}
+declare const Link: React.ForwardRefExoticComponent<LinkProps & React.RefAttributes<HTMLElement>>;
+
+interface CollapsibleProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    /** Controlled open state. */
+    open?: boolean;
+    /** Optional. Starting state when uncontrolled. Defaults to false. */
+    defaultOpen?: boolean;
+    /** Called when the section opens or closes. */
+    onOpenChange?: (open: boolean) => void;
+    /** Optional. Stops the section from being toggled. */
+    disabled?: boolean;
+    children: React.ReactNode;
+}
+declare const Collapsible: ({ open: openProp, defaultOpen, onOpenChange, disabled, className, children, ...rest }: CollapsibleProps) => React.JSX.Element;
+interface CollapsibleTriggerProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
+    /** The label, or a function that receives the open state, for text that changes such as "Show more" and "Show less". */
+    children: React.ReactNode | ((open: boolean) => React.ReactNode);
+    /** Optional. Hide the chevron. Defaults to false. */
+    hideIndicator?: boolean;
+    /** Optional. Put the chevron before the label. Defaults to false. */
+    indicatorStart?: boolean;
+}
+declare const CollapsibleTrigger: ({ children, hideIndicator, indicatorStart, className, onClick, ...rest }: CollapsibleTriggerProps) => React.JSX.Element;
+interface CollapsibleContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Optional. Keep the content in the page while closed (hidden from everyone). Defaults to true, which keeps state and allows the animation. Set false to remove it from the page when closed. */
+    keepMounted?: boolean;
+}
+declare const CollapsibleContent: ({ keepMounted, className, children, ...rest }: CollapsibleContentProps) => React.JSX.Element | null;
+
+type Direction = "horizontal" | "vertical";
+interface ResizablePanelProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Optional. Starting size as a percent of the group. Panels without one share the remaining space equally. */
+    defaultSize?: number;
+    /** Optional. Smallest size in percent. Defaults to 10. */
+    minSize?: number;
+    /** Optional. Largest size in percent. Defaults to 100. */
+    maxSize?: number;
+    children?: React.ReactNode;
+}
+declare const ResizablePanel: ({ defaultSize: _d, minSize: _mi, maxSize: _ma, className, children, ...rest }: ResizablePanelProps) => React.JSX.Element;
+interface ResizableHandleProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Optional. Show a grip so the handle is easy to spot. Defaults to false. */
+    withHandle?: boolean;
+    /** Optional. Stops this divider from being moved. */
+    disabled?: boolean;
+    /** Optional. Accessible name. Defaults to "Resize". */
+    "aria-label"?: string;
+}
+declare const ResizableHandle: ({ withHandle, disabled, className, onKeyDown, ...rest }: ResizableHandleProps) => React.JSX.Element;
+interface ResizablePanelGroupProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange"> {
+    /** Optional. "horizontal" puts panels side by side, "vertical" stacks them. Defaults to "horizontal". */
+    direction?: Direction;
+    /** Called with every panel's size in percent as the layout changes. */
+    onLayout?: (sizes: number[]) => void;
+    /** Put ResizablePanel and ResizableHandle children in alternating order. */
+    children: React.ReactNode;
+}
+declare const ResizablePanelGroup: ({ direction, onLayout, className, children, ...rest }: ResizablePanelGroupProps) => React.JSX.Element;
+
+type Axis = "vertical" | "horizontal";
+interface ScrollAreaProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Optional. Which directions can scroll. Defaults to "vertical". */
+    orientation?: Axis | "both";
+    /** Optional. When the custom scrollbar shows. "hover" on pointer over, focus or scroll; "scroll" only while scrolling; "auto" and "always" whenever there is overflow. Defaults to "hover". */
+    type?: "hover" | "scroll" | "auto" | "always";
+    /** Optional. Milliseconds the scrollbar stays visible after scrolling stops. Defaults to 600. */
+    scrollHideDelay?: number;
+    /** Optional. Classes for the scrolling viewport, for example padding. */
+    viewportClassName?: string;
+    /** Accessible name for the scrollable region. Recommended, because the viewport can be focused with the keyboard. */
+    "aria-label"?: string;
+    children?: React.ReactNode;
+}
+declare const ScrollArea: React.ForwardRefExoticComponent<ScrollAreaProps & React.RefAttributes<HTMLDivElement>>;
+
+interface BottomSheetProps {
+    /** Whether the sheet is open. */
+    open: boolean;
+    /** Called when the sheet asks to open or close (Escape, backdrop, swipe down, close button). */
+    onOpenChange: (open: boolean) => void;
+    /** Heading shown at the top. Also names the dialog for screen readers. */
+    title?: React.ReactNode;
+    /** Optional. Short text under the title. */
+    description?: React.ReactNode;
+    /** Optional. Fixed area under the content, for actions. */
+    footer?: React.ReactNode;
+    /** Optional. Heights the sheet can rest at, as fractions of the screen height, smallest first. Defaults to [0.5]. */
+    snapPoints?: number[];
+    /** Optional. Which snap point to start at (index). Defaults to 0. */
+    defaultSnap?: number;
+    /** Called with the new snap index when the sheet settles at another height. */
+    onSnapChange?: (index: number) => void;
+    /** Optional. Allow closing by Escape, backdrop click and swiping down. Defaults to true. */
+    dismissible?: boolean;
+    /** Optional. Show a backdrop, trap focus and lock page scroll. Set false for a sheet that sits beside the page. Defaults to true. */
+    modal?: boolean;
+    /** Optional. Show the drag handle. Defaults to true. */
+    showHandle?: boolean;
+    /** Optional. Show a close button. Defaults to true. */
+    showCloseButton?: boolean;
+    /** Optional. Classes for the sheet surface. */
+    className?: string;
+    /** Optional. Accessible name when there is no title. */
+    "aria-label"?: string;
+    children?: React.ReactNode;
+}
+declare const BottomSheet: ({ open, onOpenChange, title, description, footer, snapPoints, defaultSnap, onSnapChange, dismissible, modal, showHandle, showCloseButton, className, "aria-label": ariaLabel, children, }: BottomSheetProps) => React.ReactPortal | null;
+
+type ConfirmVariant = "default" | "info" | "danger" | "warning" | "success";
+interface ConfirmDialogProps {
+    /** Whether the dialog is open. */
+    open: boolean;
+    /** Called with false when the dialog should close (Cancel, Escape, backdrop, or after a successful confirm). */
+    onOpenChange: (open: boolean) => void;
+    /** The question or heading. */
+    title: React.ReactNode;
+    /** Optional. A sentence that explains the consequence. */
+    description?: React.ReactNode;
+    /** Optional. Extra content under the description, such as a list or an input. */
+    children?: React.ReactNode;
+    /** Optional. Sets the icon and the confirm button colour. Use "danger" for deletes. Defaults to "default". */
+    variant?: ConfirmVariant;
+    /** Optional. Replace the icon, or pass null to hide it. */
+    icon?: React.ReactNode;
+    /** Optional. Confirm button text. Name the action, for example "Delete project". Defaults to "Confirm". */
+    confirmText?: string;
+    /** Optional. Cancel button text. Defaults to "Cancel". */
+    cancelText?: string;
+    /** Optional. Hide the cancel button, for a message that only needs "OK". Defaults to false. */
+    hideCancel?: boolean;
+    /** Optional. Runs when confirmed. Return a promise to show a loading state; the dialog closes when it resolves and stays open with the error if it throws. */
+    onConfirm?: () => void | Promise<void>;
+    /** Optional. Runs when the dialog is cancelled or dismissed. */
+    onCancel?: () => void;
+    /** Optional. Force the loading state yourself. */
+    loading?: boolean;
+    /** Optional. Disable the confirm button, for example until a box is ticked. */
+    confirmDisabled?: boolean;
+    /** Optional. Dialog width. Defaults to "28rem". */
+    width?: string;
+}
+declare const ConfirmDialog: ({ open, onOpenChange, title, description, children, variant, icon, confirmText, cancelText, hideCancel, onConfirm, onCancel, loading: loadingProp, confirmDisabled, width, }: ConfirmDialogProps) => React.JSX.Element;
+type ConfirmOptions = Omit<ConfirmDialogProps, "open" | "onOpenChange" | "onCancel" | "loading">;
+type ConfirmFn = (options: ConfirmOptions) => Promise<boolean>;
+interface ConfirmProviderProps {
+    children: React.ReactNode;
+}
+/** Wrap your app once. Then call `useConfirm()` anywhere to ask a question and await the answer. */
+declare const ConfirmProvider: ({ children }: ConfirmProviderProps) => React.JSX.Element;
+declare const useConfirm: () => ConfirmFn;
+
+interface TagInputProps {
+    /** Controlled tags. */
+    value?: string[];
+    /** Uncontrolled starting tags. */
+    defaultValue?: string[];
+    /** Called with the full list of tags when one is added or removed. */
+    onChange?: (tags: string[]) => void;
+    /** Optional. Words offered while typing. Tags already added are left out. */
+    suggestions?: string[];
+    /** Optional. Show the suggestions as soon as the field is focused, before typing. Defaults to false. */
+    showSuggestionsOnFocus?: boolean;
+    /** Optional. Let people add tags that are not in the suggestions. Defaults to true. */
+    allowCustom?: boolean;
+    /** Optional. Maximum number of tags. */
+    maxTags?: number;
+    /** Optional. Maximum characters in one tag. */
+    maxLength?: number;
+    /** Optional. Allow the same tag more than once. Defaults to false. Duplicates are compared ignoring case. */
+    allowDuplicates?: boolean;
+    /** Optional. Characters that end a tag while typing or pasting, in addition to Enter. Defaults to [","]. */
+    delimiters?: string[];
+    /** Optional. Add the text left in the field when it loses focus. Defaults to true. */
+    addOnBlur?: boolean;
+    /** Optional. Return true to accept a tag, or false / a message to reject it. */
+    validate?: (tag: string) => boolean | string;
+    /** Optional. Change a tag before it is added, for example make it lowercase. */
+    transform?: (tag: string) => string;
+    /** Optional. Called when a tag is rejected, with the reason. */
+    onInvalid?: (tag: string, reason: string) => void;
+    /** Optional. Called as the person types. */
+    onInputChange?: (text: string) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    error?: boolean;
+    id?: string;
+    /** Optional. Adds hidden inputs (one per tag) for native forms. */
+    name?: string;
+    className?: string;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+    "aria-invalid"?: boolean | "true" | "false";
+    /** Optional. Called when the field loses focus. */
+    onBlur?: React.FocusEventHandler<HTMLInputElement>;
+}
+declare const TagInput: ({ value, defaultValue, onChange, suggestions, showSuggestionsOnFocus, allowCustom, maxTags, maxLength, allowDuplicates, delimiters, addOnBlur, validate, transform, onInvalid, onInputChange, placeholder, disabled, error, id, name, className, "aria-label": ariaLabel, "aria-describedby": describedBy, "aria-invalid": ariaInvalid, onBlur, }: TagInputProps) => React.JSX.Element;
+
+type Trend = "up" | "down" | "neutral";
+interface StatCardProps extends Omit<React.HTMLAttributes<HTMLElement>, "children" | "title"> {
+    /** What is being measured, for example "Active users". */
+    label: React.ReactNode;
+    /** The headline figure. Pass it already formatted, for example "12,480" or "$4.2k". */
+    value: React.ReactNode;
+    /** Optional. The change. A number is shown as a percentage ("12" becomes "12%"); a string is shown as given ("+340" or "2.1 pts"). */
+    delta?: number | string;
+    /** Optional. Short text after the change, such as "vs last month". */
+    deltaLabel?: string;
+    /** Optional. Direction of the change. Worked out from the sign of delta when left out. */
+    trend?: Trend;
+    /** Optional. Set when a lower number is better (costs, churn, errors), so a drop shows as good news. Defaults to false. */
+    lowerIsBetter?: boolean;
+    /** Optional. A short line under the value. */
+    description?: React.ReactNode;
+    /** Optional. An icon shown in a rounded tile at the top right. */
+    icon?: React.ReactNode;
+    /** Optional. A small trend line drawn from these values, oldest first. */
+    sparkline?: number[];
+    /** Optional. Show placeholder bars while the numbers load. Defaults to false. */
+    loading?: boolean;
+    /** Optional. Make the whole card a link. */
+    href?: string;
+    /** Optional. Make the whole card a button. Ignored when href is set. */
+    onClick?: React.MouseEventHandler<HTMLElement>;
+    /** Optional. Content under the figures, such as a small action or note. */
+    footer?: React.ReactNode;
+}
+declare const StatCard: ({ label, value, delta, deltaLabel, trend, lowerIsBetter, description, icon, sparkline, loading, href, onClick, footer, className, ...rest }: StatCardProps) => React.JSX.Element;
+
+interface ChartSeries {
+    /** The key in each data row that holds this series' number. */
+    key: string;
+    /** Optional. Name shown in the legend and tooltip. Defaults to the key. */
+    label?: string;
+}
+type Cell = string | number | null | undefined;
+interface ChartBaseProps {
+    /** One object per x position (or per category), for example `{ month: "Jan", sales: 120, refunds: 8 }`. */
+    data: Record<string, Cell>[];
+    /** The key in each row that holds the x label or category name. */
+    index: string;
+    /** The numeric series to plot. Up to 8; each keeps its colour for good, whichever are shown. */
+    series: (string | ChartSeries)[];
+    /** Optional. Heading above the chart. Also names the chart for screen readers. */
+    title?: React.ReactNode;
+    /** Optional. A short sentence under the title. */
+    description?: React.ReactNode;
+    /** Optional. Plot height in px, including the axis labels. Defaults to 280. */
+    height?: number;
+    /** Optional. Formats values in the tooltip, labels and axis, for example `(v) => "$" + v`. */
+    valueFormat?: (value: number) => string;
+    /** Optional. Formats the x labels and category names. */
+    indexFormat?: (value: string) => string;
+    /** Optional. Show the legend. Shown automatically for two or more series. */
+    showLegend?: boolean;
+    /** Optional. Show the "View as table" switch. Defaults to true. */
+    showTableToggle?: boolean;
+    /** Optional. Start with the table instead of the chart. Defaults to false. */
+    defaultView?: "chart" | "table";
+    /** Optional. Text for an empty data set. */
+    emptyText?: string;
+    className?: string;
+}
+interface LineChartProps extends ChartBaseProps {
+    /** Optional. Fill under each line with a light wash of its colour. Defaults to false. */
+    area?: boolean;
+    /** Optional. Where the y axis starts. Defaults to 0. Use "auto" to fit the data, which exaggerates small changes. */
+    yMin?: number | "auto";
+}
+declare const LineChart: (props: LineChartProps) => React.JSX.Element;
+interface BarChartProps extends ChartBaseProps {
+    /** Optional. "vertical" draws columns, "horizontal" draws bars from the left. Defaults to "vertical". Use horizontal for long category names. */
+    orientation?: "vertical" | "horizontal";
+    /** Optional. Stack the series on top of each other instead of side by side. Values should not be negative. Defaults to false. */
+    stacked?: boolean;
+}
+declare const BarChart: (props: BarChartProps) => React.JSX.Element;
+
+type Status = "idle" | "copied" | "failed";
+/** Copy text to the clipboard. Uses the modern API and falls back to a hidden textarea where it is blocked. */
+declare const copyText: (text: string) => Promise<boolean>;
+/** Hook behind CopyButton, for your own trigger. Returns the status and a copy function. */
+declare const useCopyToClipboard: (resetAfter?: number) => {
+    status: Status;
+    copied: boolean;
+    copy: (text: string) => Promise<boolean>;
+};
+interface CopyButtonProps extends Omit<ButtonProps, "children" | "onClick" | "onCopy" | "onError" | "startIcon" | "endIcon" | "loading" | "iconOnly" | "value"> {
+    /** What to copy. Pass a function (it may be async) to read the value only when clicked. */
+    value: string | (() => string | Promise<string>);
+    /** Optional. Button text. Leave out for an icon-only button. */
+    label?: string;
+    /** Optional. Text shown after copying. Defaults to "Copied". */
+    copiedLabel?: string;
+    /** Optional. Milliseconds before it returns to normal. Defaults to 2000. */
+    resetAfter?: number;
+    /** Called with the copied text after a successful copy. */
+    onCopy?: (value: string) => void;
+    /** Called when copying fails. */
+    onError?: (error: unknown) => void;
+    /** Optional. Name for an icon-only button, for example "Copy API key". Defaults to "Copy". Needed when there is no label. */
+    "aria-label"?: string;
+}
+declare const CopyButton: ({ value, label, copiedLabel, resetAfter, onCopy, onError, variant, size, "aria-label": ariaLabel, className, ...rest }: CopyButtonProps) => React.JSX.Element;
+
+interface OverlayProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Whether the overlay is shown. */
+    open: boolean;
+    /** Called when the overlay asks to close: a click on the dimmed area or Escape. Leave out for an overlay that cannot be dismissed. */
+    onOpenChange?: (open: boolean) => void;
+    /** Optional. "viewport" covers the whole screen. "container" covers the nearest positioned parent (give it `relative`), for example to dim one card while it loads. Defaults to "viewport". */
+    scope?: "viewport" | "container";
+    /** Optional. How dark the dimming is. Defaults to "medium". */
+    tone?: "light" | "medium" | "dark";
+    /** Optional. Blur what is behind. Defaults to "none". */
+    blur?: "none" | "sm" | "md";
+    /** Optional. Stop the page behind from scrolling while a viewport overlay is open. Defaults to true. */
+    lockScroll?: boolean;
+    /** Optional. Close on Escape when onOpenChange is set. Defaults to true. */
+    closeOnEscape?: boolean;
+    /** Optional. Show a spinner with this text, for waiting states. The text is announced to screen readers. */
+    loadingText?: string;
+    /** Optional. Show a spinner without visible text. Announced as "Loading". */
+    loading?: boolean;
+    /** Optional. Stacking order for a viewport overlay. Defaults to 40. */
+    zIndex?: number;
+    /** Optional. Content centred over the dimming, such as a message or your own panel. Clicks on it do not close the overlay. */
+    children?: React.ReactNode;
+}
+declare const Overlay: ({ open, onOpenChange, scope, tone, blur, lockScroll, closeOnEscape, loading, loadingText, zIndex, className, style, onClick, children, ...rest }: OverlayProps) => React.JSX.Element | null;
+
+type PortalContainer = HTMLElement | null | (() => HTMLElement | null);
+/** The element Genesis overlays render into by default: the nearest theme root, so theme variables still apply, otherwise the page body. */
+declare const getPortalContainer: () => HTMLElement | null;
+interface PortalProps {
+    /** What to render outside the normal place in the page. */
+    children?: React.ReactNode;
+    /** Optional. Where to render it: an element, or a function that returns one (called after the page loads). Defaults to the theme root, or the page body. */
+    container?: PortalContainer;
+    /** Optional. Render in place instead, with no portal. Useful to switch the portal off in a tight layout or a test. Defaults to false. */
+    disabled?: boolean;
+}
+/**
+ * Renders children into another part of the page, usually `document.body`, so they are not clipped by a parent's
+ * `overflow: hidden`, covered by its stacking context, or moved by its `transform`. React events still bubble
+ * through the component tree as if the content were in place. Nothing renders on the server or in the first render.
+ */
+declare const Portal: ({ children, container, disabled }: PortalProps) => React.JSX.Element | null;
+
+type Tag = "span" | "div" | "p" | "label" | "a" | "h1" | "h2" | "h3" | "legend" | "caption";
+interface VisuallyHiddenProps extends React.HTMLAttributes<HTMLElement> {
+    /** Optional. The HTML element to render. Defaults to "span". */
+    as?: Tag;
+    /** Optional. Show the content when it receives keyboard focus, for example a "Skip to content" link. The element must be focusable (a link or button, or give it tabIndex={0}). Defaults to false. */
+    focusable?: boolean;
+    /** Optional. For as="label": the id of the field it names. */
+    htmlFor?: string;
+    /** Optional. For as="a": where the link goes. */
+    href?: string;
+    children?: React.ReactNode;
+}
+/**
+ * Hides content from the screen but keeps it for screen readers and search. Unlike `display: none` or `hidden`,
+ * the text stays in the accessibility tree. Use it for names and context that sighted users get from the layout.
+ */
+declare const VisuallyHidden: ({ as, focusable, className, children, ...rest }: VisuallyHiddenProps) => React.JSX.Element;
+
+interface SkipLinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "href"> {
+    /** The target on the page, as an id with a hash, for example "#main". */
+    href?: string;
+    /** Optional. Link text. Defaults to "Skip to main content". */
+    children?: React.ReactNode;
+}
+/**
+ * The first focusable thing on a page. Hidden until a keyboard user tabs to it, then it lets them jump past the
+ * navigation to the main content. On activation it moves keyboard focus to the target, not just the scroll position.
+ */
+declare const SkipLink: ({ href, children, onClick, ...rest }: SkipLinkProps) => React.JSX.Element;
+
+interface LoadMoreProps {
+    /** Called to fetch the next batch. Return a promise to get a loading state and to catch errors automatically. */
+    onLoadMore: () => void | Promise<unknown>;
+    /** Whether there is more to load. When false the button is replaced by the end message. */
+    hasMore: boolean;
+    /** Optional. Force the loading state yourself, for example when the request is managed by a data library. */
+    loading?: boolean;
+    /** Optional. An error to show with a retry button. Pass true for a default message. Left out, errors thrown by onLoadMore are shown. */
+    error?: boolean | string;
+    /** Optional. How many items are shown now. With total, shows "Showing 20 of 134". */
+    loaded?: number;
+    /** Optional. Total number of items, when it is known. */
+    total?: number;
+    /** Optional. Button text. Defaults to "Load more". */
+    label?: string;
+    /** Optional. Text shown when there is nothing more to load. Set to an empty string to show nothing. Defaults to "You have reached the end." */
+    endText?: string;
+    /** Optional. Also load the next batch automatically when the button scrolls into view. The button stays for keyboard and screen reader users. Defaults to false. */
+    autoLoad?: boolean;
+    /** Optional. Button style, from Button. Defaults to "outlined". */
+    variant?: ButtonProps["variant"];
+    /** Optional. Button size, from Button. */
+    size?: ButtonProps["size"];
+    className?: string;
+}
+declare const LoadMore: ({ onLoadMore, hasMore, loading: loadingProp, error: errorProp, loaded, total, label, endText, autoLoad, variant, size, className, }: LoadMoreProps) => React.JSX.Element;
+
+interface CursorPaginationProps {
+    /** Whether there is an earlier page. */
+    hasPrevious: boolean;
+    /** Whether there is a later page. */
+    hasNext: boolean;
+    /** Called to go to the previous page. Return a promise to show a loading state on the button. */
+    onPrevious: () => void | Promise<unknown>;
+    /** Called to go to the next page. Return a promise to show a loading state on the button. */
+    onNext: () => void | Promise<unknown>;
+    /** Optional. Force a loading state: true for both buttons, or the direction being loaded. */
+    loading?: boolean | "previous" | "next";
+    /** Optional. Text between the buttons, such as "Showing 21–40" or "Page 3". Announced to screen readers when it changes. */
+    summary?: React.ReactNode;
+    /** Optional. Accessible name of the navigation. Defaults to "Pagination". */
+    "aria-label"?: string;
+    /** Optional. Rows-per-page choices. When set, a selector is shown. */
+    pageSizeOptions?: number[];
+    /** Optional. Current rows per page, for the selector. */
+    pageSize?: number;
+    /** Called when a different page size is chosen. */
+    onPageSizeChange?: (size: number) => void;
+    /** Optional. Button style, from Button. Defaults to "outlined". */
+    variant?: ButtonProps["variant"];
+    /** Optional. Button size, from Button. Defaults to "sm". */
+    size?: ButtonProps["size"];
+    className?: string;
+}
+declare const CursorPagination: ({ hasPrevious, hasNext, onPrevious, onNext, loading, summary, "aria-label": ariaLabel, pageSizeOptions, pageSize, onPageSizeChange, variant, size, className, }: CursorPaginationProps) => React.JSX.Element;
+
+type RootRef = React.RefObject<HTMLElement> | HTMLElement | null;
+interface UseInfiniteScrollOptions {
+    /** Called to fetch the next batch. Return a promise to track loading and catch errors. */
+    onLoadMore: () => void | Promise<unknown>;
+    /** Whether there is more to load. */
+    hasMore: boolean;
+    /** Optional. Force the loading state, for example when a data library manages the request. */
+    loading?: boolean;
+    /** Optional. Force an error message. Left out, errors thrown by onLoadMore are used. */
+    error?: string | boolean;
+    /** Optional. The scrolling element to watch. Leave out to watch the page. */
+    root?: RootRef;
+    /** Optional. How early to load, as a CSS margin around the viewport. Defaults to "300px", which loads before the end is reached. */
+    rootMargin?: string;
+    /** Optional. Turn automatic loading off. Defaults to false. */
+    disabled?: boolean;
+}
+/** Calls onLoadMore when the returned sentinel scrolls into view. Put the sentinel after the last item. */
+declare const useInfiniteScroll: ({ onLoadMore, hasMore, loading: loadingProp, error: errorProp, root, rootMargin, disabled }: UseInfiniteScrollOptions) => {
+    sentinelRef: React.RefObject<HTMLDivElement>;
+    loading: boolean;
+    error: string | boolean;
+    loadNow: () => Promise<void>;
+};
+interface InfiniteScrollProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "onError"> {
+    /** The items loaded so far. */
+    children: React.ReactNode;
+    /** Called to fetch the next batch. Return a promise to show the loader and catch errors automatically. */
+    onLoadMore: () => void | Promise<unknown>;
+    /** Whether there is more to load. */
+    hasMore: boolean;
+    /** Optional. Force the loading state. */
+    loading?: boolean;
+    /** Optional. Force an error. Pass true for a default message. */
+    error?: string | boolean;
+    /** Optional. Give the list a fixed height and make it the scrolling area. Leave out to scroll with the page, or use scrollContainer. */
+    height?: number | string;
+    /** Optional. A scrolling element of your own to watch, instead of the page. */
+    scrollContainer?: RootRef;
+    /** Optional. Shown while loading. Defaults to a spinner with "Loading more…". */
+    loader?: React.ReactNode;
+    /** Optional. Shown when everything has loaded. Set to null for nothing. Defaults to "You have reached the end." */
+    endMessage?: React.ReactNode;
+    /** Optional. Keep a "Load more" button for keyboard and screen reader users and for when scrolling does not trigger. Defaults to true. */
+    showButton?: boolean;
+    /** Optional. How many items are shown. Announced to screen readers after each batch. */
+    itemCount?: number;
+    /** Optional. How early to load, as a CSS margin around the viewport. Defaults to "300px". */
+    rootMargin?: string;
+    /** Optional. Name for the scrolling area when height is set. */
+    "aria-label"?: string;
+}
+declare const InfiniteScroll: ({ children, onLoadMore, hasMore, loading: loadingProp, error: errorProp, height, scrollContainer, loader, endMessage, showButton, itemCount, rootMargin, className, "aria-label": ariaLabel, ...rest }: InfiniteScrollProps) => React.JSX.Element;
+
+type Placement = "top" | "bottom" | "left" | "right";
+type TargetRef = string | HTMLElement | React.RefObject<HTMLElement> | (() => HTMLElement | null) | null;
+interface TourStep {
+    /** The element to highlight: a CSS selector such as "#save", an element, a ref, or a function that returns one. Leave out for a centred step with no highlight, for example a welcome message. */
+    target?: TargetRef;
+    /** Heading of the step. Also names the dialog for screen readers. */
+    title: React.ReactNode;
+    /** The explanation. Keep it to a sentence or two. */
+    content?: React.ReactNode;
+    /** Optional. Preferred side of the target for the card. It moves to the other side when there is no room. Defaults to "bottom". */
+    placement?: Placement;
+    /** Optional. Button text for this step's Next button. */
+    nextLabel?: string;
+}
+interface TourProps {
+    /** The steps, in order. */
+    steps: TourStep[];
+    /** Whether the tour is running. */
+    open: boolean;
+    /** Called with false when the tour ends: finished, skipped or closed. */
+    onOpenChange: (open: boolean) => void;
+    /** Controlled current step (0-based). */
+    step?: number;
+    /** Optional. Starting step when uncontrolled. Defaults to 0. */
+    defaultStep?: number;
+    /** Called with the new step index when the person moves between steps. */
+    onStepChange?: (step: number) => void;
+    /** Called when the last step's button is pressed. */
+    onFinish?: () => void;
+    /** Called when the tour is skipped or closed before the end, with the step it stopped on. */
+    onSkip?: (step: number) => void;
+    /** Optional. Space between the highlight and the target, in px. Defaults to 6. */
+    spotlightPadding?: number;
+    /** Optional. Close the tour when the dimmed area is clicked. Defaults to false, so a stray click does not end the tour. */
+    closeOnOverlayClick?: boolean;
+    /** Optional. Hide the "Skip tour" button. Defaults to false. */
+    hideSkip?: boolean;
+    /** Optional. Text of the buttons. */
+    labels?: {
+        next?: string;
+        back?: string;
+        done?: string;
+        skip?: string;
+        close?: string;
+    };
+    /** Optional. Stacking order. Defaults to 300. */
+    zIndex?: number;
+}
+declare const Tour: ({ steps, open, onOpenChange, step: stepProp, defaultStep, onStepChange, onFinish, onSkip, spotlightPadding, closeOnOverlayClick, hideSkip, labels, zIndex, }: TourProps) => React.ReactPortal | null;
+
+interface SignaturePadHandle {
+    /** Remove everything. */
+    clear: () => void;
+    /** Remove the last stroke. */
+    undo: () => void;
+    /** True when nothing has been drawn or typed. */
+    isEmpty: () => boolean;
+    /** The pad as an image data URL, or null when empty. Defaults to PNG. */
+    toDataURL: (type?: "image/png" | "image/jpeg" | "image/webp", quality?: number) => string | null;
+    /** The pad as an image Blob, or null when empty. */
+    toBlob: (type?: "image/png" | "image/jpeg" | "image/webp", quality?: number) => Promise<Blob | null>;
+}
+interface SignaturePadProps {
+    /** Optional. Controlled image (a data URL), or null for empty. Works with FormField. */
+    value?: string | null;
+    /** Optional. Starting image when uncontrolled, for example a saved signature. */
+    defaultValue?: string | null;
+    /** Called with the pad as a PNG data URL when a stroke ends, or null when it is cleared. */
+    onChange?: (dataUrl: string | null) => void;
+    /** Optional. "signature" shows a baseline and a prompt. "drawing" is a plain canvas. Defaults to "signature". */
+    variant?: "signature" | "drawing";
+    /** Optional. Height in px. The width fills the space. Defaults to 180. */
+    height?: number;
+    /** Optional. Ink colour. Defaults to near-black. */
+    color?: string;
+    /** Optional. Line thickness in px at a 400px wide pad. Defaults to 2.5. */
+    strokeWidth?: number;
+    /** Optional. A set of colours to choose from. Shows a colour picker above the pad. */
+    colors?: string[];
+    /** Optional. Colour behind the ink in the exported image. Defaults to transparent. Use "#ffffff" for JPEG. */
+    backgroundColor?: string;
+    /** Optional. Prompt shown on an empty signature pad. Defaults to "Sign here". */
+    placeholder?: string;
+    /** Optional. Offer typing a name as an alternative, for people who cannot draw. Defaults to true for signatures. */
+    allowTyped?: boolean;
+    /** Optional. Show the pad but do not allow changes. */
+    readOnly?: boolean;
+    disabled?: boolean;
+    /** Optional. Show the error border. */
+    error?: boolean;
+    id?: string;
+    /** Optional. Adds a hidden input holding the image, for native forms. */
+    name?: string;
+    className?: string;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+    "aria-invalid"?: boolean | "true" | "false";
+    onBlur?: React.FocusEventHandler<HTMLElement>;
+}
+declare const SignaturePad: React.ForwardRefExoticComponent<SignaturePadProps & React.RefAttributes<SignaturePadHandle>>;
+
 interface DividerProps {
     width?: string;
     height?: string;
@@ -757,6 +2228,56 @@ interface ModalProps {
 }
 declare function Modal({ children, showModal, setShowModal, closeModal, closeOnOutsideClick, className, width, closeOnEscape, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, "aria-describedby": ariaDescribedBy, }: ModalProps): React.JSX.Element;
 
+type MultiSelectOption = SelectOption;
+type MultiSelectGroup = SelectGroup;
+type Val = string | number;
+interface MultiSelectProps {
+    /** Flat options, or groups of options. */
+    options: (MultiSelectOption | MultiSelectGroup)[];
+    /** Controlled selected values. */
+    value?: Val[];
+    /** Uncontrolled initial values. */
+    defaultValue?: Val[];
+    /** Called with the new values and their options. */
+    onChange?: (values: Val[], options: MultiSelectOption[]) => void;
+    placeholder?: string;
+    /** Optional. Type to filter the list. Defaults to true. */
+    searchable?: boolean;
+    /** Optional. Called whenever the user types (for server search; combine with filter={false}). */
+    onInputChange?: (query: string) => void;
+    /** Optional. Custom matcher, or false to disable client-side filtering. */
+    filter?: ((option: MultiSelectOption, query: string) => boolean) | false;
+    /** Optional. Show a "Select all" row (hidden while searching or when maxSelected is set). */
+    showSelectAll?: boolean;
+    /** Optional. Maximum number of selections. Remaining options are disabled once reached. */
+    maxSelected?: number;
+    /** Optional. Show this many tags when closed, then a "+N" tag. Shows all when omitted. */
+    maxTagCount?: number;
+    /** Optional. Show a clear-all button when something is selected. Defaults to true. */
+    clearable?: boolean;
+    /** Optional. Text shown when nothing matches. */
+    emptyText?: string;
+    loading?: boolean;
+    disabled?: boolean;
+    error?: boolean;
+    /** Optional. "sm" = 320px, "lg" = 313px, default = full width (same as Input). */
+    size?: "sm" | "lg";
+    /** Optional. Open the list above or below. Defaults to "bottom". */
+    placement?: "bottom" | "top";
+    /** Optional. Max height of the list in px. Defaults to 264. */
+    maxHeight?: number;
+    id?: string;
+    /** Optional. Adds hidden inputs (one per value) for native forms. */
+    name?: string;
+    className?: string;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+}
+declare const MultiSelect: {
+    ({ options, value, defaultValue, onChange, placeholder, searchable, onInputChange, filter, showSelectAll, maxSelected, maxTagCount, clearable, emptyText, loading, disabled, error, size, placement, maxHeight, id, name, className, "aria-label": ariaLabel, "aria-describedby": ariaDescribedby, }: MultiSelectProps): React.JSX.Element;
+    displayName: string;
+};
+
 interface NoticeProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof noticeVariants> {
     children?: ReactNode;
     noticeTitle?: string;
@@ -767,7 +2288,7 @@ interface NoticeProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeo
     setOpen: (value: boolean) => void;
 }
 declare const noticeVariants: (props?: ({
-    variant?: "success" | "error" | "warning" | "default" | "info" | null | undefined;
+    variant?: "success" | "warning" | "error" | "default" | "info" | null | undefined;
     position?: "center" | "bottom" | "top" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 declare const Notice: ({ children, variant, position, noticeTitle, open, setOpen, showIcon, }: NoticeProps) => React.JSX.Element;
@@ -796,6 +2317,53 @@ type TablePaginationProps = {
 };
 declare const Pagination: React.FC<TablePaginationProps>;
 
+type Side = "top" | "bottom" | "left" | "right";
+type Align = "start" | "center" | "end";
+interface PopoverRenderApi {
+    /** Close the popover (for example from a "Done" button inside it). */
+    close: () => void;
+}
+interface PopoverProps {
+    /** The element that opens the popover (usually a Button). */
+    children: React.ReactNode;
+    /** Content of the floating panel. Pass a function to get a close() helper. */
+    content: React.ReactNode | ((api: PopoverRenderApi) => React.ReactNode);
+    /** Optional. Controlled open state. */
+    open?: boolean;
+    /** Optional. Initial open state when uncontrolled. */
+    defaultOpen?: boolean;
+    /** Optional. Called whenever the popover wants to open or close. */
+    onOpenChange?: (open: boolean) => void;
+    /** Optional. Preferred side of the trigger. It flips if there is not enough room. Defaults to "bottom". */
+    side?: Side;
+    /** Optional. Alignment along the trigger's edge. Defaults to "center". */
+    align?: Align;
+    /** Optional. Gap between trigger and panel in px. Defaults to 8. */
+    offset?: number;
+    /** Optional. Show a small arrow pointing at the trigger. Defaults to true. */
+    arrow?: boolean;
+    /** Optional. "click" toggles on click, "hover" opens on hover or focus. Defaults to "click". */
+    trigger?: "click" | "hover";
+    /** Optional. Delay in ms before a hover popover closes. Defaults to 120. */
+    hoverCloseDelay?: number;
+    /** Optional. Close when clicking outside. Defaults to true. */
+    closeOnOutsideClick?: boolean;
+    /** Optional. Close when Escape is pressed. Defaults to true. */
+    closeOnEscape?: boolean;
+    disabled?: boolean;
+    /** Optional. Accessible name for the panel. Use this or aria-labelledby. */
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    /** Optional. Extra classes for the panel (width, padding…). */
+    className?: string;
+    /** Optional. Extra classes for the trigger wrapper. */
+    triggerClassName?: string;
+}
+declare const Popover: {
+    ({ children, content, open: openProp, defaultOpen, onOpenChange, side, align, offset, arrow, trigger, hoverCloseDelay, closeOnOutsideClick, closeOnEscape, disabled, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledby, className, triggerClassName, }: PopoverProps): React.JSX.Element;
+    displayName: string;
+};
+
 type ProgressBarProps = {
     progress: number;
     progressText?: string;
@@ -812,10 +2380,42 @@ interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size">
 }
 declare const radioVariants: (props?: ({
     size?: "sm" | "lg" | null | undefined;
-    intent?: "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "primary" | "success" | "error" | "warning" | "default" | "bluegray" | "bluelight" | "rose" | null | undefined;
+    intent?: "primary" | "success" | "warning" | "error" | "default" | "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "bluegray" | "bluelight" | "rose" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 declare const Radio: React.ForwardRefExoticComponent<RadioProps & React.RefAttributes<HTMLInputElement>>;
 
+interface RatingProps {
+    /** Controlled value (0 to max). Fractions such as 4.3 render partially filled in read-only mode. */
+    value?: number;
+    /** Uncontrolled initial value. Defaults to 0. */
+    defaultValue?: number;
+    /** Called when the user picks a value. */
+    onChange?: (value: number) => void;
+    /** Optional. Number of stars. Defaults to 5. */
+    max?: number;
+    /** Optional. Allow half-star steps. Defaults to false. */
+    allowHalf?: boolean;
+    /** Optional. Display only: not focusable or clickable. Defaults to false. */
+    readOnly?: boolean;
+    disabled?: boolean;
+    /** Optional. Defaults to "md". */
+    size?: "sm" | "md" | "lg";
+    /** Optional. Fill color. Defaults to "warning" (amber). */
+    color?: "warning" | "primary" | "success" | "error";
+    /** Optional. Clicking the current value again resets to 0. Defaults to false. */
+    clearable?: boolean;
+    /** Optional. Adds a hidden input for native forms. */
+    name?: string;
+    id?: string;
+    className?: string;
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+}
+declare const Rating: {
+    ({ value, defaultValue, onChange, max, allowHalf, readOnly, disabled, size, color, clearable, name, id, className, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledby, }: RatingProps): React.JSX.Element;
+    displayName: string;
+};
+
 type UploadStatus = "idle" | "uploading" | "success" | "error";
 interface UploadItem {
     id: string;
@@ -851,51 +2451,37 @@ interface FileUploadControlProps {
 declare const defaultGetFileIcon: (fileName: string, fileType: string) => React.JSX.Element;
 declare function FileUploadControl({ items, onAddFiles, onUpdateItem, onRejectFiles, onDelete, onRetry, onPreview, onUpload, multiple, accept, maxSizeMB, className, hintText, showSizeText, getFileIcon, autoUpload, disabled, }: FileUploadControlProps): React.JSX.Element;
 
-interface SelectOption {
-    label: string;
+interface SegmentedOption {
+    /** Text or element shown in the segment. */
+    label?: React.ReactNode;
     value: string | number;
-    /** Optional. Unselectable and skipped by the keyboard. */
-    disabled?: boolean;
-    /** Optional. Secondary line under the label. */
-    description?: string;
     /** Optional. Icon shown before the label. */
     icon?: JSX.Element;
+    disabled?: boolean;
+    /** Required when the option has an icon but no label. */
+    "aria-label"?: string;
 }
-interface SelectGroup {
-    label: string;
-    options: SelectOption[];
-}
-interface SelectProps {
-    /** Flat options, or groups of options. */
-    options: (SelectOption | SelectGroup)[];
-    /** Controlled value. Use null for "nothing selected". */
-    value?: string | number | null;
-    /** Uncontrolled initial value. */
-    defaultValue?: string | number | null;
-    /** Called with the new value (null when cleared) and its option. */
-    onChange?: (value: string | number | null, option: SelectOption | null) => void;
-    placeholder?: string;
+interface SegmentedControlProps {
+    options: SegmentedOption[];
+    /** Controlled value. */
+    value?: string | number;
+    /** Uncontrolled initial value. Defaults to the first enabled option. */
+    defaultValue?: string | number;
+    onChange?: (value: string | number, option: SegmentedOption) => void;
+    /** Optional. Defaults to "md". */
+    size?: "sm" | "md" | "lg";
+    /** Optional. Stretch to the width of the container. Defaults to false. */
+    fullWidth?: boolean;
     disabled?: boolean;
-    error?: boolean;
-    /** Optional. "sm" = 320px, "lg" = 313px, default = full width (same as Input). */
-    size?: "sm" | "lg";
-    /** Optional. Open the list above or below. Defaults to "bottom". */
-    placement?: "bottom" | "top";
-    /** Optional. Show a clear button when a value is selected. Defaults to false. */
-    clearable?: boolean;
-    /** Optional. Max height of the list in px. Defaults to 264. */
-    maxHeight?: number;
-    /** Optional. Text shown when options is empty. */
-    emptyText?: string;
-    id?: string;
     /** Optional. Adds a hidden input for native forms. */
     name?: string;
+    id?: string;
     className?: string;
     "aria-label"?: string;
-    "aria-describedby"?: string;
+    "aria-labelledby"?: string;
 }
-declare const Select: {
-    ({ options, value, defaultValue, onChange, placeholder, disabled, error, size, placement, clearable, maxHeight, emptyText, id, name, className, "aria-label": ariaLabel, "aria-describedby": ariaDescribedby, }: SelectProps): React.JSX.Element;
+declare const SegmentedControl: {
+    ({ options, value, defaultValue, onChange, size, fullWidth, disabled, name, id, className, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledby, }: SegmentedControlProps): React.JSX.Element;
     displayName: string;
 };
 
@@ -1028,6 +2614,69 @@ declare const TableRow: ({ children, className, indent, ...props }: TableRowProp
 declare const TableHeadCell: ({ children, className, icon, sticky, shadow, left, shadowRight, right, ...props }: TableHeadCellProps) => React.JSX.Element;
 declare const TableDataCell: ({ children, className, icon, sticky, shadow, shadowRight, left, right, ...props }: TableCellProps) => React.JSX.Element;
 
+type ToastIntent = "default" | "primary" | "success" | "warning" | "error" | "loading";
+type ToastPosition = "top-right" | "top-left" | "top-center" | "bottom-right" | "bottom-left" | "bottom-center";
+interface ToastAction {
+    label: string;
+    onClick: () => void;
+}
+interface ToastOptions {
+    /** Optional. Reuse an id to update an existing toast instead of adding a new one. */
+    id?: string;
+    /** Optional. Bold first line. */
+    title?: React.ReactNode;
+    /** Optional. Message text. */
+    description?: React.ReactNode;
+    /** Optional. Defaults to "default". */
+    intent?: ToastIntent;
+    /** Optional. Milliseconds before auto-dismiss. Use Infinity to keep it until dismissed. Defaults to the provider's duration (loading toasts default to Infinity). */
+    duration?: number;
+    /** Optional. A button shown under the message. */
+    action?: ToastAction;
+    /** Optional. Show a close button. Defaults to true. */
+    dismissible?: boolean;
+    /** Optional. Custom icon, or false for none. */
+    icon?: JSX.Element | false;
+    /** Optional. Called after the toast is removed. */
+    onDismiss?: () => void;
+}
+type Message = React.ReactNode;
+interface ToastPromiseMessages<T> {
+    loading: Message;
+    success: Message | ((data: T) => Message);
+    error: Message | ((error: unknown) => Message);
+}
+interface ToastApi {
+    /** Show a toast. Returns its id. */
+    toast: (options: ToastOptions | Message) => string;
+    success: (message: Message, options?: ToastOptions) => string;
+    error: (message: Message, options?: ToastOptions) => string;
+    warning: (message: Message, options?: ToastOptions) => string;
+    info: (message: Message, options?: ToastOptions) => string;
+    loading: (message: Message, options?: ToastOptions) => string;
+    /** Change an existing toast (for example loading → success). */
+    update: (id: string, options: ToastOptions) => void;
+    /** Dismiss one toast by id, or all of them when called without an id. */
+    dismiss: (id?: string) => void;
+    /** Show a loading toast that turns into success or error when the promise settles. */
+    promise: <T>(promise: Promise<T>, messages: ToastPromiseMessages<T>, options?: ToastOptions) => Promise<T>;
+}
+interface ToastProviderProps {
+    children: React.ReactNode;
+    /** Optional. Where toasts appear. Defaults to "top-right". */
+    position?: ToastPosition;
+    /** Optional. Default auto-dismiss time in ms. Defaults to 5000. */
+    duration?: number;
+    /** Optional. How many toasts show at once. Extra toasts wait in a queue. Defaults to 3. */
+    maxVisible?: number;
+    /** Optional. Show a shrinking bar for the remaining time. Defaults to false. */
+    showProgress?: boolean;
+    /** Optional. Accessible name of the notification area. Defaults to "Notifications". */
+    label?: string;
+}
+declare const useToast: () => ToastApi;
+declare const ToastProvider: ({ children, position, duration, maxVisible, showProgress, label, }: ToastProviderProps) => React.JSX.Element;
+
 interface TabItem {
     label: string;
     value: string;
@@ -1139,7 +2788,7 @@ interface ToggleProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"
 }
 declare const toggleVariants: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
-    intent?: "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "primary" | "success" | "error" | "warning" | "default" | "bluegray" | "bluelight" | "rose" | null | undefined;
+    intent?: "primary" | "success" | "warning" | "error" | "default" | "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "bluegray" | "bluelight" | "rose" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 declare const Toggle: React.ForwardRefExoticComponent<ToggleProps & React.RefAttributes<HTMLInputElement>>;
 
@@ -1213,7 +2862,7 @@ interface TypographyProps extends HTMLAttributes<HTMLHeadingElement | HTMLParagr
 }
 declare const typographyVariant: (props?: ({
     variant?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "b1" | "b2" | "b3" | "b4" | "b5" | null | undefined;
-    intent?: "primary" | "success" | "error" | "warning" | "default" | null | undefined;
+    intent?: "primary" | "success" | "warning" | "error" | "default" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 declare const Typography: ({ as, variant, intent, children, className, ...props }: TypographyProps) => React.JSX.Element;
 
@@ -1345,4 +2994,4 @@ interface ThemeScriptProps {
  */
 declare const ThemeScript: ({ defaultMode, storageKey, nonce, }: ThemeScriptProps) => React.JSX.Element;
 
-export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, Avatar, AvatarGroup, Breadcrumbs as BreadCrumb, Button, Calendar, type CalendarProps, type CalendarRange, Callout, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, Chip, CircularProgressBar as CircularProgress, type ColorFamily, ColorPicker, type ColorPickerProps, type ColorPickerToken, type ColorShade, DatePicker, type DatePickerProps, type DateRange, DateRangePicker, type DateRangePickerProps, type DateRangePreset, DateTimePicker, type DateTimePickerProps, Divider, Drawer, Dropdown, DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, DropdownWithIcon, FileSelector, FileUpload, FileUploadControl, FileUploadPreview, GlobalNavigation, HelperText, Input, Label, ListPagination, Loading, Modal, Notice, OTPInput, Pagination, ProgressBar, Radio, Select, type SelectGroup, type SelectOption, type SelectProps, Sidebar, Skeleton, Slider, Spinner, SplitButton, Stepper, Tab, TabList, TabPanel, Table, TableBody, TableDataCell, TableHead, TableHeadCell, TableRow, TabsContainer, TextInputWithLabel, Textarea, ThemeColorPicker, type ThemeColorPickerProps, type ThemeContextValue, type ThemeMode, ThemeModeSwitch, type ThemeModeSwitchProps, ThemeProvider, type ThemeProviderProps, type ThemeScale, ThemeScript, type ThemeScriptProps, type ThemeShade, TimePicker, type TimePickerProps, Toggle, Tooltip, TreeView, Typography, defaultGetFileIcon, getDefaultRangePresets, useTheme };
+export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, type ActiveFilter, Alert, type AlertProps, Avatar, AvatarGroup, Badge, type BadgeProps, BarChart, type BarChartProps, BottomSheet, type BottomSheetProps, Breadcrumbs as BreadCrumb, Button, Calendar, type CalendarProps, type CalendarRange, Callout, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Carousel, type CarouselProps, type ChartSeries, Checkbox, Chip, CircularProgressBar as CircularProgress, CodeBlock, type CodeBlockProps, Collapsible, CollapsibleContent, type CollapsibleContentProps, type CollapsibleProps, CollapsibleTrigger, type CollapsibleTriggerProps, type ColorFamily, ColorPicker, type ColorPickerProps, type ColorPickerToken, type ColorShade, Combobox, type ComboboxGroup, type ComboboxOption, type ComboboxProps, type CommandGroup, type CommandItem, CommandPalette, type CommandPaletteProps, ConfirmDialog, type ConfirmDialogProps, type ConfirmOptions, ConfirmProvider, type ConfirmProviderProps, type ConfirmVariant, ContextMenu, ContextMenuCheckboxItem, type ContextMenuCheckboxItemProps, ContextMenuContent, type ContextMenuContentProps, ContextMenuItem, type ContextMenuItemProps, ContextMenuLabel, type ContextMenuProps, ContextMenuSeparator, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, type ContextMenuTriggerProps, CopyButton, type CopyButtonProps, CursorPagination, type CursorPaginationProps, DataGrid, type DataGridColumn, type DataGridProps, type DataGridSort, DatePicker, type DatePickerProps, type DateRange, DateRangePicker, type DateRangePickerProps, type DateRangePreset, DateTimePicker, type DateTimePickerProps, Divider, Drawer, Dropdown, DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, DropdownWithIcon, EmptyState, type EmptyStateProps, type FieldControlProps, type FieldValidator, FileSelector, FileUpload, FileUploadControl, FileUploadPreview, Form, type FormErrors, FormField, type FormFieldProps, type FormProps, type FormState, type GalleryImage, GlobalNavigation, HelperText, ImageGallery, type ImageGalleryProps, InfiniteScroll, type InfiniteScrollProps, Input, Kbd, type KbdProps, Label, Lightbox, type LightboxProps, LineChart, type LineChartProps, Link, type LinkProps, ListPagination, LoadMore, type LoadMoreProps, Loading, Menubar, MenubarCheckboxItem, type MenubarCheckboxItemProps, MenubarContent, type MenubarContentProps, MenubarItem, type MenubarItemProps, MenubarLabel, MenubarMenu, type MenubarProps, MenubarSeparator, MenubarSub, MenubarSubContent, MenubarSubTrigger, MenubarTrigger, type MenubarTriggerProps, Modal, MultiSelect, type MultiSelectGroup, type MultiSelectOption, type MultiSelectProps, Navbar, type NavbarItem, type NavbarLinkRenderProps, type NavbarProps, Notice, NumberInput, type NumberInputProps, OTPInput, Overlay, type OverlayProps, Pagination, PasswordInput, type PasswordInputProps, type PasswordStrength, Popover, type PopoverProps, type PopoverRenderApi, Portal, type PortalContainer, type PortalProps, ProgressBar, Radio, Rating, type RatingProps, ResizableHandle, type ResizableHandleProps, ResizablePanel, ResizablePanelGroup, type ResizablePanelGroupProps, type ResizablePanelProps, RichTextEditor, type RichTextEditorProps, type RichTextToolbarItem, ScrollArea, type ScrollAreaProps, SearchInput, type SearchInputProps, SegmentedControl, type SegmentedControlProps, type SegmentedOption, Select, type SelectGroup, type SelectOption, type SelectProps, Sidebar, SignaturePad, type SignaturePadHandle, type SignaturePadProps, Skeleton, SkipLink, type SkipLinkProps, Slider, type SortDirection, Spinner, SplitButton, StatCard, type StatCardProps, Stepper, Tab, TabList, TabPanel, Table, TableBody, TableDataCell, TableHead, TableHeadCell, TableRow, TableToolbar, type TableToolbarProps, TabsContainer, TagInput, type TagInputProps, TextInputWithLabel, Textarea, ThemeColorPicker, type ThemeColorPickerProps, type ThemeContextValue, type ThemeMode, ThemeModeSwitch, type ThemeModeSwitchProps, ThemeProvider, type ThemeProviderProps, type ThemeScale, ThemeScript, type ThemeScriptProps, type ThemeShade, TimePicker, type TimePickerProps, Timeline, type TimelineItem, type TimelineProps, type TimelineStatus, type ToastAction, type ToastApi, type ToastIntent, type ToastOptions, type ToastPosition, ToastProvider, type ToastProviderProps, Toggle, Tooltip, Tour, type TourProps, type TourStep, TreeView, Typography, type UseInfiniteScrollOptions, VisuallyHidden, type VisuallyHiddenProps, compose, copyText, defaultGetFileIcon, getDefaultRangePresets, getPasswordStrength, getPortalContainer, sanitizeHtml, useConfirm, useCopyToClipboard, useFormContext, useInfiniteScroll, useTheme, useToast, validators };