@weave-design-system/react 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,677 @@
+import * as react from 'react';
+import { ComponentPropsWithoutRef } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Placement } from '@floating-ui/react';
+import { DragEndEvent, DragOverEvent } from '@dnd-kit/core';
+import { ClassValue } from 'clsx';
+
+type ButtonVariant = 'primary' | 'secondary' | 'ghost' | 'destructive' | 'outline';
+type ButtonSize = 'sm' | 'md' | 'lg';
+interface ButtonProps extends ComponentPropsWithoutRef<'button'> {
+    /** Visual style variant */
+    variant?: ButtonVariant;
+    /** Size of the button */
+    size?: ButtonSize;
+    /** Show loading spinner and disable interaction */
+    loading?: boolean;
+    /** Icon element to show before children */
+    leftIcon?: React.ReactNode;
+    /** Icon element to show after children */
+    rightIcon?: React.ReactNode;
+}
+
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface InputGroupProps extends Omit<ComponentPropsWithoutRef<'input'>, 'size'> {
+    /** Label text displayed above the input */
+    label: string;
+    /** Helper text displayed below the input */
+    helperText?: string;
+    /** Error message — sets the input to error state */
+    error?: string;
+    /** Success message — sets the input to success state */
+    success?: string;
+}
+
+declare const InputGroup: react.ForwardRefExoticComponent<InputGroupProps & react.RefAttributes<HTMLInputElement>>;
+
+interface TextareaGroupProps extends ComponentPropsWithoutRef<'textarea'> {
+    /** Label text displayed above the textarea */
+    label: string;
+    /** Helper text displayed below the textarea */
+    helperText?: string;
+    /** Error message — sets the textarea to error state */
+    error?: string;
+}
+
+declare const TextareaGroup: react.ForwardRefExoticComponent<TextareaGroupProps & react.RefAttributes<HTMLTextAreaElement>>;
+
+interface SelectGroupProps extends ComponentPropsWithoutRef<'select'> {
+    /** Label text displayed above the select */
+    label: string;
+    /** Helper text displayed below the select */
+    helperText?: string;
+    /** Error message — sets the select to error state */
+    error?: string;
+    /** Placeholder option text */
+    placeholder?: string;
+}
+
+declare const SelectGroup: react.ForwardRefExoticComponent<SelectGroupProps & react.RefAttributes<HTMLSelectElement>>;
+
+interface CheckboxProps extends Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'size'> {
+    /** Label text displayed next to the checkbox */
+    label: string;
+    /** Controlled checked state */
+    checked?: boolean;
+    /** Default checked state for uncontrolled usage */
+    defaultChecked?: boolean;
+    /** Change handler */
+    onCheckedChange?: (checked: boolean) => void;
+}
+
+declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;
+
+interface RadioProps extends Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'size'> {
+    /** Label text displayed next to the radio button */
+    label: string;
+}
+
+declare const Radio: react.ForwardRefExoticComponent<RadioProps & react.RefAttributes<HTMLInputElement>>;
+
+interface ToggleProps {
+    /** Label text displayed next to the toggle */
+    label: string;
+    /** Controlled on/off state */
+    checked?: boolean;
+    /** Default state for uncontrolled usage */
+    defaultChecked?: boolean;
+    /** Change handler */
+    onCheckedChange?: (checked: boolean) => void;
+    /** Whether the toggle is disabled */
+    disabled?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Accessible name override */
+    'aria-label'?: string;
+}
+
+declare function Toggle({ label, checked: controlledChecked, defaultChecked, onCheckedChange, disabled, className, 'aria-label': ariaLabel, }: ToggleProps): react_jsx_runtime.JSX.Element;
+
+type BadgeVariant = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info';
+interface BadgeProps {
+    /** Badge content */
+    children: React.ReactNode;
+    /** Visual variant */
+    variant?: BadgeVariant;
+    /** Show a remove button */
+    removable?: boolean;
+    /** Called when the remove button is clicked */
+    onRemove?: () => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+
+declare function Badge({ children, variant, removable, onRemove, className, }: BadgeProps): react_jsx_runtime.JSX.Element;
+
+type AvatarSize = 'sm' | 'md' | 'lg' | 'xl';
+interface AvatarProps {
+    /** Full name — used for initials fallback and alt text */
+    name: string;
+    /** Image URL */
+    src?: string;
+    /** Size variant */
+    size?: AvatarSize;
+    /** Additional CSS classes */
+    className?: string;
+}
+interface AvatarGroupProps {
+    /** Avatar elements */
+    children: React.ReactNode;
+    /** Maximum number to display before +N overflow */
+    max?: number;
+    /** Additional CSS classes */
+    className?: string;
+}
+
+declare function Avatar({ name, src, size, className }: AvatarProps): react_jsx_runtime.JSX.Element;
+
+declare function AvatarGroup({ children, max, className }: AvatarGroupProps): react_jsx_runtime.JSX.Element;
+
+type LinkVariant = 'inline' | 'withIcon';
+interface LinkProps extends ComponentPropsWithoutRef<'a'> {
+    /** Visual variant */
+    variant?: LinkVariant;
+}
+
+declare const Link: react.ForwardRefExoticComponent<LinkProps & react.RefAttributes<HTMLAnchorElement>>;
+
+type TooltipVariant = 'dark' | 'light';
+interface TooltipProps {
+    /** Tooltip content */
+    content: React.ReactNode;
+    /** The trigger element */
+    children: React.ReactElement;
+    /** Visual variant */
+    variant?: TooltipVariant;
+    /** Placement relative to trigger */
+    placement?: Placement;
+    /** Delay before showing (ms) */
+    delayMs?: number;
+}
+
+declare function Tooltip({ content, children, variant, placement, delayMs, }: TooltipProps): react_jsx_runtime.JSX.Element;
+
+interface SliderProps {
+    /** Label text */
+    label: string;
+    /** Current value (controlled) */
+    value?: number;
+    /** Default value (uncontrolled) */
+    defaultValue?: number;
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Step increment */
+    step?: number;
+    /** Change handler */
+    onChange?: (value: number) => void;
+    /** Whether the slider is disabled */
+    disabled?: boolean;
+    /** Show value label next to the slider */
+    showValue?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+
+declare function Slider({ label, value: controlledValue, defaultValue, min, max, step, onChange, disabled, showValue, className, }: SliderProps): react_jsx_runtime.JSX.Element;
+
+interface DateInputProps extends Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'size'> {
+    /** Label text displayed above the input */
+    label: string;
+    /** Helper text displayed below the input */
+    helperText?: string;
+    /** Error message */
+    error?: string;
+}
+
+declare const DateInput: react.ForwardRefExoticComponent<DateInputProps & react.RefAttributes<HTMLInputElement>>;
+
+interface ComboboxOption {
+    value: string;
+    label: string;
+}
+interface ComboboxProps {
+    /** Label text */
+    label: string;
+    /** Available options */
+    options: ComboboxOption[];
+    /** Controlled selected value */
+    value?: string;
+    /** Default selected value */
+    defaultValue?: string;
+    /** Change handler */
+    onChange?: (value: string) => void;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Error message */
+    error?: string;
+    /** Whether the combobox is disabled */
+    disabled?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+
+declare function Combobox({ label, options, value: controlledValue, defaultValue, onChange, placeholder, error, disabled, className, }: ComboboxProps): react_jsx_runtime.JSX.Element;
+
+interface FileUploadDropzoneProps {
+    /** Called when files are dropped or selected */
+    onFiles?: (files: File[]) => void;
+    /** Accepted file types (e.g., "image/*,.pdf") */
+    accept?: string;
+    /** Allow multiple files */
+    multiple?: boolean;
+    /** Whether the dropzone is disabled */
+    disabled?: boolean;
+    /** Description text */
+    description?: string;
+    /** Additional CSS classes */
+    className?: string;
+}
+
+declare function FileUploadDropzone({ onFiles, accept, multiple, disabled, description, className, }: FileUploadDropzoneProps): react_jsx_runtime.JSX.Element;
+
+interface CardProps extends ComponentPropsWithoutRef<'div'> {
+}
+interface CardHeaderProps extends ComponentPropsWithoutRef<'div'> {
+}
+interface CardContentProps extends ComponentPropsWithoutRef<'div'> {
+}
+interface CardActionsProps extends ComponentPropsWithoutRef<'div'> {
+}
+
+declare const Card: react.ForwardRefExoticComponent<CardProps & react.RefAttributes<HTMLDivElement>> & {
+    Header: react.ForwardRefExoticComponent<CardHeaderProps & react.RefAttributes<HTMLDivElement>>;
+    Content: react.ForwardRefExoticComponent<CardContentProps & react.RefAttributes<HTMLDivElement>>;
+    Actions: react.ForwardRefExoticComponent<CardActionsProps & react.RefAttributes<HTMLDivElement>>;
+};
+
+interface SidebarProps {
+    /** Whether the sidebar is collapsed to rail mode (56px) */
+    collapsed?: boolean;
+    /** Called when collapse state changes */
+    onCollapsedChange?: (collapsed: boolean) => void;
+    /** Header slot (logo area) */
+    header?: React.ReactNode;
+    /** Navigation slot */
+    children: React.ReactNode;
+    /** Footer slot */
+    footer?: React.ReactNode;
+    /** Additional CSS classes */
+    className?: string;
+}
+
+declare const SidebarContext: react.Context<{
+    collapsed: boolean;
+}>;
+declare const useSidebar: () => {
+    collapsed: boolean;
+};
+declare function Sidebar({ collapsed, onCollapsedChange, header, children, footer, className, }: SidebarProps): react_jsx_runtime.JSX.Element;
+
+interface TopBarProps {
+    /** Logo or brand element */
+    logo?: React.ReactNode;
+    /** Navigation tabs or links */
+    navigation?: React.ReactNode;
+    /** Right-side actions (search, notifications, avatar) */
+    actions?: React.ReactNode;
+    /** Additional CSS classes */
+    className?: string;
+}
+
+declare function TopBar({ logo, navigation, actions, className }: TopBarProps): react_jsx_runtime.JSX.Element;
+
+interface CommandItem {
+    id: string;
+    label: string;
+    icon?: React.ReactNode;
+    section?: string;
+    onSelect: () => void;
+}
+interface CommandPaletteProps {
+    /** Whether the palette is open */
+    open: boolean;
+    /** Called when open state changes */
+    onOpenChange: (open: boolean) => void;
+    /** Available command items */
+    items: CommandItem[];
+    /** Placeholder text for the search input */
+    placeholder?: string;
+}
+
+declare function CommandPalette({ open, onOpenChange, items, placeholder, }: CommandPaletteProps): react_jsx_runtime.JSX.Element | null;
+
+interface SidebarNavItemProps {
+    /** Icon element */
+    icon: React.ReactNode;
+    /** Label text */
+    label: string;
+    /** Whether this item is currently active */
+    active?: boolean;
+    /** Click handler */
+    onClick?: () => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+
+declare function SidebarNavItem({ icon, label, active, onClick, className, }: SidebarNavItemProps): react_jsx_runtime.JSX.Element;
+
+type TabsVariant = 'underline' | 'pill';
+interface TabsProps {
+    /** Controlled active tab value */
+    value?: string;
+    /** Default active tab value */
+    defaultValue?: string;
+    /** Called when active tab changes */
+    onValueChange?: (value: string) => void;
+    /** Visual variant */
+    variant?: TabsVariant;
+    /** Tab content */
+    children: React.ReactNode;
+    /** Additional CSS classes */
+    className?: string;
+}
+interface TabsListProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface TabsTriggerProps {
+    /** Unique value identifying this tab */
+    value: string;
+    children: React.ReactNode;
+    className?: string;
+    disabled?: boolean;
+}
+interface TabsPanelProps {
+    /** Value matching the corresponding trigger */
+    value: string;
+    children: React.ReactNode;
+    className?: string;
+}
+
+declare function TabsRoot({ value: controlledValue, defaultValue, onValueChange, variant, children, className, }: TabsProps): react_jsx_runtime.JSX.Element;
+declare function TabsList({ children, className }: TabsListProps): react_jsx_runtime.JSX.Element;
+declare function TabsTrigger({ value, children, className, disabled }: TabsTriggerProps): react_jsx_runtime.JSX.Element;
+declare function TabsPanel({ value, children, className }: TabsPanelProps): react_jsx_runtime.JSX.Element | null;
+declare const Tabs: typeof TabsRoot & {
+    List: typeof TabsList;
+    Trigger: typeof TabsTrigger;
+    Panel: typeof TabsPanel;
+};
+
+interface BreadcrumbItem {
+    label: string;
+    href?: string;
+    onClick?: () => void;
+}
+interface BreadcrumbsProps {
+    /** Breadcrumb items — last item is treated as active/current */
+    items: BreadcrumbItem[];
+    /** Additional CSS classes */
+    className?: string;
+}
+
+declare function Breadcrumbs({ items, className }: BreadcrumbsProps): react_jsx_runtime.JSX.Element;
+
+interface StatCardProps {
+    label: string;
+    value: string | number;
+    trend?: {
+        value: number;
+        direction: 'up' | 'down';
+    };
+    className?: string;
+}
+declare function StatCard({ label, value, trend, className }: StatCardProps): react_jsx_runtime.JSX.Element;
+
+interface ProgressBarProps {
+    label?: string;
+    value: number;
+    max?: number;
+    showValue?: boolean;
+    className?: string;
+}
+declare function ProgressBar({ label, value, max, showValue, className }: ProgressBarProps): react_jsx_runtime.JSX.Element;
+
+interface CircularProgressProps {
+    value: number;
+    max?: number;
+    size?: number;
+    strokeWidth?: number;
+    className?: string;
+}
+declare function CircularProgress({ value, max, size, strokeWidth, className }: CircularProgressProps): react_jsx_runtime.JSX.Element;
+
+declare const Table: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.TableHTMLAttributes<HTMLTableElement>, HTMLTableElement>, "ref"> & react.RefAttributes<HTMLTableElement>> & {
+    Head: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & react.RefAttributes<HTMLTableSectionElement>>;
+    Body: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLTableSectionElement>, HTMLTableSectionElement>, "ref"> & react.RefAttributes<HTMLTableSectionElement>>;
+    Row: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLTableRowElement>, HTMLTableRowElement>, "ref"> & react.RefAttributes<HTMLTableRowElement>>;
+    HeaderCell: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.ThHTMLAttributes<HTMLTableHeaderCellElement>, HTMLTableHeaderCellElement>, "ref"> & react.RefAttributes<HTMLTableCellElement>>;
+    Cell: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.TdHTMLAttributes<HTMLTableDataCellElement>, HTMLTableDataCellElement>, "ref"> & react.RefAttributes<HTMLTableCellElement>>;
+};
+
+type TimelineColor = 'rust' | 'forest' | 'default';
+interface TimelineItem {
+    id: string;
+    title: string;
+    description?: string;
+    timestamp: string;
+    color?: TimelineColor;
+}
+interface TimelineProps {
+    items: TimelineItem[];
+    className?: string;
+}
+declare function Timeline({ items, className }: TimelineProps): react_jsx_runtime.JSX.Element;
+
+interface ActivityItem {
+    id: string;
+    name: string;
+    avatarSrc?: string;
+    action: string;
+    timestamp: string;
+}
+interface ActivityFeedProps {
+    items: ActivityItem[];
+    className?: string;
+}
+declare function ActivityFeed({ items, className }: ActivityFeedProps): react_jsx_runtime.JSX.Element;
+
+interface EmptyStateProps {
+    icon: React.ReactNode;
+    title: string;
+    description?: string;
+    actionLabel?: string;
+    onAction?: () => void;
+    className?: string;
+}
+declare function EmptyState({ icon, title, description, actionLabel, onAction, className }: EmptyStateProps): react_jsx_runtime.JSX.Element;
+
+type ToastVariant = 'success' | 'error' | 'warning' | 'info';
+interface ToastData {
+    id: string;
+    title: string;
+    message?: string;
+    variant: ToastVariant;
+    duration?: number;
+}
+interface ToastContextValue {
+    toast: (data: Omit<ToastData, 'id'>) => void;
+}
+declare const useToast: () => ToastContextValue;
+declare function ToastProvider({ children }: {
+    children: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+
+interface ModalProps {
+    open: boolean;
+    onClose: () => void;
+    children: React.ReactNode;
+    className?: string;
+}
+declare function ModalRoot({ open, onClose, children, className }: ModalProps): react_jsx_runtime.JSX.Element | null;
+declare const Modal: typeof ModalRoot & {
+    Header: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        onClose?: () => void;
+    } & react.RefAttributes<HTMLDivElement>>;
+    Body: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+    Footer: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+};
+
+type AlertBannerVariant = 'info' | 'warning' | 'error';
+interface AlertBannerProps {
+    message: string;
+    variant?: AlertBannerVariant;
+    dismissible?: boolean;
+    className?: string;
+}
+declare function AlertBanner({ message, variant, dismissible, className }: AlertBannerProps): react_jsx_runtime.JSX.Element | null;
+
+type SkeletonShape = 'text' | 'avatar' | 'image' | 'custom';
+interface SkeletonLoaderProps {
+    shape?: SkeletonShape;
+    width?: string | number;
+    height?: string | number;
+    lines?: number;
+    className?: string;
+}
+declare function SkeletonLoader({ shape, width, height, lines, className }: SkeletonLoaderProps): react_jsx_runtime.JSX.Element;
+
+interface AccordionProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface AccordionItemProps {
+    value: string;
+    children: React.ReactNode;
+    className?: string;
+}
+interface AccordionTriggerProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface AccordionContentProps {
+    children: React.ReactNode;
+    className?: string;
+}
+declare function AccordionRoot({ children, className }: AccordionProps): react_jsx_runtime.JSX.Element;
+declare function AccordionItem({ value, children, className }: AccordionItemProps): react_jsx_runtime.JSX.Element;
+declare function AccordionTrigger({ children, className }: AccordionTriggerProps): react_jsx_runtime.JSX.Element;
+declare function AccordionContent({ children, className }: AccordionContentProps): react_jsx_runtime.JSX.Element;
+declare const Accordion: typeof AccordionRoot & {
+    Item: typeof AccordionItem;
+    Trigger: typeof AccordionTrigger;
+    Content: typeof AccordionContent;
+};
+
+interface ActionMenuItem {
+    label: string;
+    icon?: React.ReactNode;
+    onClick?: () => void;
+    destructive?: boolean;
+    divider?: boolean;
+}
+interface ActionMenuProps {
+    items: ActionMenuItem[];
+    className?: string;
+}
+declare function ActionMenu({ items, className }: ActionMenuProps): react_jsx_runtime.JSX.Element;
+
+interface PaginationProps {
+    currentPage: number;
+    totalPages: number;
+    onPageChange: (page: number) => void;
+    className?: string;
+}
+declare function Pagination({ currentPage, totalPages, onPageChange, className }: PaginationProps): react_jsx_runtime.JSX.Element;
+
+interface NotificationDotProps {
+    children: React.ReactNode;
+    show?: boolean;
+    className?: string;
+}
+declare function NotificationDot({ children, show, className }: NotificationDotProps): react_jsx_runtime.JSX.Element;
+
+interface CarouselProps {
+    children: React.ReactNode;
+    className?: string;
+}
+declare function Carousel({ children, className }: CarouselProps): react_jsx_runtime.JSX.Element;
+
+interface ImagePlaceholderProps {
+    width?: string | number;
+    height?: string | number;
+    label?: string;
+    className?: string;
+}
+declare function ImagePlaceholder({ width, height, label, className }: ImagePlaceholderProps): react_jsx_runtime.JSX.Element;
+
+interface TaskCardProps {
+    /** Unique identifier for drag-and-drop */
+    id?: string;
+    title: string;
+    priority?: 'urgent' | 'high' | 'medium' | 'low';
+    labels?: {
+        text: string;
+        variant?: 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info';
+    }[];
+    assignee?: {
+        name: string;
+        src?: string;
+    };
+    dueDate?: string;
+    className?: string;
+    onClick?: () => void;
+    /** Show drag grip handle */
+    draggable?: boolean;
+    /** Props spread from useSortable — used internally by KanbanBoard */
+    dragHandleProps?: Record<string, unknown>;
+}
+declare function TaskCard({ title, priority, labels, assignee, dueDate, className, onClick, draggable, dragHandleProps }: TaskCardProps): react_jsx_runtime.JSX.Element;
+
+interface KanbanColumnProps {
+    /** Unique column identifier for drop targeting */
+    id: string;
+    title: string;
+    count?: number;
+    onAdd?: () => void;
+    /** Item IDs for sortable context */
+    itemIds?: string[];
+    children: React.ReactNode;
+    className?: string;
+}
+declare function KanbanColumn({ id, title, count, onAdd, itemIds, children, className }: KanbanColumnProps): react_jsx_runtime.JSX.Element;
+
+interface SortableTaskCardProps extends TaskCardProps {
+    /** Unique sortable ID — required */
+    id: string;
+}
+declare function SortableTaskCard({ id, className, ...props }: SortableTaskCardProps): react_jsx_runtime.JSX.Element;
+
+interface KanbanBoardProps {
+    /** Called when an item is dropped */
+    onDragEnd?: (event: DragEndEvent) => void;
+    /** Called when dragging over a new container */
+    onDragOver?: (event: DragOverEvent) => void;
+    children: React.ReactNode;
+    className?: string;
+}
+declare function KanbanBoard({ onDragEnd, onDragOver, children, className }: KanbanBoardProps): react_jsx_runtime.JSX.Element;
+
+type Priority = 'urgent' | 'high' | 'medium' | 'low';
+interface PrioritySelectorProps {
+    value?: Priority;
+    onChange?: (priority: Priority) => void;
+    className?: string;
+}
+declare function PrioritySelector({ value, onChange, className }: PrioritySelectorProps): react_jsx_runtime.JSX.Element;
+
+interface Comment {
+    id: string;
+    author: {
+        name: string;
+        avatarSrc?: string;
+    };
+    content: string;
+    timestamp: string;
+    replies?: Comment[];
+}
+interface CommentThreadProps {
+    comments: Comment[];
+    className?: string;
+}
+declare function CommentThread({ comments, className }: CommentThreadProps): react_jsx_runtime.JSX.Element;
+
+interface RichTextToolbarProps {
+    activeFormats?: string[];
+    onFormatToggle?: (format: string) => void;
+    className?: string;
+}
+declare function RichTextToolbar({ activeFormats, onFormatToggle, className }: RichTextToolbarProps): react_jsx_runtime.JSX.Element;
+
+declare function useReducedMotion(): boolean;
+
+interface UseControllableStateParams<T> {
+    value?: T;
+    defaultValue: T;
+    onChange?: (value: T) => void;
+}
+declare function useControllableState<T>({ value: controlledValue, defaultValue, onChange, }: UseControllableStateParams<T>): [T, (value: T) => void];
+
+declare function useFocusTrap<T extends HTMLElement>(active?: boolean): react.RefObject<T>;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+export { Accordion, type AccordionContentProps, type AccordionItemProps, type AccordionProps, type AccordionTriggerProps, ActionMenu, type ActionMenuItem, type ActionMenuProps, ActivityFeed, type ActivityFeedProps, type ActivityItem, AlertBanner, type AlertBannerProps, type AlertBannerVariant, Avatar, AvatarGroup, type AvatarGroupProps, type AvatarProps, type AvatarSize, Badge, type BadgeProps, type BadgeVariant, type BreadcrumbItem, Breadcrumbs, type BreadcrumbsProps, Button, type ButtonProps, type ButtonSize, type ButtonVariant, Card, type CardActionsProps, type CardContentProps, type CardHeaderProps, type CardProps, Carousel, type CarouselProps, Checkbox, type CheckboxProps, CircularProgress, type CircularProgressProps, Combobox, type ComboboxOption, type ComboboxProps, type CommandItem, CommandPalette, type CommandPaletteProps, type Comment, CommentThread, type CommentThreadProps, DateInput, type DateInputProps, EmptyState, type EmptyStateProps, FileUploadDropzone, type FileUploadDropzoneProps, ImagePlaceholder, type ImagePlaceholderProps, InputGroup, type InputGroupProps, KanbanBoard, type KanbanBoardProps, KanbanColumn, type KanbanColumnProps, Link, type LinkProps, type LinkVariant, Modal, type ModalProps, NotificationDot, type NotificationDotProps, Pagination, type PaginationProps, type Priority, PrioritySelector, type PrioritySelectorProps, ProgressBar, type ProgressBarProps, Radio, type RadioProps, RichTextToolbar, type RichTextToolbarProps, SelectGroup, type SelectGroupProps, Sidebar, SidebarContext, SidebarNavItem, type SidebarNavItemProps, type SidebarProps, SkeletonLoader, type SkeletonLoaderProps, type SkeletonShape, Slider, type SliderProps, SortableTaskCard, type SortableTaskCardProps, StatCard, type StatCardProps, Table, Tabs, type TabsListProps, type TabsPanelProps, type TabsProps, type TabsTriggerProps, type TabsVariant, TaskCard, type TaskCardProps, TextareaGroup, type TextareaGroupProps, Timeline, type TimelineColor, type TimelineItem, type TimelineProps, type ToastData, ToastProvider, type ToastVariant, Toggle, type ToggleProps, Tooltip, type TooltipProps, type TooltipVariant, TopBar, type TopBarProps, cn, useControllableState, useFocusTrap, useReducedMotion, useSidebar, useToast };