@boostdev/design-system-components 1.2.0 → 1.2.2

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode, HTMLAttributes, ElementType, ComponentPropsWithoutRef, ReactElement, ButtonHTMLAttributes, MouseEventHandler, InputHTMLAttributes, HTMLInputTypeAttribute, SelectHTMLAttributes, TextareaHTMLAttributes, CSSProperties, JSX } from 'react';
+import { HTMLAttributes, ReactNode, ElementType, ComponentPropsWithoutRef, AnchorHTMLAttributes, ReactElement, ButtonHTMLAttributes, MouseEventHandler, InputHTMLAttributes, FieldsetHTMLAttributes, HTMLInputTypeAttribute, SelectHTMLAttributes, TextareaHTMLAttributes, JSX } from 'react';
 export { cn } from '@boostdev/design-system-foundation';
 
 /** Allows consumers to pass a CSS class to the component's root element. */
@@ -13,44 +13,42 @@ interface AccordionItem {
     content: ReactNode;
     disabled?: boolean;
 }
-interface AccordionProps extends WithClassName {
+interface AccordionProps extends WithClassName, HTMLAttributes<HTMLDivElement> {
     items: AccordionItem[];
     allowMultiple?: boolean;
     defaultOpen?: string[];
 }
-declare function Accordion({ items, allowMultiple, defaultOpen, className, }: Readonly<AccordionProps>): react_jsx_runtime.JSX.Element;
+declare function Accordion({ items, allowMultiple, defaultOpen, className, ...rest }: Readonly<AccordionProps>): react_jsx_runtime.JSX.Element;
 
-interface AlertProps extends WithClassName {
+interface AlertProps extends WithClassName, Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
     variant?: 'info' | 'success' | 'warning' | 'error';
     icon?: ReactNode;
     title?: string;
-    children: ReactNode;
     onDismiss?: () => void;
 }
-declare function Alert({ variant, icon, title, children, onDismiss, className, }: Readonly<AlertProps>): react_jsx_runtime.JSX.Element;
+declare function Alert({ variant, icon, title, children, onDismiss, className, ...rest }: Readonly<AlertProps>): react_jsx_runtime.JSX.Element;
 
-interface AvatarProps extends WithClassName {
+interface AvatarProps extends WithClassName, HTMLAttributes<HTMLSpanElement> {
     src?: string;
     alt?: string;
     name?: string;
     size?: 'small' | 'medium' | 'large';
 }
-declare function Avatar({ src, alt, name, size, className }: Readonly<AvatarProps>): react_jsx_runtime.JSX.Element;
+declare function Avatar({ src, alt, name, size, className, ...rest }: Readonly<AvatarProps>): react_jsx_runtime.JSX.Element;
 
-interface BadgeProps extends WithClassName {
-    children: ReactNode;
+interface BadgeProps extends WithClassName, HTMLAttributes<HTMLSpanElement> {
     variant?: 'primary' | 'secondary' | 'success' | 'error' | 'warning';
 }
-declare function Badge({ children, variant, className }: BadgeProps): react_jsx_runtime.JSX.Element;
+declare function Badge({ children, variant, className, ...rest }: BadgeProps): react_jsx_runtime.JSX.Element;
 
 interface BreadcrumbItem {
     label: string;
     href?: string;
 }
-interface BreadcrumbProps extends WithClassName {
+interface BreadcrumbProps extends WithClassName, HTMLAttributes<HTMLElement> {
     items: BreadcrumbItem[];
 }
-declare function Breadcrumb({ items, className }: Readonly<BreadcrumbProps>): react_jsx_runtime.JSX.Element;
+declare function Breadcrumb({ items, className, ...rest }: Readonly<BreadcrumbProps>): react_jsx_runtime.JSX.Element;
 
 interface CollapsibleProps extends WithClassName, Omit<HTMLAttributes<HTMLDetailsElement>, 'onToggle'> {
     /** The trigger label — always visible */
@@ -71,30 +69,30 @@ interface CollapsibleProps extends WithClassName, Omit<HTMLAttributes<HTMLDetail
 }
 declare function Collapsible({ summary, children, open, defaultOpen, onToggle, name, className, ...rest }: Readonly<CollapsibleProps>): react_jsx_runtime.JSX.Element;
 
-interface CalendarProps extends WithClassName {
+interface CalendarProps extends WithClassName, Omit<HTMLAttributes<HTMLDivElement>, 'defaultValue' | 'onChange'> {
     value?: Date;
     defaultValue?: Date;
     min?: Date;
     max?: Date;
     onChange?: (date: Date) => void;
 }
-declare function Calendar({ value, defaultValue, min, max, onChange, className }: Readonly<CalendarProps>): react_jsx_runtime.JSX.Element;
+declare function Calendar({ value, defaultValue, min, max, onChange, className, ...rest }: Readonly<CalendarProps>): react_jsx_runtime.JSX.Element;
 
-interface CarouselProps extends WithClassName {
+interface CarouselProps extends WithClassName, HTMLAttributes<HTMLElement> {
     items: ReactNode[];
     label: string;
 }
-declare function Carousel({ items, label, className }: Readonly<CarouselProps>): react_jsx_runtime.JSX.Element;
+declare function Carousel({ items, label, className, ...rest }: Readonly<CarouselProps>): react_jsx_runtime.JSX.Element;
 
 interface DescriptionItem {
     term: ReactNode;
     details: ReactNode | ReactNode[];
 }
-interface DescriptionListProps extends WithClassName {
+interface DescriptionListProps extends WithClassName, HTMLAttributes<HTMLDListElement> {
     items: DescriptionItem[];
     layout?: 'stacked' | 'inline';
 }
-declare function DescriptionList({ items, layout, className }: Readonly<DescriptionListProps>): react_jsx_runtime.JSX.Element;
+declare function DescriptionList({ items, layout, className, ...rest }: Readonly<DescriptionListProps>): react_jsx_runtime.JSX.Element;
 
 type LinkOwnProps<T extends ElementType> = WithClassName & {
     as?: T;
@@ -106,57 +104,55 @@ type LinkOwnProps<T extends ElementType> = WithClassName & {
 type LinkProps<T extends ElementType = 'a'> = LinkOwnProps<T> & Omit<ComponentPropsWithoutRef<T>, keyof LinkOwnProps<T>>;
 declare function Link<T extends ElementType = 'a'>({ as, children, variant, external, externalLabel, className, ...props }: LinkProps<T>): react_jsx_runtime.JSX.Element;
 
-interface LoadingProps extends WithClassName {
+interface LoadingProps extends WithClassName, HTMLAttributes<HTMLDivElement> {
     size?: 'small' | 'medium' | 'large';
 }
-declare function Loading({ size, className }: LoadingProps): react_jsx_runtime.JSX.Element;
+declare function Loading({ size, className, ...rest }: LoadingProps): react_jsx_runtime.JSX.Element;
 
-interface NotificationBannerProps extends WithClassName {
+interface NotificationBannerProps extends WithClassName, HTMLAttributes<HTMLDivElement> {
     variant?: 'info' | 'success' | 'warning' | 'error';
     children: ReactNode;
     action?: ReactNode;
     onDismiss?: () => void;
 }
-declare function NotificationBanner({ variant, children, action, onDismiss, className, }: Readonly<NotificationBannerProps>): react_jsx_runtime.JSX.Element;
+declare function NotificationBanner({ variant, children, action, onDismiss, className, ...rest }: Readonly<NotificationBannerProps>): react_jsx_runtime.JSX.Element;
 
-interface PaginationProps extends WithClassName {
+interface PaginationProps extends WithClassName, HTMLAttributes<HTMLElement> {
     currentPage: number;
     totalPages: number;
     onPageChange: (page: number) => void;
 }
-declare function Pagination({ currentPage, totalPages, onPageChange, className, }: Readonly<PaginationProps>): react_jsx_runtime.JSX.Element;
+declare function Pagination({ currentPage, totalPages, onPageChange, className, ...rest }: Readonly<PaginationProps>): react_jsx_runtime.JSX.Element;
 
-interface ProgressProps extends WithClassName {
+interface ProgressProps extends WithClassName, HTMLAttributes<HTMLDivElement> {
     value: number;
     max?: number;
     label: string;
     showLabel?: boolean;
     size?: 'small' | 'medium' | 'large';
 }
-declare function Progress({ value, max, label, showLabel, size, className, }: Readonly<ProgressProps>): react_jsx_runtime.JSX.Element;
+declare function Progress({ value, max, label, showLabel, size, className, ...rest }: Readonly<ProgressProps>): react_jsx_runtime.JSX.Element;
 
-interface ProgressCircleProps extends WithClassName {
+interface ProgressCircleProps extends WithClassName, HTMLAttributes<HTMLDivElement> {
     value: number;
     max?: number;
     label: string;
     showValue?: boolean;
     size?: 'small' | 'medium' | 'large';
 }
-declare function ProgressCircle({ value, max, label, showValue, size, className, }: Readonly<ProgressCircleProps>): react_jsx_runtime.JSX.Element;
+declare function ProgressCircle({ value, max, label, showValue, size, className, ...rest }: Readonly<ProgressCircleProps>): react_jsx_runtime.JSX.Element;
 
-interface SeparatorProps extends WithClassName {
+interface SeparatorProps extends WithClassName, HTMLAttributes<HTMLElement> {
     orientation?: 'horizontal' | 'vertical';
 }
-declare function Separator({ orientation, className }: Readonly<SeparatorProps>): react_jsx_runtime.JSX.Element;
+declare function Separator({ orientation, className, ...rest }: Readonly<SeparatorProps>): react_jsx_runtime.JSX.Element;
 
-type SkeletonProps = WithClassName;
-declare function Skeleton({ className }: SkeletonProps): react_jsx_runtime.JSX.Element;
+type SkeletonProps = WithClassName & HTMLAttributes<HTMLDivElement>;
+declare function Skeleton({ className, ...rest }: SkeletonProps): react_jsx_runtime.JSX.Element;
 
-interface SkipLinkProps extends WithClassName {
-    href?: string;
-    children?: string;
+interface SkipLinkProps extends WithClassName, AnchorHTMLAttributes<HTMLAnchorElement> {
 }
-declare function SkipLink({ href, children, className }: SkipLinkProps): react_jsx_runtime.JSX.Element;
+declare function SkipLink({ href, children, className, ...rest }: SkipLinkProps): react_jsx_runtime.JSX.Element;
 
 interface TableColumn<Row> {
     key: string;
@@ -180,26 +176,25 @@ interface TabItem {
     content: ReactNode;
     disabled?: boolean;
 }
-interface TabsProps extends WithClassName {
+interface TabsProps extends WithClassName, HTMLAttributes<HTMLDivElement> {
     tabs: TabItem[];
     defaultTab?: string;
 }
-declare function Tabs({ tabs, defaultTab, className }: Readonly<TabsProps>): react_jsx_runtime.JSX.Element;
+declare function Tabs({ tabs, defaultTab, className, ...rest }: Readonly<TabsProps>): react_jsx_runtime.JSX.Element;
 
-interface TooltipProps extends WithClassName {
+interface TooltipProps extends WithClassName, Omit<HTMLAttributes<HTMLSpanElement>, 'content'> {
     content: ReactNode;
     placement?: 'top' | 'bottom' | 'left' | 'right';
     children: ReactElement;
 }
-declare function Tooltip({ content, placement, children, className, }: Readonly<TooltipProps>): react_jsx_runtime.JSX.Element;
+declare function Tooltip({ content, placement, children, className, ...rest }: Readonly<TooltipProps>): react_jsx_runtime.JSX.Element;
 
 type TypographyVariant = 'h1' | 'h2' | 'h3' | 'body' | 'body_s';
-interface TypographyProps extends WithClassName {
+interface TypographyProps extends WithClassName, HTMLAttributes<HTMLElement> {
     variant?: TypographyVariant;
     component?: ElementType;
-    children: ReactNode;
 }
-declare function Typography({ variant, component, children, className }: TypographyProps): react_jsx_runtime.JSX.Element;
+declare function Typography({ variant, component, children, className, ...rest }: TypographyProps): react_jsx_runtime.JSX.Element;
 
 interface ButtonProps extends WithClassName, ButtonHTMLAttributes<HTMLButtonElement | HTMLAnchorElement> {
     href?: string;
@@ -227,36 +222,30 @@ interface CommandItem {
     shortcut?: string;
     onSelect: () => void;
 }
-interface CommandProps extends WithClassName {
-    id?: string;
+interface CommandProps extends WithClassName, HTMLAttributes<HTMLDialogElement> {
     isOpen: boolean;
     onOpen?: () => void;
     onClose: () => void;
     items: CommandItem[];
     placeholder?: string;
 }
-declare function Command({ id: idProp, isOpen, onOpen, onClose, items, placeholder, className, }: Readonly<CommandProps>): react_jsx_runtime.JSX.Element;
+declare function Command({ id: idProp, isOpen, onOpen, onClose, items, placeholder, className, ...rest }: Readonly<CommandProps>): react_jsx_runtime.JSX.Element;
 
-interface DialogProps extends WithClassName {
-    children: ReactNode;
-    id?: string;
+interface DialogProps extends WithClassName, HTMLAttributes<HTMLDialogElement> {
     isOpen?: boolean;
     onOpen?: () => void;
     onClose?: () => void;
 }
-declare function Dialog({ children, id: idProp, isOpen, className, onOpen, onClose }: DialogProps): react_jsx_runtime.JSX.Element;
+declare function Dialog({ children, id: idProp, isOpen, className, onOpen, onClose, ...rest }: DialogProps): react_jsx_runtime.JSX.Element;
 
-interface DrawerProps extends WithClassName {
-    id?: string;
+interface DrawerProps extends WithClassName, Omit<HTMLAttributes<HTMLDialogElement>, 'title'> {
     isOpen: boolean;
     onOpen?: () => void;
     onClose: () => void;
     title: ReactNode;
-    children: ReactNode;
     side?: 'left' | 'right';
-    ariaLabel?: string;
 }
-declare function Drawer({ id: idProp, isOpen, onOpen, onClose, title, children, side, ariaLabel, className, }: Readonly<DrawerProps>): react_jsx_runtime.JSX.Element;
+declare function Drawer({ id: idProp, isOpen, onOpen, onClose, title, children, side, className, ...rest }: Readonly<DrawerProps>): react_jsx_runtime.JSX.Element;
 
 interface DropdownMenuItem {
     id: string;
@@ -266,26 +255,25 @@ interface DropdownMenuItem {
     icon?: ReactElement;
     separator?: boolean;
 }
-interface DropdownMenuProps extends WithClassName {
+interface DropdownMenuProps extends WithClassName, HTMLAttributes<HTMLDivElement> {
     trigger: ReactElement;
     items: DropdownMenuItem[];
     placement?: 'bottom-start' | 'bottom-end';
 }
-declare function DropdownMenu({ trigger, items, placement, className, }: Readonly<DropdownMenuProps>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenu({ trigger, items, placement, className, ...rest }: Readonly<DropdownMenuProps>): react_jsx_runtime.JSX.Element;
 
-interface PopoverProps extends WithClassName {
+interface PopoverProps extends WithClassName, Omit<HTMLAttributes<HTMLSpanElement>, 'content'> {
     children: ReactElement;
     content: ReactNode;
     placement?: 'top' | 'bottom' | 'left' | 'right';
-    'aria-label'?: string;
 }
-declare function Popover({ children, content, placement, className, 'aria-label': ariaLabel, }: Readonly<PopoverProps>): react_jsx_runtime.JSX.Element;
+declare function Popover({ children, content, placement, className, 'aria-label': ariaLabel, ...rest }: Readonly<PopoverProps>): react_jsx_runtime.JSX.Element;
 
-interface RatingProps extends WithClassName {
+interface RatingProps extends WithClassName, HTMLAttributes<HTMLDivElement> {
     value: number;
     max?: number;
 }
-declare function Rating({ value, max, className }: RatingProps): react_jsx_runtime.JSX.Element;
+declare function Rating({ value, max, className, ...rest }: RatingProps): react_jsx_runtime.JSX.Element;
 
 type ToastVariant = 'success' | 'error' | 'info';
 interface ToastContextType {
@@ -304,22 +292,20 @@ interface CheckboxProps extends WithClassName, Omit<InputHTMLAttributes<HTMLInpu
 }
 declare function Checkbox({ label, name, error, hint, className, ...props }: CheckboxProps): react_jsx_runtime.JSX.Element;
 
-interface CheckboxGroupProps extends WithClassName {
+interface CheckboxGroupProps extends WithClassName, FieldsetHTMLAttributes<HTMLFieldSetElement> {
     legend: string;
-    children: ReactNode;
     error?: string;
     hint?: string;
     required?: boolean;
-    disabled?: boolean;
 }
-declare function CheckboxGroup({ legend, children, error, hint, required, disabled, className, }: Readonly<CheckboxGroupProps>): react_jsx_runtime.JSX.Element;
+declare function CheckboxGroup({ legend, children, error, hint, required, className, ...rest }: Readonly<CheckboxGroupProps>): react_jsx_runtime.JSX.Element;
 
 interface ComboboxOption {
     value: string;
     label: string;
     disabled?: boolean;
 }
-interface ComboboxProps extends WithClassName {
+interface ComboboxProps extends WithClassName, Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
     label: ReactNode;
     name: string;
     options: ComboboxOption[];
@@ -330,9 +316,9 @@ interface ComboboxProps extends WithClassName {
     error?: string;
     hint?: string;
 }
-declare function Combobox({ label, name, options, placeholder, value, onChange, disabled, error, hint, className, }: Readonly<ComboboxProps>): react_jsx_runtime.JSX.Element;
+declare function Combobox({ label, name, options, placeholder, value, onChange, disabled, error, hint, className, ...rest }: Readonly<ComboboxProps>): react_jsx_runtime.JSX.Element;
 
-interface FileInputProps extends WithClassName {
+interface FileInputProps extends WithClassName, Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
     label: string;
     name: string;
     accept?: string;
@@ -343,7 +329,7 @@ interface FileInputProps extends WithClassName {
     hint?: string;
     onChange?: (files: FileList | null) => void;
 }
-declare function FileInput({ label, name, accept, multiple, disabled, required, error, hint, onChange, className, }: Readonly<FileInputProps>): react_jsx_runtime.JSX.Element;
+declare function FileInput({ label, name, accept, multiple, disabled, required, error, hint, onChange, className, ...rest }: Readonly<FileInputProps>): react_jsx_runtime.JSX.Element;
 
 interface FormInputProps extends WithClassName, Omit<InputHTMLAttributes<HTMLInputElement>, 'type'> {
     label: ReactNode;
@@ -355,7 +341,7 @@ interface FormInputProps extends WithClassName, Omit<InputHTMLAttributes<HTMLInp
 }
 declare function FormInput({ label, name, ariaLabel, error, hint, className, required, ...props }: FormInputProps): react_jsx_runtime.JSX.Element;
 
-interface NumberInputProps extends WithClassName {
+interface NumberInputProps extends WithClassName, Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
     label: string;
     name: string;
     value?: number;
@@ -368,7 +354,7 @@ interface NumberInputProps extends WithClassName {
     hint?: string;
     onChange?: (value: number) => void;
 }
-declare function NumberInput({ label, name, value, defaultValue, min, max, step, disabled, error, hint, onChange, className, }: Readonly<NumberInputProps>): react_jsx_runtime.JSX.Element;
+declare function NumberInput({ label, name, value, defaultValue, min, max, step, disabled, error, hint, onChange, className, ...rest }: Readonly<NumberInputProps>): react_jsx_runtime.JSX.Element;
 
 interface RadioProps extends WithClassName, Omit<InputHTMLAttributes<HTMLInputElement>, 'type'> {
     label: ReactNode;
@@ -379,18 +365,15 @@ interface RadioProps extends WithClassName, Omit<InputHTMLAttributes<HTMLInputEl
 }
 declare function Radio({ label, name, description, error, hint, className, ...props }: RadioProps): react_jsx_runtime.JSX.Element;
 
-interface RadioGroupProps extends WithClassName {
+interface RadioGroupProps extends WithClassName, FieldsetHTMLAttributes<HTMLFieldSetElement> {
     legend: string;
-    children: ReactNode;
     error?: string;
     hint?: string;
     required?: boolean;
-    disabled?: boolean;
 }
-declare function RadioGroup({ legend, children, error, hint, required, disabled, className, }: Readonly<RadioGroupProps>): react_jsx_runtime.JSX.Element;
+declare function RadioGroup({ legend, children, error, hint, required, className, ...rest }: Readonly<RadioGroupProps>): react_jsx_runtime.JSX.Element;
 
-interface SegmentedControlProps extends WithClassName {
-    children: ReactNode;
+interface SegmentedControlProps extends WithClassName, HTMLAttributes<HTMLDivElement> {
     /**
      * Zero-based index of the active item.
      * When omitted, auto-detected from the first child that has
@@ -401,9 +384,8 @@ interface SegmentedControlProps extends WithClassName {
     size?: 'small' | 'medium' | 'large';
     /** "outline" (default) — sliding inset border; "filled" — sliding filled thumb */
     variant?: 'outline' | 'filled';
-    'aria-label'?: string;
 }
-declare function SegmentedControl({ children, selectedIndex: selectedIndexProp, disabled, size, variant, className, 'aria-label': ariaLabel, }: Readonly<SegmentedControlProps>): react_jsx_runtime.JSX.Element;
+declare function SegmentedControl({ children, selectedIndex: selectedIndexProp, disabled, size, variant, className, ...rest }: Readonly<SegmentedControlProps>): react_jsx_runtime.JSX.Element;
 
 interface SelectOption {
     value: string;
@@ -449,38 +431,31 @@ interface TextareaProps extends WithClassName, TextareaHTMLAttributes<HTMLTextAr
 }
 declare function Textarea({ label, name, error, hint, className, required, ...props }: Readonly<TextareaProps>): react_jsx_runtime.JSX.Element;
 
-interface ButtonGroupProps extends WithClassName {
-    children: ReactNode;
+interface ButtonGroupProps extends WithClassName, HTMLAttributes<HTMLDivElement> {
     variant?: 'flow' | 'card' | 'modal' | 'content';
-    'aria-label'?: string;
 }
-declare function ButtonGroup({ children, className, variant, 'aria-label': ariaLabel }: ButtonGroupProps): react_jsx_runtime.JSX.Element;
+declare function ButtonGroup({ children, className, variant, ...rest }: ButtonGroupProps): react_jsx_runtime.JSX.Element;
 
-interface CardProps extends WithClassName {
-    children: ReactNode;
+interface CardProps extends WithClassName, HTMLAttributes<HTMLElement> {
     variant?: 'default' | 'elevated' | 'outlined';
     padding?: 'none' | 'small' | 'medium' | 'large';
     textAlign?: 'start' | 'center' | 'end';
-    style?: CSSProperties;
-    onClick?: () => void;
-    'aria-label'?: string;
 }
-declare function Card({ children, className, variant, padding, textAlign, style, onClick, 'aria-label': ariaLabel, }: CardProps): react_jsx_runtime.JSX.Element;
+declare function Card({ children, className, variant, padding, textAlign, onClick, ...rest }: CardProps): react_jsx_runtime.JSX.Element;
 
 type IntrinsicElement = keyof JSX.IntrinsicElements;
-type SectionHeaderProps = WithClassName & {
+type SectionHeaderProps = WithClassName & Omit<HTMLAttributes<HTMLDivElement>, 'title'> & {
     title: string;
     subtitle?: string;
     alignment?: 'start' | 'center' | 'end';
     size?: 'small' | 'medium' | 'large';
     titleAs?: IntrinsicElement;
 };
-declare function SectionHeader({ title, subtitle, className, alignment, size, titleAs }: Readonly<SectionHeaderProps>): react_jsx_runtime.JSX.Element;
+declare function SectionHeader({ title, subtitle, className, alignment, size, titleAs, ...rest }: Readonly<SectionHeaderProps>): react_jsx_runtime.JSX.Element;
 
-interface IconWrapperProps extends WithClassName {
+interface IconWrapperProps extends WithClassName, HTMLAttributes<HTMLDivElement> {
     children: ReactNode;
-    'aria-hidden'?: boolean | 'true' | 'false';
 }
-declare function IconWrapper({ children, className, 'aria-hidden': ariaHidden }: IconWrapperProps): react_jsx_runtime.JSX.Element;
+declare function IconWrapper({ children, className, ...rest }: IconWrapperProps): react_jsx_runtime.JSX.Element;
 
 export { Accordion, type AccordionItem, Alert, Avatar, Badge, Breadcrumb, type BreadcrumbItem, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, Calendar, Card, Carousel, Checkbox, CheckboxGroup, type CheckboxGroupProps, Collapsible, type CollapsibleProps, Combobox, type ComboboxOption, Command, type CommandItem, type DescriptionItem, DescriptionList, Dialog, Drawer, DropdownMenu, type DropdownMenuItem, FileInput, FormInput, IconWrapper, type IconWrapperProps, Link, Loading, NotificationBanner, NumberInput, Pagination, Popover, Progress, ProgressCircle, Radio, RadioGroup, type RadioGroupProps, Rating, SectionHeader, SegmentedControl, type SegmentedControlProps, Select, type SelectOption, Separator, Skeleton, SkipLink, Slider, Switch, type TabItem, Table, type TableColumn, Tabs, Textarea, ToastProvider, Tooltip, Typography, type WithClassName, useToast };