@mesob/ui 0.2.5 → 0.3.1

package/dist/components.d.ts

@@ -1,51 +1,54 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as React$1 from 'react';
-import { ReactNode, ComponentType } from 'react';
+import { ReactNode, ComponentType, ReactElement } from 'react';
 export { u as useEntityPagination, a as useEntityParams } from './use-entity-params-nqD69tdX.js';
 import * as react_hook_form from 'react-hook-form';
 import { Control, UseFormRegister, ControllerRenderProps, FieldError as FieldError$1, FieldValues, FieldPath, ControllerProps } from 'react-hook-form';
 import { Locale } from './lib/locale.js';
 import { Editor } from '@tiptap/react';
-import * as AccordionPrimitive from '@radix-ui/react-accordion';
+import { Accordion as Accordion$1 } from '@base-ui/react/accordion';
 import * as class_variance_authority_types from 'class-variance-authority/types';
+import { useRender } from '@base-ui/react/use-render';
 import { VariantProps } from 'class-variance-authority';
-import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
-import * as AspectRatioPrimitive from '@radix-ui/react-aspect-ratio';
-import * as AvatarPrimitive from '@radix-ui/react-avatar';
-import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import { ComponentColor, ComponentSize, ComponentRadius, InputWrapperOrder } from './lib/theme-schema.js';
+import { AlertDialog as AlertDialog$1 } from '@base-ui/react/alert-dialog';
+import { Avatar as Avatar$1 } from '@base-ui/react/avatar';
+import { Button as Button$1 } from '@base-ui/react/button';
+import { Separator as Separator$1 } from '@base-ui/react/separator';
 import { DayPicker, DayButton } from 'react-day-picker';
+export { DateRange } from 'react-day-picker';
 import useEmblaCarousel, { UseEmblaCarouselType } from 'embla-carousel-react';
 import * as RechartsPrimitive from 'recharts';
-import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
-import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
-import { Command as Command$1 } from 'cmdk';
-import * as DialogPrimitive from '@radix-ui/react-dialog';
-import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import { Checkbox as Checkbox$1 } from '@base-ui/react/checkbox';
+import { Collapsible as Collapsible$1 } from '@base-ui/react/collapsible';
+import { ColorFormat } from './lib/color-utils.js';
+import { Combobox as Combobox$1 } from '@base-ui/react/combobox';
+import { Autocomplete } from '@base-ui/react/autocomplete';
+import { Dialog as Dialog$1 } from '@base-ui/react/dialog';
+import { ContextMenu as ContextMenu$1 } from '@base-ui/react/context-menu';
 import { ColumnDef, SortingState, ColumnFiltersState, VisibilityState, Column, Table as Table$1 } from '@tanstack/react-table';
-import { Drawer as Drawer$1 } from 'vaul';
-import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
-import * as LabelPrimitive from '@radix-ui/react-label';
-import { Slot } from '@radix-ui/react-slot';
-import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
+export { DirectionProvider, useDirection } from '@base-ui/react/direction-provider';
+import { Menu } from '@base-ui/react/menu';
+import { PreviewCard } from '@base-ui/react/preview-card';
 import { OTPInput } from 'input-otp';
-import * as MenubarPrimitive from '@radix-ui/react-menubar';
-import * as NavigationMenuPrimitive from '@radix-ui/react-navigation-menu';
-import * as PopoverPrimitive from '@radix-ui/react-popover';
-import * as ProgressPrimitive from '@radix-ui/react-progress';
-import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import { Menubar as Menubar$1 } from '@base-ui/react/menubar';
+import { NavigationMenu as NavigationMenu$1 } from '@base-ui/react/navigation-menu';
+import { Popover as Popover$1 } from '@base-ui/react/popover';
+import { Progress as Progress$1 } from '@base-ui/react/progress';
+import { Radio } from '@base-ui/react/radio';
+import { RadioGroup as RadioGroup$1 } from '@base-ui/react/radio-group';
 import * as ResizablePrimitive from 'react-resizable-panels';
-import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
-import * as SelectPrimitive from '@radix-ui/react-select';
-import * as TooltipPrimitive from '@radix-ui/react-tooltip';
-import * as SliderPrimitive from '@radix-ui/react-slider';
+import { ScrollArea as ScrollArea$1 } from '@base-ui/react/scroll-area';
+import { Select as Select$1 } from '@base-ui/react/select';
+import { Tooltip as Tooltip$1 } from '@base-ui/react/tooltip';
+import { Slider as Slider$1 } from '@base-ui/react/slider';
 import { ToasterProps } from 'sonner';
 export { toast } from 'sonner';
 import { IconLoader2 } from '@tabler/icons-react';
-import * as SwitchPrimitive from '@radix-ui/react-switch';
-import * as TabsPrimitive from '@radix-ui/react-tabs';
-import * as TogglePrimitive from '@radix-ui/react-toggle';
-import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
-import * as VisuallyHiddenPrimitive from '@radix-ui/react-visually-hidden';
+import { Switch as Switch$1 } from '@base-ui/react/switch';
+import { Tabs as Tabs$1 } from '@base-ui/react/tabs';
+import { Toggle as Toggle$1 } from '@base-ui/react/toggle';
+import { ToggleGroup as ToggleGroup$1 } from '@base-ui/react/toggle-group';
 import 'nuqs';
 import 'zod';
 
@@ -135,6 +138,120 @@ type AppSidebarProps = {
 };
 declare function AppSidebar({ logo, navItems, footer, pathname, roles, }: AppSidebarProps): react_jsx_runtime.JSX.Element;
 
+type LoaderType = 'oval' | 'bars' | 'dots';
+type LoaderProps = {
+    type?: LoaderType;
+    size?: number | string;
+    color?: string;
+    className?: string;
+    children?: React$1.ReactNode;
+};
+declare const Loader: React$1.ForwardRefExoticComponent<LoaderProps & React$1.RefAttributes<HTMLOutputElement>>;
+
+type LoadingOverlayProps = {
+    visible: boolean;
+    zIndex?: number;
+    blur?: number;
+    opacity?: number;
+    loaderSize?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number;
+    loaderType?: LoaderType;
+    loaderColor?: string;
+    loaderProps?: React$1.ComponentProps<typeof Loader>;
+    className?: string;
+};
+declare function LoadingOverlay({ visible, zIndex, blur, opacity, loaderSize, loaderType, loaderColor, loaderProps, className, }: LoadingOverlayProps): react_jsx_runtime.JSX.Element | null;
+
+type EmptyCardLoadingProps = {
+    className?: string;
+    zIndex?: number;
+    minHeight?: boolean;
+    loaderSize?: LoadingOverlayProps['loaderSize'];
+    loaderType?: LoadingOverlayProps['loaderType'];
+};
+declare function EmptyCardLoading({ className, zIndex, minHeight, loaderSize, loaderType, }: EmptyCardLoadingProps): react_jsx_runtime.JSX.Element;
+
+type EntityPageLoadingProps = {
+    className?: string;
+    loaderSize?: LoadingOverlayProps['loaderSize'];
+    loaderType?: LoadingOverlayProps['loaderType'];
+};
+declare function EntityPageLoading({ className, loaderSize, loaderType, }: EntityPageLoadingProps): react_jsx_runtime.JSX.Element;
+
+type ErrorPageViewProps = {
+    code: string;
+    title: string;
+    description: string;
+    primaryAction: ReactNode;
+    secondaryAction?: ReactNode;
+    onRetry?: () => void;
+};
+declare function ErrorPageView({ code, title, description, primaryAction, secondaryAction, onRetry, }: ErrorPageViewProps): react_jsx_runtime.JSX.Element;
+
+type NoDataAvailableProps = {
+    title: string;
+    message: string;
+    iconType?: 'certificate' | 'alert' | 'cart' | 'message';
+    buttonText?: string;
+    buttonLink?: string;
+    icon?: React$1.ReactNode;
+};
+declare function NoDataAvailable({ title, message, iconType, buttonText, buttonLink, icon, }: NoDataAvailableProps): react_jsx_runtime.JSX.Element;
+
+type DisplayTableVariant = 'horizontal' | 'vertical';
+type DisplayTableData = {
+    caption?: React$1.ReactNode;
+    head?: React$1.ReactNode[];
+    body: React$1.ReactNode[][];
+    foot?: React$1.ReactNode[];
+};
+type ScrollContainerProps = React$1.HTMLAttributes<HTMLDivElement> & {
+    minWidth?: number;
+    maxHeight?: number;
+    type?: 'native' | 'scroll-area';
+};
+declare function DisplayTableScrollContainer({ className, minWidth, maxHeight, type, children, style, ...props }: ScrollContainerProps): react_jsx_runtime.JSX.Element;
+declare namespace DisplayTableScrollContainer {
+    var displayName: string;
+}
+declare const DisplayTableThead: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const DisplayTableTbody: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const DisplayTableTfoot: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+declare const DisplayTableTr: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & {
+    variant?: DisplayTableVariant;
+} & React$1.RefAttributes<HTMLTableRowElement>>;
+declare const DisplayTableTh: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCellElement> & {
+    w?: number | string;
+} & React$1.RefAttributes<HTMLTableCellElement>>;
+declare const DisplayTableTd: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+declare const DisplayTableCaption: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;
+declare const DisplayTable: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableElement> & {
+    variant?: DisplayTableVariant;
+    striped?: boolean;
+    stripedInverted?: boolean;
+    highlightOnHover?: boolean;
+    withTableBorder?: boolean;
+    withColumnBorders?: boolean;
+    withRowBorders?: boolean;
+    stickyHeader?: boolean;
+    stickyHeaderOffset?: number;
+    captionSide?: "top" | "bottom";
+    tabularNums?: boolean;
+    data?: DisplayTableData;
+} & React$1.RefAttributes<HTMLTableElement>> & {
+    Thead: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+    Tbody: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+    Tfoot: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableSectionElement> & React$1.RefAttributes<HTMLTableSectionElement>>;
+    Tr: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableRowElement> & {
+        variant?: DisplayTableVariant;
+    } & React$1.RefAttributes<HTMLTableRowElement>>;
+    Th: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCellElement> & {
+        w?: number | string;
+    } & React$1.RefAttributes<HTMLTableCellElement>>;
+    Td: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCellElement> & React$1.RefAttributes<HTMLTableCellElement>>;
+    Caption: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLTableCaptionElement> & React$1.RefAttributes<HTMLTableCaptionElement>>;
+    ScrollContainer: typeof DisplayTableScrollContainer;
+};
+
 type BulkAction = {
     label: string;
     icon?: ReactNode;
@@ -158,25 +275,16 @@ type TabItem = {
     href?: string;
     content?: ReactNode;
 };
-type LinkComponentProps$1 = {
-    href: string;
-    className?: string;
-    children: ReactNode;
-    ref?: React.Ref<HTMLAnchorElement>;
-};
 type EntityDetailHeaderProps = {
     title: ReactNode;
     icon?: ReactNode;
-    backButton?: ReactNode;
+    showBack?: boolean;
+    loading?: boolean;
     actions?: ReactNode;
     tabs: TabItem[];
-    activeTab?: string;
-    defaultTab?: string;
-    onTabChange?: (value: string) => void;
     className?: string;
-    linkComponent?: ComponentType<LinkComponentProps$1>;
 };
-declare function EntityDetailHeader({ title, icon, backButton, actions, tabs, activeTab: controlledActiveTab, defaultTab, onTabChange, className, linkComponent: LinkComponent, }: EntityDetailHeaderProps): react_jsx_runtime.JSX.Element;
+declare function EntityDetailHeader({ title, icon, showBack, loading, actions, tabs, className, }: EntityDetailHeaderProps): react_jsx_runtime.JSX.Element;
 
 type EntityDrawerProps = {
     title: ReactNode;
@@ -214,18 +322,31 @@ type EntityEmptyStateProps = {
 };
 declare function EntityEmptyState({ icon: Icon, title, description, entityName, actionLabel, onAction, children, className, }: EntityEmptyStateProps): react_jsx_runtime.JSX.Element;
 
-type FilterOption = {
+type FilterOption$2 = {
     label: string;
     value: string;
 };
 type EntityFilterProps = {
-    options: FilterOption[];
+    options: FilterOption$2[];
     placeholder?: string;
     className?: string;
     label?: string;
 };
 declare function EntityFilter({ options, placeholder, className, label, }: EntityFilterProps): react_jsx_runtime.JSX.Element;
 
+type FilterOption$1 = {
+    label: string;
+    value: string;
+};
+type EntityFilterStateProps = {
+    value: string;
+    onValueChange: (v: string) => void;
+    options: FilterOption$1[];
+    placeholder?: string;
+    className?: string;
+};
+declare function EntityFilterState({ value, onValueChange, options, placeholder, className, }: EntityFilterStateProps): react_jsx_runtime.JSX.Element;
+
 type EntityFormActionsProps = {
     mode: 'new' | 'edit';
     onSubmit?: () => void;
@@ -249,8 +370,10 @@ type EntityHeaderProps = {
     filter?: ReactNode;
     sort?: ReactNode;
     view?: ReactNode;
+    /** When false, render without Card wrapper (e.g. inside EntitySection) */
+    wrapInCard?: boolean;
 };
-declare function EntityHeader({ title, icon, actions, search, filter, sort, view, }: EntityHeaderProps): react_jsx_runtime.JSX.Element;
+declare function EntityHeader({ title, icon, actions, search, filter, sort, view, wrapInCard, }: EntityHeaderProps): react_jsx_runtime.JSX.Element;
 
 type EntityLoadingStateProps = {
     view: 'table' | 'card';
@@ -268,25 +391,233 @@ type EntitySearchProps = {
 };
 declare function EntitySearch({ paramKey, placeholder, className, }: EntitySearchProps): react_jsx_runtime.JSX.Element;
 
-type SortOption = {
+type EntitySearchStateProps = {
+    value: string;
+    onValueChange: (v: string) => void;
+    placeholder?: string;
+    className?: string;
+    debounceMs?: number;
+};
+declare function EntitySearchState({ value, onValueChange, placeholder, className, debounceMs, }: EntitySearchStateProps): react_jsx_runtime.JSX.Element;
+
+type EntitySectionView = 'table' | 'card' | 'list';
+type FilterOption = {
+    label: string;
+    value: string;
+};
+type SortOption$2 = {
+    label: string;
+    value: string;
+};
+type EntityParams = {
+    search: string;
+    filter: string;
+    sort: string;
+    order: 'asc' | 'desc';
+    view: EntitySectionView;
+    page: number;
+    pageSize: number;
+};
+type UseEntitySectionStateConfig = {
+    defaultSort?: string;
+    defaultOrder?: 'asc' | 'desc';
+    defaultPageSize?: number;
+    defaultView?: EntitySectionView;
+    searchPlaceholder?: string;
+    /** API query param name for search (default 'search') */
+    searchParamName?: string;
+    filterOptions?: FilterOption[];
+    sortOptions?: SortOption$2[];
+    views?: EntitySectionView[];
+};
+declare function useEntitySectionState(config?: UseEntitySectionStateConfig): {
+    search: string;
+    setSearch: React$1.Dispatch<React$1.SetStateAction<string>>;
+    filter: string;
+    setFilter: React$1.Dispatch<React$1.SetStateAction<string>>;
+    sort: string;
+    setSort: React$1.Dispatch<React$1.SetStateAction<string>>;
+    order: "desc" | "asc";
+    setOrder: React$1.Dispatch<React$1.SetStateAction<"desc" | "asc">>;
+    view: EntitySectionView;
+    setView: React$1.Dispatch<React$1.SetStateAction<EntitySectionView>>;
+    page: number;
+    setPage: React$1.Dispatch<React$1.SetStateAction<number>>;
+    pageSize: number;
+    setPageSize: React$1.Dispatch<React$1.SetStateAction<number>>;
+    setPageReset: () => void;
+    queryConfig: {
+        params: {
+            query: {
+                sort?: string | undefined;
+                order?: "desc" | "asc" | undefined;
+                filter?: string | undefined;
+                page: number;
+                limit: number;
+            };
+        };
+    };
+    params: EntityParams;
+    setParams: (update: Partial<EntityParams>) => void;
+    filterOptions: FilterOption[];
+    sortOptions: SortOption$2[];
+    views: EntitySectionView[];
+};
+
+type EntitySectionState = {
+    search: string;
+    setSearch: (v: string) => void;
+    filter: string;
+    setFilter: (v: string) => void;
+    sort: string;
+    setSort: (v: string) => void;
+    order: 'asc' | 'desc';
+    setOrder: (v: 'asc' | 'desc') => void;
+    view: EntitySectionView;
+    setView: (v: EntitySectionView) => void;
+    page: number;
+    setPage: (v: number) => void;
+    pageSize: number;
+    setPageSize: (v: number) => void;
+    setPageReset: () => void;
+    filterOptions: {
+        label: string;
+        value: string;
+    }[];
+    sortOptions: {
+        label: string;
+        value: string;
+    }[];
+    views: EntitySectionView[];
+};
+type EntitySectionConfig = {
+    searchPlaceholder?: string;
+    filterOptions?: {
+        label: string;
+        value: string;
+    }[];
+    sortOptions?: {
+        label: string;
+        value: string;
+    }[];
+    views?: EntitySectionView[];
+};
+type EntitySectionProps = {
+    title: ReactNode;
+    icon?: ReactNode;
+    actions?: ReactNode;
+    config?: EntitySectionConfig;
+    state: EntitySectionState;
+    onOpenChange?: (open: boolean) => void;
+    /** When false, the toolbar row (search, filter, sort, view) is not rendered */
+    showToolbar?: boolean;
+    children: (state: EntitySectionState) => ReactNode;
+};
+declare function EntitySection({ title, icon, actions, config, state, onOpenChange, showToolbar, children, }: EntitySectionProps): react_jsx_runtime.JSX.Element;
+
+type EntitySelectorModalSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+type EntitySelectorModalProps = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title?: ReactNode;
+    size?: EntitySelectorModalSize;
+    contentClassName?: string;
+    footer?: ReactNode;
+    children: ReactNode;
+};
+declare function EntitySelectorModal({ open, onOpenChange, title, size, contentClassName, footer, children, }: EntitySelectorModalProps): react_jsx_runtime.JSX.Element;
+
+type BaseItem = {
+    id: string;
+};
+type EntitySelectorColumn<T> = {
+    key: string;
+    header: ReactNode;
+    cell: (item: T) => ReactNode;
+    className?: string;
+};
+type EntitySelectorConfig<T extends BaseItem> = {
+    title: string;
+    modalSize?: EntitySelectorModalSize;
+    contentClassName?: string;
+    multiple?: boolean;
+    minSelect?: number;
+    maxSelect?: number;
+    entityName: string;
+    entityIcon: React.ComponentType<{
+        className?: string;
+    }>;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    columns: EntitySelectorColumn<T>[];
+    columnCount?: number;
+    getItemLabel: (item: T) => string;
+    searchPlaceholder?: string;
+    filterOptions?: {
+        label: string;
+        value: string;
+    }[];
+    sortOptions?: {
+        label: string;
+        value: string;
+    }[];
+    showViewToggle?: boolean;
+    wrapHeaderInCard?: boolean;
+    renderCard?: (item: T, selected: boolean, onToggle: () => void) => ReactNode;
+};
+type EntitySelectorProps<T extends BaseItem> = {
+    trigger: ReactNode;
+    config: EntitySelectorConfig<T>;
+    onSelect: (items: T[]) => void;
+    items: T[];
+    total?: number;
+    isLoading?: boolean;
+    state: EntitySectionState;
+};
+declare function EntitySelector<T extends BaseItem>({ trigger, config, onSelect, items, total: totalProp, isLoading, state, }: EntitySelectorProps<T>): react_jsx_runtime.JSX.Element;
+
+type SortOption$1 = {
     label: string;
     value: string;
 };
 type EntitySortProps = {
-    options: SortOption[];
+    options: SortOption$1[];
     defaultSort?: string;
     defaultOrder?: 'asc' | 'desc';
     className?: string;
 };
 declare function EntitySort({ options, defaultSort, defaultOrder, className, }: EntitySortProps): react_jsx_runtime.JSX.Element;
 
-type ViewOption = 'table' | 'card' | 'list';
+type SortOption = {
+    label: string;
+    value: string;
+};
+type EntitySortStateProps = {
+    sort: string;
+    order: 'asc' | 'desc';
+    onSortChange: (v: string) => void;
+    onOrderChange: (v: 'asc' | 'desc') => void;
+    options: SortOption[];
+    className?: string;
+};
+declare function EntitySortState({ sort, order, onSortChange, onOrderChange, options, className, }: EntitySortStateProps): react_jsx_runtime.JSX.Element;
+
+type ViewOption$1 = 'table' | 'card' | 'list';
 type EntityViewToggleProps = {
-    views?: ViewOption[];
+    views?: ViewOption$1[];
     className?: string;
 };
 declare function EntityViewToggle({ views, className, }: EntityViewToggleProps): react_jsx_runtime.JSX.Element;
 
+type ViewOption = 'table' | 'card' | 'list';
+type EntityViewToggleStateProps = {
+    value: ViewOption;
+    onValueChange: (v: ViewOption) => void;
+    views?: ViewOption[];
+    className?: string;
+};
+declare function EntityViewToggleState({ value, onValueChange, views, className, }: EntityViewToggleStateProps): react_jsx_runtime.JSX.Element;
+
 type PageBodyProps = {
     className?: string;
     children: ReactNode;
@@ -302,10 +633,9 @@ declare function PageContainer({ className, children }: PageContainerProps): rea
 type PageGoBackProps = {
     onBack: () => void;
     label?: string;
-    className?: string;
     children?: ReactNode;
 };
-declare function PageGoBack({ onBack, label, className, children, }: PageGoBackProps): react_jsx_runtime.JSX.Element;
+declare function PageGoBack({ onBack, label, children, }: PageGoBackProps): react_jsx_runtime.JSX.Element;
 
 type PageSectionProps = {
     title?: ReactNode;
@@ -332,12 +662,16 @@ declare function PageTitle({ icon, back, action, children, className, }: PageTit
 type SectionProps = {
     title: ReactNode;
     children: ReactNode;
+    /** Shown in header before expand/collapse button, only when section is open */
+    actions?: ReactNode;
     defaultOpen?: boolean;
+    lazy?: boolean;
+    onOpenChange?: (open: boolean) => void;
     className?: string;
     headerClassName?: string;
     contentClassName?: string;
 };
-declare function Section({ title, children, defaultOpen, className, headerClassName, contentClassName, }: SectionProps): react_jsx_runtime.JSX.Element;
+declare function Section({ title, children, actions, defaultOpen, lazy, onOpenChange, className, headerClassName, contentClassName, }: SectionProps): react_jsx_runtime.JSX.Element;
 
 type ShellProps = {
     sidebar: React$1.ReactNode;
@@ -484,29 +818,100 @@ type ThemeToggleProps = {
 };
 declare function ThemeToggle({ className }: ThemeToggleProps): react_jsx_runtime.JSX.Element;
 
-declare function Accordion({ ...props }: React$1.ComponentProps<typeof AccordionPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function AccordionItem({ className, ...props }: React$1.ComponentProps<typeof AccordionPrimitive.Item>): react_jsx_runtime.JSX.Element;
-declare function AccordionTrigger({ className, children, ...props }: React$1.ComponentProps<typeof AccordionPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
-declare function AccordionContent({ className, children, ...props }: React$1.ComponentProps<typeof AccordionPrimitive.Content>): react_jsx_runtime.JSX.Element;
+type AccordionProps = React$1.ComponentProps<typeof Accordion$1.Root> & {
+    variant?: 'default' | 'separated' | 'contained' | 'filled';
+    radius?: unknown;
+    chevronPosition?: 'left' | 'right';
+    chevronSize?: number | string;
+    chevronIconSize?: number | string;
+    chevron?: React$1.ReactNode | null;
+    disableChevronRotation?: boolean;
+    transitionDuration?: number;
+    order?: 2 | 3 | 4 | 5 | 6;
+    unstyled?: boolean;
+};
+declare function Accordion({ className, variant, chevronPosition, transitionDuration, unstyled, radius: _radius, chevronSize: _chevronSize, chevronIconSize: _chevronIconSize, chevron: _chevron, disableChevronRotation: _disableChevronRotation, order: _order, ...props }: AccordionProps): react_jsx_runtime.JSX.Element;
+declare function AccordionItem({ className, ...props }: React$1.ComponentProps<typeof Accordion$1.Item>): react_jsx_runtime.JSX.Element;
+declare function AccordionTrigger({ className, children, chevron, chevronPosition, icon, ...props }: React$1.ComponentProps<typeof Accordion$1.Trigger> & {
+    chevron?: React$1.ReactNode | null;
+    chevronPosition?: 'left' | 'right';
+    icon?: React$1.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function AccordionContent({ className, children, ...props }: React$1.ComponentProps<typeof Accordion$1.Panel>): react_jsx_runtime.JSX.Element;
 
-declare const alertVariants: (props?: ({
-    variant?: "default" | "destructive" | null | undefined;
+declare const actionIconVariants: (props?: ({
+    variant?: "secondary" | "destructive" | "default" | "outline" | "ghost" | "light" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    radius?: "xs" | "sm" | "md" | "lg" | "xl" | "full" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare function Alert({ className, variant, ...props }: React$1.ComponentProps<'div'> & VariantProps<typeof alertVariants>): react_jsx_runtime.JSX.Element;
+type ActionIconProps = React$1.ComponentProps<'button'> & VariantProps<typeof actionIconVariants> & {
+    render?: useRender.RenderProp;
+    loading?: boolean;
+    color?: ComponentColor;
+};
+declare function ActionIcon({ className, variant, size, radius, color, render, loading, disabled, children, ...props }: ActionIconProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+
+type Position = {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+};
+type AffixProps = React$1.ComponentProps<'div'> & {
+    position: Position;
+    zIndex?: number;
+    withinPortal?: boolean;
+};
+declare function Affix({ className, position, zIndex, withinPortal, children, style, ...props }: AffixProps): react_jsx_runtime.JSX.Element;
+
+type AlertProps = React$1.ComponentProps<'div'> & {
+    variant?: 'default' | 'destructive' | 'filled' | 'light' | 'outline';
+    radius?: unknown;
+    color?: unknown;
+};
+declare function Alert({ className, variant, radius: _radius, color: _color, ...props }: AlertProps): react_jsx_runtime.JSX.Element;
 declare function AlertTitle({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
 declare function AlertDescription({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
-
-declare function AlertDialog({ ...props }: React$1.ComponentProps<typeof AlertDialogPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function AlertDialogTrigger({ ...props }: React$1.ComponentProps<typeof AlertDialogPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
-declare function AlertDialogPortal({ ...props }: React$1.ComponentProps<typeof AlertDialogPrimitive.Portal>): react_jsx_runtime.JSX.Element;
-declare function AlertDialogOverlay({ className, ...props }: React$1.ComponentProps<typeof AlertDialogPrimitive.Overlay>): react_jsx_runtime.JSX.Element;
-declare function AlertDialogContent({ className, ...props }: React$1.ComponentProps<typeof AlertDialogPrimitive.Content>): react_jsx_runtime.JSX.Element;
+declare function AlertAction({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+
+declare function AlertDialog({ ...props }: React$1.ComponentProps<typeof AlertDialog$1.Root>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogTrigger({ ...props }: React$1.ComponentProps<typeof AlertDialog$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogPortal({ ...props }: React$1.ComponentProps<typeof AlertDialog$1.Portal>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogOverlay({ className, ...props }: React$1.ComponentProps<typeof AlertDialog$1.Backdrop>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogContent({ className, size, ...props }: React$1.ComponentProps<typeof AlertDialog$1.Popup> & {
+    size?: 'default' | 'sm';
+}): react_jsx_runtime.JSX.Element;
 declare function AlertDialogHeader({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
 declare function AlertDialogFooter({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
-declare function AlertDialogTitle({ className, ...props }: React$1.ComponentProps<typeof AlertDialogPrimitive.Title>): react_jsx_runtime.JSX.Element;
-declare function AlertDialogDescription({ className, ...props }: React$1.ComponentProps<typeof AlertDialogPrimitive.Description>): react_jsx_runtime.JSX.Element;
-declare function AlertDialogAction({ className, ...props }: React$1.ComponentProps<typeof AlertDialogPrimitive.Action>): react_jsx_runtime.JSX.Element;
-declare function AlertDialogCancel({ className, ...props }: React$1.ComponentProps<typeof AlertDialogPrimitive.Cancel>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogMedia({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogTitle({ className, ...props }: React$1.ComponentProps<typeof AlertDialog$1.Title>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogDescription({ className, ...props }: React$1.ComponentProps<typeof AlertDialog$1.Description>): react_jsx_runtime.JSX.Element;
+declare function AlertDialogAction({ className, variant, ...props }: React$1.ComponentProps<typeof AlertDialog$1.Close> & {
+    variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost' | 'link' | 'light';
+}): react_jsx_runtime.JSX.Element;
+declare function AlertDialogCancel({ className, ...props }: React$1.ComponentProps<typeof AlertDialog$1.Close>): react_jsx_runtime.JSX.Element;
+
+declare const anchorVariants: (props?: ({
+    variant?: "default" | "muted" | "gradient" | "subtle" | null | undefined;
+    underline?: "always" | "never" | "hover" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    weight?: "bold" | "normal" | "medium" | "semibold" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type AnchorProps = React$1.ComponentProps<'a'> & VariantProps<typeof anchorVariants>;
+declare function Anchor({ className, variant, underline, size, weight, children, href, ...props }: AnchorProps): react_jsx_runtime.JSX.Element;
+
+type AngleSliderProps = React$1.ComponentProps<'div'> & {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    onChangeEnd?: (value: number) => void;
+    size?: number;
+    step?: number;
+    withLabel?: boolean;
+    formatLabel?: (value: number) => React$1.ReactNode;
+    disabled?: boolean;
+};
+declare function AngleSlider({ className, value: valueProp, defaultValue, onChange, onChangeEnd, size, step, withLabel, formatLabel, disabled, ...props }: AngleSliderProps): react_jsx_runtime.JSX.Element;
 
 type AnimatedTabItem = {
     name: string;
@@ -528,51 +933,94 @@ type AnimatedTabsProps = {
     className?: string;
     linkComponent?: ComponentType<LinkComponentProps>;
 };
-declare function AnimatedTabs({ tabs, activeTab: controlledActiveTab, defaultTab, onTabChange, className, linkComponent: LinkComponent, }: AnimatedTabsProps): react_jsx_runtime.JSX.Element;
+declare function AnimatedTabs({ tabs, activeTab: controlledActiveTab, defaultTab, onTabChange, className, linkComponent: linkProp, }: AnimatedTabsProps): react_jsx_runtime.JSX.Element;
 
-declare function AspectRatio({ ...props }: React.ComponentProps<typeof AspectRatioPrimitive.Root>): react_jsx_runtime.JSX.Element;
+type AspectRatioProps = React$1.ComponentProps<'div'> & {
+    ratio?: number;
+};
+declare function AspectRatio({ className, ratio, style, children, ...props }: AspectRatioProps): react_jsx_runtime.JSX.Element;
 
-declare function Avatar({ className, ...props }: React$1.ComponentProps<typeof AvatarPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function AvatarImage({ className, ...props }: React$1.ComponentProps<typeof AvatarPrimitive.Image>): react_jsx_runtime.JSX.Element;
-declare function AvatarFallback({ className, ...props }: React$1.ComponentProps<typeof AvatarPrimitive.Fallback>): react_jsx_runtime.JSX.Element;
+type AvatarProps = React$1.ComponentProps<typeof Avatar$1.Root> & {
+    size?: ComponentSize;
+    radius?: ComponentRadius;
+};
+declare function Avatar({ className, size, radius: _radius, ...props }: AvatarProps): react_jsx_runtime.JSX.Element;
+declare function AvatarImage({ className, ...props }: React$1.ComponentProps<typeof Avatar$1.Image>): react_jsx_runtime.JSX.Element;
+declare function AvatarFallback({ className, ...props }: React$1.ComponentProps<typeof Avatar$1.Fallback>): react_jsx_runtime.JSX.Element;
+
+type BackgroundImageProps = React$1.ComponentProps<'div'> & {
+    src: string;
+    radius?: ComponentRadius;
+};
+declare function BackgroundImage({ className, src, radius, style, ...props }: BackgroundImageProps): react_jsx_runtime.JSX.Element;
 
 declare const badgeVariants: (props?: ({
-    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+    variant?: "link" | "secondary" | "destructive" | "default" | "outline" | "ghost" | "light" | "dot" | "success" | "warning" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    radius?: "none" | "sm" | "md" | "lg" | "full" | null | undefined;
+    circle?: boolean | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare function Badge({ className, variant, asChild, ...props }: React$1.ComponentProps<'span'> & VariantProps<typeof badgeVariants> & {
-    asChild?: boolean;
-}): react_jsx_runtime.JSX.Element;
+type BadgeProps = React$1.ComponentProps<'span'> & VariantProps<typeof badgeVariants> & {
+    render?: useRender.RenderProp;
+    leftSection?: React$1.ReactNode;
+    rightSection?: React$1.ReactNode;
+    color?: ComponentColor;
+};
+declare function Badge({ className, variant, size, radius, circle, color, render, leftSection, rightSection, children, ...props }: BadgeProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+
+declare const blockquoteVariants: (props?: ({
+    variant?: "primary" | "secondary" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Blockquote({ className, variant, ...props }: React$1.ComponentProps<'blockquote'> & VariantProps<typeof blockquoteVariants>): react_jsx_runtime.JSX.Element;
 
 declare function Breadcrumb({ ...props }: React$1.ComponentProps<'nav'>): react_jsx_runtime.JSX.Element;
 declare function BreadcrumbList({ className, ...props }: React$1.ComponentProps<'ol'>): react_jsx_runtime.JSX.Element;
 declare function BreadcrumbItem({ className, ...props }: React$1.ComponentProps<'li'>): react_jsx_runtime.JSX.Element;
-declare function BreadcrumbLink({ asChild, className, ...props }: React$1.ComponentProps<'a'> & {
-    asChild?: boolean;
-}): react_jsx_runtime.JSX.Element;
+declare function BreadcrumbLink({ className, render, ...props }: React$1.ComponentProps<'a'> & {
+    render?: useRender.RenderProp;
+}): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
 declare function BreadcrumbPage({ className, ...props }: React$1.ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
 declare function BreadcrumbSeparator({ children, className, ...props }: React$1.ComponentProps<'li'>): react_jsx_runtime.JSX.Element;
 declare function BreadcrumbEllipsis({ className, ...props }: React$1.ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
 
+declare const burgerVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type BurgerProps = Omit<React$1.ComponentProps<'button'>, 'children'> & VariantProps<typeof burgerVariants> & {
+    opened: boolean;
+    ariaLabel?: string;
+};
+declare function Burger({ className, size, opened, ariaLabel, ...props }: BurgerProps): react_jsx_runtime.JSX.Element;
+
 declare const buttonVariants: (props?: ({
-    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
-    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
+    variant?: "link" | "secondary" | "destructive" | "default" | "outline" | "ghost" | "light" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | "default" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | "icon-xl" | null | undefined;
+    radius?: "xs" | "sm" | "md" | "lg" | "xl" | "full" | null | undefined;
+    fullWidth?: boolean | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-type ButtonProps = React$1.ComponentProps<'button'> & VariantProps<typeof buttonVariants> & {
-    asChild?: boolean;
+type ButtonLoaderProps = {
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+};
+type ButtonProps = Button$1.Props & VariantProps<typeof buttonVariants> & {
     leftIcon?: React$1.ReactNode;
     rightIcon?: React$1.ReactNode;
+    leftSection?: React$1.ReactNode;
+    rightSection?: React$1.ReactNode;
+    loading?: boolean;
+    loaderProps?: ButtonLoaderProps;
+    color?: ComponentColor;
 };
-declare function Button({ className, variant, size, asChild, leftIcon, rightIcon, children, ...props }: ButtonProps): react_jsx_runtime.JSX.Element;
+declare function Button({ className, variant, size, radius, fullWidth, color, leftIcon, rightIcon, leftSection, rightSection, loading, loaderProps, disabled, children, ...props }: ButtonProps): react_jsx_runtime.JSX.Element;
 
-declare function Separator({ className, orientation, decorative, ...props }: React$1.ComponentProps<typeof SeparatorPrimitive.Root>): react_jsx_runtime.JSX.Element;
+declare function Separator({ className, orientation, ...props }: React$1.ComponentProps<typeof Separator$1>): react_jsx_runtime.JSX.Element;
 
-declare const buttonGroupVariants: (props?: ({
-    orientation?: "horizontal" | "vertical" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-declare function ButtonGroup({ className, orientation, ...props }: React.ComponentProps<'fieldset'> & VariantProps<typeof buttonGroupVariants>): react_jsx_runtime.JSX.Element;
-declare function ButtonGroupText({ className, asChild, ...props }: React.ComponentProps<'div'> & {
-    asChild?: boolean;
+declare function ButtonGroup({ className, orientation, ...props }: React.ComponentProps<'fieldset'> & {
+    orientation?: 'horizontal' | 'vertical';
 }): react_jsx_runtime.JSX.Element;
+declare function ButtonGroupText({ className, render, ...props }: React.ComponentProps<'div'> & {
+    render?: useRender.RenderProp;
+}): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
 declare function ButtonGroupSeparator({ className, orientation, ...props }: React.ComponentProps<typeof Separator>): react_jsx_runtime.JSX.Element;
 
 declare function Calendar({ className, classNames, showOutsideDays, captionLayout, buttonVariant, formatters, components, ...props }: React$1.ComponentProps<typeof DayPicker> & {
@@ -580,7 +1028,14 @@ declare function Calendar({ className, classNames, showOutsideDays, captionLayou
 }): react_jsx_runtime.JSX.Element;
 declare function CalendarDayButton({ className, day, modifiers, ...props }: React$1.ComponentProps<typeof DayButton>): react_jsx_runtime.JSX.Element;
 
-declare function Card({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+type CardProps = React$1.ComponentProps<'div'> & {
+    size?: 'default' | 'sm';
+    padding?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    radius?: ComponentRadius;
+    withBorder?: boolean;
+    variant?: 'default' | 'outline' | 'filled';
+};
+declare function Card({ className, children, size, padding, radius, withBorder, variant, ...props }: CardProps): react_jsx_runtime.JSX.Element;
 declare function CardHeader({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
 declare function CardTitle({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
 declare function CardDescription({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
@@ -604,6 +1059,11 @@ declare function CarouselItem({ className, ...props }: React$1.ComponentProps<'f
 declare function CarouselPrevious({ className, variant, size, ...props }: React$1.ComponentProps<typeof Button>): react_jsx_runtime.JSX.Element;
 declare function CarouselNext({ className, variant, size, ...props }: React$1.ComponentProps<typeof Button>): react_jsx_runtime.JSX.Element;
 
+type CenterProps = React$1.ComponentProps<'div'> & {
+    inline?: boolean;
+};
+declare function Center({ className, inline, children, ...props }: CenterProps): react_jsx_runtime.JSX.Element;
+
 declare const THEMES: {
     readonly light: "";
     readonly dark: ".dark";
@@ -642,63 +1102,254 @@ declare function ChartLegendContent({ className, hideIcon, payload, verticalAlig
     nameKey?: string;
 }): react_jsx_runtime.JSX.Element | null;
 
-declare function Checkbox({ className, ...props }: React$1.ComponentProps<typeof CheckboxPrimitive.Root>): react_jsx_runtime.JSX.Element;
+type CheckboxProps = React$1.ComponentProps<typeof Checkbox$1.Root> & {
+    size?: ComponentSize;
+    color?: ComponentColor;
+};
+declare function Checkbox({ className, size, color: _color, ...props }: CheckboxProps): react_jsx_runtime.JSX.Element;
+
+declare const chipVariants: (props?: ({
+    variant?: "input" | "secondary" | "default" | "outline" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ChipProps = React$1.ComponentProps<'div'> & VariantProps<typeof chipVariants> & {
+    onRemove?: () => void;
+    removable?: boolean;
+};
+declare function Chip({ className, variant, onRemove, removable, children, ...props }: ChipProps): react_jsx_runtime.JSX.Element;
+
+type CloseButtonProps = Omit<React$1.ComponentProps<typeof Button>, 'children'> & {
+    iconSize?: number;
+};
+declare function CloseButton({ className, size, variant, iconSize, ...props }: CloseButtonProps): react_jsx_runtime.JSX.Element;
+
+declare const codeVariants: (props?: ({
+    variant?: "inline" | "block" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Code({ className, variant, ...props }: React$1.ComponentProps<'code'> & VariantProps<typeof codeVariants>): react_jsx_runtime.JSX.Element;
+
+declare function Collapsible({ ...props }: React.ComponentProps<typeof Collapsible$1.Root>): react_jsx_runtime.JSX.Element;
+declare function CollapsibleTrigger({ ...props }: React.ComponentProps<typeof Collapsible$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function CollapsibleContent({ className, ...props }: React.ComponentProps<typeof Collapsible$1.Panel>): react_jsx_runtime.JSX.Element;
+
+declare function Input({ className, type, ...props }: React$1.ComponentProps<'input'>): react_jsx_runtime.JSX.Element;
+
+declare function Label({ className, ...props }: React$1.ComponentProps<'label'>): react_jsx_runtime.JSX.Element;
+
+declare function FieldSet({ className, ...props }: React.ComponentProps<'fieldset'>): react_jsx_runtime.JSX.Element;
+declare function FieldLegend({ className, variant, ...props }: React.ComponentProps<'legend'> & {
+    variant?: 'legend' | 'label';
+}): react_jsx_runtime.JSX.Element;
+declare function FieldGroup({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare const fieldVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | "responsive" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Field({ className, orientation, ...props }: React.ComponentProps<'fieldset'> & VariantProps<typeof fieldVariants>): react_jsx_runtime.JSX.Element;
+declare function FieldContent({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function FieldLabel({ className, ...props }: React.ComponentProps<typeof Label>): react_jsx_runtime.JSX.Element;
+declare function FieldTitle({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function FieldDescription({ className, ...props }: React.ComponentProps<'p'>): react_jsx_runtime.JSX.Element;
+declare function FieldSeparator({ children, className, ...props }: React.ComponentProps<'div'> & {
+    children?: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function FieldError({ className, children, errors, ...props }: React.ComponentProps<'div'> & {
+    errors?: Array<{
+        message?: string;
+    } | undefined>;
+}): react_jsx_runtime.JSX.Element | null;
 
-declare function Collapsible({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function CollapsibleTrigger({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleTrigger>): react_jsx_runtime.JSX.Element;
-declare function CollapsibleContent({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleContent>): react_jsx_runtime.JSX.Element;
+type InputWrapperProps = {
+    /** Input element or component to wrap */
+    children: React$1.ReactNode;
+    /** Label text */
+    label?: React$1.ReactNode;
+    /** Description text (helper text) */
+    description?: React$1.ReactNode;
+    /** Error message or array of errors */
+    error?: React$1.ReactNode | Array<{
+        message?: string;
+    } | undefined>;
+    /** Adds required attribute to the input and asterisk to label */
+    required?: boolean;
+    /** Shows asterisk on label without required attribute */
+    withAsterisk?: boolean;
+    /** Controls order of elements */
+    inputWrapperOrder?: InputWrapperOrder;
+    /** Props for label */
+    labelProps?: React$1.ComponentProps<typeof FieldLabel>;
+    /** Props for description */
+    descriptionProps?: React$1.ComponentProps<typeof FieldDescription>;
+    /** Props for error */
+    errorProps?: React$1.ComponentProps<typeof FieldError>;
+    /** Input container wrapper function */
+    inputContainer?: (children: React$1.ReactNode) => React$1.ReactNode;
+    /** Disabled state (passed to Field) */
+    disabled?: boolean;
+    /** Class name for wrapper */
+    className?: string;
+};
+declare function InputWrapper({ children, label, description, error, required, withAsterisk, inputWrapperOrder, labelProps, descriptionProps, errorProps, inputContainer, disabled, className, }: InputWrapperProps): react_jsx_runtime.JSX.Element;
+
+type ColorInputProps = Omit<React$1.ComponentProps<typeof Input>, 'type' | 'value' | 'defaultValue' | 'onChange'> & Omit<InputWrapperProps, 'children'> & {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onValueChange?: (value: string) => void;
+    onChangeEnd?: (value: string) => void;
+    format?: ColorFormat;
+    size?: ComponentSize;
+    /** If true, input value resets to last valid on blur. @default true */
+    fixOnBlur?: boolean;
+    /** If true, user can only pick via picker/swatches, not type. */
+    disallowInput?: boolean;
+    /** Show color preview swatch on the left. @default true */
+    withPreview?: boolean;
+    /** Show eye dropper button. @default true when supported */
+    withEyeDropper?: boolean;
+    eyeDropperIcon?: React$1.ReactNode;
+    /** Close dropdown when a swatch is clicked. @default false */
+    closeOnColorSwatchClick?: boolean;
+    /** Preset swatches in dropdown */
+    swatches?: string[];
+    swatchesPerRow?: number;
+    /** Show saturation/hue/alpha picker in dropdown. @default true */
+    withPicker?: boolean;
+    /** When false, no dropdown popover (e.g. when used inside ColorPicker). @default true */
+    withPopover?: boolean;
+};
+declare const ColorInput: React$1.ForwardRefExoticComponent<Omit<ColorInputProps, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+
+type ColorPickerProps = Omit<React$1.ComponentProps<typeof ColorInput>, 'label' | 'description' | 'error' | 'onChange' | 'onValueChange' | 'size'> & Omit<InputWrapperProps, 'children'> & {
+    size?: ComponentSize;
+    value?: string;
+    onChange?: (value: string) => void;
+    onChangeEnd?: (value: string) => void;
+    /** hex | hexa | rgb | rgba | hsl | hsla */
+    format?: ColorFormat;
+    /** Show saturation + hue (+ alpha) picker. false = swatches only */
+    withPicker?: boolean;
+    fullWidth?: boolean;
+    /** Preset colors */
+    swatches?: string[];
+    swatchesPerRow?: number;
+    /** Called when a swatch is clicked (e.g. to close parent dropdown) */
+    onColorSwatchClick?: () => void;
+    saturationLabel?: string;
+    hueLabel?: string;
+    alphaLabel?: string;
+};
+declare function ColorPicker({ label, description, error, required, withAsterisk, inputWrapperOrder, labelProps, descriptionProps, errorProps, disabled, className, size, format, withPicker, fullWidth, swatches, swatchesPerRow, onColorSwatchClick, value, onChange, onChangeEnd, saturationLabel, hueLabel, alphaLabel, ...inputProps }: ColorPickerProps): react_jsx_runtime.JSX.Element;
+
+type ColorSwatchProps = React$1.ComponentProps<'div'> & {
+    color: string;
+    size?: number | string;
+    radius?: ComponentRadius;
+    withShadow?: boolean;
+};
+declare function ColorSwatch({ className, color, size, radius, withShadow, children, style, ...props }: ColorSwatchProps): react_jsx_runtime.JSX.Element;
+
+type ComboboxOption = {
+    value: string;
+    label: string;
+    disabled?: boolean;
+};
+type ComboboxProps = Omit<Combobox$1.Root.Props<string>, 'children' | 'onValueChange' | 'value' | 'inputValue' | 'onInputValueChange'> & {
+    options: ComboboxOption[];
+    value?: string | null;
+    onValueChange?: (value: string | null) => void;
+    placeholder?: string;
+    emptyText?: string;
+    disabled?: boolean;
+    showClear?: boolean;
+    className?: string;
+};
+declare function Combobox({ options, value, onValueChange, placeholder, emptyText, disabled, showClear, className, ...props }: ComboboxProps): react_jsx_runtime.JSX.Element;
 
-declare function Dialog({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function DialogTrigger({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
-declare function DialogPortal({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Portal>): react_jsx_runtime.JSX.Element;
-declare function DialogClose({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Close>): react_jsx_runtime.JSX.Element;
-declare function DialogOverlay({ className, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Overlay>): react_jsx_runtime.JSX.Element;
-declare function DialogContent({ className, children, showCloseButton, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Content> & {
+declare function Dialog({ ...props }: React$1.ComponentProps<typeof Dialog$1.Root>): react_jsx_runtime.JSX.Element;
+declare function DialogTrigger({ ...props }: React$1.ComponentProps<typeof Dialog$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function DialogPortal({ ...props }: React$1.ComponentProps<typeof Dialog$1.Portal>): react_jsx_runtime.JSX.Element;
+declare function DialogClose({ ...props }: React$1.ComponentProps<typeof Dialog$1.Close>): react_jsx_runtime.JSX.Element;
+declare function DialogOverlay({ className, ...props }: React$1.ComponentProps<typeof Dialog$1.Backdrop>): react_jsx_runtime.JSX.Element;
+declare function DialogContent({ className, children, showCloseButton, ...props }: React$1.ComponentProps<typeof Dialog$1.Popup> & {
     showCloseButton?: boolean;
 }): react_jsx_runtime.JSX.Element;
 declare function DialogHeader({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
 declare function DialogFooter({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
-declare function DialogTitle({ className, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Title>): react_jsx_runtime.JSX.Element;
-declare function DialogDescription({ className, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Description>): react_jsx_runtime.JSX.Element;
+declare function DialogTitle({ className, ...props }: React$1.ComponentProps<typeof Dialog$1.Title>): react_jsx_runtime.JSX.Element;
+declare function DialogDescription({ className, ...props }: React$1.ComponentProps<typeof Dialog$1.Description>): react_jsx_runtime.JSX.Element;
 
-declare function Command({ className, ...props }: React$1.ComponentProps<typeof Command$1>): react_jsx_runtime.JSX.Element;
-declare function CommandDialog({ title, description, children, className, showCloseButton, ...props }: React$1.ComponentProps<typeof Dialog> & {
+type CommandProps = Omit<React$1.ComponentProps<typeof Autocomplete.Root>, 'children'> & {
+    className?: string;
+    children?: React$1.ReactNode;
+};
+declare function Command({ className, children, ...props }: CommandProps): react_jsx_runtime.JSX.Element;
+declare function CommandDialog({ title, description, children, className, showCloseButton, commandProps, ...props }: Omit<React$1.ComponentProps<typeof Dialog>, 'children'> & {
     title?: string;
     description?: string;
     className?: string;
     showCloseButton?: boolean;
+    commandProps?: Omit<React$1.ComponentProps<typeof Autocomplete.Root>, 'children'>;
+    children?: React$1.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function CommandInput({ className, onValueChange, onChange, ...props }: React$1.ComponentProps<typeof Autocomplete.Input> & {
+    onValueChange?: (value: string) => void;
+}): react_jsx_runtime.JSX.Element;
+declare function CommandList({ className, ...props }: React$1.ComponentProps<typeof Autocomplete.List>): react_jsx_runtime.JSX.Element;
+declare function CommandEmpty({ className, ...props }: React$1.ComponentProps<typeof Autocomplete.Empty>): react_jsx_runtime.JSX.Element;
+type CommandGroupProps = Omit<React$1.ComponentProps<typeof Autocomplete.Group>, 'children'> & {
+    heading?: string;
+    children?: React$1.ReactNode | ((item: unknown, index: number) => React$1.ReactNode);
+};
+declare function CommandGroup({ className, heading, items, children, ...props }: CommandGroupProps): react_jsx_runtime.JSX.Element;
+declare function CommandSeparator({ className, ...props }: React$1.ComponentProps<typeof Separator>): react_jsx_runtime.JSX.Element;
+declare function CommandItem({ className, onSelect, onClick, ...props }: React$1.ComponentProps<typeof Autocomplete.Item> & {
+    onSelect?: React$1.MouseEventHandler<HTMLElement>;
 }): react_jsx_runtime.JSX.Element;
-declare function CommandInput({ className, ...props }: React$1.ComponentProps<typeof Command$1.Input>): react_jsx_runtime.JSX.Element;
-declare function CommandList({ className, ...props }: React$1.ComponentProps<typeof Command$1.List>): react_jsx_runtime.JSX.Element;
-declare function CommandEmpty({ ...props }: React$1.ComponentProps<typeof Command$1.Empty>): react_jsx_runtime.JSX.Element;
-declare function CommandGroup({ className, ...props }: React$1.ComponentProps<typeof Command$1.Group>): react_jsx_runtime.JSX.Element;
-declare function CommandSeparator({ className, ...props }: React$1.ComponentProps<typeof Command$1.Separator>): react_jsx_runtime.JSX.Element;
-declare function CommandItem({ className, ...props }: React$1.ComponentProps<typeof Command$1.Item>): react_jsx_runtime.JSX.Element;
 declare function CommandShortcut({ className, ...props }: React$1.ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
 
-declare function ContextMenu({ ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuTrigger({ ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuGroup({ ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Group>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuPortal({ ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Portal>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuSub({ ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Sub>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuRadioGroup({ ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.RadioGroup>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuSubTrigger({ className, inset, children, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.SubTrigger> & {
+declare const containerVariants: (props?: ({
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "fluid" | null | undefined;
+    px?: "none" | "sm" | "md" | "lg" | "xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ContainerProps = React$1.ComponentProps<'div'> & VariantProps<typeof containerVariants> & {
+    fluid?: boolean;
+};
+declare function Container({ className, size, px, fluid, children, ...props }: ContainerProps): react_jsx_runtime.JSX.Element;
+
+declare function ContextMenu({ ...props }: React$1.ComponentProps<typeof ContextMenu$1.Root>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuTrigger({ className, ...props }: React$1.ComponentProps<typeof ContextMenu$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuGroup({ ...props }: React$1.ComponentProps<typeof ContextMenu$1.Group>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuPortal({ ...props }: React$1.ComponentProps<typeof ContextMenu$1.Portal>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuSub({ ...props }: React$1.ComponentProps<typeof ContextMenu$1.SubmenuRoot>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuRadioGroup({ ...props }: React$1.ComponentProps<typeof ContextMenu$1.RadioGroup>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuSubTrigger({ className, inset, children, ...props }: React$1.ComponentProps<typeof ContextMenu$1.SubmenuTrigger> & {
     inset?: boolean;
 }): react_jsx_runtime.JSX.Element;
-declare function ContextMenuSubContent({ className, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.SubContent>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuContent({ className, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Content>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuItem({ className, inset, variant, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Item> & {
+declare function ContextMenuSubContent({ className, align, alignOffset, side, sideOffset, ...props }: React$1.ComponentProps<typeof ContextMenu$1.Popup> & Pick<React$1.ComponentProps<typeof ContextMenu$1.Positioner>, 'align' | 'alignOffset' | 'side' | 'sideOffset'>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuContent({ className, ...props }: React$1.ComponentProps<typeof ContextMenu$1.Popup>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuPositioner({ align, alignOffset, side, sideOffset, className, ...props }: React$1.ComponentProps<typeof ContextMenu$1.Positioner>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuItem({ className, inset, variant, ...props }: React$1.ComponentProps<typeof ContextMenu$1.Item> & {
     inset?: boolean;
     variant?: 'default' | 'destructive';
 }): react_jsx_runtime.JSX.Element;
-declare function ContextMenuCheckboxItem({ className, children, checked, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.CheckboxItem>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuRadioItem({ className, children, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.RadioItem>): react_jsx_runtime.JSX.Element;
-declare function ContextMenuLabel({ className, inset, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Label> & {
+declare function ContextMenuCheckboxItem({ className, children, checked, inset, ...props }: React$1.ComponentProps<typeof ContextMenu$1.CheckboxItem> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function ContextMenuRadioItem({ className, children, inset, ...props }: React$1.ComponentProps<typeof ContextMenu$1.RadioItem> & {
     inset?: boolean;
 }): react_jsx_runtime.JSX.Element;
-declare function ContextMenuSeparator({ className, ...props }: React$1.ComponentProps<typeof ContextMenuPrimitive.Separator>): react_jsx_runtime.JSX.Element;
+declare function ContextMenuLabel({ className, inset, ...props }: React$1.ComponentProps<typeof ContextMenu$1.GroupLabel> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function ContextMenuSeparator({ className, ...props }: React$1.ComponentProps<typeof ContextMenu$1.Separator>): react_jsx_runtime.JSX.Element;
 declare function ContextMenuShortcut({ className, ...props }: React$1.ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
 
+type CopyButtonProps = Omit<React$1.ComponentProps<typeof Button>, 'onClick' | 'children'> & {
+    value: string;
+    timeout?: number;
+    children?: React$1.ReactNode;
+};
+declare function CopyButton({ value, timeout, children, size, variant, className, ...props }: CopyButtonProps): react_jsx_runtime.JSX.Element;
+
 type DataTableProps<TData, TValue> = {
     columns: ColumnDef<TData, TValue>[];
     data: TData[];
@@ -748,39 +1399,46 @@ type DataTableViewOptionsProps<TData> = {
 };
 declare function DataTableViewOptions<TData>({ table, }: DataTableViewOptionsProps<TData>): react_jsx_runtime.JSX.Element;
 
-declare function Drawer({ ...props }: React$1.ComponentProps<typeof Drawer$1.Root>): react_jsx_runtime.JSX.Element;
-declare function DrawerTrigger({ ...props }: React$1.ComponentProps<typeof Drawer$1.Trigger>): react_jsx_runtime.JSX.Element;
-declare function DrawerPortal({ ...props }: React$1.ComponentProps<typeof Drawer$1.Portal>): react_jsx_runtime.JSX.Element;
-declare function DrawerClose({ ...props }: React$1.ComponentProps<typeof Drawer$1.Close>): react_jsx_runtime.JSX.Element;
-declare function DrawerOverlay({ className, ...props }: React$1.ComponentProps<typeof Drawer$1.Overlay>): react_jsx_runtime.JSX.Element;
-declare function DrawerContent({ className, children, ...props }: React$1.ComponentProps<typeof Drawer$1.Content>): react_jsx_runtime.JSX.Element;
+declare function Drawer({ ...props }: React$1.ComponentProps<typeof Dialog$1.Root>): react_jsx_runtime.JSX.Element;
+declare function DrawerTrigger({ ...props }: React$1.ComponentProps<typeof Dialog$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function DrawerPortal({ ...props }: React$1.ComponentProps<typeof Dialog$1.Portal>): react_jsx_runtime.JSX.Element;
+declare function DrawerClose({ ...props }: React$1.ComponentProps<typeof Dialog$1.Close>): react_jsx_runtime.JSX.Element;
+declare function DrawerOverlay({ className, ...props }: React$1.ComponentProps<typeof Dialog$1.Backdrop>): react_jsx_runtime.JSX.Element;
+declare function DrawerContent({ className, children, side, ...props }: React$1.ComponentProps<typeof Dialog$1.Popup> & {
+    side?: 'top' | 'right' | 'bottom' | 'left';
+}): react_jsx_runtime.JSX.Element;
 declare function DrawerHeader({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
 declare function DrawerFooter({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
-declare function DrawerTitle({ className, ...props }: React$1.ComponentProps<typeof Drawer$1.Title>): react_jsx_runtime.JSX.Element;
-declare function DrawerDescription({ className, ...props }: React$1.ComponentProps<typeof Drawer$1.Description>): react_jsx_runtime.JSX.Element;
-
-declare function DropdownMenu({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function DropdownMenuPortal({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Portal>): react_jsx_runtime.JSX.Element;
-declare function DropdownMenuTrigger({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
-declare function DropdownMenuContent({ className, sideOffset, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Content>): react_jsx_runtime.JSX.Element;
-declare function DropdownMenuGroup({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Group>): react_jsx_runtime.JSX.Element;
-declare function DropdownMenuItem({ className, inset, variant, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+declare function DrawerTitle({ className, ...props }: React$1.ComponentProps<typeof Dialog$1.Title>): react_jsx_runtime.JSX.Element;
+declare function DrawerDescription({ className, ...props }: React$1.ComponentProps<typeof Dialog$1.Description>): react_jsx_runtime.JSX.Element;
+
+declare function DropdownMenu({ ...props }: React$1.ComponentProps<typeof Menu.Root>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuPortal({ ...props }: React$1.ComponentProps<typeof Menu.Portal>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: React$1.ComponentProps<typeof Menu.Trigger>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuContent({ className, ...props }: React$1.ComponentProps<typeof Menu.Popup>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuPositioner({ align, alignOffset, side, sideOffset, className, ...props }: React$1.ComponentProps<typeof Menu.Positioner>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuGroup({ ...props }: React$1.ComponentProps<typeof Menu.Group>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: React$1.ComponentProps<typeof Menu.Item> & {
     inset?: boolean;
     variant?: 'default' | 'destructive';
 }): react_jsx_runtime.JSX.Element;
-declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>): react_jsx_runtime.JSX.Element;
-declare function DropdownMenuRadioGroup({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): react_jsx_runtime.JSX.Element;
-declare function DropdownMenuRadioItem({ className, children, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>): react_jsx_runtime.JSX.Element;
-declare function DropdownMenuLabel({ className, inset, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+declare function DropdownMenuCheckboxItem({ className, children, checked, inset, ...props }: React$1.ComponentProps<typeof Menu.CheckboxItem> & {
     inset?: boolean;
 }): react_jsx_runtime.JSX.Element;
-declare function DropdownMenuSeparator({ className, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Separator>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: React$1.ComponentProps<typeof Menu.RadioGroup>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, inset, ...props }: React$1.ComponentProps<typeof Menu.RadioItem> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: React$1.ComponentProps<typeof Menu.GroupLabel> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React$1.ComponentProps<typeof Menu.Separator>): react_jsx_runtime.JSX.Element;
 declare function DropdownMenuShortcut({ className, ...props }: React$1.ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
-declare function DropdownMenuSub({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Sub>): react_jsx_runtime.JSX.Element;
-declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+declare function DropdownMenuSub({ ...props }: React$1.ComponentProps<typeof Menu.SubmenuRoot>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: React$1.ComponentProps<typeof Menu.SubmenuTrigger> & {
     inset?: boolean;
 }): react_jsx_runtime.JSX.Element;
-declare function DropdownMenuSubContent({ className, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): react_jsx_runtime.JSX.Element;
+declare function DropdownMenuSubContent({ className, align, alignOffset, side, sideOffset, ...props }: React$1.ComponentProps<typeof Menu.Popup> & Pick<React$1.ComponentProps<typeof Menu.Positioner>, 'align' | 'alignOffset' | 'side' | 'sideOffset'>): react_jsx_runtime.JSX.Element;
 
 declare function Empty({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
 declare function EmptyHeader({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
@@ -792,29 +1450,49 @@ declare function EmptyTitle({ className, ...props }: React.ComponentProps<'div'>
 declare function EmptyDescription({ className, ...props }: React.ComponentProps<'p'>): react_jsx_runtime.JSX.Element;
 declare function EmptyContent({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
 
-declare function Label({ className, ...props }: React$1.ComponentProps<typeof LabelPrimitive.Root>): react_jsx_runtime.JSX.Element;
+type FileButtonProps = Omit<React$1.ComponentProps<typeof Button>, 'onChange' | 'onClick'> & {
+    onChange: (files: FileList | null) => void;
+    accept?: string;
+    multiple?: boolean;
+    capture?: boolean | 'user' | 'environment';
+};
+declare function FileButton({ onChange, accept, multiple, capture, children, disabled, className, ...props }: FileButtonProps): react_jsx_runtime.JSX.Element;
 
-declare function FieldSet({ className, ...props }: React.ComponentProps<'fieldset'>): react_jsx_runtime.JSX.Element;
-declare function FieldLegend({ className, variant, ...props }: React.ComponentProps<'legend'> & {
-    variant?: 'legend' | 'label';
-}): react_jsx_runtime.JSX.Element;
-declare function FieldGroup({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
-declare const fieldVariants: (props?: ({
-    orientation?: "horizontal" | "vertical" | "responsive" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-declare function Field({ className, orientation, ...props }: React.ComponentProps<'fieldset'> & VariantProps<typeof fieldVariants>): react_jsx_runtime.JSX.Element;
-declare function FieldContent({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
-declare function FieldLabel({ className, ...props }: React.ComponentProps<typeof Label>): react_jsx_runtime.JSX.Element;
-declare function FieldTitle({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
-declare function FieldDescription({ className, ...props }: React.ComponentProps<'p'>): react_jsx_runtime.JSX.Element;
-declare function FieldSeparator({ children, className, ...props }: React.ComponentProps<'div'> & {
-    children?: React.ReactNode;
-}): react_jsx_runtime.JSX.Element;
-declare function FieldError({ className, children, errors, ...props }: React.ComponentProps<'div'> & {
-    errors?: Array<{
-        message?: string;
-    } | undefined>;
-}): react_jsx_runtime.JSX.Element | null;
+type FileInputProps = Omit<React$1.ComponentProps<'input'>, 'type'> & {
+    onFilesChange?: (files: File[]) => void;
+    clearable?: boolean;
+};
+declare function FileInput({ className, onFilesChange, clearable, multiple, ...props }: FileInputProps): react_jsx_runtime.JSX.Element;
+
+type FlexProps = React$1.ComponentProps<'div'> & {
+    gap?: ComponentSize | number;
+    rowGap?: ComponentSize | number;
+    columnGap?: ComponentSize | number;
+    align?: 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+    justify?: 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
+    wrap?: 'wrap' | 'nowrap' | 'wrap-reverse';
+    direction?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
+};
+declare function Flex({ className, gap, rowGap, columnGap, align, justify, wrap, direction, style, ...props }: FlexProps): react_jsx_runtime.JSX.Element;
+
+type FloatingIndicatorProps = Omit<React$1.ComponentProps<'div'>, 'target'> & {
+    target: HTMLElement | null;
+    parent: HTMLElement | null;
+    transitionDuration?: number;
+    displayAfterTransitionEnd?: boolean;
+};
+declare function FloatingIndicator({ className, target, parent, transitionDuration, displayAfterTransitionEnd, style, ...props }: FloatingIndicatorProps): react_jsx_runtime.JSX.Element | null;
+
+type FocusTrapProps = {
+    children: ReactElement;
+    active?: boolean;
+    refProp?: string;
+};
+declare function FocusTrap({ children, active, refProp, }: FocusTrapProps): ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare namespace FocusTrap {
+    var InitialFocus: typeof FocusTrapInitialFocus;
+}
+declare function FocusTrapInitialFocus(props: React.ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
 
 declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues = TFieldValues>(props: react_hook_form.FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React$1.JSX.Element;
 declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => react_jsx_runtime.JSX.Element;
@@ -831,24 +1509,87 @@ declare const useFormField: () => {
     formMessageId: string;
 };
 declare function FormItem({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
-declare function FormLabel({ className, ...props }: React$1.ComponentProps<typeof LabelPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function FormControl({ ...props }: React$1.ComponentProps<typeof Slot>): react_jsx_runtime.JSX.Element;
+declare function FormLabel({ className, ...props }: React$1.ComponentProps<typeof Label>): react_jsx_runtime.JSX.Element;
+declare function FormControl({ render, children, ...props }: React$1.ComponentProps<'input'> & {
+    render?: useRender.RenderProp;
+}): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
 declare function FormDescription({ className, ...props }: React$1.ComponentProps<'p'>): react_jsx_runtime.JSX.Element;
 declare function FormMessage({ className, ...props }: React$1.ComponentProps<'p'>): react_jsx_runtime.JSX.Element | null;
 
-declare function HoverCard({ ...props }: React$1.ComponentProps<typeof HoverCardPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function HoverCardTrigger({ ...props }: React$1.ComponentProps<typeof HoverCardPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
-declare function HoverCardContent({ className, align, sideOffset, ...props }: React$1.ComponentProps<typeof HoverCardPrimitive.Content>): react_jsx_runtime.JSX.Element;
+declare const gridVariants: (props?: ({
+    gutter?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const gridColVariants: (props?: ({
+    span?: 4 | 1 | "auto" | 2 | 3 | 5 | 7 | 6 | 8 | 10 | 9 | 12 | 11 | null | undefined;
+    sm?: 4 | 1 | 2 | 3 | 5 | 7 | 6 | 8 | 10 | 9 | 12 | 11 | null | undefined;
+    md?: 4 | 1 | 2 | 3 | 5 | 7 | 6 | 8 | 10 | 9 | 12 | 11 | null | undefined;
+    lg?: 4 | 1 | 2 | 3 | 5 | 7 | 6 | 8 | 10 | 9 | 12 | 11 | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type GridProps = React$1.ComponentProps<'div'> & VariantProps<typeof gridVariants>;
+type GridColProps = React$1.ComponentProps<'div'> & VariantProps<typeof gridColVariants> & {
+    offset?: number;
+};
+declare function Grid({ className, gutter, children, ...props }: GridProps): react_jsx_runtime.JSX.Element;
+declare namespace Grid {
+    var Col: typeof GridCol;
+}
+declare function GridCol({ className, span, sm, md, lg, offset, style, children, ...props }: GridColProps): react_jsx_runtime.JSX.Element;
+
+type GroupProps = React$1.ComponentProps<'div'> & {
+    gap?: ComponentSize | number;
+    wrap?: 'wrap' | 'nowrap';
+    align?: 'start' | 'center' | 'end' | 'stretch';
+    justify?: 'start' | 'center' | 'end' | 'between' | 'around';
+    grow?: boolean;
+};
+declare function Group({ className, gap, wrap, align, justify, grow, style, ...props }: GroupProps): react_jsx_runtime.JSX.Element;
+
+type HighlightProps = React$1.ComponentProps<'span'> & {
+    children: string;
+    highlight: string | string[];
+    className?: string;
+    highlightClassName?: string;
+};
+declare function Highlight({ children, highlight, className, highlightClassName, ...props }: HighlightProps): react_jsx_runtime.JSX.Element;
+
+declare function HoverCard({ ...props }: React$1.ComponentProps<typeof PreviewCard.Root>): react_jsx_runtime.JSX.Element;
+declare function HoverCardTrigger({ ...props }: React$1.ComponentProps<typeof PreviewCard.Trigger>): react_jsx_runtime.JSX.Element;
+declare function HoverCardContent({ className, align, alignOffset, side, sideOffset, ...props }: React$1.ComponentProps<typeof PreviewCard.Popup> & {
+    align?: React$1.ComponentProps<typeof PreviewCard.Positioner>['align'];
+    alignOffset?: React$1.ComponentProps<typeof PreviewCard.Positioner>['alignOffset'];
+    side?: React$1.ComponentProps<typeof PreviewCard.Positioner>['side'];
+    sideOffset?: React$1.ComponentProps<typeof PreviewCard.Positioner>['sideOffset'];
+}): react_jsx_runtime.JSX.Element;
 
-declare function Input({ className, type, ...props }: React$1.ComponentProps<'input'>): react_jsx_runtime.JSX.Element;
+type ImageProps = React$1.ComponentProps<'img'> & {
+    fallback?: React$1.ReactNode;
+    radius?: 'none' | 'sm' | 'md' | 'lg' | 'full';
+    fit?: 'contain' | 'cover' | 'fill' | 'none' | 'scale-down';
+};
+declare function Image({ className, src, alt, fallback, radius, fit, onError, ...props }: ImageProps): react_jsx_runtime.JSX.Element;
 
-declare function InputGroup({ className, ...props }: React$1.ComponentProps<'fieldset'>): react_jsx_runtime.JSX.Element;
+declare const indicatorVariants: (props?: ({
+    position?: "top-start" | "top-end" | "bottom-start" | "bottom-end" | "top-center" | "bottom-center" | "middle-start" | "middle-end" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | null | undefined;
+    color?: "primary" | "secondary" | "accent" | "destructive" | null | undefined;
+    withBorder?: boolean | null | undefined;
+    processing?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type IndicatorProps = React$1.ComponentProps<'div'> & VariantProps<typeof indicatorVariants> & {
+    label?: string | number;
+    offset?: number;
+    disabled?: boolean;
+    inline?: boolean;
+};
+declare function Indicator({ className, position, size, color, withBorder, processing, label, offset, disabled, inline, children, style, ...props }: IndicatorProps): react_jsx_runtime.JSX.Element;
+
+declare function InputGroup({ className, disabled, ...props }: React$1.ComponentProps<'fieldset'>): react_jsx_runtime.JSX.Element;
 declare const inputGroupAddonVariants: (props?: ({
     align?: "inline-end" | "inline-start" | "block-end" | "block-start" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare function InputGroupAddon({ className, align, ...props }: React$1.ComponentProps<'fieldset'> & VariantProps<typeof inputGroupAddonVariants>): react_jsx_runtime.JSX.Element;
+declare function InputGroupAddon({ className, align, type, ...props }: React$1.ComponentProps<'button'> & VariantProps<typeof inputGroupAddonVariants>): react_jsx_runtime.JSX.Element;
 declare const inputGroupButtonVariants: (props?: ({
-    size?: "sm" | "icon-sm" | "xs" | "icon-xs" | null | undefined;
+    size?: "xs" | "sm" | "icon-xs" | "icon-sm" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 declare function InputGroupButton({ className, type, variant, size, ...props }: Omit<React$1.ComponentProps<typeof Button>, 'size'> & VariantProps<typeof inputGroupButtonVariants>): react_jsx_runtime.JSX.Element;
 declare function InputGroupText({ className, ...props }: React$1.ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
@@ -868,11 +1609,11 @@ declare function ItemGroup({ className, ...props }: React$1.ComponentProps<'ul'>
 declare function ItemSeparator({ className, ...props }: React$1.ComponentProps<typeof Separator>): react_jsx_runtime.JSX.Element;
 declare const itemVariants: (props?: ({
     variant?: "default" | "outline" | "muted" | null | undefined;
-    size?: "default" | "sm" | null | undefined;
+    size?: "xs" | "sm" | "default" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare function Item({ className, variant, size, asChild, ...props }: React$1.ComponentProps<'div'> & VariantProps<typeof itemVariants> & {
-    asChild?: boolean;
-}): react_jsx_runtime.JSX.Element;
+declare function Item({ className, variant, size, render, ...props }: React$1.ComponentProps<'div'> & VariantProps<typeof itemVariants> & {
+    render?: useRender.RenderProp;
+}): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
 declare const itemMediaVariants: (props?: ({
     variant?: "image" | "default" | "icon" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
@@ -884,32 +1625,78 @@ declare function ItemActions({ className, ...props }: React$1.ComponentProps<'di
 declare function ItemHeader({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
 declare function ItemFooter({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
 
+type TextareaBaseProps = Omit<React$1.ComponentProps<'textarea'>, 'size'> & {
+    size?: ComponentSize;
+};
+declare const Textarea: React$1.ForwardRefExoticComponent<Omit<TextareaBaseProps, "ref"> & React$1.RefAttributes<HTMLTextAreaElement>>;
+type TextareaInputProps = TextareaBaseProps & Omit<InputWrapperProps, 'children'> & {
+    autosize?: boolean;
+    minRows?: number;
+    maxRows?: number;
+};
+declare const TextareaInput: React$1.ForwardRefExoticComponent<Omit<TextareaInputProps, "ref"> & React$1.RefAttributes<HTMLTextAreaElement>>;
+
+type JsonInputProps = Omit<React$1.ComponentProps<typeof Textarea>, 'value' | 'onChange'> & {
+    value?: string | object;
+    defaultValue?: string | object;
+    onChange?: (value: string) => void;
+    onValueChange?: (value: object | null) => void;
+    formatOnBlur?: boolean;
+    validationError?: string;
+};
+declare function JsonInput({ className, value, defaultValue, onChange, onValueChange, formatOnBlur, validationError, onBlur, ...props }: JsonInputProps): react_jsx_runtime.JSX.Element;
+
 declare function Kbd({ className, ...props }: React.ComponentProps<'kbd'>): react_jsx_runtime.JSX.Element;
 declare function KbdGroup({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
 
-declare function Menubar({ className, ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function MenubarMenu({ ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Menu>): react_jsx_runtime.JSX.Element;
-declare function MenubarGroup({ ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Group>): react_jsx_runtime.JSX.Element;
-declare function MenubarPortal({ ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Portal>): react_jsx_runtime.JSX.Element;
-declare function MenubarRadioGroup({ ...props }: React$1.ComponentProps<typeof MenubarPrimitive.RadioGroup>): react_jsx_runtime.JSX.Element;
-declare function MenubarTrigger({ className, ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
-declare function MenubarContent({ className, align, alignOffset, sideOffset, ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Content>): react_jsx_runtime.JSX.Element;
-declare function MenubarItem({ className, inset, variant, ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Item> & {
+declare const listVariants: (props?: ({
+    listStyle?: "none" | "decimal" | "disc" | null | undefined;
+    spacing?: "none" | "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type BaseListProps = VariantProps<typeof listVariants> & {
+    ordered?: boolean;
+};
+type ListProps = BaseListProps & (({
+    ordered?: false;
+} & React$1.ComponentProps<'ul'>) | ({
+    ordered: true;
+} & React$1.ComponentProps<'ol'>));
+declare function List({ className, listStyle, spacing, ordered, ...props }: ListProps): react_jsx_runtime.JSX.Element;
+declare function ListItem({ className, ...props }: React$1.ComponentProps<'li'>): react_jsx_runtime.JSX.Element;
+
+type MarkProps = React$1.ComponentProps<'mark'> & {
+    color?: ComponentColor;
+};
+declare function Mark({ className, color, ...props }: MarkProps): react_jsx_runtime.JSX.Element;
+
+declare function Menubar({ className, ...props }: React$1.ComponentProps<typeof Menubar$1>): react_jsx_runtime.JSX.Element;
+declare function MenubarMenu({ ...props }: React$1.ComponentProps<typeof Menu.Root>): react_jsx_runtime.JSX.Element;
+declare function MenubarGroup({ ...props }: React$1.ComponentProps<typeof Menu.Group>): react_jsx_runtime.JSX.Element;
+declare function MenubarPortal({ ...props }: React$1.ComponentProps<typeof Menu.Portal>): react_jsx_runtime.JSX.Element;
+declare function MenubarRadioGroup({ ...props }: React$1.ComponentProps<typeof Menu.RadioGroup>): react_jsx_runtime.JSX.Element;
+declare function MenubarTrigger({ className, ...props }: React$1.ComponentProps<typeof Menu.Trigger>): react_jsx_runtime.JSX.Element;
+declare function MenubarContent({ className, ...props }: React$1.ComponentProps<typeof Menu.Popup>): react_jsx_runtime.JSX.Element;
+declare function MenubarPositioner({ align, alignOffset, side, sideOffset, className, ...props }: React$1.ComponentProps<typeof Menu.Positioner>): react_jsx_runtime.JSX.Element;
+declare function MenubarItem({ className, inset, variant, ...props }: React$1.ComponentProps<typeof Menu.Item> & {
     inset?: boolean;
     variant?: 'default' | 'destructive';
 }): react_jsx_runtime.JSX.Element;
-declare function MenubarCheckboxItem({ className, children, checked, ...props }: React$1.ComponentProps<typeof MenubarPrimitive.CheckboxItem>): react_jsx_runtime.JSX.Element;
-declare function MenubarRadioItem({ className, children, ...props }: React$1.ComponentProps<typeof MenubarPrimitive.RadioItem>): react_jsx_runtime.JSX.Element;
-declare function MenubarLabel({ className, inset, ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Label> & {
+declare function MenubarCheckboxItem({ className, children, checked, inset, ...props }: React$1.ComponentProps<typeof Menu.CheckboxItem> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function MenubarRadioItem({ className, children, inset, ...props }: React$1.ComponentProps<typeof Menu.RadioItem> & {
     inset?: boolean;
 }): react_jsx_runtime.JSX.Element;
-declare function MenubarSeparator({ className, ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Separator>): react_jsx_runtime.JSX.Element;
+declare function MenubarLabel({ className, inset, ...props }: React$1.ComponentProps<typeof Menu.GroupLabel> & {
+    inset?: boolean;
+}): react_jsx_runtime.JSX.Element;
+declare function MenubarSeparator({ className, ...props }: React$1.ComponentProps<typeof Menu.Separator>): react_jsx_runtime.JSX.Element;
 declare function MenubarShortcut({ className, ...props }: React$1.ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
-declare function MenubarSub({ ...props }: React$1.ComponentProps<typeof MenubarPrimitive.Sub>): react_jsx_runtime.JSX.Element;
-declare function MenubarSubTrigger({ className, inset, children, ...props }: React$1.ComponentProps<typeof MenubarPrimitive.SubTrigger> & {
+declare function MenubarSub({ ...props }: React$1.ComponentProps<typeof Menu.SubmenuRoot>): react_jsx_runtime.JSX.Element;
+declare function MenubarSubTrigger({ className, inset, children, ...props }: React$1.ComponentProps<typeof Menu.SubmenuTrigger> & {
     inset?: boolean;
 }): react_jsx_runtime.JSX.Element;
-declare function MenubarSubContent({ className, ...props }: React$1.ComponentProps<typeof MenubarPrimitive.SubContent>): react_jsx_runtime.JSX.Element;
+declare function MenubarSubContent({ className, align, alignOffset, side, sideOffset, ...props }: React$1.ComponentProps<typeof Menu.Popup> & Pick<React$1.ComponentProps<typeof Menu.Positioner>, 'align' | 'alignOffset' | 'side' | 'sideOffset'>): react_jsx_runtime.JSX.Element;
 
 type CurrencyOption = {
     label: string;
@@ -930,17 +1717,94 @@ type MoneyInputProps = {
 };
 declare const MoneyInput: React$1.ForwardRefExoticComponent<MoneyInputProps & React$1.RefAttributes<HTMLDivElement>>;
 
-declare function NavigationMenu({ className, children, viewport, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Root> & {
+type MultiSelectOption = {
+    value: string;
+    label: string;
+    disabled?: boolean;
+};
+type MultiSelectProps = Omit<React$1.ComponentProps<typeof Autocomplete.Root>, 'children' | 'onValueChange' | 'inline'> & {
+    options: MultiSelectOption[];
+    value?: string[];
+    onValueChange?: (value: string[]) => void;
+    placeholder?: string;
+    emptyText?: string;
+    className?: string;
+    disabled?: boolean;
+};
+declare function MultiSelect({ options, value, onValueChange, placeholder, emptyText, className, disabled, ...props }: MultiSelectProps): react_jsx_runtime.JSX.Element;
+
+type NativeSelectOption = {
+    value: string;
+    label: string;
+} | string;
+type NativeSelectBaseProps = Omit<React$1.ComponentProps<'select'>, 'size'> & {
+    size?: ComponentSize;
+    data?: NativeSelectOption[];
+    rightSection?: React$1.ReactNode;
+};
+declare const NativeSelectBase: React$1.ForwardRefExoticComponent<Omit<NativeSelectBaseProps, "ref"> & React$1.RefAttributes<HTMLSelectElement>>;
+type NativeSelectProps = NativeSelectBaseProps & Omit<InputWrapperProps, 'children'>;
+declare const NativeSelect: React$1.ForwardRefExoticComponent<Omit<NativeSelectProps, "ref"> & React$1.RefAttributes<HTMLSelectElement>>;
+
+declare const navLinkVariants: (props?: ({
+    active?: boolean | null | undefined;
+    variant?: "default" | "subtle" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type NavLinkProps = React$1.ComponentProps<'a'> & VariantProps<typeof navLinkVariants> & {
+    label: string;
+    icon?: React$1.ReactNode;
+    rightSection?: React$1.ReactNode;
+    disabled?: boolean;
+};
+declare function NavLink({ className, active, variant, label, icon, rightSection, disabled, children, href, ...props }: NavLinkProps): react_jsx_runtime.JSX.Element;
+
+declare function NavigationMenu({ className, children, viewport, ...props }: React$1.ComponentProps<typeof NavigationMenu$1.Root> & {
     viewport?: boolean;
 }): react_jsx_runtime.JSX.Element;
-declare function NavigationMenuList({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.List>): react_jsx_runtime.JSX.Element;
-declare function NavigationMenuItem({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Item>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuList({ className, ...props }: React$1.ComponentProps<typeof NavigationMenu$1.List>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuItem({ className, ...props }: React$1.ComponentProps<typeof NavigationMenu$1.Item>): react_jsx_runtime.JSX.Element;
 declare const navigationMenuTriggerStyle: (props?: class_variance_authority_types.ClassProp | undefined) => string;
-declare function NavigationMenuTrigger({ className, children, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
-declare function NavigationMenuContent({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Content>): react_jsx_runtime.JSX.Element;
-declare function NavigationMenuViewport({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Viewport>): react_jsx_runtime.JSX.Element;
-declare function NavigationMenuLink({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Link>): react_jsx_runtime.JSX.Element;
-declare function NavigationMenuIndicator({ className, ...props }: React$1.ComponentProps<typeof NavigationMenuPrimitive.Indicator>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuTrigger({ className, children, ...props }: React$1.ComponentProps<typeof NavigationMenu$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuContent({ className, ...props }: React$1.ComponentProps<typeof NavigationMenu$1.Content>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuViewport({ className, ...props }: React$1.ComponentProps<typeof NavigationMenu$1.Viewport>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuLink({ className, ...props }: React$1.ComponentProps<typeof NavigationMenu$1.Link>): react_jsx_runtime.JSX.Element;
+declare function NavigationMenuIndicator({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+
+type NumberFormatterProps = React$1.ComponentProps<'span'> & {
+    value: number;
+    prefix?: string;
+    suffix?: string;
+    thousandsSeparator?: string;
+    decimalSeparator?: string;
+    decimalScale?: number;
+    fixedDecimalScale?: boolean;
+};
+declare function NumberFormatter({ className, value, prefix, suffix, thousandsSeparator, decimalSeparator, decimalScale, fixedDecimalScale, ...props }: NumberFormatterProps): react_jsx_runtime.JSX.Element;
+
+type NumberInputProps = Omit<React$1.ComponentProps<'input'>, 'type' | 'value' | 'defaultValue' | 'onChange' | 'size'> & Omit<InputWrapperProps, 'children'> & {
+    value?: number | string;
+    defaultValue?: number | string;
+    onChange?: (value: number | string) => void;
+    size?: ComponentSize;
+    min?: number;
+    max?: number;
+    step?: number;
+    decimalScale?: number;
+    thousandsSeparator?: string;
+    decimalSeparator?: string;
+    /** Show increment/decrement controls */
+    controls?: boolean;
+    leftSection?: React$1.ReactNode;
+    rightSection?: React$1.ReactNode;
+};
+declare const NumberInput: React$1.ForwardRefExoticComponent<Omit<NumberInputProps, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+
+type OverlayProps = React$1.ComponentProps<'div'> & {
+    blur?: number;
+    opacity?: number;
+    color?: string;
+};
+declare function Overlay({ className, blur, opacity, color, style, ...props }: OverlayProps): react_jsx_runtime.JSX.Element;
 
 declare function Pagination({ className, ...props }: React$1.ComponentProps<'nav'>): react_jsx_runtime.JSX.Element;
 declare function PaginationContent({ className, ...props }: React$1.ComponentProps<'ul'>): react_jsx_runtime.JSX.Element;
@@ -953,15 +1817,74 @@ declare function PaginationPrevious({ className, ...props }: React$1.ComponentPr
 declare function PaginationNext({ className, ...props }: React$1.ComponentProps<typeof PaginationLink>): react_jsx_runtime.JSX.Element;
 declare function PaginationEllipsis({ className, ...props }: React$1.ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
 
-declare function Popover({ ...props }: React$1.ComponentProps<typeof PopoverPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function PopoverTrigger({ ...props }: React$1.ComponentProps<typeof PopoverPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
-declare function PopoverContent({ className, align, sideOffset, ...props }: React$1.ComponentProps<typeof PopoverPrimitive.Content>): react_jsx_runtime.JSX.Element;
-declare function PopoverAnchor({ ...props }: React$1.ComponentProps<typeof PopoverPrimitive.Anchor>): react_jsx_runtime.JSX.Element;
+type PaperProps = React$1.ComponentProps<'div'> & {
+    padding?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    radius?: ComponentRadius;
+    withBorder?: boolean;
+    shadow?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+};
+declare function Paper({ className, padding, radius, withBorder, shadow, ...props }: PaperProps): react_jsx_runtime.JSX.Element;
 
-declare function Progress({ className, value, ...props }: React$1.ComponentProps<typeof ProgressPrimitive.Root>): react_jsx_runtime.JSX.Element;
+type PasswordInputBaseProps = Omit<React$1.ComponentProps<'input'>, 'type' | 'size'> & {
+    showToggle?: boolean;
+    size?: ComponentSize;
+};
+declare const PasswordInput: React$1.ForwardRefExoticComponent<Omit<PasswordInputBaseProps, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+type PasswordInputWithWrapperProps = PasswordInputBaseProps & Omit<InputWrapperProps, 'children'>;
+declare const PasswordInputWithWrapper: React$1.ForwardRefExoticComponent<Omit<PasswordInputWithWrapperProps, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
 
-declare function RadioGroup({ className, ...props }: React$1.ComponentProps<typeof RadioGroupPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function RadioGroupItem({ className, ...props }: React$1.ComponentProps<typeof RadioGroupPrimitive.Item>): react_jsx_runtime.JSX.Element;
+declare const pillVariants: (props?: ({
+    variant?: "default" | "contrast" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    radius?: "xs" | "sm" | "md" | "lg" | "xl" | "full" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type PillProps = Omit<React$1.ComponentProps<'span'>, 'disabled'> & VariantProps<typeof pillVariants> & {
+    withRemoveButton?: boolean;
+    onRemove?: () => void;
+    removeButtonProps?: React$1.ComponentProps<typeof CloseButton>;
+    disabled?: boolean;
+};
+declare function Pill({ className, variant, size, radius, withRemoveButton, onRemove, removeButtonProps, children, disabled, ...props }: PillProps): react_jsx_runtime.JSX.Element;
+
+declare function Popover({ ...props }: React$1.ComponentProps<typeof Popover$1.Root>): react_jsx_runtime.JSX.Element;
+declare function PopoverTrigger({ ...props }: React$1.ComponentProps<typeof Popover$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function PopoverContent({ className, align, alignOffset, side, sideOffset, anchor, ...props }: React$1.ComponentProps<typeof Popover$1.Popup> & {
+    align?: React$1.ComponentProps<typeof Popover$1.Positioner>['align'];
+    alignOffset?: React$1.ComponentProps<typeof Popover$1.Positioner>['alignOffset'];
+    side?: React$1.ComponentProps<typeof Popover$1.Positioner>['side'];
+    sideOffset?: React$1.ComponentProps<typeof Popover$1.Positioner>['sideOffset'];
+    anchor?: React$1.ComponentProps<typeof Popover$1.Positioner>['anchor'];
+}): react_jsx_runtime.JSX.Element;
+declare function PopoverHeader({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function PopoverTitle({ className, ...props }: React$1.ComponentProps<typeof Popover$1.Title>): react_jsx_runtime.JSX.Element;
+declare function PopoverDescription({ className, ...props }: React$1.ComponentProps<typeof Popover$1.Description>): react_jsx_runtime.JSX.Element;
+declare function PopoverAnchor({ ...props }: React$1.ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
+
+type ProgressProps = React$1.ComponentProps<typeof Progress$1.Root> & {
+    size?: ComponentSize;
+    radius?: ComponentRadius;
+    color?: ComponentColor;
+};
+declare function Progress({ className, value, size, radius, color: _color, ...props }: ProgressProps): react_jsx_runtime.JSX.Element;
+
+declare function RadioGroup({ className, ...props }: React$1.ComponentProps<typeof RadioGroup$1>): react_jsx_runtime.JSX.Element;
+type RadioGroupItemProps = React$1.ComponentProps<typeof Radio.Root> & {
+    size?: ComponentSize;
+    variant?: 'outline' | 'filled';
+};
+declare function RadioGroupItem({ className, size, variant, ...props }: RadioGroupItemProps): react_jsx_runtime.JSX.Element;
+
+type RatingProps = Omit<React$1.ComponentProps<'div'>, 'onChange'> & {
+    count?: number;
+    value?: number;
+    onChange?: (value: number) => void;
+    readOnly?: boolean;
+    disabled?: boolean;
+    allowHalf?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    color?: string;
+};
+declare function Rating({ count, value, onChange, readOnly, disabled, allowHalf, size, color, className, ...props }: RatingProps): react_jsx_runtime.JSX.Element;
 
 declare function ResizablePanelGroup({ className, ...props }: React$1.ComponentProps<typeof ResizablePrimitive.PanelGroup>): react_jsx_runtime.JSX.Element;
 declare function ResizablePanel({ ...props }: React$1.ComponentProps<typeof ResizablePrimitive.Panel>): react_jsx_runtime.JSX.Element;
@@ -969,37 +1892,56 @@ declare function ResizableHandle({ withHandle, className, ...props }: React$1.Co
     withHandle?: boolean;
 }): react_jsx_runtime.JSX.Element;
 
-declare function ScrollArea({ className, children, ...props }: React$1.ComponentProps<typeof ScrollAreaPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function ScrollBar({ className, orientation, ...props }: React$1.ComponentProps<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>): react_jsx_runtime.JSX.Element;
+type RingProgressProps = React$1.ComponentProps<'div'> & {
+    value: number;
+    size?: number;
+    thickness?: number;
+    color?: string;
+    label?: React$1.ReactNode;
+};
+declare function RingProgress({ value, size, thickness, color, label, className, ...props }: RingProgressProps): react_jsx_runtime.JSX.Element;
 
-declare function Select({ ...props }: React$1.ComponentProps<typeof SelectPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function SelectGroup({ ...props }: React$1.ComponentProps<typeof SelectPrimitive.Group>): react_jsx_runtime.JSX.Element;
-declare function SelectValue({ ...props }: React$1.ComponentProps<typeof SelectPrimitive.Value>): react_jsx_runtime.JSX.Element;
-declare function SelectTrigger({ className, size, children, ...props }: React$1.ComponentProps<typeof SelectPrimitive.Trigger> & {
+declare function ScrollArea({ className, children, ...props }: React$1.ComponentProps<typeof ScrollArea$1.Root>): react_jsx_runtime.JSX.Element;
+declare function ScrollBar({ className, orientation, ...props }: React$1.ComponentProps<typeof ScrollArea$1.Scrollbar>): react_jsx_runtime.JSX.Element;
+
+declare const Select: typeof Select$1.Root;
+declare function SelectGroup({ className, ...props }: Select$1.Group.Props): react_jsx_runtime.JSX.Element;
+declare function SelectValue({ className, ...props }: Select$1.Value.Props): react_jsx_runtime.JSX.Element;
+declare function SelectTrigger({ className, size, children, ...props }: Select$1.Trigger.Props & {
     size?: 'sm' | 'default';
 }): react_jsx_runtime.JSX.Element;
-declare function SelectContent({ className, children, position, align, ...props }: React$1.ComponentProps<typeof SelectPrimitive.Content>): react_jsx_runtime.JSX.Element;
-declare function SelectLabel({ className, ...props }: React$1.ComponentProps<typeof SelectPrimitive.Label>): react_jsx_runtime.JSX.Element;
-declare function SelectItem({ className, children, ...props }: React$1.ComponentProps<typeof SelectPrimitive.Item>): react_jsx_runtime.JSX.Element;
-declare function SelectSeparator({ className, ...props }: React$1.ComponentProps<typeof SelectPrimitive.Separator>): react_jsx_runtime.JSX.Element;
-declare function SelectScrollUpButton({ className, ...props }: React$1.ComponentProps<typeof SelectPrimitive.ScrollUpButton>): react_jsx_runtime.JSX.Element;
-declare function SelectScrollDownButton({ className, ...props }: React$1.ComponentProps<typeof SelectPrimitive.ScrollDownButton>): react_jsx_runtime.JSX.Element;
-
-declare function Sheet({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function SheetTrigger({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
-declare function SheetClose({ ...props }: React$1.ComponentProps<typeof DialogPrimitive.Close>): react_jsx_runtime.JSX.Element;
-declare function SheetContent({ className, children, side, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Content> & {
+declare function SelectContent({ className, children, side, sideOffset, align, alignOffset, alignItemWithTrigger, ...props }: Select$1.Popup.Props & Pick<Select$1.Positioner.Props, 'align' | 'alignOffset' | 'side' | 'sideOffset' | 'alignItemWithTrigger'>): react_jsx_runtime.JSX.Element;
+declare function SelectLabel({ className, ...props }: Select$1.GroupLabel.Props): react_jsx_runtime.JSX.Element;
+declare function SelectItem({ className, children, ...props }: Select$1.Item.Props): react_jsx_runtime.JSX.Element;
+declare function SelectSeparator({ className, ...props }: Select$1.Separator.Props): react_jsx_runtime.JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: React$1.ComponentProps<typeof Select$1.ScrollUpArrow>): react_jsx_runtime.JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: React$1.ComponentProps<typeof Select$1.ScrollDownArrow>): react_jsx_runtime.JSX.Element;
+
+type SemiCircleProgressProps = React$1.ComponentProps<'div'> & {
+    value: number;
+    size?: number;
+    thickness?: number;
+    color?: string;
+    label?: React$1.ReactNode;
+};
+declare function SemiCircleProgress({ className, value, size, thickness, color, label, ...props }: SemiCircleProgressProps): react_jsx_runtime.JSX.Element;
+
+declare function Sheet({ ...props }: React$1.ComponentProps<typeof Dialog$1.Root>): react_jsx_runtime.JSX.Element;
+declare function SheetTrigger({ ...props }: React$1.ComponentProps<typeof Dialog$1.Trigger>): react_jsx_runtime.JSX.Element;
+declare function SheetClose({ ...props }: React$1.ComponentProps<typeof Dialog$1.Close>): react_jsx_runtime.JSX.Element;
+declare function SheetContent({ className, children, side, showCloseButton, ...props }: React$1.ComponentProps<typeof Dialog$1.Popup> & {
     side?: 'top' | 'right' | 'bottom' | 'left';
+    showCloseButton?: boolean;
 }): react_jsx_runtime.JSX.Element;
 declare function SheetHeader({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
 declare function SheetFooter({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
-declare function SheetTitle({ className, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Title>): react_jsx_runtime.JSX.Element;
-declare function SheetDescription({ className, ...props }: React$1.ComponentProps<typeof DialogPrimitive.Description>): react_jsx_runtime.JSX.Element;
+declare function SheetTitle({ className, ...props }: React$1.ComponentProps<typeof Dialog$1.Title>): react_jsx_runtime.JSX.Element;
+declare function SheetDescription({ className, ...props }: React$1.ComponentProps<typeof Dialog$1.Description>): react_jsx_runtime.JSX.Element;
 
-declare function TooltipProvider({ delayDuration, ...props }: React$1.ComponentProps<typeof TooltipPrimitive.Provider>): react_jsx_runtime.JSX.Element;
-declare function Tooltip({ children, ...props }: React$1.ComponentProps<typeof TooltipPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function TooltipTrigger({ ...props }: React$1.ComponentProps<typeof TooltipPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
-declare function TooltipContent({ className, sideOffset, children, ...props }: React$1.ComponentProps<typeof TooltipPrimitive.Content>): react_jsx_runtime.JSX.Element;
+declare function TooltipProvider({ delay, ...props }: Tooltip$1.Provider.Props): react_jsx_runtime.JSX.Element;
+declare function Tooltip({ ...props }: Tooltip$1.Root.Props): react_jsx_runtime.JSX.Element;
+declare function TooltipTrigger({ ...props }: Tooltip$1.Trigger.Props): react_jsx_runtime.JSX.Element;
+declare function TooltipContent({ className, side, sideOffset, align, alignOffset, children, ...props }: Tooltip$1.Popup.Props & Pick<Tooltip$1.Positioner.Props, 'align' | 'alignOffset' | 'side' | 'sideOffset'>): react_jsx_runtime.JSX.Element;
 
 type SidebarContextProps = {
     state: 'expanded' | 'collapsed';
@@ -1036,49 +1978,108 @@ declare function SidebarFooter({ className, ...props }: React$1.ComponentProps<'
 declare function SidebarSeparator({ className, ...props }: React$1.ComponentProps<typeof Separator>): react_jsx_runtime.JSX.Element;
 declare function SidebarContent({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
 declare function SidebarGroup({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
-declare function SidebarGroupLabel({ className, asChild, ...props }: React$1.ComponentProps<'div'> & {
-    asChild?: boolean;
-}): react_jsx_runtime.JSX.Element;
-declare function SidebarGroupAction({ className, asChild, ...props }: React$1.ComponentProps<'button'> & {
-    asChild?: boolean;
-}): react_jsx_runtime.JSX.Element;
+declare function SidebarGroupLabel({ className, render, ...props }: React$1.ComponentProps<'div'> & {
+    render?: useRender.RenderProp;
+}): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+declare function SidebarGroupAction({ className, render, ...props }: React$1.ComponentProps<'button'> & {
+    render?: useRender.RenderProp;
+}): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
 declare function SidebarGroupContent({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
 declare function SidebarMenu({ className, ...props }: React$1.ComponentProps<'ul'>): react_jsx_runtime.JSX.Element;
 declare function SidebarMenuItem({ className, ...props }: React$1.ComponentProps<'li'>): react_jsx_runtime.JSX.Element;
 declare const sidebarMenuButtonVariants: (props?: ({
     variant?: "default" | "outline" | null | undefined;
-    size?: "default" | "sm" | "lg" | null | undefined;
+    size?: "sm" | "lg" | "default" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare function SidebarMenuButton({ asChild, isActive, variant, size, tooltip, className, ...props }: React$1.ComponentProps<'button'> & {
-    asChild?: boolean;
+declare function SidebarMenuButton({ render, isActive, variant, size, tooltip, className, ...props }: React$1.ComponentProps<'button'> & {
+    render?: useRender.RenderProp;
     isActive?: boolean;
     tooltip?: string | React$1.ComponentProps<typeof TooltipContent>;
 } & VariantProps<typeof sidebarMenuButtonVariants>): react_jsx_runtime.JSX.Element;
-declare function SidebarMenuAction({ className, asChild, showOnHover, ...props }: React$1.ComponentProps<'button'> & {
-    asChild?: boolean;
+declare function SidebarMenuAction({ className, render, showOnHover, ...props }: React$1.ComponentProps<'button'> & {
+    render?: useRender.RenderProp;
     showOnHover?: boolean;
-}): react_jsx_runtime.JSX.Element;
+}): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
 declare function SidebarMenuBadge({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
 declare function SidebarMenuSkeleton({ className, showIcon, ...props }: React$1.ComponentProps<'div'> & {
     showIcon?: boolean;
 }): react_jsx_runtime.JSX.Element;
 declare function SidebarMenuSub({ className, ...props }: React$1.ComponentProps<'ul'>): react_jsx_runtime.JSX.Element;
 declare function SidebarMenuSubItem({ className, ...props }: React$1.ComponentProps<'li'>): react_jsx_runtime.JSX.Element;
-declare function SidebarMenuSubButton({ asChild, size, isActive, className, ...props }: React$1.ComponentProps<'a'> & {
-    asChild?: boolean;
+declare function SidebarMenuSubButton({ render, size, isActive, className, ...props }: React$1.ComponentProps<'a'> & {
+    render?: useRender.RenderProp;
     size?: 'sm' | 'md';
     isActive?: boolean;
-}): react_jsx_runtime.JSX.Element;
+}): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
 
-declare function Skeleton({ className, ...props }: React.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare const simpleGridVariants: (props?: ({
+    cols?: 4 | 1 | "auto" | 2 | 3 | 5 | 6 | null | undefined;
+    spacing?: "0" | "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type SimpleGridProps = React$1.ComponentProps<'div'> & VariantProps<typeof simpleGridVariants> & {
+    verticalSpacing?: '0' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+    minChildWidth?: string | number;
+};
+declare function SimpleGrid({ className, cols, spacing, verticalSpacing, minChildWidth, style, children, ...props }: SimpleGridProps): react_jsx_runtime.JSX.Element;
+
+type SkeletonProps = React.ComponentProps<'div'> & {
+    radius?: ComponentRadius;
+    circle?: boolean;
+    animate?: boolean;
+};
+declare function Skeleton({ className, radius: _radius, circle, animate, ...props }: SkeletonProps): react_jsx_runtime.JSX.Element;
 
-declare function Slider({ className, defaultValue, value, min, max, ...props }: React$1.ComponentProps<typeof SliderPrimitive.Root>): react_jsx_runtime.JSX.Element;
+declare function Slider({ className, defaultValue, value, min, max, ...props }: Slider$1.Root.Props): react_jsx_runtime.JSX.Element;
 
 declare const Toaster: ({ ...props }: ToasterProps) => react_jsx_runtime.JSX.Element;
 
-declare function Spinner({ className, ...props }: React.ComponentProps<typeof IconLoader2>): react_jsx_runtime.JSX.Element;
+type SpaceProps = React$1.ComponentProps<'div'> & {
+    /** Height (vertical spacer). Theme size or CSS value. */
+    h?: ComponentSize | number | string;
+    /** Width (horizontal spacer). Theme size or CSS value. */
+    w?: ComponentSize | number | string;
+};
+declare function Space({ className, h, w, style, ...props }: SpaceProps): react_jsx_runtime.JSX.Element;
+
+type SpinnerProps = Omit<React.ComponentProps<typeof IconLoader2>, 'size'> & {
+    size?: ComponentSize;
+};
+declare function Spinner({ className, size, ...props }: SpinnerProps): react_jsx_runtime.JSX.Element;
+
+type SpoilerProps = React$1.ComponentProps<'div'> & {
+    maxHeight?: number;
+    showLabel?: string;
+    hideLabel?: string;
+    initialState?: boolean;
+};
+declare function Spoiler({ maxHeight, showLabel, hideLabel, initialState, children, className, ...props }: SpoilerProps): react_jsx_runtime.JSX.Element;
 
-declare function Switch({ className, ...props }: React$1.ComponentProps<typeof SwitchPrimitive.Root>): react_jsx_runtime.JSX.Element;
+type StackProps = React$1.ComponentProps<'div'> & {
+    gap?: ComponentSize | number;
+    align?: 'start' | 'center' | 'end' | 'stretch';
+    justify?: 'start' | 'center' | 'end' | 'between' | 'around';
+};
+declare function Stack({ className, gap, align, justify, style, ...props }: StackProps): react_jsx_runtime.JSX.Element;
+
+type StepperProps = React$1.ComponentProps<'div'> & {
+    activeStep: number;
+    orientation?: 'horizontal' | 'vertical';
+    totalSteps?: number;
+};
+declare function Stepper({ activeStep, orientation, totalSteps, className, children, ...props }: StepperProps): react_jsx_runtime.JSX.Element;
+type StepProps = React$1.ComponentProps<'div'> & {
+    index: number;
+    label?: string;
+    description?: string;
+    isLast?: boolean;
+};
+declare function Step({ index, label, description, isLast, className, children, ...props }: StepProps): react_jsx_runtime.JSX.Element;
+
+type SwitchProps = React$1.ComponentProps<typeof Switch$1.Root> & {
+    size?: ComponentSize;
+    color?: ComponentColor;
+};
+declare function Switch({ className, size, color: _color, ...props }: SwitchProps): react_jsx_runtime.JSX.Element;
 
 declare function Table({ className, ...props }: React$1.ComponentProps<'table'>): react_jsx_runtime.JSX.Element;
 declare function TableHeader({ className, ...props }: React$1.ComponentProps<'thead'>): react_jsx_runtime.JSX.Element;
@@ -1089,24 +2090,171 @@ declare function TableHead({ className, ...props }: React$1.ComponentProps<'th'>
 declare function TableCell({ className, ...props }: React$1.ComponentProps<'td'>): react_jsx_runtime.JSX.Element;
 declare function TableCaption({ className, ...props }: React$1.ComponentProps<'caption'>): react_jsx_runtime.JSX.Element;
 
-declare function Tabs({ className, ...props }: React$1.ComponentProps<typeof TabsPrimitive.Root>): react_jsx_runtime.JSX.Element;
-declare function TabsList({ className, ...props }: React$1.ComponentProps<typeof TabsPrimitive.List>): react_jsx_runtime.JSX.Element;
-declare function TabsTrigger({ className, ...props }: React$1.ComponentProps<typeof TabsPrimitive.Trigger>): react_jsx_runtime.JSX.Element;
-declare function TabsContent({ className, ...props }: React$1.ComponentProps<typeof TabsPrimitive.Content>): react_jsx_runtime.JSX.Element;
+type TableOfContentsItem = {
+    id: string;
+    label: string;
+    depth?: number;
+};
+type TableOfContentsProps = React$1.ComponentProps<'nav'> & {
+    items: TableOfContentsItem[];
+    /** Currently active item id (e.g. from scroll spy) */
+    activeId?: string | null;
+    /** Called when an item is clicked (e.g. scroll to #id) */
+    onItemClick?: (id: string) => void;
+    size?: ComponentSize;
+    /** Left padding offset per depth level (px) */
+    depthOffset?: number;
+    minDepth?: number;
+};
+declare function TableOfContents({ className, items, activeId, onItemClick, size, depthOffset, minDepth, ...props }: TableOfContentsProps): react_jsx_runtime.JSX.Element;
+
+declare function Tabs({ className, orientation, ...props }: React$1.ComponentProps<typeof Tabs$1.Root>): react_jsx_runtime.JSX.Element;
+declare const tabsListVariants: (props?: ({
+    variant?: "line" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function TabsList({ className, ...props }: React$1.ComponentProps<typeof Tabs$1.List> & VariantProps<typeof tabsListVariants> & {
+    variant?: 'default' | 'line' | 'outline' | 'pills';
+    radius?: unknown;
+}): react_jsx_runtime.JSX.Element;
+declare function TabsTrigger({ className, ...props }: React$1.ComponentProps<typeof Tabs$1.Tab>): react_jsx_runtime.JSX.Element;
+declare function TabsContent({ className, ...props }: React$1.ComponentProps<typeof Tabs$1.Panel>): react_jsx_runtime.JSX.Element;
+
+type TagsInputProps = Omit<React$1.ComponentProps<'div'>, 'onChange'> & {
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (value: string[]) => void;
+    placeholder?: string;
+    maxTags?: number;
+    allowDuplicates?: boolean;
+    splitChars?: string[];
+    disabled?: boolean;
+};
+declare function TagsInput({ className, value, defaultValue, onChange, placeholder, maxTags, allowDuplicates, splitChars, disabled, ...props }: TagsInputProps): react_jsx_runtime.JSX.Element;
+
+declare const textVariants: (props?: ({
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | null | undefined;
+    weight?: "bold" | "light" | "normal" | "medium" | "semibold" | "extrabold" | null | undefined;
+    align?: "center" | "left" | "right" | "start" | "end" | "justify" | null | undefined;
+    transform?: "none" | "capitalize" | "lowercase" | "uppercase" | null | undefined;
+    decoration?: "none" | "line-through" | "underline" | null | undefined;
+    variant?: "primary" | "secondary" | "accent" | "destructive" | "default" | "muted" | "success" | "warning" | "dimmed" | null | undefined;
+    truncate?: boolean | null | undefined;
+    inherit?: boolean | null | undefined;
+    italic?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type TextProps = React$1.ComponentPropsWithoutRef<'span'> & VariantProps<typeof textVariants> & {
+    as?: 'span' | 'p' | 'div' | 'label' | 'strong' | 'em';
+    lineClamp?: number;
+    gradient?: boolean;
+    span?: boolean;
+};
+declare function Text({ className, size, weight, align, transform, decoration, variant, truncate, inherit, italic, as, lineClamp, gradient, span, style, children, ...props }: TextProps): React$1.ReactElement;
+
+type TextInputProps = Omit<React.ComponentProps<'input'>, 'size'> & Omit<InputWrapperProps, 'children'> & {
+    /** Input size */
+    size?: ComponentSize;
+    /** Left section (icon, text, etc.) */
+    leftSection?: React.ReactNode;
+    /** Right section (icon, button, etc.) */
+    rightSection?: React.ReactNode;
+    /** Pointer events for right section */
+    rightSectionPointerEvents?: 'none' | 'all';
+};
+declare const TextInput: React$1.ForwardRefExoticComponent<Omit<TextInputProps, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+
+declare const themeIconVariants: (props?: ({
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | null | undefined;
+    variant?: "default" | "outline" | "light" | "filled" | "gradient" | "subtle" | null | undefined;
+    color?: "primary" | "secondary" | "accent" | "destructive" | "success" | "warning" | null | undefined;
+    radius?: "none" | "sm" | "md" | "lg" | "full" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ThemeIconProps = React$1.ComponentProps<'div'> & VariantProps<typeof themeIconVariants>;
+declare function ThemeIcon({ className, size, variant, color, radius, children, ...props }: ThemeIconProps): react_jsx_runtime.JSX.Element;
 
-declare function Textarea({ className, ...props }: React$1.ComponentProps<'textarea'>): react_jsx_runtime.JSX.Element;
+declare function Timeline({ className, ...props }: React$1.ComponentProps<'ol'>): react_jsx_runtime.JSX.Element;
+declare function TimelineItem({ className, ...props }: React$1.ComponentProps<'li'>): react_jsx_runtime.JSX.Element;
+declare function TimelineDot({ className, variant, ...props }: React$1.ComponentProps<'div'> & {
+    variant?: 'default' | 'primary' | 'secondary';
+}): react_jsx_runtime.JSX.Element;
+declare function TimelineContent({ className, ...props }: React$1.ComponentProps<'div'>): react_jsx_runtime.JSX.Element;
+declare function TimelineTitle({ className, ...props }: React$1.ComponentProps<'h3'>): react_jsx_runtime.JSX.Element;
+declare function TimelineDescription({ className, ...props }: React$1.ComponentProps<'p'>): react_jsx_runtime.JSX.Element;
+declare function TimelineTime({ className, ...props }: React$1.ComponentProps<'time'>): react_jsx_runtime.JSX.Element;
+
+declare const titleVariants: (props?: ({
+    order?: 4 | 1 | 2 | 3 | 5 | 6 | null | undefined;
+    variant?: "primary" | "secondary" | "accent" | "default" | "muted" | "dimmed" | "gradient" | null | undefined;
+    weight?: "bold" | "light" | "normal" | "medium" | "semibold" | "extrabold" | null | undefined;
+    align?: "center" | "left" | "right" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type TitleProps = Omit<React$1.ComponentProps<'h1'>, 'ref'> & VariantProps<typeof titleVariants>;
+declare function Title({ className, order, variant, weight, align, children, ...props }: TitleProps): react_jsx_runtime.JSX.Element;
 
 declare const toggleVariants: (props?: ({
     variant?: "default" | "outline" | null | undefined;
-    size?: "default" | "sm" | "lg" | null | undefined;
+    size?: "sm" | "lg" | "default" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare function Toggle({ className, variant, size, ...props }: React$1.ComponentProps<typeof TogglePrimitive.Root> & VariantProps<typeof toggleVariants>): react_jsx_runtime.JSX.Element;
+declare function Toggle({ className, variant, size, ...props }: React$1.ComponentProps<typeof Toggle$1> & VariantProps<typeof toggleVariants>): react_jsx_runtime.JSX.Element;
 
-declare function ToggleGroup({ className, variant, size, spacing, children, ...props }: React$1.ComponentProps<typeof ToggleGroupPrimitive.Root> & VariantProps<typeof toggleVariants> & {
+declare function ToggleGroup({ className, variant, size, spacing, children, ...props }: React$1.ComponentProps<typeof ToggleGroup$1> & VariantProps<typeof toggleVariants> & {
     spacing?: number;
 }): react_jsx_runtime.JSX.Element;
-declare function ToggleGroupItem({ className, children, variant, size, ...props }: React$1.ComponentProps<typeof ToggleGroupPrimitive.Item> & VariantProps<typeof toggleVariants>): react_jsx_runtime.JSX.Element;
-
-declare function VisuallyHidden({ ...props }: React$1.ComponentProps<typeof VisuallyHiddenPrimitive.Root>): react_jsx_runtime.JSX.Element;
-
-export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, Alert, AlertDescription, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, AlertTitle, type AnimatedTabItem, AnimatedTabs, AppBreadcrumbs, AppHeaderActions, AppSidebar, AspectRatio, Avatar, AvatarFallback, AvatarImage, Badge, Breadcrumb, BreadcrumbContext, type BreadcrumbContextValue, BreadcrumbEllipsis, BreadcrumbItem, type BreadcrumbItemData, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbProvider, BreadcrumbSeparator, Button, ButtonGroup, ButtonGroupSeparator, ButtonGroupText, Calendar, CalendarDayButton, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Carousel, type CarouselApi, CarouselContent, CarouselItem, CarouselNext, CarouselPrevious, type ChartConfig, ChartContainer, ChartLegend, ChartLegendContent, ChartStyle, ChartTooltip, ChartTooltipContent, Checkbox, Collapsible, CollapsibleContent, CollapsibleTrigger, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuPortal, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, type CurrencyOption, DataTable, DataTableAction, DataTableColumnHeader, DataTablePagination, DataTableViewOptions, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, DrawerTitle, DrawerTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, Empty, EmptyContent, EmptyDescription, EmptyHeader, EmptyMedia, EmptyTitle, EntityBulkActions, EntityDetailHeader, EntityDrawer, EntityDrawerTrigger, EntityEmptyState, EntityFilter, EntityFormActions, EntityHeader, EntityLoadingState, EntitySearch, EntitySort, EntityViewToggle, Field, FieldContent, FieldDescription, FieldError, FieldGroup, FieldLabel, FieldLegend, FieldSeparator, FieldSet, FieldTitle, Form, FormControl, FormDescription, FormField, FormItem, FormLabel, FormMessage, HoverCard, HoverCardContent, HoverCardTrigger, Input, InputGroup, InputGroupAddon, InputGroupButton, InputGroupInput, InputGroupText, InputGroupTextarea, InputOTP, InputOTPGroup, InputOTPSeparator, InputOTPSlot, Item, ItemActions, ItemContent, ItemDescription, ItemFooter, ItemGroup, ItemHeader, ItemMedia, ItemSeparator, ItemTitle, Kbd, KbdGroup, Label, LocaleInputRichText, type LocaleInputRichTextProps, LocaleInputText, type LocaleInputTextProps, LocaleInputTextarea, type LocaleInputTextareaProps, LocaleRichText, type LocaleRichTextProps, LocaleText, Menubar, MenubarCheckboxItem, MenubarContent, MenubarGroup, MenubarItem, MenubarLabel, MenubarMenu, MenubarPortal, MenubarRadioGroup, MenubarRadioItem, MenubarSeparator, MenubarShortcut, MenubarSub, MenubarSubContent, MenubarSubTrigger, MenubarTrigger, MesobLogo, MoneyInput, type MoneyInputProps, type NavItem, NavigationMenu, NavigationMenuContent, NavigationMenuIndicator, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuTrigger, NavigationMenuViewport, PageBody, PageContainer, PageGoBack, PageSection, PageSubTitle, PageTitle, Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, PoweredBy, Progress, RadioGroup, RadioGroupItem, ResizableHandle, ResizablePanel, ResizablePanelGroup, RichTextDisplay, RichTextEditor, RichTextEditorContent, RichTextEditorControl, RichTextEditorControlsGroup, RichTextEditorToolbar, RichTextInput, ScrollArea, ScrollBar, Section, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, Separator, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetTitle, SheetTrigger, Shell, Sidebar, SidebarContent, SidebarContext, type SidebarContextProps, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, Skeleton, Slider, Spinner, SpotlightSearch, Switch, type TabItem, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, Textarea, ThemeToggle, Toaster, Toggle, ToggleGroup, ToggleGroupItem, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, VisuallyHidden, badgeVariants, buttonGroupVariants, buttonVariants, navigationMenuTriggerStyle, toggleVariants, useBreadcrumbs, useFormField, useRichTextEditorContext, useSidebar };
+declare function ToggleGroupItem({ className, children, variant, size, ...props }: React$1.ComponentProps<typeof Toggle$1> & VariantProps<typeof toggleVariants>): react_jsx_runtime.JSX.Element;
+
+type TransitionName = 'fade' | 'fade-up' | 'fade-down' | 'fade-left' | 'fade-right' | 'slide-down' | 'slide-up' | 'slide-left' | 'slide-right' | 'scale';
+type TransitionProps = {
+    mounted: boolean;
+    children: (styles: React$1.CSSProperties) => React$1.ReactElement;
+    transition?: TransitionName;
+    duration?: number;
+    exitDuration?: number;
+    timingFunction?: string;
+    keepMounted?: boolean;
+    onExited?: () => void;
+    onEntered?: () => void;
+    onExit?: () => void;
+    onEnter?: () => void;
+    enterDelay?: number;
+    exitDelay?: number;
+};
+declare function Transition({ mounted, children, transition, duration, exitDuration, timingFunction, keepMounted, onExited, onEntered, onExit, onEnter, enterDelay, exitDelay, }: TransitionProps): react_jsx_runtime.JSX.Element | null;
+
+type TreeNodeData = {
+    label: React$1.ReactNode;
+    value: string;
+    children?: TreeNodeData[];
+    nodeProps?: Record<string, unknown>;
+};
+type TreeProps = React$1.ComponentProps<'div'> & {
+    data: TreeNodeData[];
+    /** Selected value (controlled) */
+    selectedValue?: string | null;
+    /** Called when selection changes */
+    onSelectedValueChange?: (value: string | null) => void;
+    /** Expanded values (controlled). If undefined, internal state is used. */
+    expandedValues?: Set<string>;
+    onExpandedValuesChange?: (values: Set<string>) => void;
+    /** Padding left per level (px) */
+    levelOffset?: number;
+    /** Expand node on click (when it has children) */
+    expandOnClick?: boolean;
+    /** Select node on click */
+    selectOnClick?: boolean;
+    renderNode?: (payload: {
+        node: TreeNodeData;
+        level: number;
+        expanded: boolean;
+        hasChildren: boolean;
+        selected: boolean;
+    }) => React$1.ReactNode;
+};
+declare function Tree({ className, data, selectedValue, onSelectedValueChange, expandedValues: expandedProp, onExpandedValuesChange, levelOffset, expandOnClick, selectOnClick, renderNode, ...props }: TreeProps): react_jsx_runtime.JSX.Element;
+
+type UnstyledButtonProps = React$1.ComponentProps<'button'> & {
+    render?: React$1.ComponentProps<typeof useRender>['render'];
+};
+declare function UnstyledButton({ className, render, ...props }: UnstyledButtonProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+
+declare function VisuallyHidden({ className, ...props }: React$1.ComponentProps<'span'>): react_jsx_runtime.JSX.Element;
+
+export { Accordion, AccordionContent, AccordionItem, type AccordionProps, AccordionTrigger, ActionIcon, type ActionIconProps, Affix, Alert, AlertAction, AlertDescription, AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogMedia, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, type AlertProps, AlertTitle, Anchor, type AnchorProps, AngleSlider, type AngleSliderProps, type AnimatedTabItem, AnimatedTabs, AppBreadcrumbs, AppHeaderActions, AppSidebar, AspectRatio, Avatar, AvatarFallback, AvatarImage, type AvatarProps, BackgroundImage, type BackgroundImageProps, Badge, type BadgeProps, Blockquote, Breadcrumb, BreadcrumbContext, type BreadcrumbContextValue, BreadcrumbEllipsis, BreadcrumbItem, type BreadcrumbItemData, BreadcrumbLink, BreadcrumbList, BreadcrumbPage, BreadcrumbProvider, BreadcrumbSeparator, Burger, Button, ButtonGroup, ButtonGroupSeparator, ButtonGroupText, type ButtonLoaderProps, type ButtonProps, Calendar, CalendarDayButton, DisplayTableCaption as Caption, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Carousel, type CarouselApi, CarouselContent, CarouselItem, CarouselNext, CarouselPrevious, Center, type ChartConfig, ChartContainer, ChartLegend, ChartLegendContent, ChartStyle, ChartTooltip, ChartTooltipContent, Checkbox, type CheckboxProps, Chip, CloseButton, Code, Collapsible, CollapsibleContent, CollapsibleTrigger, ColorFormat, ColorInput, ColorPicker, type ColorPickerProps, ColorSwatch, type ColorSwatchProps, Combobox, type ComboboxOption, Command, CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, Container, type ContainerProps, ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuPortal, ContextMenuPositioner, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, CopyButton, type CurrencyOption, DataTable, DataTableAction, DataTableColumnHeader, DataTablePagination, DataTableViewOptions, Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, DisplayTable, type DisplayTableData, type DisplayTableVariant, Drawer, DrawerClose, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, DrawerPortal, DrawerTitle, DrawerTrigger, DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuPositioner, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, Empty, EmptyCardLoading, type EmptyCardLoadingProps, EmptyContent, EmptyDescription, EmptyHeader, EmptyMedia, EmptyTitle, EntityBulkActions, EntityDetailHeader, EntityDrawer, EntityDrawerTrigger, EntityEmptyState, EntityFilter, EntityFilterState, EntityFormActions, EntityHeader, EntityLoadingState, EntityPageLoading, type EntityPageLoadingProps, type EntityParams, EntitySearch, EntitySearchState, EntitySection, type EntitySectionState, type EntitySectionView, EntitySelector, type EntitySelectorColumn, type EntitySelectorConfig, EntitySelectorModal, type EntitySelectorModalSize, type EntitySelectorProps, EntitySort, EntitySortState, EntityViewToggle, EntityViewToggleState, ErrorPageView, Field, FieldContent, FieldDescription, FieldError, FieldGroup, FieldLabel, FieldLegend, FieldSeparator, FieldSet, FieldTitle, FileButton, FileInput, Flex, type FlexProps, FloatingIndicator, type FloatingIndicatorProps, FocusTrap, FocusTrapInitialFocus, Form, FormControl, FormDescription, FormField, FormItem, FormLabel, FormMessage, Grid, GridCol, Group, type GroupProps, Highlight, HoverCard, HoverCardContent, HoverCardTrigger, Image, Indicator, Input, InputGroup, InputGroupAddon, InputGroupButton, InputGroupInput, InputGroupText, InputGroupTextarea, InputOTP, InputOTPGroup, InputOTPSeparator, InputOTPSlot, InputWrapper, type InputWrapperProps, Item, ItemActions, ItemContent, ItemDescription, ItemFooter, ItemGroup, ItemHeader, ItemMedia, ItemSeparator, ItemTitle, JsonInput, Kbd, KbdGroup, Label, List, ListItem, Loader, type LoaderProps, type LoaderType, LoadingOverlay, type LoadingOverlayProps, LocaleInputRichText, type LocaleInputRichTextProps, LocaleInputText, type LocaleInputTextProps, LocaleInputTextarea, type LocaleInputTextareaProps, LocaleRichText, type LocaleRichTextProps, LocaleText, Mark, type MarkProps, Menubar, MenubarCheckboxItem, MenubarContent, MenubarGroup, MenubarItem, MenubarLabel, MenubarMenu, MenubarPortal, MenubarPositioner, MenubarRadioGroup, MenubarRadioItem, MenubarSeparator, MenubarShortcut, MenubarSub, MenubarSubContent, MenubarSubTrigger, MenubarTrigger, MesobLogo, MoneyInput, type MoneyInputProps, MultiSelect, type MultiSelectOption, NativeSelect, NativeSelectBase, type NativeSelectBaseProps, type NativeSelectOption, type NativeSelectProps, type NavItem, NavLink, NavigationMenu, NavigationMenuContent, NavigationMenuIndicator, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuTrigger, NavigationMenuViewport, NoDataAvailable, type NoDataAvailableProps, NumberFormatter, NumberInput, type NumberInputProps, Overlay, PageBody, PageContainer, PageGoBack, PageSection, PageSubTitle, PageTitle, Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, Paper, type PaperProps, PasswordInput, type PasswordInputBaseProps, PasswordInputWithWrapper, type PasswordInputWithWrapperProps, Pill, type PillProps, Popover, PopoverAnchor, PopoverContent, PopoverDescription, PopoverHeader, PopoverTitle, PopoverTrigger, PoweredBy, Progress, type ProgressProps, RadioGroup, RadioGroupItem, type RadioGroupItemProps, Rating, ResizableHandle, ResizablePanel, ResizablePanelGroup, RichTextDisplay, RichTextEditor, RichTextEditorContent, RichTextEditorControl, RichTextEditorControlsGroup, RichTextEditorToolbar, RichTextInput, RingProgress, ScrollArea, ScrollBar, DisplayTableScrollContainer as ScrollContainer, Section, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, SemiCircleProgress, Separator, Sheet, SheetClose, SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetTitle, SheetTrigger, Shell, Sidebar, SidebarContent, SidebarContext, type SidebarContextProps, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, SimpleGrid, type SimpleGridProps, Skeleton, type SkeletonProps, Slider, Space, type SpaceProps, Spinner, type SpinnerProps, Spoiler, SpotlightSearch, Stack, type StackProps, Step, Stepper, Switch, type SwitchProps, type TabItem, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableOfContents, type TableOfContentsItem, type TableOfContentsProps, TableRow, Tabs, TabsContent, TabsList, TabsTrigger, TagsInput, DisplayTableTbody as Tbody, DisplayTableTd as Td, Text, TextInput, type TextInputProps, type TextProps, Textarea, type TextareaBaseProps, TextareaInput, type TextareaInputProps, DisplayTableTfoot as Tfoot, DisplayTableTh as Th, DisplayTableThead as Thead, ThemeIcon, type ThemeIconProps, ThemeToggle, Timeline, TimelineContent, TimelineDescription, TimelineDot, TimelineItem, TimelineTime, TimelineTitle, Title, type TitleProps, Toaster, Toggle, ToggleGroup, ToggleGroupItem, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, DisplayTableTr as Tr, Transition, type TransitionName, type TransitionProps, Tree, type TreeNodeData, type TreeProps, UnstyledButton, type UnstyledButtonProps, type UseEntitySectionStateConfig, type ViewOption, VisuallyHidden, actionIconVariants, anchorVariants, badgeVariants, blockquoteVariants, burgerVariants, buttonVariants, chipVariants, codeVariants, containerVariants, gridColVariants, gridVariants, indicatorVariants, listVariants, navLinkVariants, navigationMenuTriggerStyle, pillVariants, simpleGridVariants, tabsListVariants, textVariants, themeIconVariants, titleVariants, toggleVariants, useBreadcrumbs, useEntitySectionState, useFormField, useRichTextEditorContext, useSidebar };