@lukeashford/aurelius 2.9.0 → 2.10.0

package/dist/index.d.mts

@@ -1,70 +1,70 @@
-import React from 'react';
+import React$1 from 'react';
 import { Config } from 'dompurify';
 
 type ButtonVariant = 'primary' | 'important' | 'elevated' | 'outlined' | 'featured' | 'ghost' | 'danger';
 type ButtonSize = 'sm' | 'md' | 'lg' | 'xl';
-interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
     variant?: ButtonVariant;
     size?: ButtonSize;
     loading?: boolean;
 }
-declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
 
-interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+interface InputProps extends React$1.InputHTMLAttributes<HTMLInputElement> {
     error?: boolean;
-    leadingIcon?: React.ReactNode;
-    trailingIcon?: React.ReactNode;
+    leadingIcon?: React$1.ReactNode;
+    trailingIcon?: React$1.ReactNode;
 }
-declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+declare const Input: React$1.ForwardRefExoticComponent<InputProps & React$1.RefAttributes<HTMLInputElement>>;
 
 type CardVariant = 'default' | 'elevated' | 'outlined' | 'ghost' | 'featured';
-interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
+interface CardProps extends React$1.HTMLAttributes<HTMLDivElement> {
     variant?: CardVariant;
     interactive?: boolean;
     selected?: boolean;
     noPadding?: boolean;
 }
-interface CardHeaderProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
-    title?: React.ReactNode;
-    subtitle?: React.ReactNode;
-    action?: React.ReactNode;
+interface CardHeaderProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, 'title'> {
+    title?: React$1.ReactNode;
+    subtitle?: React$1.ReactNode;
+    action?: React$1.ReactNode;
 }
-interface CardBodyProps extends React.HTMLAttributes<HTMLDivElement> {
+interface CardBodyProps extends React$1.HTMLAttributes<HTMLDivElement> {
 }
-interface CardFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+interface CardFooterProps extends React$1.HTMLAttributes<HTMLDivElement> {
     align?: 'start' | 'center' | 'end' | 'between';
 }
-interface CardMediaProps extends React.HTMLAttributes<HTMLDivElement> {
+interface CardMediaProps extends React$1.HTMLAttributes<HTMLDivElement> {
     src?: string;
     alt?: string;
     aspect?: 'video' | 'square' | 'wide';
     position?: 'top' | 'bottom';
     isVideo?: boolean;
 }
-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>>;
-    Media: React.ForwardRefExoticComponent<CardMediaProps & React.RefAttributes<HTMLDivElement>>;
+declare const Card: React$1.ForwardRefExoticComponent<CardProps & React$1.RefAttributes<HTMLDivElement>> & {
+    Header: React$1.ForwardRefExoticComponent<CardHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+    Body: React$1.ForwardRefExoticComponent<CardBodyProps & React$1.RefAttributes<HTMLDivElement>>;
+    Footer: React$1.ForwardRefExoticComponent<CardFooterProps & React$1.RefAttributes<HTMLDivElement>>;
+    Media: React$1.ForwardRefExoticComponent<CardMediaProps & React$1.RefAttributes<HTMLDivElement>>;
 };
 
 type ContainerSize = 'sm' | 'md' | 'lg' | 'xl' | 'fluid' | 'responsive';
-interface ContainerProps extends React.HTMLAttributes<HTMLDivElement> {
+interface ContainerProps extends React$1.HTMLAttributes<HTMLDivElement> {
     size?: ContainerSize;
 }
-declare const Container: React.ForwardRefExoticComponent<ContainerProps & React.RefAttributes<HTMLDivElement>>;
+declare const Container: React$1.ForwardRefExoticComponent<ContainerProps & React$1.RefAttributes<HTMLDivElement>>;
 
 type RowGutter = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12;
 type RowJustify = 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
 type RowAlign = 'start' | 'center' | 'end' | 'stretch' | 'baseline';
-interface RowProps extends React.HTMLAttributes<HTMLDivElement> {
+interface RowProps extends React$1.HTMLAttributes<HTMLDivElement> {
     gutter?: RowGutter;
     gutterX?: RowGutter;
     gutterY?: RowGutter;
     justify?: RowJustify;
     align?: RowAlign;
 }
-declare const Row: React.ForwardRefExoticComponent<RowProps & React.RefAttributes<HTMLDivElement>>;
+declare const Row: React$1.ForwardRefExoticComponent<RowProps & React$1.RefAttributes<HTMLDivElement>>;
 
 type ColSpan = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 'auto' | 'full';
 type ColOffset = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
@@ -77,18 +77,18 @@ interface ResponsiveValue<T> {
     xl?: T;
     '2xl'?: T;
 }
-interface ColProps extends React.HTMLAttributes<HTMLDivElement> {
+interface ColProps extends React$1.HTMLAttributes<HTMLDivElement> {
     span?: ColSpan | ResponsiveValue<ColSpan>;
     offset?: ColOffset | ResponsiveValue<ColOffset>;
     order?: ColOrder | ResponsiveValue<ColOrder>;
 }
-declare const Col: React.ForwardRefExoticComponent<ColProps & React.RefAttributes<HTMLDivElement>>;
+declare const Col: React$1.ForwardRefExoticComponent<ColProps & React$1.RefAttributes<HTMLDivElement>>;
 
 type StackDirection = 'horizontal' | 'vertical';
 type StackAlign = 'start' | 'center' | 'end' | 'stretch' | 'baseline';
 type StackJustify = 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
 type StackGap = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12;
-interface StackProps extends React.HTMLAttributes<HTMLDivElement> {
+interface StackProps extends React$1.HTMLAttributes<HTMLDivElement> {
     direction?: StackDirection;
     align?: StackAlign;
     justify?: StackJustify;
@@ -96,140 +96,220 @@ interface StackProps extends React.HTMLAttributes<HTMLDivElement> {
     wrap?: boolean;
     as?: 'div' | 'section' | 'article' | 'nav' | 'aside' | 'header' | 'footer' | 'main';
 }
-declare const Stack: React.ForwardRefExoticComponent<StackProps & React.RefAttributes<HTMLDivElement>>;
+declare const Stack: React$1.ForwardRefExoticComponent<StackProps & React$1.RefAttributes<HTMLDivElement>>;
 
 type DividerOrientation = 'horizontal' | 'vertical';
 type DividerVariant = 'solid' | 'dashed' | 'dotted';
-interface DividerProps extends React.HTMLAttributes<HTMLHRElement> {
+interface DividerProps extends React$1.HTMLAttributes<HTMLHRElement> {
     orientation?: DividerOrientation;
     variant?: DividerVariant;
-    label?: React.ReactNode;
+    label?: React$1.ReactNode;
     color?: 'default' | 'gold' | 'muted';
 }
-declare const Divider: React.ForwardRefExoticComponent<DividerProps & React.RefAttributes<HTMLHRElement>>;
+declare const Divider: React$1.ForwardRefExoticComponent<DividerProps & React$1.RefAttributes<HTMLHRElement>>;
 
 type AvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
 type AvatarStatus = 'online' | 'offline' | 'busy';
-interface AvatarProps extends React.HTMLAttributes<HTMLDivElement> {
+interface AvatarProps extends React$1.HTMLAttributes<HTMLDivElement> {
     src?: string;
     alt?: string;
     name?: string;
     size?: AvatarSize;
     status?: AvatarStatus;
 }
-declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLDivElement>>;
+declare const Avatar: React$1.ForwardRefExoticComponent<AvatarProps & React$1.RefAttributes<HTMLDivElement>>;
 
 type BadgeVariant = 'default' | 'gold' | 'success' | 'error' | 'warning' | 'info';
-interface BadgeProps extends React.HTMLAttributes<HTMLSpanElement> {
+interface BadgeProps extends React$1.HTMLAttributes<HTMLSpanElement> {
     variant?: BadgeVariant;
 }
-declare const Badge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<HTMLSpanElement>>;
+declare const Badge: React$1.ForwardRefExoticComponent<BadgeProps & React$1.RefAttributes<HTMLSpanElement>>;
 
 type TooltipSide = 'top' | 'right' | 'bottom' | 'left';
 interface TooltipProps {
-    content: React.ReactNode;
-    children: React.ReactElement;
+    content: React$1.ReactNode;
+    children: React$1.ReactElement;
     open?: boolean;
     side?: TooltipSide;
 }
-declare const Tooltip: React.FC<TooltipProps>;
+declare const Tooltip: React$1.FC<TooltipProps>;
 
-interface TableProps extends React.TableHTMLAttributes<HTMLTableElement> {
+interface TableProps extends React$1.TableHTMLAttributes<HTMLTableElement> {
     responsive?: boolean;
 }
-declare const Table: React.ForwardRefExoticComponent<TableProps & React.RefAttributes<HTMLTableElement>>;
-interface TableHeaderProps extends React.HTMLAttributes<HTMLTableSectionElement> {
+declare const Table: React$1.ForwardRefExoticComponent<TableProps & React$1.RefAttributes<HTMLTableElement>>;
+interface TableHeaderProps extends React$1.HTMLAttributes<HTMLTableSectionElement> {
 }
-declare const TableHeader: React.ForwardRefExoticComponent<TableHeaderProps & React.RefAttributes<HTMLTableSectionElement>>;
-interface TableBodyProps extends React.HTMLAttributes<HTMLTableSectionElement> {
+declare const TableHeader: React$1.ForwardRefExoticComponent<TableHeaderProps & React$1.RefAttributes<HTMLTableSectionElement>>;
+interface TableBodyProps extends React$1.HTMLAttributes<HTMLTableSectionElement> {
 }
-declare const TableBody: React.ForwardRefExoticComponent<TableBodyProps & React.RefAttributes<HTMLTableSectionElement>>;
-interface TableFooterProps extends React.HTMLAttributes<HTMLTableSectionElement> {
+declare const TableBody: React$1.ForwardRefExoticComponent<TableBodyProps & React$1.RefAttributes<HTMLTableSectionElement>>;
+interface TableFooterProps extends React$1.HTMLAttributes<HTMLTableSectionElement> {
 }
-declare const TableFooter: React.ForwardRefExoticComponent<TableFooterProps & React.RefAttributes<HTMLTableSectionElement>>;
-interface TableRowProps extends React.HTMLAttributes<HTMLTableRowElement> {
+declare const TableFooter: React$1.ForwardRefExoticComponent<TableFooterProps & React$1.RefAttributes<HTMLTableSectionElement>>;
+interface TableRowProps extends React$1.HTMLAttributes<HTMLTableRowElement> {
     hoverable?: boolean;
     selected?: boolean;
 }
-declare const TableRow: React.ForwardRefExoticComponent<TableRowProps & React.RefAttributes<HTMLTableRowElement>>;
-interface TableHeadProps extends React.ThHTMLAttributes<HTMLTableCellElement> {
+declare const TableRow: React$1.ForwardRefExoticComponent<TableRowProps & React$1.RefAttributes<HTMLTableRowElement>>;
+interface TableHeadProps extends React$1.ThHTMLAttributes<HTMLTableCellElement> {
     sortable?: boolean;
     sortDirection?: 'asc' | 'desc' | null;
 }
-declare const TableHead: React.ForwardRefExoticComponent<TableHeadProps & React.RefAttributes<HTMLTableCellElement>>;
-interface TableCellProps extends React.TdHTMLAttributes<HTMLTableCellElement> {
+declare const TableHead: React$1.ForwardRefExoticComponent<TableHeadProps & React$1.RefAttributes<HTMLTableCellElement>>;
+interface TableCellProps extends React$1.TdHTMLAttributes<HTMLTableCellElement> {
 }
-declare const TableCell: React.ForwardRefExoticComponent<TableCellProps & React.RefAttributes<HTMLTableCellElement>>;
-interface TableCaptionProps extends React.HTMLAttributes<HTMLTableCaptionElement> {
+declare const TableCell: React$1.ForwardRefExoticComponent<TableCellProps & React$1.RefAttributes<HTMLTableCellElement>>;
+interface TableCaptionProps extends React$1.HTMLAttributes<HTMLTableCaptionElement> {
 }
-declare const TableCaption: React.ForwardRefExoticComponent<TableCaptionProps & React.RefAttributes<HTMLTableCaptionElement>>;
+declare const TableCaption: React$1.ForwardRefExoticComponent<TableCaptionProps & React$1.RefAttributes<HTMLTableCaptionElement>>;
 
-interface ListProps extends React.HTMLAttributes<HTMLUListElement> {
+interface ListProps extends React$1.HTMLAttributes<HTMLUListElement> {
     variant?: 'default' | 'bordered' | 'divided';
     ordered?: boolean;
 }
-declare const List: React.ForwardRefExoticComponent<ListProps & React.RefAttributes<HTMLUListElement>>;
-interface ListItemProps extends React.LiHTMLAttributes<HTMLLIElement> {
-    leading?: React.ReactNode;
-    trailing?: React.ReactNode;
+declare const List: React$1.ForwardRefExoticComponent<ListProps & React$1.RefAttributes<HTMLUListElement>>;
+interface ListItemProps extends React$1.LiHTMLAttributes<HTMLLIElement> {
+    leading?: React$1.ReactNode;
+    trailing?: React$1.ReactNode;
     interactive?: boolean;
     selected?: boolean;
     disabled?: boolean;
 }
-declare const ListItem: React.ForwardRefExoticComponent<ListItemProps & React.RefAttributes<HTMLLIElement>>;
-interface ListItemTextProps extends React.HTMLAttributes<HTMLDivElement> {
-    primary: React.ReactNode;
-    secondary?: React.ReactNode;
+declare const ListItem: React$1.ForwardRefExoticComponent<ListItemProps & React$1.RefAttributes<HTMLLIElement>>;
+interface ListItemTextProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    primary: React$1.ReactNode;
+    secondary?: React$1.ReactNode;
 }
-declare const ListItemText: React.ForwardRefExoticComponent<ListItemTextProps & React.RefAttributes<HTMLDivElement>>;
-interface ListSubheaderProps extends React.HTMLAttributes<HTMLLIElement> {
+declare const ListItemText: React$1.ForwardRefExoticComponent<ListItemTextProps & React$1.RefAttributes<HTMLDivElement>>;
+interface ListSubheaderProps extends React$1.HTMLAttributes<HTMLLIElement> {
 }
-declare const ListSubheader: React.ForwardRefExoticComponent<ListSubheaderProps & React.RefAttributes<HTMLLIElement>>;
+declare const ListSubheader: React$1.ForwardRefExoticComponent<ListSubheaderProps & React$1.RefAttributes<HTMLLIElement>>;
 
-interface LabelProps extends React.LabelHTMLAttributes<HTMLLabelElement> {
+type FileChipStatus = 'pending' | 'uploading' | 'complete' | 'error';
+interface FileChipProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, 'children'> {
+    /**
+     * File name to display
+     */
+    name: string;
+    /**
+     * File size in bytes (optional, will be formatted)
+     */
+    size?: number;
+    /**
+     * MIME type for icon selection
+     */
+    type?: string;
+    /**
+     * Upload/processing status
+     */
+    status?: FileChipStatus;
+    /**
+     * Preview image URL (for images)
+     */
+    previewUrl?: string;
+    /**
+     * Called when the remove button is clicked
+     */
+    onRemove?: () => void;
+    /**
+     * Whether the chip is removable
+     */
+    removable?: boolean;
+    /**
+     * Error message to display (when status is 'error')
+     */
+    error?: string;
+}
+declare const FileChip: React$1.ForwardRefExoticComponent<FileChipProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface AttachmentItem {
+    /**
+     * Unique identifier
+     */
+    id: string;
+    /**
+     * The File object
+     */
+    file: File;
+    /**
+     * Blob URL for image previews
+     */
+    previewUrl?: string;
+    /**
+     * Current status
+     */
+    status: FileChipStatus;
+    /**
+     * Error message if status is 'error'
+     */
+    error?: string;
+}
+interface AttachmentPreviewProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Array of attachments to display
+     */
+    attachments: AttachmentItem[];
+    /**
+     * Called when an attachment should be removed
+     */
+    onRemove?: (id: string) => void;
+    /**
+     * Whether attachments are removable
+     */
+    removable?: boolean;
+    /**
+     * Maximum number of attachments to show before collapsing
+     * Set to 0 or undefined to show all
+     */
+    maxVisible?: number;
+}
+declare const AttachmentPreview: React$1.ForwardRefExoticComponent<AttachmentPreviewProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface LabelProps extends React$1.LabelHTMLAttributes<HTMLLabelElement> {
     required?: boolean;
 }
-declare const Label: React.ForwardRefExoticComponent<LabelProps & React.RefAttributes<HTMLLabelElement>>;
+declare const Label: React$1.ForwardRefExoticComponent<LabelProps & React$1.RefAttributes<HTMLLabelElement>>;
 
-interface HelperTextProps extends React.HTMLAttributes<HTMLParagraphElement> {
+interface HelperTextProps extends React$1.HTMLAttributes<HTMLParagraphElement> {
     error?: boolean;
 }
-declare const HelperText: React.ForwardRefExoticComponent<HelperTextProps & React.RefAttributes<HTMLParagraphElement>>;
+declare const HelperText: React$1.ForwardRefExoticComponent<HelperTextProps & React$1.RefAttributes<HTMLParagraphElement>>;
 
-interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+interface TextareaProps extends React$1.TextareaHTMLAttributes<HTMLTextAreaElement> {
     error?: boolean;
 }
-declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+declare const Textarea: React$1.ForwardRefExoticComponent<TextareaProps & React$1.RefAttributes<HTMLTextAreaElement>>;
 
 interface SelectOption {
     label: string;
     value: string | number;
 }
-interface SelectProps extends React.SelectHTMLAttributes<HTMLSelectElement> {
+interface SelectProps extends React$1.SelectHTMLAttributes<HTMLSelectElement> {
     error?: boolean;
     options?: SelectOption[];
 }
-declare const Select: React.ForwardRefExoticComponent<SelectProps & React.RefAttributes<HTMLSelectElement>>;
+declare const Select: React$1.ForwardRefExoticComponent<SelectProps & React$1.RefAttributes<HTMLSelectElement>>;
 
-interface CheckboxProps extends React.InputHTMLAttributes<HTMLInputElement> {
+interface CheckboxProps extends React$1.InputHTMLAttributes<HTMLInputElement> {
     label?: string;
 }
-declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLInputElement>>;
+declare const Checkbox: React$1.ForwardRefExoticComponent<CheckboxProps & React$1.RefAttributes<HTMLInputElement>>;
 
-interface RadioProps extends React.InputHTMLAttributes<HTMLInputElement> {
+interface RadioProps extends React$1.InputHTMLAttributes<HTMLInputElement> {
     label?: string;
 }
-declare const Radio: React.ForwardRefExoticComponent<RadioProps & React.RefAttributes<HTMLInputElement>>;
+declare const Radio: React$1.ForwardRefExoticComponent<RadioProps & React$1.RefAttributes<HTMLInputElement>>;
 
-interface SwitchProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'onChange'> {
+interface SwitchProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, 'onChange'> {
     checked?: boolean;
     defaultChecked?: boolean;
     onCheckedChange?: (checked: boolean) => void;
     label?: string;
 }
-declare const Switch: React.ForwardRefExoticComponent<SwitchProps & React.RefAttributes<HTMLButtonElement>>;
+declare const Switch: React$1.ForwardRefExoticComponent<SwitchProps & React$1.RefAttributes<HTMLButtonElement>>;
 
-interface SliderProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+interface SliderProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, 'onChange'> {
     value?: number;
     defaultValue?: number;
     min?: number;
@@ -242,46 +322,46 @@ interface SliderProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChan
     formatValue?: (value: number) => string;
     size?: 'sm' | 'md' | 'lg';
 }
-declare const Slider: React.ForwardRefExoticComponent<SliderProps & React.RefAttributes<HTMLDivElement>>;
+declare const Slider: React$1.ForwardRefExoticComponent<SliderProps & React$1.RefAttributes<HTMLDivElement>>;
 
-interface InputGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+interface InputGroupProps extends React$1.HTMLAttributes<HTMLDivElement> {
 }
-declare const InputGroup: React.ForwardRefExoticComponent<InputGroupProps & React.RefAttributes<HTMLDivElement>>;
-interface InputAddonProps extends React.HTMLAttributes<HTMLDivElement> {
+declare const InputGroup: React$1.ForwardRefExoticComponent<InputGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+interface InputAddonProps extends React$1.HTMLAttributes<HTMLDivElement> {
 }
-declare const InputLeftAddon: React.ForwardRefExoticComponent<InputAddonProps & React.RefAttributes<HTMLDivElement>>;
-declare const InputRightAddon: React.ForwardRefExoticComponent<InputAddonProps & React.RefAttributes<HTMLDivElement>>;
-interface InputElementProps extends React.HTMLAttributes<HTMLDivElement> {
+declare const InputLeftAddon: React$1.ForwardRefExoticComponent<InputAddonProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const InputRightAddon: React$1.ForwardRefExoticComponent<InputAddonProps & React$1.RefAttributes<HTMLDivElement>>;
+interface InputElementProps extends React$1.HTMLAttributes<HTMLDivElement> {
 }
-declare const InputLeftElement: React.ForwardRefExoticComponent<InputElementProps & React.RefAttributes<HTMLDivElement>>;
-declare const InputRightElement: React.ForwardRefExoticComponent<InputElementProps & React.RefAttributes<HTMLDivElement>>;
-interface InputWrapperProps extends React.HTMLAttributes<HTMLDivElement> {
+declare const InputLeftElement: React$1.ForwardRefExoticComponent<InputElementProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const InputRightElement: React$1.ForwardRefExoticComponent<InputElementProps & React$1.RefAttributes<HTMLDivElement>>;
+interface InputWrapperProps extends React$1.HTMLAttributes<HTMLDivElement> {
 }
-declare const InputWrapper: React.ForwardRefExoticComponent<InputWrapperProps & React.RefAttributes<HTMLDivElement>>;
+declare const InputWrapper: React$1.ForwardRefExoticComponent<InputWrapperProps & React$1.RefAttributes<HTMLDivElement>>;
 
 type AlertVariant = 'info' | 'success' | 'warning' | 'error';
-interface AlertProps extends React.HTMLAttributes<HTMLDivElement> {
+interface AlertProps extends React$1.HTMLAttributes<HTMLDivElement> {
     variant?: AlertVariant;
     title?: string;
 }
-declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
+declare const Alert: React$1.ForwardRefExoticComponent<AlertProps & React$1.RefAttributes<HTMLDivElement>>;
 
 type SpinnerSize = 'sm' | 'md' | 'lg';
-interface SpinnerProps extends React.SVGAttributes<SVGElement> {
+interface SpinnerProps extends React$1.SVGAttributes<SVGElement> {
     size?: SpinnerSize;
 }
 declare const Spinner: {
-    ({ className, size, ...rest }: SpinnerProps): React.JSX.Element;
+    ({ className, size, ...rest }: SpinnerProps): React$1.JSX.Element;
     displayName: string;
 };
 
-interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
+interface SkeletonProps extends React$1.HTMLAttributes<HTMLDivElement> {
 }
-declare const Skeleton: React.ForwardRefExoticComponent<SkeletonProps & React.RefAttributes<HTMLDivElement>>;
+declare const Skeleton: React$1.ForwardRefExoticComponent<SkeletonProps & React$1.RefAttributes<HTMLDivElement>>;
 
 type ProgressSize = 'sm' | 'md' | 'lg';
 type ProgressVariant = 'default' | 'success' | 'warning' | 'error';
-interface ProgressProps extends React.HTMLAttributes<HTMLDivElement> {
+interface ProgressProps extends React$1.HTMLAttributes<HTMLDivElement> {
     value?: number;
     max?: number;
     size?: ProgressSize;
@@ -290,7 +370,7 @@ interface ProgressProps extends React.HTMLAttributes<HTMLDivElement> {
     formatValue?: (value: number, max: number) => string;
     indeterminate?: boolean;
 }
-declare const Progress: React.ForwardRefExoticComponent<ProgressProps & React.RefAttributes<HTMLDivElement>>;
+declare const Progress: React$1.ForwardRefExoticComponent<ProgressProps & React$1.RefAttributes<HTMLDivElement>>;
 
 type ToastVariant = 'default' | 'success' | 'error' | 'warning' | 'info';
 type ToastPosition = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top-center' | 'bottom-center';
@@ -300,28 +380,28 @@ interface ToastData {
     description?: string;
     variant?: ToastVariant;
     duration?: number;
-    action?: React.ReactNode;
+    action?: React$1.ReactNode;
 }
 declare function useToast(): {
     toast: (options: Omit<ToastData, "id">) => string;
     dismiss: (id: string) => void;
 };
 interface ToastProviderProps {
-    children: React.ReactNode;
+    children: React$1.ReactNode;
     position?: ToastPosition;
     defaultDuration?: number;
 }
-declare const ToastProvider: React.FC<ToastProviderProps>;
+declare const ToastProvider: React$1.FC<ToastProviderProps>;
 
 interface ModalProps {
     isOpen: boolean;
     onClose: () => void;
     title?: string;
-    children: React.ReactNode;
+    children: React$1.ReactNode;
     className?: string;
 }
 declare const Modal: {
-    ({ isOpen, onClose, title, children, className }: ModalProps): React.ReactPortal | null;
+    ({ isOpen, onClose, title, children, className }: ModalProps): React$1.ReactPortal | null;
     displayName: string;
 };
 
@@ -332,17 +412,17 @@ interface DrawerProps {
     position?: DrawerPosition;
     title?: string;
     size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
-    children: React.ReactNode;
+    children: React$1.ReactNode;
     className?: string;
 }
-declare const Drawer: React.FC<DrawerProps>;
+declare const Drawer: React$1.FC<DrawerProps>;
 
 type PopoverPosition = 'top' | 'bottom' | 'left' | 'right';
 type PopoverAlign = 'start' | 'center' | 'end';
 interface PopoverProps {
-    children: React.ReactNode;
+    children: React$1.ReactNode;
     /** The trigger element */
-    trigger: React.ReactElement;
+    trigger: React$1.ReactElement;
     /** Position relative to trigger */
     position?: PopoverPosition;
     /** Alignment along the position axis */
@@ -354,10 +434,10 @@ interface PopoverProps {
     /** Close when clicking outside */
     closeOnClickOutside?: boolean;
 }
-declare const Popover: React.FC<PopoverProps>;
+declare const Popover: React$1.FC<PopoverProps>;
 
 interface ConfirmDialogProps extends Omit<ModalProps, 'children'> {
-    description?: React.ReactNode;
+    description?: React$1.ReactNode;
     confirmText?: string;
     cancelText?: string;
     onConfirm: () => void | Promise<void>;
@@ -365,15 +445,15 @@ interface ConfirmDialogProps extends Omit<ModalProps, 'children'> {
     confirmVariant?: 'primary' | 'important' | 'danger';
     isLoading?: boolean;
 }
-declare const ConfirmDialog: React.FC<ConfirmDialogProps>;
+declare const ConfirmDialog: React$1.FC<ConfirmDialogProps>;
 interface AlertDialogProps extends Omit<ModalProps, 'children'> {
-    description?: React.ReactNode;
+    description?: React$1.ReactNode;
     acknowledgeText?: string;
     variant?: 'default' | 'warning' | 'error';
 }
-declare const AlertDialog: React.FC<AlertDialogProps>;
+declare const AlertDialog: React$1.FC<AlertDialogProps>;
 interface PromptDialogProps extends Omit<ModalProps, 'children'> {
-    description?: React.ReactNode;
+    description?: React$1.ReactNode;
     placeholder?: string;
     defaultValue?: string;
     submitText?: string;
@@ -382,9 +462,9 @@ interface PromptDialogProps extends Omit<ModalProps, 'children'> {
     onCancel?: () => void;
     isLoading?: boolean;
 }
-declare const PromptDialog: React.FC<PromptDialogProps>;
+declare const PromptDialog: React$1.FC<PromptDialogProps>;
 
-interface TabsProps extends React.HTMLAttributes<HTMLDivElement> {
+interface TabsProps extends React$1.HTMLAttributes<HTMLDivElement> {
     /** The id of the initially active tab */
     defaultValue?: string;
     /** Controlled active tab value */
@@ -392,24 +472,24 @@ interface TabsProps extends React.HTMLAttributes<HTMLDivElement> {
     /** Callback when active tab changes */
     onValueChange?: (value: string) => void;
 }
-declare const Tabs: React.ForwardRefExoticComponent<TabsProps & React.RefAttributes<HTMLDivElement>>;
-interface TabListProps extends React.HTMLAttributes<HTMLDivElement> {
+declare const Tabs: React$1.ForwardRefExoticComponent<TabsProps & React$1.RefAttributes<HTMLDivElement>>;
+interface TabListProps extends React$1.HTMLAttributes<HTMLDivElement> {
 }
-declare const TabList: React.ForwardRefExoticComponent<TabListProps & React.RefAttributes<HTMLDivElement>>;
-interface TabProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+declare const TabList: React$1.ForwardRefExoticComponent<TabListProps & React$1.RefAttributes<HTMLDivElement>>;
+interface TabProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
     /** Unique identifier for this tab */
     value: string;
 }
-declare const Tab: React.ForwardRefExoticComponent<TabProps & React.RefAttributes<HTMLButtonElement>>;
-interface TabPanelProps extends React.HTMLAttributes<HTMLDivElement> {
+declare const Tab: React$1.ForwardRefExoticComponent<TabProps & React$1.RefAttributes<HTMLButtonElement>>;
+interface TabPanelProps extends React$1.HTMLAttributes<HTMLDivElement> {
     /** Value matching the corresponding Tab */
     value: string;
     /** Force the panel to stay mounted when inactive */
     forceMount?: boolean;
 }
-declare const TabPanel: React.ForwardRefExoticComponent<TabPanelProps & React.RefAttributes<HTMLDivElement>>;
+declare const TabPanel: React$1.ForwardRefExoticComponent<TabPanelProps & React$1.RefAttributes<HTMLDivElement>>;
 
-interface AccordionProps extends React.HTMLAttributes<HTMLDivElement> {
+interface AccordionProps extends React$1.HTMLAttributes<HTMLDivElement> {
     /** Allow multiple items to be open at once */
     type?: 'single' | 'multiple';
     /** Default expanded item(s) */
@@ -419,165 +499,781 @@ interface AccordionProps extends React.HTMLAttributes<HTMLDivElement> {
     /** Callback when expanded items change */
     onValueChange?: (value: string | string[]) => void;
 }
-declare const Accordion: React.ForwardRefExoticComponent<AccordionProps & React.RefAttributes<HTMLDivElement>>;
-interface AccordionItemProps extends React.HTMLAttributes<HTMLDivElement> {
+declare const Accordion: React$1.ForwardRefExoticComponent<AccordionProps & React$1.RefAttributes<HTMLDivElement>>;
+interface AccordionItemProps extends React$1.HTMLAttributes<HTMLDivElement> {
     /** Unique identifier for this item */
     value: string;
     /** Disable this item */
     disabled?: boolean;
 }
-declare const AccordionItem: React.ForwardRefExoticComponent<AccordionItemProps & React.RefAttributes<HTMLDivElement>>;
-interface AccordionTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+declare const AccordionItem: React$1.ForwardRefExoticComponent<AccordionItemProps & React$1.RefAttributes<HTMLDivElement>>;
+interface AccordionTriggerProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
 }
-declare const AccordionTrigger: React.ForwardRefExoticComponent<AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-interface AccordionContentProps extends React.HTMLAttributes<HTMLDivElement> {
+declare const AccordionTrigger: React$1.ForwardRefExoticComponent<AccordionTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+interface AccordionContentProps extends React$1.HTMLAttributes<HTMLDivElement> {
 }
-declare const AccordionContent: React.ForwardRefExoticComponent<AccordionContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionContent: React$1.ForwardRefExoticComponent<AccordionContentProps & React$1.RefAttributes<HTMLDivElement>>;
 
 interface MenuProps {
-    children: React.ReactNode;
+    children: React$1.ReactNode;
     open?: boolean;
     onOpenChange?: (open: boolean) => void;
 }
-declare const Menu: React.FC<MenuProps>;
-interface MenuTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+declare const Menu: React$1.FC<MenuProps>;
+interface MenuTriggerProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
     asChild?: boolean;
 }
-declare const MenuTrigger: React.ForwardRefExoticComponent<MenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-interface MenuContentProps extends React.HTMLAttributes<HTMLDivElement> {
+declare const MenuTrigger: React$1.ForwardRefExoticComponent<MenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+interface MenuContentProps extends React$1.HTMLAttributes<HTMLDivElement> {
     align?: 'start' | 'center' | 'end';
     side?: 'top' | 'bottom';
 }
-declare const MenuContent: React.ForwardRefExoticComponent<MenuContentProps & React.RefAttributes<HTMLDivElement>>;
-interface MenuItemProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
-    icon?: React.ReactNode;
+declare const MenuContent: React$1.ForwardRefExoticComponent<MenuContentProps & React$1.RefAttributes<HTMLDivElement>>;
+interface MenuItemProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    icon?: React$1.ReactNode;
     destructive?: boolean;
 }
-declare const MenuItem: React.ForwardRefExoticComponent<MenuItemProps & React.RefAttributes<HTMLButtonElement>>;
-declare const MenuSeparator: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-declare const MenuLabel: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const MenuItem: React$1.ForwardRefExoticComponent<MenuItemProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const MenuSeparator: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
+declare const MenuLabel: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
 
-interface NavbarProps extends React.HTMLAttributes<HTMLElement> {
+interface NavbarProps extends React$1.HTMLAttributes<HTMLElement> {
     fixed?: boolean;
     bordered?: boolean;
 }
-declare const Navbar: React.ForwardRefExoticComponent<NavbarProps & React.RefAttributes<HTMLElement>>;
-interface NavbarBrandProps extends React.HTMLAttributes<HTMLDivElement> {
+declare const Navbar: React$1.ForwardRefExoticComponent<NavbarProps & React$1.RefAttributes<HTMLElement>>;
+interface NavbarBrandProps extends React$1.HTMLAttributes<HTMLDivElement> {
 }
-declare const NavbarBrand: React.ForwardRefExoticComponent<NavbarBrandProps & React.RefAttributes<HTMLDivElement>>;
-interface NavbarContentProps extends React.HTMLAttributes<HTMLDivElement> {
+declare const NavbarBrand: React$1.ForwardRefExoticComponent<NavbarBrandProps & React$1.RefAttributes<HTMLDivElement>>;
+interface NavbarContentProps extends React$1.HTMLAttributes<HTMLDivElement> {
     position?: 'start' | 'center' | 'end';
 }
-declare const NavbarContent: React.ForwardRefExoticComponent<NavbarContentProps & React.RefAttributes<HTMLDivElement>>;
-interface NavbarItemProps extends React.HTMLAttributes<HTMLDivElement> {
+declare const NavbarContent: React$1.ForwardRefExoticComponent<NavbarContentProps & React$1.RefAttributes<HTMLDivElement>>;
+interface NavbarItemProps extends React$1.HTMLAttributes<HTMLDivElement> {
     active?: boolean;
 }
-declare const NavbarItem: React.ForwardRefExoticComponent<NavbarItemProps & React.RefAttributes<HTMLDivElement>>;
-interface NavbarLinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+declare const NavbarItem: React$1.ForwardRefExoticComponent<NavbarItemProps & React$1.RefAttributes<HTMLDivElement>>;
+interface NavbarLinkProps extends React$1.AnchorHTMLAttributes<HTMLAnchorElement> {
     active?: boolean;
 }
-declare const NavbarLink: React.ForwardRefExoticComponent<NavbarLinkProps & React.RefAttributes<HTMLAnchorElement>>;
-declare const NavbarDivider: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const NavbarLink: React$1.ForwardRefExoticComponent<NavbarLinkProps & React$1.RefAttributes<HTMLAnchorElement>>;
+declare const NavbarDivider: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & React$1.RefAttributes<HTMLDivElement>>;
 
-interface BreadcrumbProps extends React.HTMLAttributes<HTMLElement> {
-    separator?: React.ReactNode;
+interface BreadcrumbProps extends React$1.HTMLAttributes<HTMLElement> {
+    separator?: React$1.ReactNode;
 }
-declare const Breadcrumb: React.ForwardRefExoticComponent<BreadcrumbProps & React.RefAttributes<HTMLElement>>;
-interface BreadcrumbItemProps extends React.HTMLAttributes<HTMLSpanElement> {
+declare const Breadcrumb: React$1.ForwardRefExoticComponent<BreadcrumbProps & React$1.RefAttributes<HTMLElement>>;
+interface BreadcrumbItemProps extends React$1.HTMLAttributes<HTMLSpanElement> {
     current?: boolean;
 }
-declare const BreadcrumbItem: React.ForwardRefExoticComponent<BreadcrumbItemProps & React.RefAttributes<HTMLSpanElement>>;
-interface BreadcrumbLinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+declare const BreadcrumbItem: React$1.ForwardRefExoticComponent<BreadcrumbItemProps & React$1.RefAttributes<HTMLSpanElement>>;
+interface BreadcrumbLinkProps extends React$1.AnchorHTMLAttributes<HTMLAnchorElement> {
 }
-declare const BreadcrumbLink: React.ForwardRefExoticComponent<BreadcrumbLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const BreadcrumbLink: React$1.ForwardRefExoticComponent<BreadcrumbLinkProps & React$1.RefAttributes<HTMLAnchorElement>>;
 
-interface PaginationProps extends React.HTMLAttributes<HTMLElement> {
+interface PaginationProps extends React$1.HTMLAttributes<HTMLElement> {
     page: number;
     totalPages: number;
     onPageChange: (page: number) => void;
     siblingCount?: number;
     showEdges?: boolean;
 }
-declare const Pagination: React.ForwardRefExoticComponent<PaginationProps & React.RefAttributes<HTMLElement>>;
+declare const Pagination: React$1.ForwardRefExoticComponent<PaginationProps & React$1.RefAttributes<HTMLElement>>;
 
 type StepStatus = 'complete' | 'error';
 interface Step {
     id: string | number;
     label: string;
 }
-interface StepperProps extends React.HTMLAttributes<HTMLDivElement> {
+interface StepperProps extends React$1.HTMLAttributes<HTMLDivElement> {
     /** Array of steps. Each requires: id (string | number), label (string). */
     steps: Step[];
     /** ID of the current step (must match a step.id from the steps array). */
     currentStep: string | number;
     status?: StepStatus;
 }
-declare const Stepper: React.ForwardRefExoticComponent<StepperProps & React.RefAttributes<HTMLDivElement>>;
+declare const Stepper: React$1.ForwardRefExoticComponent<StepperProps & React$1.RefAttributes<HTMLDivElement>>;
 
 type MessageVariant = 'user' | 'assistant';
-interface MessageProps extends React.HTMLAttributes<HTMLDivElement> {
+interface MessageBranchInfo {
+    /**
+     * Current branch index (1-based)
+     */
+    current: number;
+    /**
+     * Total number of sibling branches
+     */
+    total: number;
+    /**
+     * Navigate to previous branch
+     */
+    onPrevious?: () => void;
+    /**
+     * Navigate to next branch
+     */
+    onNext?: () => void;
+}
+interface MessageActionsConfig {
+    /**
+     * Called when user edits a user message (creates a branch)
+     */
+    onEdit?: (newContent: string) => void;
+    /**
+     * Called when user retries an assistant message (creates a branch)
+     */
+    onRetry?: () => void;
+    /**
+     * Whether to show the copy button
+     * @default true
+     */
+    showCopy?: boolean;
+}
+interface MessageProps extends React$1.HTMLAttributes<HTMLDivElement> {
     variant?: MessageVariant;
     content: string;
     isStreaming?: boolean;
+    /**
+     * Branch navigation info (shows branch indicator if provided and total > 1)
+     */
+    branchInfo?: MessageBranchInfo;
+    /**
+     * Actions configuration (shows action bar if provided)
+     */
+    actions?: MessageActionsConfig;
+    /**
+     * Whether to hide actions (e.g., during streaming)
+     */
+    hideActions?: boolean;
+}
+declare const Message: React$1.ForwardRefExoticComponent<MessageProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface StreamingCursorProps extends React$1.HTMLAttributes<HTMLSpanElement> {
+    variant?: 'block' | 'line' | 'underscore';
+}
+declare const StreamingCursor: React$1.ForwardRefExoticComponent<StreamingCursorProps & React$1.RefAttributes<HTMLSpanElement>>;
+
+interface MarkdownContentProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    content: string;
+    sanitizeConfig?: Config;
+    /**
+     * When true, injects a streaming cursor at the end of the content
+     */
+    isStreaming?: boolean;
+    /**
+     * Additional classes for the streaming cursor
+     */
+    cursorClassName?: string;
+}
+declare const MarkdownContent: React$1.ForwardRefExoticComponent<MarkdownContentProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type ChatInputPosition = 'centered' | 'bottom';
+type AttachmentStatus = 'pending' | 'uploading' | 'complete' | 'error';
+interface Attachment {
+    id: string;
+    file: File;
+    previewUrl?: string;
+    status: AttachmentStatus;
+    error?: string;
+    progress?: number;
+}
+interface ChatInputProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, 'onSubmit'> {
+    /**
+     * Position of the input: 'centered' for empty state, 'bottom' for conversation mode
+     */
+    position?: ChatInputPosition;
+    /**
+     * Placeholder text for the input
+     */
+    placeholder?: string;
+    /**
+     * Helper text shown above the input in centered mode
+     */
+    helperText?: React$1.ReactNode;
+    /**
+     * Called when the user submits a message
+     */
+    onSubmit?: (message: string, attachments?: Attachment[]) => void;
+    /**
+     * Whether the input is disabled (e.g., during streaming)
+     */
+    disabled?: boolean;
+    /**
+     * Whether to animate the transition between positions
+     */
+    animate?: boolean;
+    /**
+     * Whether the assistant is currently streaming (shows Stop button)
+     */
+    isStreaming?: boolean;
+    /**
+     * Called when the Stop button is clicked during streaming
+     */
+    onStop?: () => void;
+    /**
+     * Current attachments (controlled mode)
+     */
+    attachments?: Attachment[];
+    /**
+     * Called when attachments change (controlled mode)
+     */
+    onAttachmentsChange?: (attachments: Attachment[]) => void;
+    /**
+     * Whether to show the attachment button
+     */
+    showAttachmentButton?: boolean;
+    /**
+     * Accepted file types for attachments
+     */
+    acceptedFileTypes?: string;
+}
+declare const ChatInput: React$1.ForwardRefExoticComponent<ChatInputProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface Conversation {
+    id: string;
+    title: string;
+    preview?: string;
+    timestamp?: string;
+    isActive?: boolean;
+}
+interface ConversationSidebarProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * List of conversations to display
+     */
+    conversations: Conversation[];
+    /**
+     * Whether the sidebar is collapsed
+     */
+    isCollapsed?: boolean;
+    /**
+     * Callback when a conversation is selected
+     */
+    onSelectConversation?: (id: string) => void;
+    /**
+     * Callback when "New Chat" is clicked
+     */
+    onNewChat?: () => void;
+    /**
+     * Callback to toggle collapse state
+     */
+    onToggleCollapse?: () => void;
+}
+/**
+ * ConversationSidebar displays a collapsible list of past conversations.
+ *
+ * When collapsed, shows a thin strip with history icon at top.
+ * When expanded, shows chevron at top-left to collapse.
+ */
+declare const ConversationSidebar: React$1.ForwardRefExoticComponent<ConversationSidebarProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * Collapsed sidebar toggle button (for external use if needed)
+ */
+interface CollapsedSidebarToggleProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    onExpand?: () => void;
+}
+declare const CollapsedSidebarToggle: React$1.ForwardRefExoticComponent<CollapsedSidebarToggleProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Conversation Tree Types
+ *
+ * These types support branching conversations where users can:
+ * - Edit their messages (creating a new branch)
+ * - Retry assistant responses (creating a new branch)
+ * - Navigate between different conversation branches
+ */
+/**
+ * A node in the conversation tree
+ */
+interface MessageNode {
+    /**
+     * Unique identifier for this message
+     */
+    id: string;
+    /**
+     * The role of the message author
+     */
+    role: 'user' | 'assistant';
+    /**
+     * The message content (may include HTML/markdown)
+     */
+    content: string;
+    /**
+     * ID of the parent message (null for root messages)
+     */
+    parentId: string | null;
+    /**
+     * IDs of child messages (branches/continuations)
+     */
+    children: string[];
+    /**
+     * Which sibling branch this message is (0, 1, 2...)
+     * Used for UI display like "1/3"
+     */
+    branchIndex?: number;
+    /**
+     * Whether this message is currently being streamed
+     */
+    isStreaming?: boolean;
+    /**
+     * Timestamp when the message was created
+     */
+    createdAt?: number;
+}
+/**
+ * The full conversation tree structure
+ */
+interface ConversationTree {
+    /**
+     * All nodes indexed by their ID
+     */
+    nodes: Record<string, MessageNode>;
+    /**
+     * IDs of root-level messages (messages with no parent)
+     */
+    rootIds: string[];
+    /**
+     * The current "head" of the viewed branch
+     * This is the leaf node that determines which path we're viewing
+     */
+    activeLeafId: string | null;
+}
+/**
+ * Helper to check if a file is an image
+ */
+declare function isImageFile(file: File): boolean;
+/**
+ * Helper to create a preview URL for an image file
+ */
+declare function createPreviewUrl(file: File): string | undefined;
+/**
+ * Helper to revoke a preview URL when no longer needed
+ */
+declare function revokePreviewUrl(url: string | undefined): void;
+/**
+ * Generate a unique ID
+ */
+declare function generateId(): string;
+/**
+ * Create an empty conversation tree
+ */
+declare function createEmptyTree(): ConversationTree;
+/**
+ * Add a message to the tree
+ */
+declare function addMessageToTree(tree: ConversationTree, message: Omit<MessageNode, 'children' | 'branchIndex'>, parentId?: string | null): ConversationTree;
+/**
+ * Get the linear path from root to the active leaf
+ */
+declare function getActivePathMessages(tree: ConversationTree): MessageNode[];
+/**
+ * Get sibling count and current index for a node
+ */
+declare function getSiblingInfo(tree: ConversationTree, nodeId: string): {
+    total: number;
+    current: number;
+};
+/**
+ * Switch to a different branch at a given node
+ */
+declare function switchBranch(tree: ConversationTree, nodeId: string, direction: 'prev' | 'next'): ConversationTree;
+/**
+ * Update a node's content (e.g., during streaming)
+ */
+declare function updateNodeContent(tree: ConversationTree, nodeId: string, content: string, isStreaming?: boolean): ConversationTree;
+/**
+ * Convert a flat message array to a conversation tree
+ */
+declare function messagesToTree(messages: Array<{
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    isStreaming?: boolean;
+}>): ConversationTree;
+/**
+ * Check if a node has multiple children (is a branch point)
+ */
+declare function isBranchPoint(tree: ConversationTree, nodeId: string): boolean;
+
+interface ChatMessage {
+    id: string;
+    variant: 'user' | 'assistant';
+    content: string;
+    isStreaming?: boolean;
 }
-declare const Message: React.ForwardRefExoticComponent<MessageProps & React.RefAttributes<HTMLDivElement>>;
+interface ChatInterfaceProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, 'onSubmit'> {
+    /**
+     * Array of messages in the conversation (flat mode)
+     * Use this OR conversationTree, not both
+     */
+    messages?: ChatMessage[];
+    /**
+     * Conversation tree for branching support
+     * Use this OR messages, not both
+     */
+    conversationTree?: ConversationTree;
+    /**
+     * Called when the conversation tree changes (for tree mode)
+     */
+    onTreeChange?: (tree: ConversationTree) => void;
+    /**
+     * List of past conversations for the sidebar
+     */
+    conversations?: Conversation[];
+    /**
+     * Called when a message is submitted
+     */
+    onMessageSubmit?: (message: string, attachments?: Attachment[]) => void;
+    /**
+     * Called when a user message is edited (creates a branch)
+     */
+    onEditMessage?: (messageId: string, newContent: string) => void;
+    /**
+     * Called when an assistant message is retried (creates a branch)
+     */
+    onRetryMessage?: (messageId: string) => void;
+    /**
+     * Called when Stop button is clicked during streaming
+     */
+    onStop?: () => void;
+    /**
+     * Called when a conversation is selected from sidebar
+     */
+    onSelectConversation?: (id: string) => void;
+    /**
+     * Called when "New Chat" is clicked
+     */
+    onNewChat?: () => void;
+    /**
+     * Whether the assistant is currently streaming a response
+     */
+    isStreaming?: boolean;
+    /**
+     * Whether to show the thinking indicator (before first response token)
+     */
+    isThinking?: boolean;
+    /**
+     * Input placeholder text
+     */
+    placeholder?: string;
+    /**
+     * Helper text shown in empty state
+     */
+    emptyStateHelper?: React$1.ReactNode;
+    /**
+     * Initial sidebar collapsed state
+     */
+    initialSidebarCollapsed?: boolean;
+    /**
+     * Custom empty state content
+     */
+    emptyState?: React$1.ReactNode;
+    /**
+     * Whether to show attachment button
+     */
+    showAttachmentButton?: boolean;
+    /**
+     * Whether to enable message actions (copy, edit, retry)
+     */
+    enableMessageActions?: boolean;
+    /**
+     * Current attachments for the input
+     */
+    attachments?: Attachment[];
+    /**
+     * Called when attachments change in the input
+     */
+    onAttachmentsChange?: (attachments: Attachment[]) => void;
+}
+/**
+ * ChatInterface is the main orchestrator for a full-featured chat experience.
+ *
+ * Features:
+ * - ConversationSidebar (left) — collapsible list of past conversations
+ * - ChatView (center) — main conversation area with smart scrolling
+ * - ArtifactsPanel (right) — agent-controlled panel for rich content
+ * - ChatInput — position-aware input that centers in empty state
+ * - Branching — support for conversation tree with branch navigation
+ * - Message Actions — copy, edit, retry
+ * - Thinking Indicator — shown between user message and response
+ */
+declare const ChatInterface: React$1.ForwardRefExoticComponent<ChatInterfaceProps & React$1.RefAttributes<HTMLDivElement>>;
 
-interface ChatHistoryItem extends Omit<MessageProps, 'variant' | 'children'> {
+interface ChatViewItem extends Omit<MessageProps, 'variant' | 'children'> {
     id?: string;
     variant?: MessageVariant;
+    /**
+     * Branch navigation info for this message
+     */
+    branchInfo?: MessageBranchInfo;
+    /**
+     * Actions configuration for this message
+     */
+    actions?: MessageActionsConfig;
+}
+interface ChatViewProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Array of chat messages to display
+     */
+    messages: ChatViewItem[];
+    /**
+     * Index of the latest user message to anchor scroll to.
+     * When this changes, the component scrolls that message to the top.
+     */
+    latestUserMessageIndex?: number;
+    /**
+     * Whether the assistant is currently streaming a response
+     */
+    isStreaming?: boolean;
+    /**
+     * Whether to show the thinking indicator (between user message and response)
+     */
+    isThinking?: boolean;
+    /**
+     * Callback when the user scrolls manually
+     */
+    onScroll?: (e: React$1.UIEvent<HTMLDivElement>) => void;
 }
-interface ChatHistoryProps extends React.HTMLAttributes<HTMLDivElement> {
-    /** Array of chat messages. Each item requires: content (string), variant ('user' | 'assistant'). Optional: id, isStreaming. */
-    messages: ChatHistoryItem[];
+/**
+ * ChatView displays a conversation thread with smart scrolling behavior.
+ *
+ * Key behaviors:
+ * - When a user message is sent, it anchors to the top of the viewport
+ * - Does NOT auto-scroll during streaming (respects user's reading position)
+ * - Smooth transitions and animations
+ */
+declare const ChatView: React$1.ForwardRefExoticComponent<ChatViewProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type ArtifactType = 'text' | 'image' | 'video';
+interface Artifact {
+    id: string;
+    type: ArtifactType;
+    content?: string;
+    src?: string;
+    alt?: string;
+    title?: string;
+    subtitle?: string;
+    isPending?: boolean;
+}
+interface UseArtifactParserReturn {
+    /**
+     * Content with artifact blocks stripped out (including incomplete ones)
+     */
+    cleanContent: string;
+    /**
+     * Parsed artifacts array
+     */
+    artifacts: Artifact[];
+    /**
+     * Whether there's an incomplete artifact currently being streamed
+     */
+    hasPendingArtifact: boolean;
 }
-declare const ChatHistory: React.FC<ChatHistoryProps>;
+/**
+ * Hook to parse :::artifact{...}::: blocks from streaming content.
+ *
+ * Key streaming behavior:
+ * - As soon as :::artifact{ is detected, everything from that point is stripped
+ * - This prevents artifact syntax from showing in the message during streaming
+ * - Complete artifacts are parsed and returned
+ * - Incomplete artifacts trigger hasPendingArtifact flag for loading states
+ *
+ * Supported artifact types:
+ * - text: Rendered with MarkdownContent (content attribute)
+ * - image: Rendered with ImageCard (src, alt, title, subtitle)
+ * - video: Rendered with VideoCard (src, title, subtitle)
+ */
+declare function useArtifactParser(content: string): UseArtifactParserReturn;
 
-interface StreamingCursorProps extends React.HTMLAttributes<HTMLSpanElement> {
-    variant?: 'block' | 'line' | 'underscore';
+interface ArtifactsPanelProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Array of artifacts to display
+     */
+    artifacts: Artifact[];
+    /**
+     * Whether the panel is visible
+     */
+    isOpen?: boolean;
+    /**
+     * Callback to close/collapse the panel
+     */
+    onClose?: () => void;
+    /**
+     * Whether artifacts are still loading (show skeletons)
+     */
+    isLoading?: boolean;
 }
-declare const StreamingCursor: React.ForwardRefExoticComponent<StreamingCursorProps & React.RefAttributes<HTMLSpanElement>>;
+/**
+ * ArtifactsPanel displays rich content artifacts in a slide-in panel.
+ *
+ * When collapsed, shows a thin strip with layers icon at top.
+ * When expanded, shows chevron at top-right to collapse.
+ */
+declare const ArtifactsPanel: React$1.ForwardRefExoticComponent<ArtifactsPanelProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * Toggle button to expand collapsed artifacts panel
+ */
+interface ArtifactsPanelToggleProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    artifactCount?: number;
+    onExpand?: () => void;
+}
+declare const ArtifactsPanelToggle: React$1.ForwardRefExoticComponent<ArtifactsPanelToggleProps & React$1.RefAttributes<HTMLButtonElement>>;
 
-interface MarkdownContentProps extends React.HTMLAttributes<HTMLDivElement> {
+type MessageActionsVariant = 'user' | 'assistant';
+interface MessageActionsProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Whether this is for a user or assistant message
+     */
+    variant: MessageActionsVariant;
+    /**
+     * The message content for copy functionality
+     */
     content: string;
-    sanitizeConfig?: Config;
+    /**
+     * Called when user wants to edit their message
+     * Consumer should handle creating a branch with the edited content
+     */
+    onEdit?: (newContent: string) => void;
+    /**
+     * Called when user wants to retry/regenerate the assistant response
+     * Consumer should handle creating a branch with a new response
+     */
+    onRetry?: () => void;
+    /**
+     * Whether the message is currently being edited
+     */
+    isEditing?: boolean;
+    /**
+     * Callback to set editing state (controlled from parent)
+     */
+    onEditingChange?: (isEditing: boolean) => void;
+    /**
+     * Initial content for the edit input (defaults to content prop)
+     */
+    editValue?: string;
+}
+declare const MessageActions: React$1.ForwardRefExoticComponent<MessageActionsProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface ThinkingIndicatorProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Whether the indicator is visible/active
+     */
+    isVisible?: boolean;
+    /**
+     * Interval between phrase changes in ms
+     * @default 2500
+     */
+    phraseInterval?: number;
+    /**
+     * Custom phrases to cycle through (defaults to built-in phrases)
+     */
+    phrases?: string[];
+}
+declare const ThinkingIndicator: React$1.ForwardRefExoticComponent<ThinkingIndicatorProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface BranchNavigatorProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Current branch index (1-based for display)
+     */
+    current: number;
+    /**
+     * Total number of sibling branches
+     */
+    total: number;
+    /**
+     * Called when navigating to previous branch
+     */
+    onPrevious?: () => void;
+    /**
+     * Called when navigating to next branch
+     */
+    onNext?: () => void;
+    /**
+     * Size variant
+     */
+    size?: 'sm' | 'md';
+    /**
+     * Whether to show the branch icon
+     */
+    showIcon?: boolean;
+}
+declare const BranchNavigator: React$1.ForwardRefExoticComponent<BranchNavigatorProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface UseScrollAnchorOptions {
+    /**
+     * Behavior for scrolling. Defaults to 'smooth'.
+     */
+    behavior?: ScrollBehavior;
+    /**
+     * Block alignment for scrollIntoView. Defaults to 'start'.
+     */
+    block?: ScrollLogicalPosition;
+}
+interface UseScrollAnchorReturn {
+    /**
+     * Ref to attach to the scrollable container
+     */
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    /**
+     * Ref to attach to the anchor element (latest user message)
+     */
+    anchorRef: React.RefObject<HTMLDivElement | null>;
+    /**
+     * Scroll the anchor element into view. Call this on user message submission.
+     */
+    scrollToAnchor: () => void;
+    /**
+     * Scroll to the bottom of the container.
+     */
+    scrollToBottom: () => void;
+    /**
+     * Check if user has scrolled away from the bottom.
+     */
+    isScrolledToBottom: () => boolean;
 }
-declare const MarkdownContent: React.ForwardRefExoticComponent<MarkdownContentProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Hook for smart scroll behavior in chat interfaces.
+ *
+ * Key behaviors:
+ * - Anchors user messages to the top of the viewport when they send a message
+ * - Does NOT auto-scroll during streaming to respect user's reading position
+ * - Allows manual scroll detection
+ */
+declare function useScrollAnchor(options?: UseScrollAnchorOptions): UseScrollAnchorReturn;
 
 type BrandIconSize = 'sm' | 'md' | 'lg';
 type BrandIconVariant = 'solid' | 'outline';
-interface BrandIconProps extends React.HTMLAttributes<HTMLDivElement> {
+interface BrandIconProps extends React$1.HTMLAttributes<HTMLDivElement> {
     size?: BrandIconSize;
     variant?: BrandIconVariant;
 }
-declare const BrandIcon: React.ForwardRefExoticComponent<BrandIconProps & React.RefAttributes<HTMLDivElement>>;
+declare const BrandIcon: React$1.ForwardRefExoticComponent<BrandIconProps & React$1.RefAttributes<HTMLDivElement>>;
 
-interface ColorSwatchProps extends React.HTMLAttributes<HTMLDivElement> {
+interface ColorSwatchProps extends React$1.HTMLAttributes<HTMLDivElement> {
     color: string;
     label?: string;
 }
-declare const ColorSwatch: React.ForwardRefExoticComponent<ColorSwatchProps & React.RefAttributes<HTMLDivElement>>;
+declare const ColorSwatch: React$1.ForwardRefExoticComponent<ColorSwatchProps & React$1.RefAttributes<HTMLDivElement>>;
 
 type AspectRatioPreset = 'landscape' | 'portrait' | 'square';
 type AspectRatio = AspectRatioPreset | `${number}/${number}`;
 interface ImageCardProps extends Omit<CardProps, 'title'> {
     src: string;
     alt: string;
-    title?: React.ReactNode;
-    subtitle?: React.ReactNode;
+    title?: React$1.ReactNode;
+    subtitle?: React$1.ReactNode;
     aspectRatio?: AspectRatio;
     objectFit?: 'cover' | 'contain';
-    overlay?: React.ReactNode;
+    overlay?: React$1.ReactNode;
     mediaClassName?: string;
     contentClassName?: string;
 }
-declare const ImageCard: React.ForwardRefExoticComponent<ImageCardProps & React.RefAttributes<HTMLDivElement>>;
+declare const ImageCard: React$1.ForwardRefExoticComponent<ImageCardProps & React$1.RefAttributes<HTMLDivElement>>;
 
 type VideoAspectRatioPreset = 'video' | 'cinema' | 'square';
 type VideoAspectRatio = VideoAspectRatioPreset | `${number}/${number}`;
 interface VideoCardProps extends Omit<CardProps, 'title'> {
     src: string;
-    title?: React.ReactNode;
-    subtitle?: React.ReactNode;
+    title?: React$1.ReactNode;
+    subtitle?: React$1.ReactNode;
     aspectRatio?: VideoAspectRatio;
     playing?: boolean;
     controls?: boolean;
@@ -589,13 +1285,13 @@ interface VideoCardProps extends Omit<CardProps, 'title'> {
     contentClassName?: string;
     playerProps?: any;
 }
-declare const VideoCard: React.ForwardRefExoticComponent<VideoCardProps & React.RefAttributes<HTMLDivElement>>;
+declare const VideoCard: React$1.ForwardRefExoticComponent<VideoCardProps & React$1.RefAttributes<HTMLDivElement>>;
 
 type SectionHeadingLevel = 'h2' | 'h3';
-interface SectionHeadingProps extends React.HTMLAttributes<HTMLHeadingElement> {
+interface SectionHeadingProps extends React$1.HTMLAttributes<HTMLHeadingElement> {
     level?: SectionHeadingLevel;
 }
-declare const SectionHeading: React.ForwardRefExoticComponent<SectionHeadingProps & React.RefAttributes<HTMLHeadingElement>>;
+declare const SectionHeading: React$1.ForwardRefExoticComponent<SectionHeadingProps & React$1.RefAttributes<HTMLHeadingElement>>;
 
 /**
  * Aurelius Design System
@@ -609,4 +1305,4 @@ declare const SectionHeading: React.ForwardRefExoticComponent<SectionHeadingProp
 
 declare const version = "2.0.0";
 
-export { Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, AccordionTrigger, type AccordionTriggerProps, Alert, AlertDialog, type AlertDialogProps, type AlertProps, type AlertVariant, type AspectRatio, type AspectRatioPreset, Avatar, type AvatarProps, type AvatarSize, Badge, type BadgeProps, type BadgeVariant, BrandIcon, type BrandIconProps, type BrandIconSize, type BrandIconVariant, Breadcrumb, BreadcrumbItem, type BreadcrumbItemProps, BreadcrumbLink, type BreadcrumbLinkProps, type BreadcrumbProps, Button, type ButtonProps, type ButtonSize, type ButtonVariant, Card, type CardBodyProps, type CardFooterProps, type CardHeaderProps, type CardMediaProps, type CardProps, type CardVariant, ChatHistory, type ChatHistoryItem, type ChatHistoryProps, Checkbox, type CheckboxProps, Col, type ColOffset, type ColOrder, type ColProps, type ColSpan, ColorSwatch, type ColorSwatchProps, ConfirmDialog, type ConfirmDialogProps, Container, type ContainerProps, type ContainerSize, Divider, type DividerProps, Drawer, type DrawerPosition, type DrawerProps, HelperText, type HelperTextProps, ImageCard, type ImageCardProps, Input, type InputAddonProps, type InputElementProps, InputGroup, type InputGroupProps, InputLeftAddon, InputLeftElement, type InputProps, InputRightAddon, InputRightElement, InputWrapper, type InputWrapperProps, Label, type LabelProps, List, ListItem, type ListItemProps, ListItemText, type ListItemTextProps, type ListProps, ListSubheader, type ListSubheaderProps, MarkdownContent, type MarkdownContentProps, Menu, MenuContent, type MenuContentProps, MenuItem, type MenuItemProps, MenuLabel, type MenuProps, MenuSeparator, MenuTrigger, type MenuTriggerProps, Message, type MessageProps, type MessageVariant, Modal, type ModalProps, Navbar, NavbarBrand, type NavbarBrandProps, NavbarContent, type NavbarContentProps, NavbarDivider, NavbarItem, type NavbarItemProps, NavbarLink, type NavbarLinkProps, type NavbarProps, Pagination, type PaginationProps, Popover, type PopoverAlign, type PopoverPosition, type PopoverProps, Progress, type ProgressProps, PromptDialog, type PromptDialogProps, Radio, type RadioProps, Row, type RowAlign, type RowGutter, type RowJustify, type RowProps, SectionHeading, type SectionHeadingLevel, type SectionHeadingProps, Select, type SelectOption, type SelectProps, Skeleton, type SkeletonProps, Slider, type SliderProps, Spinner, type SpinnerProps, Stack, type StackDirection, type StackGap, type StackProps, type Step, type StepStatus, Stepper, type StepperProps, StreamingCursor, type StreamingCursorProps, Switch, type SwitchProps, Tab, TabList, type TabListProps, TabPanel, type TabPanelProps, type TabProps, Table, TableBody, type TableBodyProps, TableCaption, type TableCaptionProps, TableCell, type TableCellProps, TableFooter, type TableFooterProps, TableHead, type TableHeadProps, TableHeader, type TableHeaderProps, type TableProps, TableRow, type TableRowProps, Tabs, type TabsProps, Textarea, type TextareaProps, type ToastData, type ToastPosition, ToastProvider, type ToastProviderProps, type ToastVariant, Tooltip, type TooltipProps, type VideoAspectRatio, type VideoAspectRatioPreset, VideoCard, type VideoCardProps, useToast, version };
+export { Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, AccordionTrigger, type AccordionTriggerProps, Alert, AlertDialog, type AlertDialogProps, type AlertProps, type AlertVariant, type Artifact, type ArtifactType, ArtifactsPanel, type ArtifactsPanelProps, ArtifactsPanelToggle, type ArtifactsPanelToggleProps, type AspectRatio, type AspectRatioPreset, type Attachment, type AttachmentItem, AttachmentPreview, type AttachmentPreviewProps, type AttachmentStatus, Avatar, type AvatarProps, type AvatarSize, Badge, type BadgeProps, type BadgeVariant, BranchNavigator, type BranchNavigatorProps, BrandIcon, type BrandIconProps, type BrandIconSize, type BrandIconVariant, Breadcrumb, BreadcrumbItem, type BreadcrumbItemProps, BreadcrumbLink, type BreadcrumbLinkProps, type BreadcrumbProps, Button, type ButtonProps, type ButtonSize, type ButtonVariant, Card, type CardBodyProps, type CardFooterProps, type CardHeaderProps, type CardMediaProps, type CardProps, type CardVariant, ChatInput, type ChatInputPosition, type ChatInputProps, ChatInterface, type ChatInterfaceProps, type ChatMessage, ChatView, type ChatViewItem, type ChatViewProps, Checkbox, type CheckboxProps, Col, type ColOffset, type ColOrder, type ColProps, type ColSpan, CollapsedSidebarToggle, type CollapsedSidebarToggleProps, ColorSwatch, type ColorSwatchProps, ConfirmDialog, type ConfirmDialogProps, Container, type ContainerProps, type ContainerSize, type Conversation, ConversationSidebar, type ConversationSidebarProps, type ConversationTree, Divider, type DividerProps, Drawer, type DrawerPosition, type DrawerProps, FileChip, type FileChipProps, type FileChipStatus, HelperText, type HelperTextProps, ImageCard, type ImageCardProps, Input, type InputAddonProps, type InputElementProps, InputGroup, type InputGroupProps, InputLeftAddon, InputLeftElement, type InputProps, InputRightAddon, InputRightElement, InputWrapper, type InputWrapperProps, Label, type LabelProps, List, ListItem, type ListItemProps, ListItemText, type ListItemTextProps, type ListProps, ListSubheader, type ListSubheaderProps, MarkdownContent, type MarkdownContentProps, Menu, MenuContent, type MenuContentProps, MenuItem, type MenuItemProps, MenuLabel, type MenuProps, MenuSeparator, MenuTrigger, type MenuTriggerProps, Message, MessageActions, type MessageActionsConfig, type MessageActionsProps, type MessageActionsVariant, type MessageBranchInfo, type MessageNode, type MessageProps, type MessageVariant, Modal, type ModalProps, Navbar, NavbarBrand, type NavbarBrandProps, NavbarContent, type NavbarContentProps, NavbarDivider, NavbarItem, type NavbarItemProps, NavbarLink, type NavbarLinkProps, type NavbarProps, Pagination, type PaginationProps, Popover, type PopoverAlign, type PopoverPosition, type PopoverProps, Progress, type ProgressProps, PromptDialog, type PromptDialogProps, Radio, type RadioProps, Row, type RowAlign, type RowGutter, type RowJustify, type RowProps, SectionHeading, type SectionHeadingLevel, type SectionHeadingProps, Select, type SelectOption, type SelectProps, Skeleton, type SkeletonProps, Slider, type SliderProps, Spinner, type SpinnerProps, Stack, type StackDirection, type StackGap, type StackProps, type Step, type StepStatus, Stepper, type StepperProps, StreamingCursor, type StreamingCursorProps, Switch, type SwitchProps, Tab, TabList, type TabListProps, TabPanel, type TabPanelProps, type TabProps, Table, TableBody, type TableBodyProps, TableCaption, type TableCaptionProps, TableCell, type TableCellProps, TableFooter, type TableFooterProps, TableHead, type TableHeadProps, TableHeader, type TableHeaderProps, type TableProps, TableRow, type TableRowProps, Tabs, type TabsProps, Textarea, type TextareaProps, ThinkingIndicator, type ThinkingIndicatorProps, type ToastData, type ToastPosition, ToastProvider, type ToastProviderProps, type ToastVariant, Tooltip, type TooltipProps, type UseArtifactParserReturn, type UseScrollAnchorOptions, type UseScrollAnchorReturn, type VideoAspectRatio, type VideoAspectRatioPreset, VideoCard, type VideoCardProps, addMessageToTree, createEmptyTree, createPreviewUrl, generateId, getActivePathMessages, getSiblingInfo, isBranchPoint, isImageFile, messagesToTree, revokePreviewUrl, switchBranch, updateNodeContent, useArtifactParser, useScrollAnchor, useToast, version };