npm - @particle-academy/react-fancy - Versions diffs - 1.0.0 → 1.3.0 - Mend

@particle-academy/react-fancy 1.0.0 → 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/README.md +120 -16
package/dist/diagram.serializers-OK4HP7AB.js +273 -0
package/dist/diagram.serializers-OK4HP7AB.js.map +1 -0
package/dist/index.cjs +7489 -329
package/dist/index.cjs.map +1 -1
package/dist/index.d.cts +1681 -34
package/dist/index.d.ts +1681 -34
package/dist/index.js +7106 -326
package/dist/index.js.map +1 -1
package/dist/styles.css +116 -0
package/dist/styles.css.map +1 -1
package/package.json +13 -11

package/dist/index.d.cts CHANGED Viewed

@@ -1,5 +1,5 @@
 import * as react from 'react';
-import { ButtonHTMLAttributes, ReactNode, InputHTMLAttributes, TextareaHTMLAttributes, SelectHTMLAttributes } from 'react';
+import { ButtonHTMLAttributes, ReactNode, InputHTMLAttributes, TextareaHTMLAttributes, SelectHTMLAttributes, HTMLAttributes, ComponentType, ReactElement, RefObject, CSSProperties } from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ClassValue } from 'clsx';
@@ -7,6 +7,7 @@ type Size = "xs" | "sm" | "md" | "lg" | "xl";
 type Color = "zinc" | "red" | "orange" | "amber" | "yellow" | "lime" | "green" | "emerald" | "teal" | "cyan" | "sky" | "blue" | "indigo" | "violet" | "purple" | "fuchsia" | "pink" | "rose";
 type Variant = "solid" | "outline" | "ghost" | "soft";
 type ActionColor = "blue" | "emerald" | "amber" | "red" | "violet" | "indigo" | "sky" | "rose" | "orange" | "zinc";
+type Placement = "top" | "bottom" | "left" | "right" | "top-start" | "top-end" | "bottom-start" | "bottom-end";
 interface ActionProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "color"> {
     /** Shape variant */
@@ -19,14 +20,14 @@ interface ActionProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "col
     checked?: boolean;
     warn?: boolean;
     alert?: boolean;
-    /** Leading icon (ReactNode) */
-    icon?: ReactNode;
-    /** Trailing icon (convenience for right-side icon) */
-    iconTrailing?: ReactNode;
+    /** Leading icon slug (resolved via Icon component, e.g. "pencil", "chevron-right") */
+    icon?: string;
+    /** Trailing icon slug (convenience for right-side icon) */
+    iconTrailing?: string;
     /** Icon placement direction */
-    iconPlace?: "left" | "right" | "top" | "bottom";
-    /** Pulsing alert icon */
-    alertIcon?: ReactNode;
+    iconPlace?: "left" | "right" | "top" | "bottom" | "top left" | "top right" | "bottom left" | "bottom right" | "left top" | "left bottom" | "right top" | "right bottom";
+    /** Pulsing alert icon slug */
+    alertIcon?: string;
     /** Position alert icon on trailing side */
     alertIconTrailing?: boolean;
     /** Emoji slug (resolved via emoji-utils) */
@@ -87,8 +88,15 @@ interface InputBaseProps {
     id?: string;
     name?: string;
 }
+type AffixPosition = "inside" | "outside";
+interface InputAffixProps {
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    prefixPosition?: AffixPosition;
+    suffixPosition?: AffixPosition;
+}
-interface InputProps extends InputBaseProps, Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "type"> {
+interface InputProps extends InputBaseProps, InputAffixProps, Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "type" | "prefix"> {
     type?: "text" | "email" | "password" | "number" | "tel" | "url" | "search";
     onValueChange?: (value: string) => void;
     leading?: ReactNode;
@@ -97,7 +105,7 @@ interface InputProps extends InputBaseProps, Omit<InputHTMLAttributes<HTMLInputE
 declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;
-interface TextareaProps extends InputBaseProps, Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "size"> {
+interface TextareaProps extends InputBaseProps, InputAffixProps, Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "size" | "prefix"> {
     autoResize?: boolean;
     minRows?: number;
     maxRows?: number;
@@ -106,7 +114,7 @@ interface TextareaProps extends InputBaseProps, Omit<TextareaHTMLAttributes<HTML
 declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
-interface SelectProps extends InputBaseProps, Omit<SelectHTMLAttributes<HTMLSelectElement>, "size"> {
+interface SelectProps extends InputBaseProps, InputAffixProps, Omit<SelectHTMLAttributes<HTMLSelectElement>, "size" | "prefix"> {
     list: InputOption[] | InputOptionGroup[];
     placeholder?: string;
     onValueChange?: (value: string) => void;
@@ -169,6 +177,8 @@ interface SliderBaseProps extends InputBaseProps {
         value: number;
         label?: string;
     }[];
+    prefix?: ReactNode;
+    suffix?: ReactNode;
 }
 interface SliderSingleProps extends SliderBaseProps {
     range?: false;
@@ -186,6 +196,19 @@ type SliderProps = SliderSingleProps | SliderRangeProps;
 declare const Slider: react.ForwardRefExoticComponent<SliderProps & react.RefAttributes<HTMLInputElement>>;
+interface MultiSwitchProps<V = string> extends InputBaseProps {
+    list: InputOption<V>[];
+    value?: V;
+    defaultValue?: V;
+    onValueChange?: (value: V) => void;
+    linear?: boolean;
+}
+declare function MultiSwitch<V = string>({ size, dirty, error, label, description, required, disabled, className, id, name, list, value: controlledValue, defaultValue, onValueChange, linear, }: MultiSwitchProps<V>): react_jsx_runtime.JSX.Element;
+declare namespace MultiSwitch {
+    var displayName: string;
+}
 interface DatePickerBaseProps extends InputBaseProps {
     min?: string;
     max?: string;
@@ -207,6 +230,7 @@ type DatePickerProps = DatePickerSingleProps | DatePickerRangeProps;
 declare const DatePicker: react.ForwardRefExoticComponent<DatePickerProps & react.RefAttributes<HTMLInputElement>>;
+type CarouselVariant = "directional" | "wizard";
 interface CarouselContextValue {
     activeIndex: number;
     totalSlides: number;
@@ -214,22 +238,36 @@ interface CarouselContextValue {
     prev: () => void;
     goTo: (index: number) => void;
     registerSlides: (count: number) => void;
+    variant: CarouselVariant;
+    loop: boolean;
+    slideNames: string[];
+    registerSlideNames: (names: string[]) => void;
+    onFinish?: () => void;
+    headless: boolean;
 }
 interface CarouselProps {
     children: ReactNode;
     defaultIndex?: number;
+    activeIndex?: number;
+    onIndexChange?: (index: number) => void;
     className?: string;
     autoPlay?: boolean;
     interval?: number;
+    loop?: boolean;
+    variant?: CarouselVariant;
+    headless?: boolean;
+    onFinish?: () => void;
 }
 interface CarouselSlideProps {
     children: ReactNode;
     className?: string;
+    name?: string;
 }
 interface CarouselControlsProps {
     className?: string;
     prevLabel?: ReactNode;
     nextLabel?: ReactNode;
+    finishLabel?: ReactNode;
 }
 interface CarouselStepsProps {
     className?: string;
@@ -237,36 +275,30 @@ interface CarouselStepsProps {
 interface CarouselPanelsProps {
     children: ReactNode;
     className?: string;
+    transition?: "none" | "fade";
 }
-declare function CarouselPanels({ children, className }: CarouselPanelsProps): react_jsx_runtime.JSX.Element;
-declare function CarouselSlide({ children, className }: CarouselSlideProps): react_jsx_runtime.JSX.Element;
-declare function CarouselControls({ className, prevLabel, nextLabel, }: CarouselControlsProps): react_jsx_runtime.JSX.Element;
-declare function CarouselSteps({ className }: CarouselStepsProps): react_jsx_runtime.JSX.Element;
-declare function CarouselRoot({ children, defaultIndex, className, }: CarouselProps): react_jsx_runtime.JSX.Element;
-declare const Carousel: typeof CarouselRoot & {
-    Panels: typeof CarouselPanels;
-    Slide: typeof CarouselSlide;
-    Controls: typeof CarouselControls;
-    Steps: typeof CarouselSteps;
+declare const Carousel: react.ForwardRefExoticComponent<CarouselProps & react.RefAttributes<HTMLDivElement>> & {
+    Panels: react.ForwardRefExoticComponent<CarouselPanelsProps & react.RefAttributes<HTMLDivElement>>;
+    Slide: react.ForwardRefExoticComponent<CarouselSlideProps & react.RefAttributes<HTMLDivElement>>;
+    Controls: react.ForwardRefExoticComponent<CarouselControlsProps & react.RefAttributes<HTMLDivElement>>;
+    Steps: react.ForwardRefExoticComponent<CarouselStepsProps & react.RefAttributes<HTMLDivElement>>;
 };
 declare function useCarousel(): CarouselContextValue;
 interface ColorPickerProps {
-    value?: Color;
-    defaultValue?: Color;
-    onChange?: (color: Color) => void;
-    colors?: Color[];
+    value?: string;
+    defaultValue?: string;
+    onChange?: (color: string) => void;
+    presets?: string[];
     size?: "sm" | "md" | "lg";
+    variant?: "outline" | "filled";
+    disabled?: boolean;
     className?: string;
 }
-declare function ColorPicker({ value, defaultValue, onChange, colors, size, className, }: ColorPickerProps): react_jsx_runtime.JSX.Element;
+declare const ColorPicker: react.ForwardRefExoticComponent<ColorPickerProps & react.RefAttributes<HTMLDivElement>>;
 interface EmojiProps {
     name?: string;
@@ -303,6 +335,15 @@ interface TableRowProps {
     children: ReactNode;
     className?: string;
     onClick?: () => void;
+    tray?: ReactNode;
+    trayTriggerPosition?: "start" | "end" | "hidden";
+    expanded?: boolean;
+    defaultExpanded?: boolean;
+    onExpandedChange?: (expanded: boolean) => void;
+}
+interface TableRowTrayProps {
+    children: ReactNode;
+    className?: string;
 }
 interface TableCellProps {
     children: ReactNode;
@@ -332,7 +373,7 @@ declare function TableHead({ children, className }: TableHeadProps): react_jsx_r
 declare function TableBody({ children, className }: TableBodyProps): react_jsx_runtime.JSX.Element;
-declare function TableRow({ children, className, onClick }: TableRowProps): react_jsx_runtime.JSX.Element;
+declare function TableRow({ children, className, onClick, tray, trayTriggerPosition, expanded: controlledExpanded, defaultExpanded, onExpandedChange, }: TableRowProps): react_jsx_runtime.JSX.Element;
 declare function TableCell({ children, className, header }: TableCellProps): react_jsx_runtime.JSX.Element;
@@ -344,6 +385,8 @@ declare function TableSearch({ className, placeholder, }: TableSearchProps): rea
 declare function TableTray({ children, className }: TableTrayProps): react_jsx_runtime.JSX.Element;
+declare function TableRowTray({ children, className }: TableRowTrayProps): react_jsx_runtime.JSX.Element;
 declare function TableRoot({ children, className }: TableProps): react_jsx_runtime.JSX.Element;
 declare const Table: typeof TableRoot & {
     Head: typeof TableHead;
@@ -354,11 +397,1615 @@ declare const Table: typeof TableRoot & {
     Pagination: typeof TablePagination;
     Search: typeof TableSearch;
     Tray: typeof TableTray;
+    RowTray: typeof TableRowTray;
 };
-declare function cn(...inputs: ClassValue[]): string;
+interface PortalProps {
+    children: ReactNode;
+    container?: HTMLElement;
+}
+declare function Portal({ children, container }: PortalProps): react.ReactPortal | null;
-declare function useControllableState<T>(controlledValue: T | undefined, defaultValue: T, onChange?: (value: T) => void): [T, (value: T | ((prev: T) => T)) => void];
+interface HeadingProps extends HTMLAttributes<HTMLHeadingElement> {
+    /** Which heading element to render */
+    as?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+    /** Text size */
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl";
+    /** Font weight */
+    weight?: "normal" | "medium" | "semibold" | "bold";
+}
+declare const Heading: react.ForwardRefExoticComponent<HeadingProps & react.RefAttributes<HTMLHeadingElement>>;
+interface TextProps extends HTMLAttributes<HTMLElement> {
+    /** Which element to render */
+    as?: "p" | "span" | "div" | "label";
+    /** Text size */
+    size?: "xs" | "sm" | "md" | "lg";
+    /** Font weight */
+    weight?: "normal" | "medium" | "semibold" | "bold";
+    /** Text color preset */
+    color?: "default" | "muted" | "accent" | "danger" | "success";
+}
+declare const Text: react.ForwardRefExoticComponent<TextProps & react.RefAttributes<HTMLElement>>;
+interface SeparatorProps {
+    /** Separator direction */
+    orientation?: "horizontal" | "vertical";
+    /** Optional centered label text */
+    label?: string;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const Separator: react.ForwardRefExoticComponent<SeparatorProps & react.RefAttributes<HTMLDivElement>>;
+interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Badge color */
+    color?: "zinc" | "red" | "blue" | "green" | "amber" | "violet" | "rose";
+    /** Visual variant */
+    variant?: "solid" | "outline" | "soft";
+    /** Badge size */
+    size?: "sm" | "md" | "lg";
+    /** Show a small dot indicator before text */
+    dot?: boolean;
+}
+declare const Badge: react.ForwardRefExoticComponent<BadgeProps & react.RefAttributes<HTMLSpanElement>>;
+interface IconProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Icon container size */
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    /** Icon name to resolve from the registered icon set (e.g., "rocket", "arrow-right") */
+    name?: string;
+    /** Which registered icon set to use (defaults to the configured default) */
+    iconSet?: string;
+}
+declare const Icon: react.ForwardRefExoticComponent<IconProps & react.RefAttributes<HTMLSpanElement>>;
+interface IconSet {
+    resolve: (name: string) => ComponentType<{
+        className?: string;
+        size?: number;
+    }> | null;
+}
+declare function registerIconSet(name: string, set: IconSet): void;
+declare function configureIcons(options: {
+    defaultSet?: string;
+}): void;
+interface AvatarProps {
+    /** Image source URL */
+    src?: string;
+    /** Alt text for the image */
+    alt?: string;
+    /** Fallback initials when no image is provided */
+    fallback?: string;
+    /** Avatar size */
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    /** Online status indicator */
+    status?: "online" | "offline" | "busy" | "away";
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const Avatar: react.ForwardRefExoticComponent<AvatarProps & react.RefAttributes<HTMLDivElement>>;
+interface SkeletonProps {
+    /** Shape of the skeleton placeholder */
+    shape?: "rect" | "circle" | "text";
+    /** Custom width (CSS value or number in px) */
+    width?: string | number;
+    /** Custom height (CSS value or number in px) */
+    height?: string | number;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const Skeleton: react.ForwardRefExoticComponent<SkeletonProps & react.RefAttributes<HTMLDivElement>>;
+interface ProgressProps {
+    value?: number;
+    max?: number;
+    variant?: "bar" | "circular";
+    size?: "sm" | "md" | "lg";
+    color?: "blue" | "green" | "amber" | "red" | "violet" | "zinc";
+    indeterminate?: boolean;
+    showValue?: boolean;
+    className?: string;
+}
+declare const Progress: react.ForwardRefExoticComponent<ProgressProps & react.RefAttributes<HTMLDivElement>>;
+interface BrandProps {
+    logo?: ReactNode;
+    name?: string;
+    tagline?: string;
+    size?: "sm" | "md" | "lg";
+    className?: string;
+}
+declare const Brand: react.ForwardRefExoticComponent<BrandProps & react.RefAttributes<HTMLDivElement>>;
+interface ProfileProps {
+    src?: string;
+    alt?: string;
+    fallback?: string;
+    name: string;
+    subtitle?: string;
+    size?: "sm" | "md" | "lg";
+    status?: "online" | "offline" | "busy" | "away";
+    className?: string;
+}
+declare const Profile: react.ForwardRefExoticComponent<ProfileProps & react.RefAttributes<HTMLDivElement>>;
+interface CardProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: "outlined" | "elevated" | "flat";
+    padding?: "none" | "sm" | "md" | "lg";
+}
+interface CardHeaderProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface CardBodyProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface CardFooterProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare const Card: react.ForwardRefExoticComponent<CardProps & react.RefAttributes<HTMLDivElement>> & {
+    Header: react.ForwardRefExoticComponent<CardHeaderProps & react.RefAttributes<HTMLDivElement>>;
+    Body: react.ForwardRefExoticComponent<CardBodyProps & react.RefAttributes<HTMLDivElement>>;
+    Footer: react.ForwardRefExoticComponent<CardFooterProps & react.RefAttributes<HTMLDivElement>>;
+};
+interface CalloutProps {
+    children: ReactNode;
+    color?: "blue" | "green" | "amber" | "red" | "zinc";
+    icon?: ReactNode;
+    dismissible?: boolean;
+    onDismiss?: () => void;
+    className?: string;
+}
+declare const Callout: react.ForwardRefExoticComponent<CalloutProps & react.RefAttributes<HTMLDivElement>>;
+interface TimelineProps {
+    children: ReactNode;
+    className?: string;
+}
+interface TimelineItemProps {
+    children: ReactNode;
+    icon?: ReactNode;
+    color?: "blue" | "green" | "amber" | "red" | "zinc";
+    active?: boolean;
+    className?: string;
+}
+interface TimelineBlockProps {
+    /** Block heading */
+    heading?: ReactNode;
+    /** Block description / body content */
+    children: ReactNode;
+    /** Optional icon displayed in the timeline dot */
+    icon?: ReactNode;
+    /** Dot/icon color */
+    color?: "blue" | "green" | "amber" | "red" | "zinc";
+    /** Whether this block is the active/current step */
+    active?: boolean;
+    className?: string;
+}
+declare const Timeline: react.ForwardRefExoticComponent<TimelineProps & react.RefAttributes<HTMLDivElement>> & {
+    Item: react.ForwardRefExoticComponent<TimelineItemProps & react.RefAttributes<HTMLDivElement>>;
+    Block: react.ForwardRefExoticComponent<TimelineBlockProps & react.RefAttributes<HTMLDivElement>>;
+};
+interface TooltipProps {
+    children: ReactElement;
+    content: ReactNode;
+    placement?: Placement;
+    delay?: number;
+    offset?: number;
+    className?: string;
+}
+declare const Tooltip: react.ForwardRefExoticComponent<TooltipProps & react.RefAttributes<HTMLDivElement>>;
+interface PopoverContextValue {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    anchorRef: React.RefObject<HTMLElement | null>;
+    placement: Placement;
+    offset: number;
+}
+interface PopoverProps {
+    children: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placement?: Placement;
+    offset?: number;
+}
+interface PopoverTriggerProps {
+    children: ReactNode;
+    className?: string;
+}
+interface PopoverContentProps {
+    children: ReactNode;
+    className?: string;
+}
+declare function PopoverTrigger({ children }: PopoverTriggerProps): ReactElement<Record<string, unknown>, string | react.JSXElementConstructor<any>>;
+declare namespace PopoverTrigger {
+    var displayName: string;
+}
+declare function PopoverContent({ children, className }: PopoverContentProps): react_jsx_runtime.JSX.Element | null;
+declare namespace PopoverContent {
+    var displayName: string;
+}
+declare function PopoverRoot({ children, open: controlledOpen, defaultOpen, onOpenChange, placement, offset, }: PopoverProps): react_jsx_runtime.JSX.Element;
+declare const Popover: typeof PopoverRoot & {
+    Trigger: typeof PopoverTrigger;
+    Content: typeof PopoverContent;
+};
+declare function usePopover(): PopoverContextValue;
+interface DropdownContextValue {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    anchorRef: React.RefObject<HTMLElement | null>;
+    activeIndex: number;
+    setActiveIndex: (index: number) => void;
+    placement: Placement;
+    offset: number;
+}
+interface DropdownProps {
+    children: ReactNode;
+    placement?: Placement;
+    offset?: number;
+}
+interface DropdownTriggerProps {
+    children: ReactNode;
+}
+interface DropdownItemsProps {
+    children: ReactNode;
+    className?: string;
+}
+interface DropdownItemProps {
+    children: ReactNode;
+    onClick?: () => void;
+    disabled?: boolean;
+    danger?: boolean;
+    className?: string;
+}
+interface DropdownSeparatorProps {
+    className?: string;
+}
+declare function DropdownTrigger({ children }: DropdownTriggerProps): ReactElement<Record<string, unknown>, string | react.JSXElementConstructor<any>>;
+declare namespace DropdownTrigger {
+    var displayName: string;
+}
+declare function DropdownItems({ children, className }: DropdownItemsProps): react_jsx_runtime.JSX.Element | null;
+declare namespace DropdownItems {
+    var displayName: string;
+}
+declare function DropdownItem({ children, onClick, disabled, danger, className, }: DropdownItemProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownItem {
+    var displayName: string;
+}
+declare function DropdownSeparator({ className }: DropdownSeparatorProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownSeparator {
+    var displayName: string;
+}
+declare function DropdownRoot({ children, placement, offset, }: DropdownProps): react_jsx_runtime.JSX.Element;
+declare const Dropdown: typeof DropdownRoot & {
+    Trigger: typeof DropdownTrigger;
+    Items: typeof DropdownItems;
+    Item: typeof DropdownItem;
+    Separator: typeof DropdownSeparator;
+};
+declare function useDropdown(): DropdownContextValue;
+interface ContextMenuContextValue {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+interface ContextMenuProps {
+    children: ReactNode;
+}
+interface ContextMenuTriggerProps {
+    children: ReactNode;
+    className?: string;
+}
+interface ContextMenuContentProps {
+    children: ReactNode;
+    className?: string;
+}
+interface ContextMenuItemProps {
+    children: ReactNode;
+    onClick?: () => void;
+    disabled?: boolean;
+    danger?: boolean;
+    className?: string;
+}
+interface ContextMenuSeparatorProps {
+    className?: string;
+}
+declare function ContextMenuTrigger({ children, className, }: ContextMenuTriggerProps): react_jsx_runtime.JSX.Element;
+declare namespace ContextMenuTrigger {
+    var displayName: string;
+}
+declare function ContextMenuContent({ children, className, }: ContextMenuContentProps): react_jsx_runtime.JSX.Element | null;
+declare namespace ContextMenuContent {
+    var displayName: string;
+}
+declare function ContextMenuItem({ children, onClick, disabled, danger, className, }: ContextMenuItemProps): react_jsx_runtime.JSX.Element;
+declare namespace ContextMenuItem {
+    var displayName: string;
+}
+declare function ContextMenuSeparator({ className }: ContextMenuSeparatorProps): react_jsx_runtime.JSX.Element;
+declare namespace ContextMenuSeparator {
+    var displayName: string;
+}
+declare function ContextMenuRoot({ children }: ContextMenuProps): react_jsx_runtime.JSX.Element;
+declare const ContextMenu: typeof ContextMenuRoot & {
+    Trigger: typeof ContextMenuTrigger;
+    Content: typeof ContextMenuContent;
+    Item: typeof ContextMenuItem;
+    Separator: typeof ContextMenuSeparator;
+};
+declare function useContextMenu(): ContextMenuContextValue;
+interface ModalContextValue {
+    open: boolean;
+    close: () => void;
+}
+interface ModalProps {
+    children: ReactNode;
+    open: boolean;
+    onClose: () => void;
+    size?: "sm" | "md" | "lg" | "xl" | "full";
+    className?: string;
+}
+interface ModalHeaderProps {
+    children: ReactNode;
+    className?: string;
+}
+interface ModalBodyProps {
+    children: ReactNode;
+    className?: string;
+}
+interface ModalFooterProps {
+    children: ReactNode;
+    className?: string;
+}
+declare function ModalHeader({ children, className }: ModalHeaderProps): react_jsx_runtime.JSX.Element;
+declare namespace ModalHeader {
+    var displayName: string;
+}
+declare function ModalBody({ children, className }: ModalBodyProps): react_jsx_runtime.JSX.Element;
+declare namespace ModalBody {
+    var displayName: string;
+}
+declare function ModalFooter({ children, className }: ModalFooterProps): react_jsx_runtime.JSX.Element;
+declare namespace ModalFooter {
+    var displayName: string;
+}
+declare function ModalRoot({ children, open, onClose, size, className, }: ModalProps): react_jsx_runtime.JSX.Element | null;
+declare const Modal: typeof ModalRoot & {
+    Header: typeof ModalHeader;
+    Body: typeof ModalBody;
+    Footer: typeof ModalFooter;
+};
+declare function useModal(): ModalContextValue;
+type ToastVariant = "default" | "success" | "error" | "warning" | "info";
+type ToastPosition = "top-right" | "top-left" | "bottom-right" | "bottom-left";
+interface ToastData {
+    id: string;
+    title: string;
+    description?: string;
+    variant?: ToastVariant;
+    duration?: number;
+}
+interface ToastContextValue {
+    toasts: ToastData[];
+    toast: (data: Omit<ToastData, "id">) => string;
+    dismiss: (id: string) => void;
+}
+interface ToastProviderProps {
+    children: ReactNode;
+    position?: ToastPosition;
+    maxToasts?: number;
+}
+declare function ToastProvider({ children, position, maxToasts, }: ToastProviderProps): react_jsx_runtime.JSX.Element;
+declare const Toast: {
+    Provider: typeof ToastProvider;
+};
+declare function useToast(): ToastContextValue;
+interface CommandContextValue {
+    open: boolean;
+    close: () => void;
+    query: string;
+    setQuery: (query: string) => void;
+    activeIndex: number;
+    setActiveIndex: (index: number) => void;
+}
+interface CommandProps {
+    children: ReactNode;
+    open: boolean;
+    onClose: () => void;
+    className?: string;
+}
+interface CommandInputProps {
+    placeholder?: string;
+    className?: string;
+}
+interface CommandListProps {
+    children: ReactNode;
+    className?: string;
+}
+interface CommandItemProps {
+    children: ReactNode;
+    value?: string;
+    onSelect?: () => void;
+    className?: string;
+}
+interface CommandGroupProps {
+    children: ReactNode;
+    heading?: string;
+    className?: string;
+}
+interface CommandEmptyProps {
+    children?: ReactNode;
+    className?: string;
+}
+declare function CommandInput({ placeholder, className, }: CommandInputProps): react_jsx_runtime.JSX.Element;
+declare namespace CommandInput {
+    var displayName: string;
+}
+declare function CommandList({ children, className }: CommandListProps): react_jsx_runtime.JSX.Element;
+declare namespace CommandList {
+    var displayName: string;
+}
+declare function CommandItem({ children, value, onSelect, className, }: CommandItemProps): react_jsx_runtime.JSX.Element | null;
+declare namespace CommandItem {
+    var displayName: string;
+}
+declare function CommandGroup({ children, heading, className, }: CommandGroupProps): react_jsx_runtime.JSX.Element;
+declare namespace CommandGroup {
+    var displayName: string;
+}
+declare function CommandEmpty({ children, className, }: CommandEmptyProps): react_jsx_runtime.JSX.Element;
+declare namespace CommandEmpty {
+    var displayName: string;
+}
+declare function CommandRoot({ children, open, onClose, className }: CommandProps): react_jsx_runtime.JSX.Element | null;
+declare const Command: typeof CommandRoot & {
+    Input: typeof CommandInput;
+    List: typeof CommandList;
+    Item: typeof CommandItem;
+    Group: typeof CommandGroup;
+    Empty: typeof CommandEmpty;
+};
+declare function useCommand(): CommandContextValue;
+type TabsVariant = "underline" | "pills" | "boxed";
+interface TabsContextValue {
+    activeTab: string;
+    setActiveTab: (tab: string) => void;
+    variant: TabsVariant;
+}
+interface TabsProps {
+    children: ReactNode;
+    defaultTab?: string;
+    activeTab?: string;
+    onTabChange?: (tab: string) => void;
+    variant?: TabsVariant;
+    className?: string;
+}
+interface TabsListProps {
+    children: ReactNode;
+    className?: string;
+}
+interface TabsTabProps {
+    children: ReactNode;
+    value: string;
+    disabled?: boolean;
+    className?: string;
+}
+interface TabsPanelsProps {
+    children: ReactNode;
+    className?: string;
+}
+interface TabsPanelProps {
+    children: ReactNode;
+    value: string;
+    className?: string;
+}
+declare function TabsList({ children, className }: TabsListProps): react_jsx_runtime.JSX.Element;
+declare namespace TabsList {
+    var displayName: string;
+}
+declare function TabsTab({ children, value, disabled, className, }: TabsTabProps): react_jsx_runtime.JSX.Element;
+declare namespace TabsTab {
+    var displayName: string;
+}
+declare function TabsPanels({ children, className }: TabsPanelsProps): react_jsx_runtime.JSX.Element;
+declare namespace TabsPanels {
+    var displayName: string;
+}
+declare function TabsPanel({ children, value, className }: TabsPanelProps): react_jsx_runtime.JSX.Element | null;
+declare namespace TabsPanel {
+    var displayName: string;
+}
+declare function TabsRoot({ children, defaultTab, activeTab: controlledTab, onTabChange, variant, className, }: TabsProps): react_jsx_runtime.JSX.Element;
+declare const Tabs: typeof TabsRoot & {
+    List: typeof TabsList;
+    Tab: typeof TabsTab;
+    Panels: typeof TabsPanels;
+    Panel: typeof TabsPanel;
+};
+declare function useTabs(): TabsContextValue;
+interface AccordionContextValue {
+    openItems: string[];
+    toggle: (value: string) => void;
+    multiple: boolean;
+}
+interface AccordionProps {
+    children: ReactNode;
+    type?: "single" | "multiple";
+    defaultOpen?: string[];
+    className?: string;
+}
+interface AccordionItemProps {
+    children: ReactNode;
+    value: string;
+    className?: string;
+}
+interface AccordionTriggerProps {
+    children: ReactNode;
+    className?: string;
+}
+interface AccordionContentProps {
+    children: ReactNode;
+    className?: string;
+}
+declare function AccordionItem({ children, value, className, }: AccordionItemProps): react_jsx_runtime.JSX.Element;
+declare namespace AccordionItem {
+    var displayName: string;
+}
+declare function AccordionTrigger({ children, className, }: AccordionTriggerProps): react_jsx_runtime.JSX.Element;
+declare namespace AccordionTrigger {
+    var displayName: string;
+}
+declare function AccordionContent({ children, className, }: AccordionContentProps): react_jsx_runtime.JSX.Element;
+declare namespace AccordionContent {
+    var displayName: string;
+}
+declare function AccordionRoot({ children, type, defaultOpen, className, }: AccordionProps): react_jsx_runtime.JSX.Element;
+declare const Accordion: typeof AccordionRoot & {
+    Item: typeof AccordionItem;
+    Trigger: typeof AccordionTrigger;
+    Content: typeof AccordionContent;
+};
+declare function useAccordion(): AccordionContextValue;
+interface BreadcrumbsProps {
+    children: ReactNode;
+    separator?: ReactNode;
+    shrink?: boolean;
+    className?: string;
+}
+interface BreadcrumbsItemProps {
+    children: ReactNode;
+    href?: string;
+    active?: boolean;
+    className?: string;
+}
+declare function BreadcrumbsItem({ children, href, active, className, }: BreadcrumbsItemProps): react_jsx_runtime.JSX.Element;
+declare namespace BreadcrumbsItem {
+    var displayName: string;
+}
+declare function BreadcrumbsRoot({ children, separator, shrink, className, }: BreadcrumbsProps): react_jsx_runtime.JSX.Element;
+declare const Breadcrumbs: typeof BreadcrumbsRoot & {
+    Item: typeof BreadcrumbsItem;
+};
+interface NavbarContextValue {
+    mobileOpen: boolean;
+    setMobileOpen: (open: boolean) => void;
+}
+interface NavbarProps {
+    children: ReactNode;
+    className?: string;
+}
+interface NavbarBrandProps {
+    children: ReactNode;
+    className?: string;
+}
+interface NavbarItemsProps {
+    children: ReactNode;
+    className?: string;
+}
+interface NavbarItemProps {
+    children: ReactNode;
+    href?: string;
+    active?: boolean;
+    className?: string;
+}
+interface NavbarToggleProps {
+    className?: string;
+}
+declare function NavbarBrand({ children, className }: NavbarBrandProps): react_jsx_runtime.JSX.Element;
+declare namespace NavbarBrand {
+    var displayName: string;
+}
+declare function NavbarItems({ children, className }: NavbarItemsProps): react_jsx_runtime.JSX.Element;
+declare namespace NavbarItems {
+    var displayName: string;
+}
+declare function NavbarItem({ children, href, active, className, }: NavbarItemProps): react_jsx_runtime.JSX.Element;
+declare namespace NavbarItem {
+    var displayName: string;
+}
+declare function NavbarToggle({ className }: NavbarToggleProps): react_jsx_runtime.JSX.Element;
+declare namespace NavbarToggle {
+    var displayName: string;
+}
+declare function NavbarRoot({ children, className }: NavbarProps): react_jsx_runtime.JSX.Element;
+declare const Navbar: typeof NavbarRoot & {
+    Brand: typeof NavbarBrand;
+    Items: typeof NavbarItems;
+    Item: typeof NavbarItem;
+    Toggle: typeof NavbarToggle;
+};
+declare function useNavbar(): NavbarContextValue;
+interface PaginationProps {
+    page: number;
+    onPageChange: (page: number) => void;
+    totalPages: number;
+    siblingCount?: number;
+    className?: string;
+}
+declare function Pagination({ page, onPageChange, totalPages, siblingCount, className, }: PaginationProps): react_jsx_runtime.JSX.Element | null;
+declare namespace Pagination {
+    var displayName: string;
+}
+interface AutocompleteOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+interface AutocompleteProps {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onSearch?: (query: string) => void;
+    options: AutocompleteOption[];
+    placeholder?: string;
+    loading?: boolean;
+    emptyMessage?: ReactNode;
+    disabled?: boolean;
+    className?: string;
+}
+declare const Autocomplete: react.ForwardRefExoticComponent<AutocompleteProps & react.RefAttributes<HTMLInputElement>>;
+interface PillboxProps {
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (values: string[]) => void;
+    placeholder?: string;
+    maxItems?: number;
+    disabled?: boolean;
+    className?: string;
+}
+declare const Pillbox: react.ForwardRefExoticComponent<PillboxProps & react.RefAttributes<HTMLDivElement>>;
+interface OtpInputProps {
+    length?: number;
+    value?: string;
+    onChange?: (value: string) => void;
+    disabled?: boolean;
+    autoFocus?: boolean;
+    className?: string;
+}
+declare const OtpInput: react.ForwardRefExoticComponent<OtpInputProps & react.RefAttributes<HTMLDivElement>>;
+interface FileUploadContextValue {
+    files: File[];
+    addFiles: (files: FileList | File[]) => void;
+    removeFile: (index: number) => void;
+    disabled: boolean;
+}
+interface FileUploadProps {
+    children: ReactNode;
+    value?: File[];
+    onChange?: (files: File[]) => void;
+    accept?: string;
+    multiple?: boolean;
+    maxFiles?: number;
+    maxSize?: number;
+    disabled?: boolean;
+    className?: string;
+}
+interface FileUploadDropzoneProps {
+    children?: ReactNode;
+    className?: string;
+}
+interface FileUploadListProps {
+    thumbnail?: boolean;
+    className?: string;
+}
+declare function FileUploadDropzone({ children, className, }: FileUploadDropzoneProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadDropzone {
+    var displayName: string;
+}
+declare function FileUploadList({ thumbnail, className }: FileUploadListProps): react_jsx_runtime.JSX.Element | null;
+declare namespace FileUploadList {
+    var displayName: string;
+}
+declare function FileUploadRoot({ children, value, onChange, maxFiles, maxSize, disabled, className, }: FileUploadProps): react_jsx_runtime.JSX.Element;
+declare const FileUpload: typeof FileUploadRoot & {
+    Dropzone: typeof FileUploadDropzone;
+    List: typeof FileUploadList;
+};
+declare function useFileUpload(): FileUploadContextValue;
+interface TimePickerProps {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    format?: "12h" | "24h";
+    minuteStep?: number;
+    disabled?: boolean;
+    className?: string;
+}
+declare const TimePicker: react.ForwardRefExoticComponent<TimePickerProps & react.RefAttributes<HTMLDivElement>>;
+type CalendarMode = "single" | "range" | "multiple";
+interface DateRange {
+    start: Date | null;
+    end: Date | null;
+}
+interface CalendarProps {
+    mode?: CalendarMode;
+    value?: Date | Date[] | DateRange | null;
+    onChange?: (value: Date | Date[] | DateRange | null) => void;
+    minDate?: Date;
+    maxDate?: Date;
+    disabledDates?: Date[];
+    className?: string;
+}
+declare const Calendar: react.ForwardRefExoticComponent<CalendarProps & react.RefAttributes<HTMLDivElement>>;
+interface ComposerProps {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onSubmit?: (value: string) => void;
+    placeholder?: string;
+    actions?: ReactNode;
+    disabled?: boolean;
+    className?: string;
+}
+declare const Composer: react.ForwardRefExoticComponent<ComposerProps & react.RefAttributes<HTMLDivElement>>;
+interface ChartBarData {
+    label: string;
+    value: number;
+    color?: string;
+}
+interface ChartBarProps {
+    data: ChartBarData[];
+    height?: number;
+    showValues?: boolean;
+    className?: string;
+}
+interface ChartDonutData {
+    label: string;
+    value: number;
+    color?: string;
+}
+interface ChartDonutProps {
+    data: ChartDonutData[];
+    size?: number;
+    strokeWidth?: number;
+    showLegend?: boolean;
+    className?: string;
+}
+interface ChartSeries {
+    label: string;
+    data: number[];
+    color?: string;
+}
+interface ChartCommonProps {
+    className?: string;
+    height?: number;
+    xAxis?: boolean | {
+        label?: string;
+        tickCount?: number;
+    };
+    yAxis?: boolean | {
+        label?: string;
+        tickCount?: number;
+    };
+    grid?: boolean | {
+        horizontal?: boolean;
+        vertical?: boolean;
+    };
+    tooltip?: boolean;
+    animate?: boolean;
+    responsive?: boolean;
+}
+interface ChartLineProps extends ChartCommonProps {
+    labels: string[];
+    series: ChartSeries[];
+    curve?: "linear" | "monotone";
+    showDots?: boolean;
+    fill?: boolean;
+    fillOpacity?: number;
+}
+type ChartAreaProps = Omit<ChartLineProps, "fill">;
+interface ChartPieData {
+    label: string;
+    value: number;
+    color?: string;
+}
+interface ChartPieProps {
+    data: ChartPieData[];
+    size?: number;
+    showLabels?: boolean;
+    tooltip?: boolean;
+    className?: string;
+}
+interface ChartSparklineProps {
+    data: number[];
+    width?: number;
+    height?: number;
+    color?: string;
+    className?: string;
+}
+interface ChartHorizontalBarProps {
+    data: ChartBarData[];
+    height?: number;
+    showValues?: boolean;
+    className?: string;
+}
+interface ChartStackedBarProps extends ChartCommonProps {
+    labels: string[];
+    series: ChartSeries[];
+}
+declare function ChartBar({ data, height, showValues, className, }: ChartBarProps): react_jsx_runtime.JSX.Element;
+declare namespace ChartBar {
+    var displayName: string;
+}
+declare function ChartDonut({ data, size, strokeWidth, showLegend, className, }: ChartDonutProps): react_jsx_runtime.JSX.Element;
+declare namespace ChartDonut {
+    var displayName: string;
+}
+declare function ChartLine({ labels, series, height, curve, showDots, fill, fillOpacity, xAxis, yAxis, grid, tooltip, animate, responsive, className, }: ChartLineProps): react_jsx_runtime.JSX.Element;
+declare namespace ChartLine {
+    var displayName: string;
+}
+declare function ChartArea(props: ChartAreaProps): react_jsx_runtime.JSX.Element;
+declare namespace ChartArea {
+    var displayName: string;
+}
+declare function ChartPie({ data, size, showLabels, tooltip, className, }: ChartPieProps): react_jsx_runtime.JSX.Element;
+declare namespace ChartPie {
+    var displayName: string;
+}
+declare function ChartSparkline({ data, width, height, color, className, }: ChartSparklineProps): react_jsx_runtime.JSX.Element;
+declare namespace ChartSparkline {
+    var displayName: string;
+}
+declare function ChartHorizontalBar({ data, height, showValues, className, }: ChartHorizontalBarProps): react_jsx_runtime.JSX.Element;
+declare namespace ChartHorizontalBar {
+    var displayName: string;
+}
+declare function ChartStackedBar({ labels, series, height, xAxis, yAxis, grid, tooltip, responsive, className, }: ChartStackedBarProps): react_jsx_runtime.JSX.Element;
+declare namespace ChartStackedBar {
+    var displayName: string;
+}
+declare const Chart: {
+    Bar: typeof ChartBar;
+    Donut: typeof ChartDonut;
+    Line: typeof ChartLine;
+    Area: typeof ChartArea;
+    Pie: typeof ChartPie;
+    Sparkline: typeof ChartSparkline;
+    HorizontalBar: typeof ChartHorizontalBar;
+    StackedBar: typeof ChartStackedBar;
+};
+/** Props passed to every render-extension component. */
+interface RenderExtensionProps {
+    /** The inner content of the custom tag (raw string). */
+    content: string;
+    /** Parsed HTML attributes from the opening tag. */
+    attributes: Record<string, string>;
+}
+/** Registers a custom tag with a React component for rendering. */
+interface RenderExtension {
+    /** Tag name to match, e.g. "questions", "thinking". Case-insensitive. */
+    tag: string;
+    /** React component that renders the matched tag. */
+    component: ComponentType<RenderExtensionProps>;
+    /**
+     * Whether this is a block-level element.
+     * Block extensions are wrapped in a `<div>`, inline in a `<span>`.
+     * @default true
+     */
+    block?: boolean;
+}
+/** Register a single render extension globally (available to all ContentRenderer and Editor instances). */
+declare function registerExtension(extension: RenderExtension): void;
+/** Register multiple render extensions globally. */
+declare function registerExtensions(extensions: RenderExtension[]): void;
+interface EditorAction {
+    icon: ReactNode;
+    label: string;
+    command: string;
+    commandArg?: string;
+    active?: boolean;
+}
+interface EditorToolbarProps {
+    actions?: EditorAction[];
+    onAction?: (command: string) => void;
+    children?: ReactNode;
+    className?: string;
+}
+interface EditorContentProps {
+    className?: string;
+}
+interface EditorProps {
+    children: ReactNode;
+    className?: string;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    outputFormat?: "html" | "markdown";
+    lineSpacing?: number;
+    placeholder?: string;
+    /** Per-instance render extensions. Merged with any globally-registered extensions. */
+    extensions?: RenderExtension[];
+}
+declare function EditorToolbar({ actions, onAction, children, className, }: EditorToolbarProps): react_jsx_runtime.JSX.Element;
+declare namespace EditorToolbar {
+    var displayName: string;
+}
+declare function EditorToolbarSeparator(): react_jsx_runtime.JSX.Element;
+declare namespace EditorToolbarSeparator {
+    var displayName: string;
+}
+declare function EditorContent({ className }: EditorContentProps): react_jsx_runtime.JSX.Element;
+declare namespace EditorContent {
+    var displayName: string;
+}
+declare function EditorRoot({ children, className, value: controlledValue, defaultValue, onChange, outputFormat, lineSpacing, placeholder, extensions: instanceExtensions, }: EditorProps): react_jsx_runtime.JSX.Element;
+declare const Editor: typeof EditorRoot & {
+    Toolbar: typeof EditorToolbar & {
+        Separator: typeof EditorToolbarSeparator;
+    };
+    Content: typeof EditorContent;
+};
+interface EditorContextValue {
+    contentRef: RefObject<HTMLDivElement | null>;
+    exec: (command: string, arg?: string) => void;
+    insertText: (text: string) => void;
+    wrapSelection: (before: string, after: string) => void;
+    outputFormat: "html" | "markdown";
+    lineSpacing: number;
+    placeholder?: string;
+    /** Merged render extensions (global + instance). */
+    extensions: RenderExtension[];
+    /** @internal Called by EditorContent on input events */
+    _onInput: () => void;
+}
+declare function useEditor(): EditorContextValue;
+interface ContentRendererProps {
+    value: string;
+    format?: "html" | "markdown" | "auto";
+    lineSpacing?: number;
+    className?: string;
+    /** Per-instance render extensions. Merged with any globally-registered extensions. */
+    extensions?: RenderExtension[];
+}
+declare function ContentRenderer({ value, format, lineSpacing, className, extensions: instanceExtensions, }: ContentRendererProps): react_jsx_runtime.JSX.Element;
+declare namespace ContentRenderer {
+    var displayName: string;
+}
+type MenuOrientation = "horizontal" | "vertical";
+interface MenuProps {
+    children: ReactNode;
+    orientation?: MenuOrientation;
+    className?: string;
+}
+interface MenuItemProps {
+    children: ReactNode;
+    href?: string;
+    icon?: ReactNode;
+    active?: boolean;
+    disabled?: boolean;
+    badge?: ReactNode;
+    onClick?: () => void;
+    className?: string;
+}
+interface MenuSubmenuProps {
+    children: ReactNode;
+    label: ReactNode;
+    icon?: ReactNode;
+    defaultOpen?: boolean;
+    className?: string;
+}
+interface MenuGroupProps {
+    children: ReactNode;
+    label?: string;
+    className?: string;
+}
+interface MenuContextValue {
+    orientation: MenuOrientation;
+}
+declare function MenuItem({ children, href, icon, active, disabled, badge, onClick, className, }: MenuItemProps): react_jsx_runtime.JSX.Element;
+declare namespace MenuItem {
+    var displayName: string;
+}
+declare function MenuSubmenu({ children, label, icon, defaultOpen, className, }: MenuSubmenuProps): react_jsx_runtime.JSX.Element;
+declare namespace MenuSubmenu {
+    var displayName: string;
+}
+declare function MenuGroup({ children, label, className }: MenuGroupProps): react_jsx_runtime.JSX.Element;
+declare namespace MenuGroup {
+    var displayName: string;
+}
+declare function MenuRoot({ children, orientation, className }: MenuProps): react_jsx_runtime.JSX.Element;
+declare const Menu: typeof MenuRoot & {
+    Item: typeof MenuItem;
+    Submenu: typeof MenuSubmenu;
+    Group: typeof MenuGroup;
+};
+declare function useMenu(): MenuContextValue;
+type SidebarCollapseMode = "icons" | "letters";
+interface SidebarProps {
+    children: ReactNode;
+    collapsed?: boolean;
+    defaultCollapsed?: boolean;
+    onCollapsedChange?: (collapsed: boolean) => void;
+    /**
+     * How items display when collapsed:
+     * - `"icons"` — show only the icon (falls back to first 3 letters if no icon)
+     * - `"letters"` — show the first 3 letters of the label
+     * @default "icons"
+     */
+    collapseMode?: SidebarCollapseMode;
+    className?: string;
+}
+interface SidebarItemProps {
+    children: ReactNode;
+    href?: string;
+    icon?: ReactNode;
+    active?: boolean;
+    disabled?: boolean;
+    badge?: ReactNode;
+    onClick?: () => void;
+    className?: string;
+}
+interface SidebarGroupProps {
+    children: ReactNode;
+    label?: string;
+    className?: string;
+}
+interface SidebarToggleProps {
+    className?: string;
+}
+interface SidebarSubmenuProps {
+    children: ReactNode;
+    label: string;
+    icon?: ReactNode;
+    defaultOpen?: boolean;
+    className?: string;
+}
+interface SidebarContextValue {
+    collapsed: boolean;
+    collapseMode: SidebarCollapseMode;
+    setCollapsed: (collapsed: boolean) => void;
+}
+declare function SidebarItem({ children, href, icon, active, disabled, badge, onClick, className, }: SidebarItemProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarItem {
+    var displayName: string;
+}
+declare function SidebarGroup({ children, label, className }: SidebarGroupProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarGroup {
+    var displayName: string;
+}
+declare function SidebarSubmenu({ children, label, icon, defaultOpen, className, }: SidebarSubmenuProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarSubmenu {
+    var displayName: string;
+}
+declare function SidebarToggle({ className }: SidebarToggleProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarToggle {
+    var displayName: string;
+}
+declare function SidebarRoot({ children, collapsed: controlledCollapsed, defaultCollapsed, onCollapsedChange, collapseMode, className, }: SidebarProps): react_jsx_runtime.JSX.Element;
+declare const Sidebar: typeof SidebarRoot & {
+    Item: typeof SidebarItem;
+    Group: typeof SidebarGroup;
+    Submenu: typeof SidebarSubmenu;
+    Toggle: typeof SidebarToggle;
+};
+declare function useSidebar(): SidebarContextValue;
+type MobileMenuVariant = "flyout" | "bottom-bar";
+type MobileMenuSide = "left" | "right";
+interface MobileMenuFlyoutProps {
+    children: ReactNode;
+    open: boolean;
+    onClose: () => void;
+    side?: MobileMenuSide;
+    title?: string;
+    className?: string;
+}
+interface MobileMenuBottomBarProps {
+    children: ReactNode;
+    className?: string;
+}
+interface MobileMenuItemProps {
+    children: ReactNode;
+    href?: string;
+    icon?: ReactNode;
+    active?: boolean;
+    disabled?: boolean;
+    badge?: ReactNode;
+    onClick?: () => void;
+    className?: string;
+}
+interface MobileMenuContextValue {
+    variant: MobileMenuVariant;
+}
+declare function MobileMenuFlyout({ children, open, onClose, side, title, className, }: MobileMenuFlyoutProps): react_jsx_runtime.JSX.Element | null;
+declare namespace MobileMenuFlyout {
+    var displayName: string;
+}
+declare function MobileMenuBottomBar({ children, className }: MobileMenuBottomBarProps): react_jsx_runtime.JSX.Element;
+declare namespace MobileMenuBottomBar {
+    var displayName: string;
+}
+declare function MobileMenuItem({ children, href, icon, active, disabled, badge, onClick, className, }: MobileMenuItemProps): react_jsx_runtime.JSX.Element;
+declare namespace MobileMenuItem {
+    var displayName: string;
+}
+declare const MobileMenu: {
+    Flyout: typeof MobileMenuFlyout;
+    BottomBar: typeof MobileMenuBottomBar;
+    Item: typeof MobileMenuItem;
+};
+declare function useMobileMenu(): MobileMenuContextValue;
+interface KanbanContextValue {
+    onCardMove?: (cardId: string, fromColumn: string, toColumn: string) => void;
+    draggedCard: string | null;
+    setDraggedCard: (id: string | null) => void;
+    dragSource: string | null;
+    setDragSource: (id: string | null) => void;
+}
+interface KanbanProps {
+    children: ReactNode;
+    onCardMove?: (cardId: string, fromColumn: string, toColumn: string) => void;
+    className?: string;
+}
+interface KanbanColumnProps {
+    children: ReactNode;
+    id: string;
+    title?: string;
+    className?: string;
+}
+interface KanbanCardProps {
+    children: ReactNode;
+    id: string;
+    className?: string;
+}
+declare function KanbanColumn({ children, id, title, className, }: KanbanColumnProps): react_jsx_runtime.JSX.Element;
+declare namespace KanbanColumn {
+    var displayName: string;
+}
+declare function KanbanCard({ children, id, className }: KanbanCardProps): react_jsx_runtime.JSX.Element;
+declare namespace KanbanCard {
+    var displayName: string;
+}
+/**
+ * Kanban board component (experimental).
+ * Uses HTML5 Drag and Drop API.
+ */
+declare function KanbanRoot({ children, onCardMove, className }: KanbanProps): react_jsx_runtime.JSX.Element;
+declare const Kanban: typeof KanbanRoot & {
+    Column: typeof KanbanColumn;
+    Card: typeof KanbanCard;
+};
+declare function useKanban(): KanbanContextValue;
+interface ViewportState {
+    panX: number;
+    panY: number;
+    zoom: number;
+}
+interface UsePanZoomOptions {
+    viewport: ViewportState;
+    setViewport: (vp: ViewportState | ((prev: ViewportState) => ViewportState)) => void;
+    minZoom: number;
+    maxZoom: number;
+    pannable: boolean;
+    zoomable: boolean;
+    containerRef: React.RefObject<HTMLElement | null>;
+}
+interface UsePanZoomReturn {
+    containerProps: {
+        onPointerDown: (e: React.PointerEvent) => void;
+        onPointerMove: (e: React.PointerEvent) => void;
+        onPointerUp: (e: React.PointerEvent) => void;
+    };
+    isPanning: boolean;
+}
+declare function usePanZoom({ viewport, setViewport, minZoom, maxZoom, pannable, zoomable, containerRef, }: UsePanZoomOptions): UsePanZoomReturn;
+interface NodeRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface UseNodeRegistryReturn {
+    registerNode: (id: string, rect: NodeRect) => void;
+    unregisterNode: (id: string) => void;
+    nodeRects: Map<string, NodeRect>;
+    version: number;
+}
+declare function useNodeRegistry(): UseNodeRegistryReturn;
+type EdgeAnchor = "top" | "bottom" | "left" | "right" | "center" | "auto";
+interface CanvasContextValue {
+    viewport: ViewportState;
+    setViewport: (vp: ViewportState | ((prev: ViewportState) => ViewportState)) => void;
+    registerNode: (id: string, rect: NodeRect) => void;
+    unregisterNode: (id: string) => void;
+    nodeRects: Map<string, NodeRect>;
+    registryVersion: number;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+}
+interface CanvasProps {
+    children: ReactNode;
+    viewport?: ViewportState;
+    defaultViewport?: ViewportState;
+    onViewportChange?: (viewport: ViewportState) => void;
+    minZoom?: number;
+    maxZoom?: number;
+    pannable?: boolean;
+    zoomable?: boolean;
+    gridSize?: number;
+    showGrid?: boolean;
+    className?: string;
+    style?: CSSProperties;
+}
+interface CanvasNodeProps {
+    children: ReactNode;
+    id: string;
+    x: number;
+    y: number;
+    className?: string;
+    style?: CSSProperties;
+}
+interface CanvasEdgeProps {
+    from: string;
+    to: string;
+    fromAnchor?: EdgeAnchor;
+    toAnchor?: EdgeAnchor;
+    curve?: "bezier" | "step" | "straight";
+    color?: string;
+    strokeWidth?: number;
+    dashed?: boolean;
+    animated?: boolean;
+    label?: ReactNode;
+    className?: string;
+    markerStart?: string;
+    markerEnd?: string;
+}
+interface CanvasMinimapProps {
+    width?: number;
+    height?: number;
+    className?: string;
+}
+interface CanvasControlsProps {
+    className?: string;
+    showZoomIn?: boolean;
+    showZoomOut?: boolean;
+    showReset?: boolean;
+    showFitAll?: boolean;
+}
+declare function CanvasNode({ children, id, x, y, className, style }: CanvasNodeProps): react_jsx_runtime.JSX.Element;
+declare namespace CanvasNode {
+    var displayName: string;
+}
+declare function CanvasEdge({ from, to, fromAnchor, toAnchor, curve, color, strokeWidth, dashed, animated, label, className, markerStart, markerEnd, }: CanvasEdgeProps): react_jsx_runtime.JSX.Element | null;
+declare namespace CanvasEdge {
+    var displayName: string;
+}
+declare function CanvasMinimap({ width, height, className }: CanvasMinimapProps): react_jsx_runtime.JSX.Element;
+declare namespace CanvasMinimap {
+    var displayName: string;
+}
+declare function CanvasControls({ className, showZoomIn, showZoomOut, showReset, showFitAll, }: CanvasControlsProps): react_jsx_runtime.JSX.Element;
+declare namespace CanvasControls {
+    var displayName: string;
+}
+declare function CanvasRoot({ children, viewport: controlledViewport, defaultViewport, onViewportChange, minZoom, maxZoom, pannable, zoomable, showGrid, className, style, }: CanvasProps): react_jsx_runtime.JSX.Element;
+declare const Canvas: typeof CanvasRoot & {
+    Node: typeof CanvasNode;
+    Edge: typeof CanvasEdge;
+    Minimap: typeof CanvasMinimap;
+    Controls: typeof CanvasControls;
+};
+declare function useCanvas(): CanvasContextValue;
+type DiagramType = "erd" | "flowchart" | "general";
+type RelationType = "one-to-one" | "one-to-many" | "many-to-many";
+type ExportFormat = "erd" | "uml" | "dfd";
+interface DiagramFieldData {
+    name: string;
+    type?: string;
+    primary?: boolean;
+    foreign?: boolean;
+    nullable?: boolean;
+}
+interface DiagramEntityData {
+    id: string;
+    name: string;
+    fields?: DiagramFieldData[];
+    x?: number;
+    y?: number;
+}
+interface DiagramRelationData {
+    id: string;
+    from: string;
+    to: string;
+    fromField?: string;
+    toField?: string;
+    type: RelationType;
+    label?: string;
+}
+interface DiagramSchema {
+    entities: DiagramEntityData[];
+    relations: DiagramRelationData[];
+}
+interface DiagramContextValue {
+    diagramType: DiagramType;
+    schema: DiagramSchema;
+    downloadableRef: React.RefObject<boolean>;
+    importableRef: React.RefObject<boolean>;
+    exportFormats: ExportFormat[];
+    onImport?: (schema: DiagramSchema) => void;
+}
+interface DiagramProps {
+    children?: ReactNode;
+    schema?: DiagramSchema;
+    type?: DiagramType;
+    viewport?: ViewportState;
+    defaultViewport?: ViewportState;
+    onViewportChange?: (viewport: ViewportState) => void;
+    downloadable?: boolean;
+    importable?: boolean;
+    exportFormats?: ExportFormat[];
+    onImport?: (schema: DiagramSchema) => void;
+    minimap?: boolean;
+    className?: string;
+}
+interface DiagramEntityProps {
+    children?: ReactNode;
+    id: string;
+    name: string;
+    x?: number;
+    y?: number;
+    color?: string;
+    className?: string;
+}
+interface DiagramFieldProps {
+    name: string;
+    type?: string;
+    primary?: boolean;
+    foreign?: boolean;
+    nullable?: boolean;
+    className?: string;
+}
+interface DiagramRelationProps {
+    from: string;
+    to: string;
+    fromField?: string;
+    toField?: string;
+    type: RelationType;
+    label?: string;
+    className?: string;
+}
+interface DiagramToolbarProps {
+    className?: string;
+}
+declare function DiagramEntity({ children, id, name, x, y, color, className, }: DiagramEntityProps): react_jsx_runtime.JSX.Element;
+declare namespace DiagramEntity {
+    var displayName: string;
+}
+declare function DiagramField({ name, type, primary, foreign, nullable, className, }: DiagramFieldProps): react_jsx_runtime.JSX.Element;
+declare namespace DiagramField {
+    var displayName: string;
+}
+declare function DiagramRelation({ from, to, type, label, className, }: DiagramRelationProps): react_jsx_runtime.JSX.Element;
+declare namespace DiagramRelation {
+    var displayName: string;
+}
+declare function DiagramToolbar({ className }: DiagramToolbarProps): react_jsx_runtime.JSX.Element | null;
+declare namespace DiagramToolbar {
+    var displayName: string;
+}
+declare function DiagramRoot({ children, schema, type, viewport, defaultViewport, onViewportChange, downloadable, importable, exportFormats, onImport, minimap, className, }: DiagramProps): react_jsx_runtime.JSX.Element;
+declare const Diagram: typeof DiagramRoot & {
+    Entity: typeof DiagramEntity;
+    Field: typeof DiagramField;
+    Relation: typeof DiagramRelation;
+    Toolbar: typeof DiagramToolbar;
+};
+declare function useDiagram(): DiagramContextValue;
+declare function cn(...inputs: ClassValue[]): string;
+declare function useControllableState<T>(controlledValue: T | undefined, defaultValue: T, onChange?: (value: T) => void): [T, (value: T | ((prev: T) => T)) => void];
+declare function useOutsideClick(ref: RefObject<HTMLElement | null>, handler: (event: MouseEvent | TouchEvent) => void, enabled?: boolean): void;
+declare function useEscapeKey(handler: () => void, enabled?: boolean): void;
+declare function useFocusTrap(ref: RefObject<HTMLElement | null>, enabled?: boolean): void;
+interface FloatingPosition {
+    x: number;
+    y: number;
+    placement: Placement;
+}
+interface UseFloatingPositionOptions {
+    placement?: Placement;
+    offset?: number;
+    enabled?: boolean;
+}
+declare function useFloatingPosition(anchorRef: RefObject<HTMLElement | null>, floatingRef: RefObject<HTMLElement | null>, options?: UseFloatingPositionOptions): FloatingPosition;
+interface UseAnimationOptions {
+    open: boolean;
+    enterClass: string;
+    exitClass: string;
+}
+interface UseAnimationReturn {
+    mounted: boolean;
+    className: string;
+    ref: React.RefObject<HTMLElement | null>;
+}
+declare function useAnimation({ open, enterClass, exitClass, }: UseAnimationOptions): UseAnimationReturn;
+declare function useId(prefix?: string): string;
 /**
  * Simplified emoji data for the picker component.
@@ -390,4 +2037,4 @@ declare function find(char: string): {
     category: string;
 } | undefined;
-export { Action, type ActionColor, type ActionProps, Carousel, type CarouselContextValue, type CarouselControlsProps, type CarouselPanelsProps, type CarouselProps, type CarouselSlideProps, type CarouselStepsProps, Checkbox, CheckboxGroup, type CheckboxGroupProps, type CheckboxProps, type Color, ColorPicker, type ColorPickerProps, DatePicker, type DatePickerProps, EMOJI_DATA, EMOJI_ENTRIES, Emoji, type EmojiProps, EmojiSelect, type EmojiSelectProps, Field, type FieldProps, Input, type InputBaseProps, type InputOption, type InputOptionGroup, type InputProps, RadioGroup, type RadioGroupProps, Select, type SelectProps, type Size, Slider, type SliderProps, Switch, type SwitchProps, Table, type TableBodyProps, type TableCellProps, type TableColumnProps, type TableHeadProps, type TablePaginationProps, type TableProps, type TableRowProps, type TableSearchProps, type TableTrayProps, Textarea, type TextareaProps, type Variant, cn, find, resolve, search, useCarousel, useControllableState };
+export { Accordion, type AccordionContentProps, type AccordionContextValue, type AccordionItemProps, type AccordionProps, type AccordionTriggerProps, Action, type ActionColor, type ActionProps, type AffixPosition, Autocomplete, type AutocompleteOption, type AutocompleteProps, Avatar, type AvatarProps, Badge, type BadgeProps, Brand, type BrandProps, Breadcrumbs, type BreadcrumbsItemProps, type BreadcrumbsProps, Calendar, type CalendarMode, type CalendarProps, Callout, type CalloutProps, Canvas, type CanvasContextValue, type CanvasControlsProps, type CanvasEdgeProps, type CanvasMinimapProps, type CanvasNodeProps, type CanvasProps, Card, type CardBodyProps, type CardFooterProps, type CardHeaderProps, type CardProps, Carousel, type CarouselContextValue, type CarouselControlsProps, type CarouselPanelsProps, type CarouselProps, type CarouselSlideProps, type CarouselStepsProps, type CarouselVariant, Chart, type ChartAreaProps, type ChartBarData, type ChartBarProps, type ChartCommonProps, type ChartDonutData, type ChartDonutProps, type ChartHorizontalBarProps, type ChartLineProps, type ChartPieData, type ChartPieProps, type ChartSeries, type ChartSparklineProps, type ChartStackedBarProps, Checkbox, CheckboxGroup, type CheckboxGroupProps, type CheckboxProps, type Color, ColorPicker, type ColorPickerProps, Command, type CommandContextValue, type CommandEmptyProps, type CommandGroupProps, type CommandInputProps, type CommandItemProps, type CommandListProps, type CommandProps, Composer, type ComposerProps, ContentRenderer, type ContentRendererProps, ContextMenu, type ContextMenuContentProps, type ContextMenuContextValue, type ContextMenuItemProps, type ContextMenuProps, type ContextMenuSeparatorProps, type ContextMenuTriggerProps, DatePicker, type DatePickerProps, type DateRange, Diagram, type DiagramContextValue, type DiagramEntityData, type DiagramEntityProps, type DiagramFieldData, type DiagramFieldProps, type DiagramProps, type DiagramRelationData, type DiagramRelationProps, type DiagramSchema, type DiagramToolbarProps, type DiagramType, Dropdown, type DropdownContextValue, type DropdownItemProps, type DropdownItemsProps, type DropdownProps, type DropdownSeparatorProps, type DropdownTriggerProps, EMOJI_DATA, EMOJI_ENTRIES, type EdgeAnchor, Editor, type EditorAction, type EditorContentProps, type EditorContextValue, type EditorProps, type EditorToolbarProps, Emoji, type EmojiProps, EmojiSelect, type EmojiSelectProps, type ExportFormat, Field, type FieldProps, FileUpload, type FileUploadContextValue, type FileUploadDropzoneProps, type FileUploadListProps, type FileUploadProps, Heading, type HeadingProps, Icon, type IconProps, type IconSet, Input, type InputAffixProps, type InputBaseProps, type InputOption, type InputOptionGroup, type InputProps, Kanban, type KanbanCardProps, type KanbanColumnProps, type KanbanContextValue, type KanbanProps, Menu, type MenuContextValue, type MenuGroupProps, type MenuItemProps, type MenuOrientation, type MenuProps, type MenuSubmenuProps, MobileMenu, type MobileMenuBottomBarProps, type MobileMenuContextValue, type MobileMenuFlyoutProps, type MobileMenuItemProps, type MobileMenuSide, type MobileMenuVariant, Modal, type ModalBodyProps, type ModalContextValue, type ModalFooterProps, type ModalHeaderProps, type ModalProps, MultiSwitch, type MultiSwitchProps, Navbar, type NavbarBrandProps, type NavbarContextValue, type NavbarItemProps, type NavbarItemsProps, type NavbarProps, type NavbarToggleProps, type NodeRect, OtpInput, type OtpInputProps, Pagination, type PaginationProps, Pillbox, type PillboxProps, type Placement, Popover, type PopoverContentProps, type PopoverContextValue, type PopoverProps, type PopoverTriggerProps, Portal, type PortalProps, Profile, type ProfileProps, Progress, type ProgressProps, RadioGroup, type RadioGroupProps, type RelationType, type RenderExtension, type RenderExtensionProps, Select, type SelectProps, Separator, type SeparatorProps, Sidebar, type SidebarCollapseMode, type SidebarContextValue, type SidebarGroupProps, type SidebarItemProps, type SidebarProps, type SidebarSubmenuProps, type SidebarToggleProps, type Size, Skeleton, type SkeletonProps, Slider, type SliderProps, Switch, type SwitchProps, Table, type TableBodyProps, type TableCellProps, type TableColumnProps, type TableHeadProps, type TablePaginationProps, type TableProps, type TableRowProps, type TableRowTrayProps, type TableSearchProps, type TableTrayProps, Tabs, type TabsContextValue, type TabsListProps, type TabsPanelProps, type TabsPanelsProps, type TabsProps, type TabsTabProps, type TabsVariant, Text, type TextProps, Textarea, type TextareaProps, TimePicker, type TimePickerProps, Timeline, type TimelineBlockProps, type TimelineItemProps, type TimelineProps, Toast, type ToastContextValue, type ToastData, type ToastPosition, type ToastProviderProps, type ToastVariant, Tooltip, type TooltipProps, type Variant, type ViewportState, cn, configureIcons, find, registerExtension, registerExtensions, registerIconSet, resolve, search, useAccordion, useAnimation, useCanvas, useCarousel, useCommand, useContextMenu, useControllableState, useDiagram, useDropdown, useEditor, useEscapeKey, useFileUpload, useFloatingPosition, useFocusTrap, useId, useKanban, useMenu, useMobileMenu, useModal, useNavbar, useNodeRegistry, useOutsideClick, usePanZoom, usePopover, useSidebar, useTabs, useToast };