@hex-core/components 1.4.0 → 1.6.0

package/dist/_tsup-dts-rollup.d.ts

@@ -0,0 +1,3556 @@
+import * as AccordionPrimitive from '@radix-ui/react-accordion';
+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 CheckboxPrimitive from '@radix-ui/react-checkbox';
+import { ClassProp } from 'class-variance-authority/types';
+import { ClassValue } from 'clsx';
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+import { ColumnDef } from '@tanstack/react-table';
+import type { ComponentSchemaDefinition } from '@hex-core/registry';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import { ControllerProps } from 'react-hook-form';
+import { DayPicker } from 'react-day-picker';
+import { DialogCloseProps } from '@radix-ui/react-dialog';
+import { DialogContentProps as DialogContentProps_2 } from '@radix-ui/react-dialog';
+import { DialogDescriptionProps } from '@radix-ui/react-dialog';
+import { DialogOverlayProps } from '@radix-ui/react-dialog';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import { DialogTitleProps } from '@radix-ui/react-dialog';
+import { DialogTriggerProps } from '@radix-ui/react-dialog';
+import { Drawer as Drawer_2 } from 'vaul';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import { FieldError } from 'react-hook-form';
+import { FieldPath } from 'react-hook-form';
+import { FieldValues } from 'react-hook-form';
+import { FormProviderProps } from 'react-hook-form';
+import { ForwardRefExoticComponent } from 'react';
+import { Group } from 'react-resizable-panels';
+import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
+import { JSX } from 'react/jsx-runtime';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as MenubarPrimitive from '@radix-ui/react-menubar';
+import * as NavigationMenuPrimitive from '@radix-ui/react-navigation-menu';
+import { OTPInput } from 'input-otp';
+import { Panel } from 'react-resizable-panels';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import { Portal } from 'vaul';
+import * as ProgressPrimitive from '@radix-ui/react-progress';
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import * as React_2 from 'react';
+import { RefAttributes } from 'react';
+import * as ScrollAreaPrimitive from '@radix-ui/react-scroll-area';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import { Separator as Separator_2 } from 'react-resizable-panels';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+import * as SliderPrimitive from '@radix-ui/react-slider';
+import { SlotProps } from '@radix-ui/react-slot';
+import * as SwitchPrimitive from '@radix-ui/react-switch';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+import { toast } from 'sonner';
+import { Toaster as Toaster_2 } from 'sonner';
+import * as ToggleGroupPrimitive from '@radix-ui/react-toggle-group';
+import * as TogglePrimitive from '@radix-ui/react-toggle';
+import * as ToolbarPrimitive from '@radix-ui/react-toolbar';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+import { VariantProps } from 'class-variance-authority';
+
+/** Root container for accordion items. Supports single or multiple open items. */
+declare const Accordion: React_2.ForwardRefExoticComponent<(AccordionPrimitive.AccordionSingleProps | AccordionPrimitive.AccordionMultipleProps) & React_2.RefAttributes<HTMLDivElement>>;
+export { Accordion }
+export { Accordion as Accordion_alias_1 }
+
+/** The collapsible content panel of an AccordionItem. */
+declare const AccordionContent: React_2.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { AccordionContent }
+export { AccordionContent as AccordionContent_alias_1 }
+
+/** A single collapsible item within an Accordion. */
+declare const AccordionItem: React_2.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { AccordionItem }
+export { AccordionItem as AccordionItem_alias_1 }
+
+declare const accordionSchema: ComponentSchemaDefinition;
+export { accordionSchema }
+export { accordionSchema as accordionSchema_alias_1 }
+
+/** The clickable header that toggles an AccordionItem open/closed. */
+declare const AccordionTrigger: React_2.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+export { AccordionTrigger }
+export { AccordionTrigger as AccordionTrigger_alias_1 }
+
+/** An inline notification banner for important messages. */
+declare const Alert: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLDivElement>>;
+export { Alert }
+export { Alert as Alert_alias_1 }
+
+/** The alert description. Renders a div so paragraph children can be styled via [&_p]. */
+declare const AlertDescription: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+export { AlertDescription }
+export { AlertDescription as AlertDescription_alias_1 }
+
+/** Root container for a destructive-action confirmation dialog. */
+declare const AlertDialog: React_2.FC<AlertDialogPrimitive.AlertDialogProps>;
+export { AlertDialog }
+export { AlertDialog as AlertDialog_alias_1 }
+
+/** The destructive action button (e.g. Delete). Receives focus by default. */
+declare const AlertDialogAction: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogActionProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+export { AlertDialogAction }
+export { AlertDialogAction as AlertDialogAction_alias_1 }
+
+/** The cancel button. Closes the dialog. */
+declare const AlertDialogCancel: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogCancelProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+export { AlertDialogCancel }
+export { AlertDialogCancel as AlertDialogCancel_alias_1 }
+
+/** Content panel for the alert dialog. No close button — user must choose action or cancel. */
+declare const AlertDialogContent: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { AlertDialogContent }
+export { AlertDialogContent as AlertDialogContent_alias_1 }
+
+/** Accessible description for the alert dialog. */
+declare const AlertDialogDescription: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogDescriptionProps & React_2.RefAttributes<HTMLParagraphElement>, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;
+export { AlertDialogDescription }
+export { AlertDialogDescription as AlertDialogDescription_alias_1 }
+
+/**
+ * Footer container for Cancel/Action buttons.
+ * @returns A div stacking buttons on mobile and right-aligning on desktop
+ */
+declare function AlertDialogFooter({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { AlertDialogFooter }
+export { AlertDialogFooter as AlertDialogFooter_alias_1 }
+
+/**
+ * Header container for title + description.
+ * @returns A div wrapping title/description with vertical rhythm
+ */
+declare function AlertDialogHeader({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { AlertDialogHeader }
+export { AlertDialogHeader as AlertDialogHeader_alias_1 }
+
+/** Dimmed backdrop behind the alert dialog. */
+declare const AlertDialogOverlay: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogOverlayProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { AlertDialogOverlay }
+export { AlertDialogOverlay as AlertDialogOverlay_alias_1 }
+
+/** Portals alert dialog content into the body. */
+declare const AlertDialogPortal: React_2.FC<AlertDialogPrimitive.AlertDialogPortalProps>;
+export { AlertDialogPortal }
+export { AlertDialogPortal as AlertDialogPortal_alias_1 }
+
+declare const alertDialogSchema: ComponentSchemaDefinition;
+export { alertDialogSchema }
+export { alertDialogSchema as alertDialogSchema_alias_1 }
+
+/** Accessible title for the alert dialog. */
+declare const AlertDialogTitle: React_2.ForwardRefExoticComponent<Omit<AlertDialogPrimitive.AlertDialogTitleProps & React_2.RefAttributes<HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;
+export { AlertDialogTitle }
+export { AlertDialogTitle as AlertDialogTitle_alias_1 }
+
+/** The element that opens the alert dialog. */
+declare const AlertDialogTrigger: React_2.ForwardRefExoticComponent<AlertDialogPrimitive.AlertDialogTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+export { AlertDialogTrigger }
+export { AlertDialogTrigger as AlertDialogTrigger_alias_1 }
+
+declare const alertSchema: ComponentSchemaDefinition;
+export { alertSchema }
+export { alertSchema as alertSchema_alias_1 }
+
+/** The alert title heading. */
+declare const AlertTitle: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLHeadingElement> & React_2.RefAttributes<HTMLHeadingElement>>;
+export { AlertTitle }
+export { AlertTitle as AlertTitle_alias_1 }
+
+declare const alertVariants: (props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { alertVariants }
+export { alertVariants as alertVariants_alias_1 }
+
+/** A container that maintains a specified width-to-height ratio for its children. */
+declare const AspectRatio: ForwardRefExoticComponent<AspectRatioPrimitive.AspectRatioProps & RefAttributes<HTMLDivElement>>;
+export { AspectRatio }
+export { AspectRatio as AspectRatio_alias_1 }
+
+declare const aspectRatioSchema: ComponentSchemaDefinition;
+export { aspectRatioSchema }
+export { aspectRatioSchema as aspectRatioSchema_alias_1 }
+
+/**
+ * A file / image attachment thumbnail with an optional remove affordance
+ * and optional upload-progress overlay. Composes with the existing
+ * `Composer` AI primitive (drop into Composer's children slot to render
+ * as part of the message draft).
+ *
+ * Auto-detects the visual variant: image MIME + `preview` URL → image
+ * thumbnail; everything else → typed file icon with name + size.
+ *
+ * Distinct from {@link Dropzone} (the upload-input affordance) and
+ * static {@link Card} previews (no remove/progress UI).
+ *
+ * @example
+ * ```tsx
+ * <Attachment
+ *   file={{ name: "screenshot.png", size: 124000, type: "image/png", preview: objectUrl }}
+ *   onRemove={() => removeFromDraft("screenshot.png")}
+ * />
+ * ```
+ */
+declare function Attachment({ className, variant, file, onRemove, progress, ref, ...props }: AttachmentProps): JSX.Element;
+export { Attachment }
+export { Attachment as Attachment_alias_1 }
+
+/** A file-shaped attachment metadata object accepted by `<Attachment>`. */
+declare interface AttachmentFile {
+    /** Display name. */
+    name: string;
+    /** Bytes. Used to render a human-readable size. */
+    size: number;
+    /** MIME type. Drives the auto-detected `variant`. */
+    type: string;
+    /**
+     * Optional preview URL for images. When `type` starts with `image/`
+     * AND `preview` is set, the attachment renders a thumbnail; otherwise
+     * it falls back to a typed file icon + name + size.
+     */
+    preview?: string;
+}
+export { AttachmentFile }
+export { AttachmentFile as AttachmentFile_alias_1 }
+
+declare interface AttachmentProps extends Omit<React_2.HTMLAttributes<HTMLDivElement>, "onProgress">, VariantProps<typeof attachmentVariants> {
+    /** Forwarded ref onto the root element. */
+    ref?: React_2.Ref<HTMLDivElement>;
+    /** Native `File` OR a metadata object. */
+    file: File | AttachmentFile;
+    /** Click handler for the remove button. When provided, a × button overlays the attachment. */
+    onRemove?: () => void;
+    /**
+     * Upload progress in `[0, 1)`. Values `>= 1` (or `undefined`) hide the
+     * progressbar — pass `undefined` once the upload completes. Internally
+     * scaled to `aria-valuenow` on a 0–100 progressbar so AT engines
+     * announce "42 percent" rather than "0.42 of 1."
+     */
+    progress?: number;
+}
+export { AttachmentProps }
+export { AttachmentProps as AttachmentProps_alias_1 }
+
+declare const attachmentSchema: ComponentSchemaDefinition;
+export { attachmentSchema }
+export { attachmentSchema as attachmentSchema_alias_1 }
+
+declare const attachmentVariants: (props?: ({
+    variant?: "file" | "image" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { attachmentVariants }
+export { attachmentVariants as attachmentVariants_alias_1 }
+
+/** Root container for an avatar (image + fallback). */
+declare const Avatar: React_2.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarProps & React_2.RefAttributes<HTMLSpanElement>, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;
+export { Avatar }
+export { Avatar as Avatar_alias_1 }
+
+/** Fallback content (usually initials or an icon) shown when the image is missing or fails. Supports delayMs to avoid flashing for fast-loading images. */
+declare const AvatarFallback: React_2.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarFallbackProps & React_2.RefAttributes<HTMLSpanElement>, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;
+export { AvatarFallback }
+export { AvatarFallback as AvatarFallback_alias_1 }
+
+/** Avatar image. AvatarFallback renders in its place when the image is missing or errors. */
+declare const AvatarImage: React_2.ForwardRefExoticComponent<Omit<AvatarPrimitive.AvatarImageProps & React_2.RefAttributes<HTMLImageElement>, "ref"> & React_2.RefAttributes<HTMLImageElement>>;
+export { AvatarImage }
+export { AvatarImage as AvatarImage_alias_1 }
+
+declare const avatarSchema: ComponentSchemaDefinition;
+export { avatarSchema }
+export { avatarSchema as avatarSchema_alias_1 }
+
+/**
+ * Renders an inline badge element with variant-based styling.
+ * @param props - Badge props including variant and className
+ * @returns A styled div element
+ */
+declare function Badge({ className, variant, ...props }: BadgeProps): JSX.Element;
+export { Badge }
+export { Badge as Badge_alias_1 }
+
+/**
+ * A small status indicator badge with multiple style variants.
+ * Used for tags, statuses, counts, and categorization.
+ */
+declare interface BadgeProps extends React_2.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+export { BadgeProps }
+export { BadgeProps as BadgeProps_alias_1 }
+
+declare const badgeSchema: ComponentSchemaDefinition;
+export { badgeSchema }
+export { badgeSchema as badgeSchema_alias_1 }
+
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { badgeVariants }
+export { badgeVariants as badgeVariants_alias_1 }
+
+/** Root nav landmark for breadcrumb navigation. */
+declare const Breadcrumb: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React_2.RefAttributes<HTMLElement>>;
+export { Breadcrumb }
+export { Breadcrumb as Breadcrumb_alias_1 }
+
+/**
+ * Ellipsis for truncated breadcrumb trails.
+ * @returns A span containing a decorative SVG (aria-hidden) plus a sr-only "More pages" label for AT.
+ */
+declare function BreadcrumbEllipsis({ className, ...props }: React_2.ComponentProps<"span">): JSX.Element;
+export { BreadcrumbEllipsis }
+export { BreadcrumbEllipsis as BreadcrumbEllipsis_alias_1 }
+
+/** A single breadcrumb list item. */
+declare const BreadcrumbItem: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React_2.RefAttributes<HTMLLIElement>>;
+export { BreadcrumbItem }
+export { BreadcrumbItem as BreadcrumbItem_alias_1 }
+
+/** A link inside a breadcrumb item. Use asChild to render e.g. Next.js Link. */
+declare const BreadcrumbLink: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+    asChild?: boolean;
+} & React_2.RefAttributes<HTMLAnchorElement>>;
+export { BreadcrumbLink }
+export { BreadcrumbLink as BreadcrumbLink_alias_1 }
+
+/** Ordered list of breadcrumb items. */
+declare const BreadcrumbList: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.OlHTMLAttributes<HTMLOListElement>, HTMLOListElement>, "ref"> & React_2.RefAttributes<HTMLOListElement>>;
+export { BreadcrumbList }
+export { BreadcrumbList as BreadcrumbList_alias_1 }
+
+/** The final breadcrumb (current page). Not interactive. */
+declare const BreadcrumbPage: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React_2.RefAttributes<HTMLSpanElement>>;
+export { BreadcrumbPage }
+export { BreadcrumbPage as BreadcrumbPage_alias_1 }
+
+declare const breadcrumbSchema: ComponentSchemaDefinition;
+export { breadcrumbSchema }
+export { breadcrumbSchema as breadcrumbSchema_alias_1 }
+
+/**
+ * Visual separator between breadcrumb items (chevron by default).
+ * @returns An li rendering a decorative chevron icon
+ */
+declare function BreadcrumbSeparator({ children, className, ...props }: React_2.ComponentProps<"li">): JSX.Element;
+export { BreadcrumbSeparator }
+export { BreadcrumbSeparator as BreadcrumbSeparator_alias_1 }
+
+declare const Button: React_2.ForwardRefExoticComponent<ButtonProps & React_2.RefAttributes<HTMLButtonElement>>;
+export { Button }
+export { Button as Button_alias_1 }
+
+declare interface ButtonProps extends React_2.ButtonHTMLAttributes<HTMLButtonElement>, ButtonVariantsProps {
+    asChild?: boolean;
+    loading?: boolean;
+}
+export { ButtonProps }
+export { ButtonProps as ButtonProps_alias_1 }
+
+declare const buttonSchema: ComponentSchemaDefinition;
+export { buttonSchema }
+export { buttonSchema as buttonSchema_alias_1 }
+
+/**
+ * CVA variants for the Button component.
+ *
+ * Lives in its own module so RSC-safe consumers (`Pagination`, future
+ * link-styled buttons in static layouts) can import variants without
+ * pulling in the full `Button` runtime — `Button` itself is client-only
+ * because of `Slot` + `forwardRef` + the loading spinner. Splitting the
+ * variants out keeps `dist/pagination.js` free of `@radix-ui/react-slot`.
+ */
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { buttonVariants }
+export { buttonVariants as buttonVariants_alias_1 }
+export { buttonVariants as buttonVariants_alias_2 }
+
+export declare type ButtonVariantsProps = VariantProps<typeof buttonVariants>;
+
+/**
+ * Calendar date grid built on react-day-picker v9. Forwards all DayPicker
+ * props. Pair `mode` + `selected` + `onSelect` for selection control;
+ * pass `captionLayout="dropdown"` with `startMonth`/`endMonth` for
+ * native year-dropdown navigation.
+ * @returns A themed react-day-picker instance with our dropdown overlay CSS.
+ */
+declare function Calendar({ className, classNames, showOutsideDays, ...props }: React_2.ComponentProps<typeof DayPicker>): JSX.Element;
+
+declare namespace Calendar {
+    var displayName: string;
+}
+export { Calendar }
+export { Calendar as Calendar_alias_1 }
+
+declare const calendarSchema: ComponentSchemaDefinition;
+export { calendarSchema }
+export { calendarSchema as calendarSchema_alias_1 }
+
+/** A container card with subtle shadow and border. */
+declare const Card: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+export { Card }
+export { Card as Card_alias_1 }
+
+/** The main content area of a Card. */
+declare const CardContent: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+export { CardContent }
+export { CardContent as CardContent_alias_1 }
+
+/** A description element inside a CardHeader. */
+declare const CardDescription: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLParagraphElement> & React_2.RefAttributes<HTMLParagraphElement>>;
+export { CardDescription }
+export { CardDescription as CardDescription_alias_1 }
+
+/** The footer section of a Card. */
+declare const CardFooter: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+export { CardFooter }
+export { CardFooter as CardFooter_alias_1 }
+
+/** The header section of a Card. */
+declare const CardHeader: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+export { CardHeader }
+export { CardHeader as CardHeader_alias_1 }
+
+declare const cardSchema: ComponentSchemaDefinition;
+export { cardSchema }
+export { cardSchema as cardSchema_alias_1 }
+
+/** The title element inside a CardHeader. */
+declare const CardTitle: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLHeadingElement> & React_2.RefAttributes<HTMLHeadingElement>>;
+export { CardTitle }
+export { CardTitle as CardTitle_alias_1 }
+
+declare const Checkbox: React_2.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+export { Checkbox }
+export { Checkbox as Checkbox_alias_1 }
+
+/**
+ * An accessible checkbox component built on Radix UI.
+ * Supports checked, unchecked, and indeterminate states with smooth animations.
+ */
+declare type CheckboxProps = React_2.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>;
+export { CheckboxProps }
+export { CheckboxProps as CheckboxProps_alias_1 }
+
+declare const checkboxSchema: ComponentSchemaDefinition;
+export { checkboxSchema }
+export { checkboxSchema as checkboxSchema_alias_1 }
+
+/**
+ * Renders a source citation chip. Uses an `<a>` when `url` is set so the
+ * chip is keyboard-focusable + opens in a new tab; falls back to a
+ * non-interactive span otherwise.
+ *
+ * @param props - title + optional url, page, index
+ * @returns An anchor or span styled as a chip
+ */
+declare function Citation({ title, url, page, index, className, children }: CitationProps): JSX.Element;
+export { Citation }
+export { Citation as Citation_alias_1 }
+
+/**
+ * Source attribution chip — renders a citation for a RAG hit, search
+ * result, or any external reference the assistant pulled from. Becomes a
+ * clickable anchor when `url` is provided; otherwise a static span.
+ *
+ * @example
+ * <Citation title="auth-overview.md" url={src.url} page={3} />
+ * @example
+ * <Cluster gap="xs">
+ *   {sources.map((s, i) => (
+ *     <Citation key={s.id} title={s.title} url={s.url} index={i + 1} />
+ *   ))}
+ * </Cluster>
+ */
+declare interface CitationProps {
+    title: string;
+    url?: string;
+    page?: number;
+    /** Numeric index for inline footnote-style display (e.g. "[1] auth.md"). */
+    index?: number;
+    className?: string;
+    children?: React_2.ReactNode;
+}
+export { CitationProps }
+export { CitationProps as CitationProps_alias_1 }
+
+declare const citationSchema: ComponentSchemaDefinition;
+export { citationSchema }
+export { citationSchema as citationSchema_alias_1 }
+
+/**
+ * Horizontal flex flow with wrap. Children flow left-to-right and wrap to next line as needed.
+ * @param props - Cluster props including `gap`, `align`, and `justify` variant keys.
+ * @returns A flex row that wraps with consistent gap.
+ * @example
+ * ```tsx
+ * <Cluster gap="sm">
+ *   <Badge>react</Badge>
+ *   <Badge>typescript</Badge>
+ *   <Badge>tailwind</Badge>
+ * </Cluster>
+ * ```
+ */
+declare function Cluster({ className, gap, align, justify, ...props }: ClusterProps): JSX.Element;
+export { Cluster }
+export { Cluster as Cluster_alias_1 }
+
+/** Cross-axis `align-items` values for horizontal flows. Includes `baseline`. */
+export declare const clusterAlignVariants: {
+    readonly start: "items-start";
+    readonly center: "items-center";
+    readonly end: "items-end";
+    readonly stretch: "items-stretch";
+    readonly baseline: "items-baseline";
+};
+
+/** Props for the Cluster component. */
+declare interface ClusterProps extends React_2.HTMLAttributes<HTMLDivElement>, VariantProps<typeof clusterVariants> {
+}
+export { ClusterProps }
+export { ClusterProps as ClusterProps_alias_1 }
+
+declare const clusterSchema: ComponentSchemaDefinition;
+export { clusterSchema }
+export { clusterSchema as clusterSchema_alias_1 }
+
+/**
+ * CVA variants for Cluster — horizontal flex flow with wrap.
+ * `gap` and `justify` pull from shared layout-variant maps; `align` adds
+ * `baseline` (text-baseline alignment for mixed-size siblings).
+ */
+declare const clusterVariants: (props?: ({
+    gap?: "sm" | "lg" | "md" | "xl" | "xs" | null | undefined;
+    align?: "center" | "start" | "end" | "stretch" | "baseline" | null | undefined;
+    justify?: "center" | "start" | "end" | "between" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { clusterVariants }
+export { clusterVariants as clusterVariants_alias_1 }
+
+/**
+ * Merge class names with Tailwind CSS conflict resolution.
+ * @param inputs - Class values (strings, arrays, objects) to merge
+ * @returns A single merged class string with Tailwind conflicts resolved
+ */
+declare function cn(...inputs: ClassValue[]): string;
+export { cn }
+export { cn as cn_alias_1 }
+
+/**
+ * Async Server Component that highlights `code` server-side and emits the
+ * resulting HTML with a header + copy island.
+ *
+ * @param props - code, optional label/language/themes
+ * @returns A bordered card wrapping the highlighted code
+ */
+declare function CodeBlock({ code, label, language, themes, className, }: CodeBlockProps): Promise<JSX.Element>;
+export { CodeBlock }
+export { CodeBlock as CodeBlock_alias_1 }
+
+declare function CodeBlockCopy({ code, className, ...props }: CodeBlockCopyProps): JSX.Element;
+export { CodeBlockCopy }
+export { CodeBlockCopy as CodeBlockCopy_alias_1 }
+
+/**
+ * Copy-to-clipboard button for the `CodeBlock` header. Lives in a
+ * client-only file so the surrounding `CodeBlock` (an async Server
+ * Component) can render server-side while this island hydrates on the
+ * client for `navigator.clipboard` access.
+ *
+ * @example
+ * <CodeBlockCopy code={code} />
+ */
+declare interface CodeBlockCopyProps extends React_2.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** The code text to copy. Must be plain text (not the highlighted HTML). */
+    code: string;
+}
+export { CodeBlockCopyProps }
+export { CodeBlockCopyProps as CodeBlockCopyProps_alias_1 }
+
+/**
+ * Syntax-highlighted code block with a language-label header and a copy
+ * button. Highlighting runs server-side via Shiki using a dual-theme
+ * (default: github-light / github-dark) so the same HTML flips on
+ * `data-theme`/`prefers-color-scheme` without client-side rehydration.
+ *
+ * Async Server Component — render inside RSC trees or pre-render in
+ * static contexts. For client-side streaming code blocks, plug Streamdown's
+ * built-in code rendering via `Markdown components={{ pre: … }}` instead.
+ *
+ * @example
+ * <CodeBlock label="pnpm" code="pnpm add @hex-core/components" />
+ * @example
+ * <CodeBlock language="tsx" code={src} />
+ */
+declare interface CodeBlockProps {
+    code: string;
+    /** Optional header label (e.g. "pnpm", "tsx"). Inferred from `language` if omitted. */
+    label?: string;
+    /** Explicit Shiki grammar key. Overrides inference from `label`. */
+    language?: SupportedLang;
+    /** Override the default github-light / github-dark theme pair. */
+    themes?: {
+        light: string;
+        dark: string;
+    };
+    className?: string;
+}
+export { CodeBlockProps }
+export { CodeBlockProps as CodeBlockProps_alias_1 }
+
+declare const codeBlockSchema: ComponentSchemaDefinition;
+export { codeBlockSchema }
+export { codeBlockSchema as codeBlockSchema_alias_1 }
+
+/** Root container controlling the expanded state of the content. */
+declare const Collapsible: ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleProps & RefAttributes<HTMLDivElement>>;
+export { Collapsible }
+export { Collapsible as Collapsible_alias_1 }
+
+/** The collapsible content shown/hidden by the trigger. */
+declare const CollapsibleContent: ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleContentProps & RefAttributes<HTMLDivElement>>;
+export { CollapsibleContent }
+export { CollapsibleContent as CollapsibleContent_alias_1 }
+
+declare const collapsibleSchema: ComponentSchemaDefinition;
+export { collapsibleSchema }
+export { collapsibleSchema as collapsibleSchema_alias_1 }
+
+/** The element that toggles the Collapsible open/closed. */
+declare const CollapsibleTrigger: ForwardRefExoticComponent<CollapsiblePrimitive.CollapsibleTriggerProps & RefAttributes<HTMLButtonElement>>;
+export { CollapsibleTrigger }
+export { CollapsibleTrigger as CollapsibleTrigger_alias_1 }
+
+/**
+ * HSL-native color picker. Edits an HSL triplet directly via three sliders
+ * (H/S/L), with a hex input as a display adapter.
+ *
+ * Round-trip safe: triplet → hex → triplet preserves the slider state because
+ * sliders are the source of truth and hex updates them only when valid.
+ *
+ * @param props - Controlled component; `value` and `onChange` are required.
+ * @returns A trigger button that opens a popover with H/S/L sliders + hex input.
+ * @example
+ * ```tsx
+ * const [color, setColor] = React.useState("240 5.9% 10%");
+ * <ColorPicker value={color} onChange={setColor} aria-label="Primary color" />
+ * ```
+ */
+declare function ColorPicker({ value, onChange, disabled, "aria-label": ariaLabel, className, }: ColorPickerProps): JSX.Element;
+export { ColorPicker }
+export { ColorPicker as ColorPicker_alias_1 }
+
+/** Props for the ColorPicker component. */
+declare interface ColorPickerProps {
+    /**
+     * Current color as an HSL triplet string (`"<H> <S>% <L>%"`, e.g. `"240 5.9% 10%"`).
+     * Match the format used by `@hex-core/tokens`; round-trip safe.
+     */
+    value: string;
+    /**
+     * Called with the next HSL triplet whenever the user drags a slider or commits a valid hex value.
+     * Not called for invalid hex input — the picker keeps the prior value until the input parses cleanly.
+     */
+    onChange: (value: string) => void;
+    /**
+     * Disable interaction. Native `disabled` attribute is set on the trigger so the
+     * popover doesn't open via mouse or keyboard activation. Tab focus still lands
+     * on the trigger per browser defaults; if you want to fully remove it from the
+     * tab order, wrap in a parent that handles `tabIndex` accordingly.
+     */
+    disabled?: boolean;
+    /** Accessible name for the trigger button (defaults to "Pick color"). */
+    "aria-label"?: string;
+    /** Additional class names merged onto the trigger. */
+    className?: string;
+}
+export { ColorPickerProps }
+export { ColorPickerProps as ColorPickerProps_alias_1 }
+
+declare const colorPickerSchema: ComponentSchemaDefinition;
+export { colorPickerSchema }
+export { colorPickerSchema as colorPickerSchema_alias_1 }
+
+/**
+ * Searchable select input built on Command + Popover.
+ *
+ * Pass `options` with `{ value, label }` shape. The selected label is shown on
+ * the trigger; the popover contains a CommandInput and filtered CommandList.
+ * @returns A trigger button that opens a filtered option list.
+ */
+declare function Combobox({ options, value, onChange, placeholder, searchPlaceholder, emptyText, disabled, className, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, }: ComboboxProps): JSX.Element;
+
+declare namespace Combobox {
+    var displayName: string;
+}
+export { Combobox }
+export { Combobox as Combobox_alias_1 }
+
+declare interface ComboboxOption {
+    /** The value returned from onChange (stable, unique). */
+    value: string;
+    /** The display label shown in the list and the trigger. */
+    label: string;
+    /** Mark as non-selectable. */
+    disabled?: boolean;
+}
+export { ComboboxOption }
+export { ComboboxOption as ComboboxOption_alias_1 }
+
+declare interface ComboboxProps {
+    /** The list of selectable options. */
+    options: ComboboxOption[];
+    /** Controlled selected value. */
+    value?: string;
+    /** Fired when the user picks an option: (value: string) => void */
+    onChange?: (value: string) => void;
+    /** Text shown on the trigger when nothing is selected. */
+    placeholder?: string;
+    /** Input placeholder inside the popover list. */
+    searchPlaceholder?: string;
+    /** Text shown when no options match the search. */
+    emptyText?: string;
+    /** Disable the trigger. */
+    disabled?: boolean;
+    /** Extra class names on the trigger button. */
+    className?: string;
+    /** Accessible label for the trigger (required when no adjacent visible label). */
+    "aria-label"?: string;
+    /** Id of an external visible label that names this combobox. */
+    "aria-labelledby"?: string;
+}
+export { ComboboxProps }
+export { ComboboxProps as ComboboxProps_alias_1 }
+
+declare const comboboxSchema: ComponentSchemaDefinition;
+export { comboboxSchema }
+export { comboboxSchema as comboboxSchema_alias_1 }
+
+/** Root Command container — drives search, filtering, and keyboard navigation over items. */
+declare const Command: React_2.ForwardRefExoticComponent<Omit<{
+    children?: React_2.ReactNode;
+} & Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { Command }
+export { Command as Command_alias_1 }
+
+/**
+ * Command menu rendered inside a Dialog — a ⌘K-style launcher.
+ * @param props - Forwarded to the underlying Dialog (open, onOpenChange, etc.)
+ * @returns A Dialog containing a Command menu.
+ */
+declare function CommandDialog({ title, description, children, ...props }: CommandDialogProps): JSX.Element;
+export { CommandDialog }
+export { CommandDialog as CommandDialog_alias_1 }
+
+declare interface CommandDialogProps extends React_2.ComponentPropsWithoutRef<typeof Dialog> {
+    /** Command children (CommandInput + CommandList + CommandItem, etc.) */
+    children: React_2.ReactNode;
+    /** Accessible title for the dialog (screen-reader only by default). */
+    title?: string;
+    /** Accessible description for the dialog (screen-reader only by default). */
+    description?: string;
+}
+
+/** Rendered when no items match the current search. */
+declare const CommandEmpty: React_2.ForwardRefExoticComponent<Omit<{
+    children?: React_2.ReactNode;
+} & Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { CommandEmpty }
+export { CommandEmpty as CommandEmpty_alias_1 }
+
+/** Logical group of items — renders a heading and filters as a unit. */
+declare const CommandGroup: React_2.ForwardRefExoticComponent<Omit<{
+    children?: React_2.ReactNode;
+} & Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React_2.HTMLAttributes<HTMLDivElement>>, "value" | "heading"> & {
+    heading?: React_2.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { CommandGroup }
+export { CommandGroup as CommandGroup_alias_1 }
+
+/** Search input for the Command menu. Fires onValueChange as the user types. */
+declare const CommandInput: React_2.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React_2.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React_2.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React_2.InputHTMLAttributes<HTMLInputElement>>, "type" | "value" | "onChange"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React_2.RefAttributes<HTMLInputElement>, "ref"> & React_2.RefAttributes<HTMLInputElement>>;
+export { CommandInput }
+export { CommandInput as CommandInput_alias_1 }
+
+/** Selectable item. onSelect fires on Enter or click. */
+declare const CommandItem: React_2.ForwardRefExoticComponent<Omit<{
+    children?: React_2.ReactNode;
+} & Omit<Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React_2.HTMLAttributes<HTMLDivElement>>, "disabled" | "value" | "onSelect"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { CommandItem }
+export { CommandItem as CommandItem_alias_1 }
+
+/** Scrollable list that contains CommandGroup / CommandItem / CommandEmpty. */
+declare const CommandList: React_2.ForwardRefExoticComponent<Omit<{
+    children?: React_2.ReactNode;
+} & Pick<Pick<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React_2.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "asChild" | "key" | keyof React_2.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+} & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { CommandList }
+export { CommandList as CommandList_alias_1 }
+
+declare const commandSchema: ComponentSchemaDefinition;
+export { commandSchema }
+export { commandSchema as commandSchema_alias_1 }
+
+/**
+ * Horizontal rule between groups. Renders as a presentational `<div>` (no role)
+ * so it can sit inside CommandList (role=listbox) without violating ARIA's
+ * required-children rule for listbox. The line is purely decorative — cmdk's
+ * built-in Separator hardcodes `role="separator"`, which axe rejects in this
+ * context, so we render the divider directly.
+ *
+ * The `data-cmdk-separator` attribute is preserved so existing CSS / test
+ * selectors that target cmdk's separator continue to match.
+ */
+declare const CommandSeparator: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+export { CommandSeparator }
+export { CommandSeparator as CommandSeparator_alias_1 }
+
+/**
+ * Keyboard shortcut hint (e.g. '⌘K') aligned to the right of an item.
+ * @returns A muted inline span rendered at the end of a CommandItem.
+ */
+declare function CommandShortcut({ className, ...props }: React_2.HTMLAttributes<HTMLSpanElement>): JSX.Element;
+
+declare namespace CommandShortcut {
+    var displayName: string;
+}
+export { CommandShortcut }
+export { CommandShortcut as CommandShortcut_alias_1 }
+
+/**
+ * Renders a chat composer with a textarea + slot for action buttons.
+ * @param props - controlled value/handlers + slot children
+ * @returns A form element with a textarea and trailing slot
+ */
+declare function Composer({ value, onValueChange, onSubmit, disabled, placeholder, submitOnEnter, textareaAriaLabel, children, className, ...rest }: ComposerProps): JSX.Element;
+export { Composer }
+export { Composer as Composer_alias_1 }
+
+/**
+ * Multi-line text input + submission shell for chat composers. Headless on
+ * data flow — `value`/`onValueChange` are required so the consumer keeps
+ * input state wherever fits (a `useChat` hook, a parent form, local state).
+ *
+ * Submits on Enter (without Shift). Children render after the textarea —
+ * the canonical place for attachment buttons + a send button.
+ *
+ * Spreads remaining props onto the underlying `<form>`, so consumers can
+ * pass `aria-label`, `id`, `name`, `data-*`, and similar attributes.
+ *
+ * @example
+ * <Composer
+ *   value={input}
+ *   onValueChange={setInput}
+ *   onSubmit={(v) => sendMessage(v)}
+ *   placeholder="Ask anything…"
+ * >
+ *   <Button type="submit">Send</Button>
+ * </Composer>
+ */
+declare interface ComposerProps extends Omit<React_2.FormHTMLAttributes<HTMLFormElement>, "onSubmit" | "children"> {
+    value: string;
+    onValueChange: (value: string) => void;
+    onSubmit: (value: string) => void;
+    disabled?: boolean;
+    placeholder?: string;
+    /** Submit on Enter without Shift. Default true. */
+    submitOnEnter?: boolean;
+    /** Accessible name for the textarea. Defaults to `placeholder` when set, else "Message". */
+    textareaAriaLabel?: string;
+    /** Trailing slot — attachment buttons, send button, etc. */
+    children?: React_2.ReactNode;
+}
+export { ComposerProps }
+export { ComposerProps as ComposerProps_alias_1 }
+
+declare const composerSchema: ComponentSchemaDefinition;
+export { composerSchema }
+export { composerSchema as composerSchema_alias_1 }
+
+/**
+ * A centered max-width wrapper for page content. Use to constrain reading-width sections.
+ * Pass `asChild` to render as a semantic landmark (`<main>`, `<section>`, etc.) instead of a plain `<div>`.
+ *
+ * @param props - Container props including `size`, `padding`, and optional `asChild`.
+ * @returns A wrapper element with `mx-auto`, max-width clamp, and optional horizontal padding.
+ * @example
+ * ```tsx
+ * <Container size="lg" padding="md" asChild>
+ *   <main>
+ *     <h1>Article title</h1>
+ *     <p>Reading-width content...</p>
+ *   </main>
+ * </Container>
+ * ```
+ */
+declare function Container({ className, size, padding, asChild, ...props }: ContainerProps): JSX.Element;
+export { Container }
+export { Container as Container_alias_1 }
+
+/** Props for the Container component. */
+declare interface ContainerProps extends React_2.HTMLAttributes<HTMLDivElement>, VariantProps<typeof containerVariants> {
+    /**
+     * Render as a different element via Radix `Slot`. Pass `<Container asChild><main>...</main></Container>`
+     * to render the layout as a `<main>` (or `<section>`, `<article>`, etc.) and inherit landmark semantics.
+     */
+    asChild?: boolean;
+}
+export { ContainerProps }
+export { ContainerProps as ContainerProps_alias_1 }
+
+declare const containerSchema: ComponentSchemaDefinition;
+export { containerSchema }
+export { containerSchema as containerSchema_alias_1 }
+
+/**
+ * CVA variants for Container — max-width wrapper bound to `--container-*` tokens.
+ * Variant names match token names (`sm`/`md`/`lg`/`xl`/`full`); `full` removes the clamp.
+ * Padding maps to `--space-*` tokens.
+ */
+declare const containerVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | "xl" | "full" | null | undefined;
+    padding?: "sm" | "lg" | "none" | "md" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { containerVariants }
+export { containerVariants as containerVariants_alias_1 }
+
+/** Root container for a context menu (right-click menu). */
+declare const ContextMenu: React_2.FC<ContextMenuPrimitive.ContextMenuProps>;
+export { ContextMenu }
+export { ContextMenu as ContextMenu_alias_1 }
+
+/** A checkable menu item. */
+declare const ContextMenuCheckboxItem: React_2.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuCheckboxItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { ContextMenuCheckboxItem }
+export { ContextMenuCheckboxItem as ContextMenuCheckboxItem_alias_1 }
+
+/** The menu panel shown when the trigger is right-clicked. */
+declare const ContextMenuContent: React_2.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { ContextMenuContent }
+export { ContextMenuContent as ContextMenuContent_alias_1 }
+
+/** Groups related items for a11y. */
+declare const ContextMenuGroup: React_2.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuGroupProps & React_2.RefAttributes<HTMLDivElement>>;
+export { ContextMenuGroup }
+export { ContextMenuGroup as ContextMenuGroup_alias_1 }
+
+/** A clickable menu item. */
+declare const ContextMenuItem: React_2.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>>;
+export { ContextMenuItem }
+export { ContextMenuItem as ContextMenuItem_alias_1 }
+
+/** A non-interactive heading label. */
+declare const ContextMenuLabel: React_2.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuLabelProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>>;
+export { ContextMenuLabel }
+export { ContextMenuLabel as ContextMenuLabel_alias_1 }
+
+/** Portals content into the body. */
+declare const ContextMenuPortal: React_2.FC<ContextMenuPrimitive.ContextMenuPortalProps>;
+export { ContextMenuPortal }
+export { ContextMenuPortal as ContextMenuPortal_alias_1 }
+
+/** Group for checkable radio items. */
+declare const ContextMenuRadioGroup: React_2.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuRadioGroupProps & React_2.RefAttributes<HTMLDivElement>>;
+export { ContextMenuRadioGroup }
+export { ContextMenuRadioGroup as ContextMenuRadioGroup_alias_1 }
+
+/** A radio menu item. */
+declare const ContextMenuRadioItem: React_2.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuRadioItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { ContextMenuRadioItem }
+export { ContextMenuRadioItem as ContextMenuRadioItem_alias_1 }
+
+declare const contextMenuSchema: ComponentSchemaDefinition;
+export { contextMenuSchema }
+export { contextMenuSchema as contextMenuSchema_alias_1 }
+
+/** Horizontal divider. */
+declare const ContextMenuSeparator: React_2.ForwardRefExoticComponent<Omit<ContextMenuPrimitive.ContextMenuSeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { ContextMenuSeparator }
+export { ContextMenuSeparator as ContextMenuSeparator_alias_1 }
+
+/**
+ * Right-aligned shortcut text (e.g. ⌘⇧N).
+ * @returns A span with muted typography
+ */
+declare function ContextMenuShortcut({ className, ...props }: React_2.HTMLAttributes<HTMLSpanElement>): JSX.Element;
+export { ContextMenuShortcut }
+export { ContextMenuShortcut as ContextMenuShortcut_alias_1 }
+
+/** The element that triggers the context menu on right-click. */
+declare const ContextMenuTrigger: React_2.ForwardRefExoticComponent<ContextMenuPrimitive.ContextMenuTriggerProps & React_2.RefAttributes<HTMLSpanElement>>;
+export { ContextMenuTrigger }
+export { ContextMenuTrigger as ContextMenuTrigger_alias_1 }
+
+/**
+ * Render a data-driven table from TanStack column definitions.
+ * @param props - Columns, data, and optional accessible labelling (`caption` or `aria-label`)
+ * @returns A styled Table rendered from the TanStack row model
+ */
+declare function DataTable<TData>({ columns, data, caption, "aria-label": ariaLabel, }: DataTableProps<TData>): JSX.Element;
+export { DataTable }
+export { DataTable as DataTable_alias_1 }
+
+/**
+ * Generic DataTable wrapper that renders a TanStack Table model using Hex UI's
+ * Table primitives. Pass columns + data; use TanStack hooks for sorting,
+ * filtering, pagination, row-selection as needed.
+ * @template TData - Row data type. Cell value types are inferred per column by TanStack.
+ */
+declare interface DataTableProps<TData> {
+    columns: ColumnDef<TData, unknown>[];
+    data: TData[];
+    /**
+     * Visible caption rendered below the table. Announced by screen readers
+     * when the user enters the table. Provide either `caption` or `aria-label`.
+     */
+    caption?: React_2.ReactNode;
+    /**
+     * Accessible label for the table when no visible caption is shown.
+     * Forwarded as `aria-label` on the underlying `<table>` element. Kebab-case
+     * to match the canonical ARIA prop convention used elsewhere in Hex UI.
+     */
+    "aria-label"?: string;
+}
+export { DataTableProps }
+export { DataTableProps as DataTableProps_alias_1 }
+
+declare const dataTableSchema: ComponentSchemaDefinition;
+export { dataTableSchema }
+export { dataTableSchema as dataTableSchema_alias_1 }
+
+/**
+ * Date picker composed from Popover + Calendar + a styled trigger button.
+ *
+ * This is a minimal single-date picker. For multi/range, compose Calendar + Popover yourself.
+ * @returns A button that opens a single-date calendar popover.
+ */
+declare function DatePicker({ value, onChange, placeholder, dateFormat, disabled, className, "aria-label": ariaLabel, captionLayout, startMonth, endMonth, }: DatePickerProps): JSX.Element;
+
+declare namespace DatePicker {
+    var displayName: string;
+}
+export { DatePicker }
+export { DatePicker as DatePicker_alias_1 }
+
+declare interface DatePickerProps {
+    /** Controlled selected date. */
+    value?: Date;
+    /** Fired when the user picks a date in the calendar. */
+    onChange?: (date: Date | undefined) => void;
+    /** Placeholder shown when no date is selected. */
+    placeholder?: string;
+    /** date-fns format string for the trigger label. */
+    dateFormat?: string;
+    /** Disable the trigger. */
+    disabled?: boolean;
+    /** Extra class names on the trigger button. */
+    className?: string;
+    /** Accessible label for the trigger (required when no visible label is adjacent). */
+    "aria-label"?: string;
+    /**
+     * Caption layout forwarded to react-day-picker. Use `"dropdown"` (or
+     * `"dropdown-years"` / `"dropdown-months"`) to render native `<select>`
+     * navigation — useful for birth-date pickers and far-out years.
+     *
+     * Always pair `dropdown` layouts with explicit `startMonth` and `endMonth`;
+     * the RDP default span is ±100 years.
+     */
+    captionLayout?: "label" | "dropdown" | "dropdown-months" | "dropdown-years";
+    /** Earliest month/year navigable in the calendar. Forwarded to react-day-picker. */
+    startMonth?: Date;
+    /** Latest month/year navigable in the calendar. Forwarded to react-day-picker. */
+    endMonth?: Date;
+}
+export { DatePickerProps }
+export { DatePickerProps as DatePickerProps_alias_1 }
+
+declare const datePickerSchema: ComponentSchemaDefinition;
+export { datePickerSchema }
+export { datePickerSchema as datePickerSchema_alias_1 }
+
+/** Root container controlling open state of a modal dialog. */
+declare const Dialog: React_2.FC<DialogPrimitive.DialogProps>;
+export { Dialog }
+export { Dialog as Dialog_alias_1 }
+
+/** Closes the dialog when rendered inside DialogContent. */
+declare const DialogClose: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React_2.RefAttributes<HTMLButtonElement>>;
+export { DialogClose }
+export { DialogClose as DialogClose_alias_1 }
+
+/** The dialog content panel, centered on the overlay. Includes a close button by default. */
+declare const DialogContent: React_2.ForwardRefExoticComponent<DialogContentProps & React_2.RefAttributes<HTMLDivElement>>;
+export { DialogContent }
+export { DialogContent as DialogContent_alias_1 }
+
+export declare interface DialogContentProps extends React_2.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
+    /**
+     * When `true` (the default), DialogContent caps its height at viewport-2rem
+     * and renders children inside a padded inner scroll container. The Close
+     * button stays anchored to the (non-scrolling) outer panel so it remains
+     * visible even when the user scrolls long content.
+     *
+     * Pass `scrollable={false}` to opt out — useful when the consumer manages
+     * its own scroll surface (e.g. CommandDialog defers scroll to cmdk's
+     * internal CommandList).
+     */
+    scrollable?: boolean;
+}
+
+/** Accessible dialog description; Radix wires it to aria-describedby automatically. */
+declare const DialogDescription: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React_2.RefAttributes<HTMLParagraphElement>, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;
+export { DialogDescription }
+export { DialogDescription as DialogDescription_alias_1 }
+
+/**
+ * Footer container inside DialogContent; aligns action buttons.
+ * @returns A div that stacks buttons on mobile and right-aligns on desktop
+ */
+declare function DialogFooter({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { DialogFooter }
+export { DialogFooter as DialogFooter_alias_1 }
+
+/**
+ * Header container inside DialogContent; stacks title and description.
+ * @returns A div wrapping title/description with vertical rhythm
+ */
+declare function DialogHeader({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { DialogHeader }
+export { DialogHeader as DialogHeader_alias_1 }
+
+/** Dimmed backdrop rendered behind the dialog content. */
+declare const DialogOverlay: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { DialogOverlay }
+export { DialogOverlay as DialogOverlay_alias_1 }
+
+/** Portals the dialog overlay and content into the body. */
+declare const DialogPortal: React_2.FC<DialogPrimitive.DialogPortalProps>;
+export { DialogPortal }
+export { DialogPortal as DialogPortal_alias_1 }
+
+declare const dialogSchema: ComponentSchemaDefinition;
+export { dialogSchema }
+export { dialogSchema as dialogSchema_alias_1 }
+
+/** Accessible dialog title; Radix wires it to aria-labelledby automatically. */
+declare const DialogTitle: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React_2.RefAttributes<HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;
+export { DialogTitle }
+export { DialogTitle as DialogTitle_alias_1 }
+
+/** The element (usually a button) that opens the dialog when clicked. */
+declare const DialogTrigger: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+export { DialogTrigger }
+export { DialogTrigger as DialogTrigger_alias_1 }
+
+/**
+ * Root container for a bottom drawer (vaul). Manages open state, drag, and snap points.
+ * @returns A drawer root that coordinates overlay, content, and dismiss behavior.
+ */
+declare function Drawer({ shouldScaleBackground, ...props }: DrawerRootProps): JSX.Element;
+
+declare namespace Drawer {
+    var displayName: string;
+}
+export { Drawer }
+export { Drawer as Drawer_alias_1 }
+
+/** Closes the drawer when rendered inside DrawerContent. */
+declare const DrawerClose: React_2.ForwardRefExoticComponent<DialogCloseProps & React_2.RefAttributes<HTMLButtonElement>>;
+export { DrawerClose }
+export { DrawerClose as DrawerClose_alias_1 }
+
+/** The drawer content panel. Slides up from the bottom and can be dragged down to dismiss. */
+declare const DrawerContent: React_2.ForwardRefExoticComponent<Omit<Omit<DialogContentProps_2 & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { DrawerContent }
+export { DrawerContent as DrawerContent_alias_1 }
+
+/** Accessible drawer description; vaul wires it to aria-describedby automatically. */
+declare const DrawerDescription: React_2.ForwardRefExoticComponent<Omit<DialogDescriptionProps & React_2.RefAttributes<HTMLParagraphElement>, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;
+export { DrawerDescription }
+export { DrawerDescription as DrawerDescription_alias_1 }
+
+/**
+ * Footer container inside DrawerContent; stacks action buttons.
+ * @returns A div that stacks buttons vertically with consistent gutters.
+ */
+declare function DrawerFooter({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { DrawerFooter }
+export { DrawerFooter as DrawerFooter_alias_1 }
+
+/**
+ * Header container inside DrawerContent; stacks title and description.
+ * @returns A div with vertical rhythm.
+ */
+declare function DrawerHeader({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { DrawerHeader }
+export { DrawerHeader as DrawerHeader_alias_1 }
+
+/** Dimmed backdrop behind the drawer content. */
+declare const DrawerOverlay: React_2.ForwardRefExoticComponent<Omit<Omit<DialogOverlayProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { DrawerOverlay }
+export { DrawerOverlay as DrawerOverlay_alias_1 }
+
+/** Portals drawer overlay and content into the body. */
+declare const DrawerPortal: Portal;
+export { DrawerPortal }
+export { DrawerPortal as DrawerPortal_alias_1 }
+
+declare type DrawerRootProps = React_2.ComponentPropsWithoutRef<typeof Drawer_2.Root>;
+
+declare const drawerSchema: ComponentSchemaDefinition;
+export { drawerSchema }
+export { drawerSchema as drawerSchema_alias_1 }
+
+/** Accessible drawer title; vaul wires it to aria-labelledby automatically. */
+declare const DrawerTitle: React_2.ForwardRefExoticComponent<Omit<DialogTitleProps & React_2.RefAttributes<HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;
+export { DrawerTitle }
+export { DrawerTitle as DrawerTitle_alias_1 }
+
+/** The element that opens the drawer when clicked. */
+declare const DrawerTrigger: React_2.ForwardRefExoticComponent<DialogTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+export { DrawerTrigger }
+export { DrawerTrigger as DrawerTrigger_alias_1 }
+
+/** Root container for a dropdown menu. */
+declare const DropdownMenu: React_2.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+export { DropdownMenu }
+export { DropdownMenu as DropdownMenu_alias_1 }
+
+/** A menu item with a checkbox state. */
+declare const DropdownMenuCheckboxItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { DropdownMenuCheckboxItem }
+export { DropdownMenuCheckboxItem as DropdownMenuCheckboxItem_alias_1 }
+
+/** The visible dropdown panel. */
+declare const DropdownMenuContent: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { DropdownMenuContent }
+export { DropdownMenuContent as DropdownMenuContent_alias_1 }
+
+/** Groups related menu items for a11y. */
+declare const DropdownMenuGroup: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React_2.RefAttributes<HTMLDivElement>>;
+export { DropdownMenuGroup }
+export { DropdownMenuGroup as DropdownMenuGroup_alias_1 }
+
+/** A clickable menu item. */
+declare const DropdownMenuItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>>;
+export { DropdownMenuItem }
+export { DropdownMenuItem as DropdownMenuItem_alias_1 }
+
+/** A non-interactive section heading inside the menu. */
+declare const DropdownMenuLabel: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>>;
+export { DropdownMenuLabel }
+export { DropdownMenuLabel as DropdownMenuLabel_alias_1 }
+
+/** Portals dropdown content into the body. */
+declare const DropdownMenuPortal: React_2.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+export { DropdownMenuPortal }
+export { DropdownMenuPortal as DropdownMenuPortal_alias_1 }
+
+/** Group for checkable radio items (one selected at a time). */
+declare const DropdownMenuRadioGroup: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React_2.RefAttributes<HTMLDivElement>>;
+export { DropdownMenuRadioGroup }
+export { DropdownMenuRadioGroup as DropdownMenuRadioGroup_alias_1 }
+
+/** A menu item in a radio group. */
+declare const DropdownMenuRadioItem: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { DropdownMenuRadioItem }
+export { DropdownMenuRadioItem as DropdownMenuRadioItem_alias_1 }
+
+declare const dropdownMenuSchema: ComponentSchemaDefinition;
+export { dropdownMenuSchema }
+export { dropdownMenuSchema as dropdownMenuSchema_alias_1 }
+
+/** Horizontal divider between menu items. */
+declare const DropdownMenuSeparator: React_2.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { DropdownMenuSeparator }
+export { DropdownMenuSeparator as DropdownMenuSeparator_alias_1 }
+
+/**
+ * Right-aligned shortcut text (e.g. ⌘K) shown next to a menu item.
+ * @returns A span with muted, tracked typography
+ */
+declare function DropdownMenuShortcut({ className, ...props }: React_2.HTMLAttributes<HTMLSpanElement>): JSX.Element;
+export { DropdownMenuShortcut }
+export { DropdownMenuShortcut as DropdownMenuShortcut_alias_1 }
+
+/** Nested submenu root. */
+declare const DropdownMenuSub: React_2.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+export { DropdownMenuSub }
+export { DropdownMenuSub as DropdownMenuSub_alias_1 }
+
+/** The element (button) that opens the dropdown. */
+declare const DropdownMenuTrigger: React_2.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+export { DropdownMenuTrigger }
+export { DropdownMenuTrigger as DropdownMenuTrigger_alias_1 }
+
+/**
+ * Drag-and-drop file input built on the native HTML5 drag-drop API plus a
+ * visually-hidden (sr-only) `<input type="file">` for screen-reader and
+ * keyboard access.
+ *
+ * Two interaction surfaces:
+ * - The visible drop area is a `role="button"` div with `tabIndex=0` and the
+ *   required `aria-label`. Click, Enter, or Space proxies through to click the
+ *   hidden input, opening the system file dialog.
+ * - The hidden input itself remains in the accessibility tree (sr-only, NOT
+ *   `aria-hidden`) so AT-driven file pickers can find it directly.
+ *
+ * Pass `children` as a node (default placeholder) or a function receiving
+ * `{ isDragOver, isDisabled, openFileDialog }` for full layout control.
+ * @returns A drop area + hidden file input pair that yields a File[].
+ */
+declare function Dropzone({ onFilesSelected, onFilesRejected, accept, multiple, maxFiles, maxSize, disabled, children, className, "aria-label": ariaLabel, ...rest }: DropzoneProps): JSX.Element;
+
+declare namespace Dropzone {
+    var displayName: string;
+}
+export { Dropzone }
+export { Dropzone as Dropzone_alias_1 }
+
+declare interface DropzoneProps extends Omit<React_2.HTMLAttributes<HTMLDivElement>, "onChange" | "onDrop" | "children"> {
+    /** Fired with the accepted file list every time the user picks or drops files. */
+    onFilesSelected?: (files: File[]) => void;
+    /**
+     * Fired when files are dropped/picked but ALL of them are filtered out by
+     * `accept` / `maxSize` / `maxFiles`. Useful for surfacing "file too large"
+     * or "wrong type" toasts to the user. Receives the rejected File[].
+     */
+    onFilesRejected?: (files: File[]) => void;
+    /** `accept` attribute forwarded to the hidden file input (e.g. "image/*", ".csv"). */
+    accept?: string;
+    /** Allow multiple files. Default true. */
+    multiple?: boolean;
+    /** Maximum total file count (after dedupe). Excess files are dropped silently — surface in your handler. */
+    maxFiles?: number;
+    /** Maximum size per file in bytes. Files over the cap are filtered before onFilesSelected fires. */
+    maxSize?: number;
+    /** Disable interaction. */
+    disabled?: boolean;
+    /** Optional render override for the dropzone body. Receives drag state. */
+    children?: React_2.ReactNode | ((state: DropzoneRenderState) => React_2.ReactNode);
+    /** Required accessible name for the drop area. */
+    "aria-label": string;
+}
+export { DropzoneProps }
+export { DropzoneProps as DropzoneProps_alias_1 }
+
+declare interface DropzoneRenderState {
+    isDragOver: boolean;
+    isDisabled: boolean;
+    openFileDialog: () => void;
+}
+export { DropzoneRenderState }
+export { DropzoneRenderState as DropzoneRenderState_alias_1 }
+
+declare const dropzoneSchema: ComponentSchemaDefinition;
+export { dropzoneSchema }
+export { dropzoneSchema as dropzoneSchema_alias_1 }
+
+/**
+ * A "zero-state" surface for lists, dashboards, and search results that have
+ * no content to show. Use to explain *why* the slot is empty and *what to do*
+ * next; pair the `action` slot with a button that creates the missing record.
+ *
+ * Distinct from {@link Loading} (transient, has a measurable wait) and
+ * {@link ErrorState} (something failed and may need a retry). If you're
+ * thinking "show a message because the request just hasn't returned yet,"
+ * reach for `Loading` — Empty is for "the request returned, and there's
+ * nothing to show."
+ *
+ * @example
+ * ```tsx
+ * <Empty
+ *   icon={<InboxIcon />}
+ *   title="No messages yet"
+ *   description="When someone sends you a message, it'll show up here."
+ *   action={<Button>Compose</Button>}
+ * />
+ * ```
+ *
+ * @returns A region landmark labeled by the title.
+ */
+declare function Empty({ className, size, icon, title, description, action, titleAs, ref, ...props }: EmptyProps): JSX.Element;
+export { Empty }
+export { Empty as Empty_alias_1 }
+
+declare interface EmptyProps extends Omit<React_2.HTMLAttributes<HTMLDivElement>, "title">, VariantProps<typeof emptyVariants> {
+    /** Forwarded ref onto the root region element. */
+    ref?: React_2.Ref<HTMLDivElement>;
+    /** Optional icon (typically an `<svg>`) rendered in a circular muted container. */
+    icon?: React_2.ReactNode;
+    /** Required heading copy. Becomes the region's accessible name via `aria-labelledby`. */
+    title: React_2.ReactNode;
+    /** Optional supporting copy that explains why the slot is empty + what to do next. */
+    description?: React_2.ReactNode;
+    /** Optional call-to-action — typically a `<Button>` that creates the missing record. */
+    action?: React_2.ReactNode;
+    /** Heading level for the title — pick to match surrounding hierarchy (default `h3`). */
+    titleAs?: EmptyTitleAs;
+}
+export { EmptyProps }
+export { EmptyProps as EmptyProps_alias_1 }
+
+declare const emptySchema: ComponentSchemaDefinition;
+export { emptySchema }
+export { emptySchema as emptySchema_alias_1 }
+
+/** Heading element used to render the Empty title. Defaults to `h3`. */
+declare type EmptyTitleAs = "h2" | "h3" | "h4" | "h5" | "h6" | "p";
+
+declare const emptyVariants: (props?: ({
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { emptyVariants }
+export { emptyVariants as emptyVariants_alias_1 }
+
+/**
+ * A surface for rendering a failed-fetch / failed-action state. Visually
+ * similar to {@link Empty} but ships with a destructive-tone bias and
+ * mounts with `role="alert"` so screen readers announce the failure on
+ * first render.
+ *
+ * Distinct from {@link Empty} (request returned, no items) and
+ * {@link Loading} (request still in flight). For inline form-field
+ * errors, use Form's `<FormMessage>` instead. For blocking destructive
+ * confirmations, use AlertDialog.
+ *
+ * @example
+ * ```tsx
+ * <ErrorState
+ *   icon={<AlertCircleIcon />}
+ *   title="Couldn't load messages"
+ *   message="The server didn't respond. Check your connection and try again."
+ *   action={<Button onClick={refetch}>Retry</Button>}
+ * />
+ * ```
+ *
+ * @returns A `role="alert"` region with an optional action slot.
+ */
+declare function ErrorState({ className, variant, icon, title, message, action, ref, ...props }: ErrorStateProps): JSX.Element;
+export { ErrorState }
+export { ErrorState as ErrorState_alias_1 }
+
+declare interface ErrorStateProps extends Omit<React_2.HTMLAttributes<HTMLDivElement>, "title">, VariantProps<typeof errorStateVariants> {
+    /** Forwarded ref onto the alert region. */
+    ref?: React_2.Ref<HTMLDivElement>;
+    /** Optional icon (typically an alert / x-circle SVG). */
+    icon?: React_2.ReactNode;
+    /** Optional heading copy. Falls back to a generic "Something went wrong" if omitted. */
+    title?: React_2.ReactNode;
+    /** Required body copy explaining what failed. */
+    message: React_2.ReactNode;
+    /**
+     * Optional call-to-action — typically a `<Button>` with `onClick={refetch}`.
+     * Slot pattern (matching `Empty.action`) so consumers control the button's
+     * variant / loading state / asChild composition without ErrorState
+     * re-implementing those concerns.
+     */
+    action?: React_2.ReactNode;
+}
+export { ErrorStateProps }
+export { ErrorStateProps as ErrorStateProps_alias_1 }
+
+declare const errorStateSchema: ComponentSchemaDefinition;
+export { errorStateSchema }
+export { errorStateSchema as errorStateSchema_alias_1 }
+
+declare const errorStateVariants: (props?: ({
+    variant?: "default" | "destructive" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { errorStateVariants }
+export { errorStateVariants as errorStateVariants_alias_1 }
+
+/**
+ * Hierarchical tree view for files, folders, settings sections, or any nested
+ * navigation. Built on the WAI-ARIA tree pattern: `role="tree"` root,
+ * `role="treeitem"` per node, `role="group"` per child group, with
+ * `aria-level` / `aria-expanded` / `aria-selected` reflecting state.
+ *
+ * Keyboard: Up/Down move between visible items; Right expands a folder or
+ * moves to the first child; Left collapses or moves to the parent;
+ * Enter/Space activate the focused node; Home/End jump to the first/last.
+ *
+ * Expanded state is uncontrolled by default (`defaultExpanded`). Pass
+ * `expanded` + `onExpandedChange` for controlled mode.
+ * @returns A keyboard-accessible nested tree.
+ */
+declare function FileTree({ nodes, defaultExpanded, expanded: expandedProp, onExpandedChange, selected, onSelect, "aria-label": ariaLabel, className, }: FileTreeProps): JSX.Element;
+
+declare namespace FileTree {
+    var displayName: string;
+}
+export { FileTree }
+export { FileTree as FileTree_alias_1 }
+
+declare interface FileTreeNode {
+    /** Stable unique id used as React key + ARIA target. */
+    id: string;
+    /** Display name (file or folder). */
+    name: string;
+    /** Nested children. Presence (even if empty array) marks the node as a folder. */
+    children?: FileTreeNode[];
+    /** Optional icon override. Default chooses folder/file based on `children`. */
+    icon?: React_2.ReactNode;
+    /** Disable selection + expand toggle. */
+    disabled?: boolean;
+}
+export { FileTreeNode }
+export { FileTreeNode as FileTreeNode_alias_1 }
+
+declare interface FileTreeProps {
+    /** Root nodes. */
+    nodes: FileTreeNode[];
+    /** Uncontrolled initial expanded ids. */
+    defaultExpanded?: string[];
+    /** Controlled expanded ids. */
+    expanded?: string[];
+    /** Fired when expanded set changes (array of ids). */
+    onExpandedChange?: (ids: string[]) => void;
+    /** Controlled selected node id. */
+    selected?: string;
+    /** Fired when the user activates a node (click, Enter, or Space). */
+    onSelect?: (id: string) => void;
+    /** Required accessible name for the tree container. */
+    "aria-label": string;
+    /** Extra class names on the root tree element. */
+    className?: string;
+}
+export { FileTreeProps }
+export { FileTreeProps as FileTreeProps_alias_1 }
+
+declare const fileTreeSchema: ComponentSchemaDefinition;
+export { fileTreeSchema }
+export { fileTreeSchema as fileTreeSchema_alias_1 }
+
+/** Cross-axis `align-items` values for vertical/grid flows (column-like). */
+export declare const flexAlignVariants: {
+    readonly start: "items-start";
+    readonly center: "items-center";
+    readonly end: "items-end";
+    readonly stretch: "items-stretch";
+};
+
+/** Root form provider. Wraps react-hook-form's FormProvider. */
+declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues = TFieldValues>(props: FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React_2.JSX.Element;
+export { Form }
+export { Form as Form_alias_1 }
+
+/**
+ * Format HSL components into an HSL triplet string (the canonical token format).
+ * @param hsl - Numeric components.
+ * @returns Triplet in the form `"<H> <S>% <L>%"`.
+ */
+declare function formatHslTriplet({ h, s, l }: HslTriplet): string;
+export { formatHslTriplet }
+export { formatHslTriplet as formatHslTriplet_alias_1 }
+
+/** Wraps the form control and wires id + aria-describedby + aria-invalid. */
+declare const FormControl: React_2.ForwardRefExoticComponent<Omit<SlotProps & React_2.RefAttributes<HTMLElement>, "ref"> & React_2.RefAttributes<HTMLElement>>;
+export { FormControl }
+export { FormControl as FormControl_alias_1 }
+
+/** Optional helper text below the control. */
+declare const FormDescription: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLParagraphElement> & React_2.RefAttributes<HTMLParagraphElement>>;
+export { FormDescription }
+export { FormDescription as FormDescription_alias_1 }
+
+/**
+ * Binds a field name to a react-hook-form Controller.
+ * Provides context so FormItem children can access field state.
+ * @param props - Controller props including name, control, render
+ * @returns A Controller with FormFieldContext
+ */
+declare const FormField: <TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>) => JSX.Element;
+export { FormField }
+export { FormField as FormField_alias_1 }
+
+/** Wraps a single form field (label + control + description + message). */
+declare const FormItem: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+export { FormItem }
+export { FormItem as FormItem_alias_1 }
+
+/** Accessible label wired to the FormItem's control. Turns red on error. */
+declare const FormLabel: React_2.ForwardRefExoticComponent<Omit<LabelPrimitive.LabelProps & React_2.RefAttributes<HTMLLabelElement>, "ref"> & React_2.RefAttributes<HTMLLabelElement>>;
+export { FormLabel }
+export { FormLabel as FormLabel_alias_1 }
+
+/** Validation error message. Renders the error string when the field is invalid. */
+declare const FormMessage: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLParagraphElement> & React_2.RefAttributes<HTMLParagraphElement>>;
+export { FormMessage }
+export { FormMessage as FormMessage_alias_1 }
+
+declare const formSchema: ComponentSchemaDefinition;
+export { formSchema }
+export { formSchema as formSchema_alias_1 }
+
+/** Gap scale bound to `--gap-*` tokens. Used by Stack, Cluster, Grid. */
+export declare const gapVariants: {
+    readonly xs: "gap-[var(--gap-xs,0.25rem)]";
+    readonly sm: "gap-[var(--gap-sm,0.5rem)]";
+    readonly md: "gap-[var(--gap-md,1rem)]";
+    readonly lg: "gap-[var(--gap-lg,1.5rem)]";
+    readonly xl: "gap-[var(--gap-xl,2rem)]";
+};
+
+/**
+ * CSS grid with column-count presets and consistent gap. Use for card grids,
+ * dashboards, image galleries, and any layout where children should align to
+ * shared row/column tracks.
+ *
+ * Pass `cols="auto-fit"` and `minColWidth` for responsive grids that fit as
+ * many columns as the viewport allows without media queries.
+ *
+ * @param props - Grid props including `cols`, `gap`, `align`, and `minColWidth`.
+ * @returns A CSS grid container.
+ * @example
+ * ```tsx
+ * <Grid cols={3} gap="md">
+ *   {items.map((i) => <Card key={i.id}>{i.title}</Card>)}
+ * </Grid>
+ * <Grid cols="auto-fit" minColWidth="20rem" gap="lg">
+ *   {responsiveItems.map(...)}
+ * </Grid>
+ * ```
+ */
+declare function Grid({ className, cols, gap, align, minColWidth, style, ...props }: GridProps): JSX.Element;
+export { Grid }
+export { Grid as Grid_alias_1 }
+
+/** Props for the Grid component. */
+declare interface GridProps extends React_2.HTMLAttributes<HTMLDivElement>, VariantProps<typeof gridVariants> {
+    /**
+     * Minimum column width for `cols="auto-fit"`. Tracks repeat to fill the container,
+     * never shrinking below this value. Ignored when `cols` is a fixed integer.
+     * @default "16rem"
+     */
+    minColWidth?: string;
+}
+export { GridProps }
+export { GridProps as GridProps_alias_1 }
+
+declare const gridSchema: ComponentSchemaDefinition;
+export { gridSchema }
+export { gridSchema as gridSchema_alias_1 }
+
+/**
+ * CVA variants for Grid — CSS grid with column-count presets and shared `gap`.
+ * `cols` accepts 1/2/3/4/6 fixed columns or `"auto-fit"` for responsive auto-sizing
+ * (in which case the consumer should pass `minColWidth` for the min track size).
+ *
+ * `cols` keys are TypeScript numeric literals (`cols={3}`) at the type level;
+ * the schema's `enumValues` serializes them as strings for JSON-shape parity.
+ */
+declare const gridVariants: (props?: ({
+    cols?: 1 | 2 | 3 | 4 | 6 | "auto-fit" | null | undefined;
+    gap?: "sm" | "lg" | "md" | "xl" | "xs" | null | undefined;
+    align?: "center" | "start" | "end" | "stretch" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { gridVariants }
+export { gridVariants as gridVariants_alias_1 }
+
+/**
+ * Convert a hex string to an HSL triplet.
+ * Accepts 3-digit (`#abc`) or 6-digit (`#aabbcc`) hex with optional `#`.
+ * @param hex - Hex color string.
+ * @returns HSL triplet, or `null` if the input is malformed.
+ */
+declare function hexToHslTriplet(hex: string): string | null;
+export { hexToHslTriplet }
+export { hexToHslTriplet as hexToHslTriplet_alias_1 }
+
+/** Root container for a hover-card. */
+declare const HoverCard: React_2.FC<HoverCardPrimitive.HoverCardProps>;
+export { HoverCard }
+export { HoverCard as HoverCard_alias_1 }
+
+/** The floating hover-card content panel. Richer than a tooltip. */
+declare const HoverCardContent: React_2.ForwardRefExoticComponent<Omit<HoverCardPrimitive.HoverCardContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { HoverCardContent }
+export { HoverCardContent as HoverCardContent_alias_1 }
+
+declare const hoverCardSchema: ComponentSchemaDefinition;
+export { hoverCardSchema }
+export { hoverCardSchema as hoverCardSchema_alias_1 }
+
+/** The element that reveals the card on hover/focus. */
+declare const HoverCardTrigger: React_2.ForwardRefExoticComponent<HoverCardPrimitive.HoverCardTriggerProps & React_2.RefAttributes<HTMLAnchorElement>>;
+export { HoverCardTrigger }
+export { HoverCardTrigger as HoverCardTrigger_alias_1 }
+
+/**
+ * Convert HSL components to RGB.
+ * @param h - Hue (0–360).
+ * @param s - Saturation (0–100).
+ * @param l - Lightness (0–100).
+ * @returns RGB channels (0–255, rounded).
+ */
+declare function hslToRgb(h: number, s: number, l: number): RgbColor;
+export { hslToRgb }
+export { hslToRgb as hslToRgb_alias_1 }
+
+/**
+ * Color conversion utilities for the HSL-triplet token format used across
+ * `@hex-core/tokens` themes (`H S% L%`, e.g. `"240 5.9% 10%"` — no `hsl()`
+ * wrapper, no commas).
+ *
+ * The triplet is the round-trip-safe serialization for Hex UI: tokens flow
+ * triplet → CSS `hsl(var(--token))` → rendered color, and the ColorPicker
+ * component edits triplets directly. Hex/RGB conversions are display
+ * adapters, not the source of truth.
+ */
+/** Parsed HSL components. `h` is degrees (0–360); `s` and `l` are percentages (0–100). */
+declare interface HslTriplet {
+    h: number;
+    s: number;
+    l: number;
+}
+export { HslTriplet }
+export { HslTriplet as HslTriplet_alias_1 }
+
+/**
+ * Convert an HSL triplet to a 6-digit hex string.
+ * @param triplet - HSL triplet (e.g. `"240 5.9% 10%"`).
+ * @returns Lowercase hex string with leading `#` (e.g. `"#181a1f"`).
+ */
+declare function hslTripletToHex(triplet: string): string;
+export { hslTripletToHex }
+export { hslTripletToHex as hslTripletToHex_alias_1 }
+
+declare const Input: React_2.ForwardRefExoticComponent<InputProps & React_2.RefAttributes<HTMLInputElement>>;
+export { Input }
+export { Input as Input_alias_1 }
+
+/** Root OTP input. Wraps input-otp's OTPInput and exposes slot context to children. */
+declare const InputOTP: React_2.ForwardRefExoticComponent<InputOTPProps & React_2.RefAttributes<HTMLInputElement>>;
+export { InputOTP }
+export { InputOTP as InputOTP_alias_1 }
+
+/** Groups slots together; place between runs of slots to add visual dividers. */
+declare const InputOTPGroup: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { InputOTPGroup }
+export { InputOTPGroup as InputOTPGroup_alias_1 }
+
+/** Props for the root InputOTP component (mirrors input-otp's OTPInput). */
+declare type InputOTPProps = React_2.ComponentPropsWithoutRef<typeof OTPInput>;
+export { InputOTPProps }
+export { InputOTPProps as InputOTPProps_alias_1 }
+
+declare const inputOTPSchema: ComponentSchemaDefinition;
+export { inputOTPSchema }
+export { inputOTPSchema as inputOTPSchema_alias_1 }
+
+/** Visual separator between slot groups (a bullet by default). */
+declare const InputOTPSeparator: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { InputOTPSeparator }
+export { InputOTPSeparator as InputOTPSeparator_alias_1 }
+
+/** A single character slot. Reads its state from OTPInputContext. */
+declare const InputOTPSlot: React_2.ForwardRefExoticComponent<InputOTPSlotProps & React_2.RefAttributes<HTMLDivElement>>;
+export { InputOTPSlot }
+export { InputOTPSlot as InputOTPSlot_alias_1 }
+
+declare interface InputOTPSlotProps extends React_2.ComponentPropsWithoutRef<"div"> {
+    /** Index of the slot in the underlying OTP value. */
+    index: number;
+}
+
+declare type InputProps = React_2.InputHTMLAttributes<HTMLInputElement>;
+export { InputProps }
+export { InputProps as InputProps_alias_1 }
+
+declare const inputSchema: ComponentSchemaDefinition;
+export { inputSchema }
+export { inputSchema as inputSchema_alias_1 }
+
+/** `justify-content` values shared by Stack and Cluster. */
+export declare const justifyVariants: {
+    readonly start: "justify-start";
+    readonly center: "justify-center";
+    readonly end: "justify-end";
+    readonly between: "justify-between";
+};
+
+declare const Label: React_2.ForwardRefExoticComponent<LabelProps & React_2.RefAttributes<HTMLLabelElement>>;
+export { Label }
+export { Label as Label_alias_1 }
+
+declare interface LabelProps extends React_2.ComponentPropsWithoutRef<typeof LabelPrimitive.Root>, VariantProps<typeof labelVariants> {
+}
+export { LabelProps }
+export { LabelProps as LabelProps_alias_1 }
+
+declare const labelSchema: ComponentSchemaDefinition;
+export { labelSchema }
+export { labelSchema as labelSchema_alias_1 }
+
+declare const labelVariants: (props?: ClassProp | undefined) => string;
+
+/**
+ * A composed loading-placeholder pattern for lists, cards, and stacks.
+ * Renders N {@link Skeleton} rows pre-arranged for the chosen layout —
+ * Skeleton is the atom (one shaped pulse), Loading is the molecule
+ * (the canonical pattern most surfaces want).
+ *
+ * Distinct from {@link Empty} (request returned, no items) and
+ * {@link ErrorState} (request failed). If you need a single shaped
+ * pulse for a specific element (an avatar circle, a heading line),
+ * reach for `Skeleton` directly. If the wait has a measurable
+ * percent-done, reach for `Progress` instead.
+ *
+ * @example
+ * ```tsx
+ * <Loading rows={5} variant="list" />
+ * ```
+ *
+ * @returns A `role="status"` region with `aria-live="polite"` and the
+ *   announced label (default "Loading…") rendered sr-only.
+ */
+declare function Loading({ className, variant, rows, label, ref, ...props }: LoadingProps): JSX.Element;
+export { Loading }
+export { Loading as Loading_alias_1 }
+
+/**
+ * Renders an animated loading indicator with optional label.
+ * @param props - variant + label
+ * @returns A status div with role="status"
+ */
+declare function LoadingIndicator({ variant, size, label, className, ...props }: LoadingIndicatorProps): JSX.Element;
+export { LoadingIndicator }
+export { LoadingIndicator as LoadingIndicator_alias_1 }
+
+/**
+ * Streaming/typing feedback for an in-flight LLM turn. Three motion variants
+ * — `dots` (bouncing trio), `pulse` (single throbbing circle), `bar`
+ * (horizontal sweep). Pure CSS, no JS — RSC-safe.
+ *
+ * @example
+ * {isLoading && <LoadingIndicator label="Thinking…" />}
+ */
+declare interface LoadingIndicatorProps extends React_2.HTMLAttributes<HTMLDivElement>, VariantProps<typeof loadingIndicatorVariants> {
+    /** Animation style. Default `dots`. */
+    variant?: "dots" | "pulse" | "bar";
+    /** Optional adjacent label, e.g. "Thinking…" or "Searching docs…". */
+    label?: string;
+}
+export { LoadingIndicatorProps }
+export { LoadingIndicatorProps as LoadingIndicatorProps_alias_1 }
+
+declare const loadingIndicatorSchema: ComponentSchemaDefinition;
+export { loadingIndicatorSchema }
+export { loadingIndicatorSchema as loadingIndicatorSchema_alias_1 }
+
+declare const loadingIndicatorVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { loadingIndicatorVariants }
+export { loadingIndicatorVariants as loadingIndicatorVariants_alias_1 }
+
+declare interface LoadingProps extends Omit<React_2.HTMLAttributes<HTMLDivElement>, "role">, VariantProps<typeof loadingVariants> {
+    /** Forwarded ref onto the status region. */
+    ref?: React_2.Ref<HTMLDivElement>;
+    /**
+     * Number of placeholder rows to render. Each row may contain multiple
+     * Skeleton elements depending on `variant` — `list` emits 1 Skeleton
+     * per row; `card` emits 3 (heading + 2 body lines); `stack` emits 3
+     * (avatar + 2 text lines). Default 3.
+     */
+    rows?: number;
+    /** Optional sr-only label that screen readers announce. Default "Loading…". */
+    label?: string;
+}
+export { LoadingProps }
+export { LoadingProps as LoadingProps_alias_1 }
+
+declare const loadingSchema: ComponentSchemaDefinition;
+export { loadingSchema }
+export { loadingSchema as loadingSchema_alias_1 }
+
+declare const loadingVariants: (props?: ({
+    variant?: "list" | "card" | "stack" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { loadingVariants }
+export { loadingVariants as loadingVariants_alias_1 }
+
+/**
+ * Renders streaming-safe markdown.
+ * @param props - children string + optional Streamdown overrides
+ * @returns A Streamdown root scoped with prose styles
+ */
+declare function Markdown({ children, className }: MarkdownProps): JSX.Element;
+export { Markdown }
+export { Markdown as Markdown_alias_1 }
+
+/**
+ * Streaming-safe markdown renderer. Wraps Vercel's `streamdown` so partial
+ * input mid-stream — unclosed code fences, half-typed tags, dangling
+ * brackets — renders gracefully instead of throwing or flashing raw text.
+ *
+ * Public prop surface is intentionally minimal (`children` + `className`)
+ * so this primitive's DTS doesn't drag in `streamdown`'s full type graph.
+ * Doing so would transitively pull Shiki's 600-literal `BundledLanguage`
+ * union into the rollup-dts pass and exhaust heap. For per-element
+ * overrides (custom `pre`, `code`, `a`, `img`, mermaid, math, line
+ * numbers, plugins, etc.) drop down to `Streamdown` directly:
+ *
+ * ```tsx
+ * import { Streamdown } from "streamdown";
+ * import { CodeBlock } from "@hex-core/components";
+ * <Streamdown components={{ pre: (p) => <CodeBlock {...p} /> }}>{md}</Streamdown>
+ * ```
+ *
+ * @example
+ * <Message role="assistant">
+ *   <Markdown>{streamingText}</Markdown>
+ * </Message>
+ */
+declare interface MarkdownProps {
+    /** Raw markdown. May be a partial chunk during streaming. */
+    children: string;
+    className?: string;
+}
+export { MarkdownProps }
+export { MarkdownProps as MarkdownProps_alias_1 }
+
+declare const markdownSchema: ComponentSchemaDefinition;
+export { markdownSchema }
+export { markdownSchema as markdownSchema_alias_1 }
+
+/** Top-level menu bar (File / Edit / View style). */
+declare const Menubar: React_2.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { Menubar }
+export { Menubar as Menubar_alias_1 }
+
+/** The menu panel shown when a trigger opens. */
+declare const MenubarContent: React_2.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { MenubarContent }
+export { MenubarContent as MenubarContent_alias_1 }
+
+/** Groups related items inside a menu content. */
+declare const MenubarGroup: typeof MenubarPrimitive.Group;
+export { MenubarGroup }
+export { MenubarGroup as MenubarGroup_alias_1 }
+
+/** A clickable menu item. */
+declare const MenubarItem: React_2.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>>;
+export { MenubarItem }
+export { MenubarItem as MenubarItem_alias_1 }
+
+/** A non-interactive heading label. */
+declare const MenubarLabel: React_2.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarLabelProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React_2.RefAttributes<HTMLDivElement>>;
+export { MenubarLabel }
+export { MenubarLabel as MenubarLabel_alias_1 }
+
+/** A top-level menu in the bar (e.g. "File"). */
+declare const MenubarMenu: typeof MenubarPrimitive.Menu;
+export { MenubarMenu }
+export { MenubarMenu as MenubarMenu_alias_1 }
+
+/** Portals menu content into the body. */
+declare const MenubarPortal: typeof MenubarPrimitive.Portal;
+export { MenubarPortal }
+export { MenubarPortal as MenubarPortal_alias_1 }
+
+/** Group for checkable radio items. */
+declare const MenubarRadioGroup: typeof MenubarPrimitive.RadioGroup;
+export { MenubarRadioGroup }
+export { MenubarRadioGroup as MenubarRadioGroup_alias_1 }
+
+declare const menubarSchema: ComponentSchemaDefinition;
+export { menubarSchema }
+export { menubarSchema as menubarSchema_alias_1 }
+
+/** Horizontal divider. */
+declare const MenubarSeparator: React_2.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarSeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { MenubarSeparator }
+export { MenubarSeparator as MenubarSeparator_alias_1 }
+
+/**
+ * Right-aligned keyboard shortcut text.
+ * @returns A span with muted typography
+ */
+declare function MenubarShortcut({ className, ...props }: React_2.HTMLAttributes<HTMLSpanElement>): JSX.Element;
+export { MenubarShortcut }
+export { MenubarShortcut as MenubarShortcut_alias_1 }
+
+/** The clickable menu label in the bar. */
+declare const MenubarTrigger: React_2.ForwardRefExoticComponent<Omit<MenubarPrimitive.MenubarTriggerProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+export { MenubarTrigger }
+export { MenubarTrigger as MenubarTrigger_alias_1 }
+
+/**
+ * Renders a chat-message row scoped to one speaker.
+ * @param props - role + content
+ * @returns A styled div tagged with `data-role={role}`
+ */
+declare function Message({ role, className, children, ...props }: MessageProps): JSX.Element;
+export { Message }
+export { Message as Message_alias_1 }
+
+/**
+ * Renders the action-button row.
+ * @param props - children buttons
+ * @returns A flex container styled for in-message actions
+ */
+declare function MessageActions({ className, children, ...props }: MessageActionsProps): JSX.Element;
+export { MessageActions }
+export { MessageActions as MessageActions_alias_1 }
+
+/**
+ * Inline action row beneath a message — typically holds copy / regenerate /
+ * thumbs-up / thumbs-down buttons. Pure container: it sets the layout and
+ * leaves the buttons (and their handlers) to the consumer.
+ *
+ * Renders below the message body with subtle hover-reveal styling — the
+ * row is dimmed by default and brightens when the parent hovers.
+ *
+ * @example
+ * <Message role="assistant">
+ *   <Markdown>{text}</Markdown>
+ *   <MessageActions>
+ *     <Button variant="ghost" size="icon" onClick={() => copy(text)}><CopyIcon /></Button>
+ *     <Button variant="ghost" size="icon" onClick={onRegenerate}><RetryIcon /></Button>
+ *   </MessageActions>
+ * </Message>
+ */
+declare interface MessageActionsProps extends React_2.HTMLAttributes<HTMLDivElement> {
+    children: React_2.ReactNode;
+}
+export { MessageActionsProps }
+export { MessageActionsProps as MessageActionsProps_alias_1 }
+
+declare const messageActionsSchema: ComponentSchemaDefinition;
+export { messageActionsSchema }
+export { messageActionsSchema as messageActionsSchema_alias_1 }
+
+/**
+ * Renders the scrolling message viewport.
+ * @param props - children + autoScroll toggle
+ * @returns A scrollable div that auto-pins to bottom when streaming
+ */
+declare function MessageList({ autoScroll, className, children, ...props }: MessageListProps): JSX.Element;
+export { MessageList }
+export { MessageList as MessageList_alias_1 }
+
+/**
+ * Auto-scrolling viewport for a stream of chat messages. When `autoScroll`
+ * is true (default), the container pins to the bottom whenever its content
+ * changes — including during streaming token updates. Detects whether the
+ * user has scrolled away from the bottom and pauses auto-scroll until they
+ * scroll back, so reading earlier turns doesn't fight the stream.
+ *
+ * @example
+ * <MessageList>
+ *   {messages.map((m) => <Message key={m.id} role={m.role}>{m.content}</Message>)}
+ * </MessageList>
+ */
+declare interface MessageListProps extends React_2.HTMLAttributes<HTMLDivElement> {
+    /** Auto-scroll to bottom on content change (when user is already near the bottom). Default: true. */
+    autoScroll?: boolean;
+    children: React_2.ReactNode;
+}
+export { MessageListProps }
+export { MessageListProps as MessageListProps_alias_1 }
+
+declare const messageListSchema: ComponentSchemaDefinition;
+export { messageListSchema }
+export { messageListSchema as messageListSchema_alias_1 }
+
+/**
+ * Single chat message row. Renders content with role-specific styling and a
+ * `data-role` attribute so consumers can target arbitrary roles via CSS.
+ *
+ * Headless: accepts any `children`. Pair with `Markdown` + `CodeBlock` for
+ * assistant turns, with `ToolCall` for agent steps, or with plain strings.
+ *
+ * @example
+ * <Message role="user">What's the weather?</Message>
+ * @example
+ * <Message role="assistant">
+ *   <Markdown>{streamingText}</Markdown>
+ *   <ToolCall name="getWeather" state="result" args={...} result={...} />
+ * </Message>
+ */
+declare interface MessageProps extends Omit<React_2.HTMLAttributes<HTMLDivElement>, "role">, VariantProps<typeof messageVariants> {
+    /** Speaker — drives variant styling and the `data-role` attribute. */
+    role: Role;
+    children: React_2.ReactNode;
+}
+export { MessageProps }
+export { MessageProps as MessageProps_alias_1 }
+
+declare const messageSchema: ComponentSchemaDefinition;
+export { messageSchema }
+export { messageSchema as messageSchema_alias_1 }
+
+declare const messageVariants: (props?: ({
+    role?: "user" | "system" | "assistant" | "tool" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { messageVariants }
+export { messageVariants as messageVariants_alias_1 }
+
+/**
+ * Searchable multi-select input built on Command + Popover.
+ *
+ * Pass `options` with `{ value, label }` and bind `value` (string[]) +
+ * `onChange`. The trigger shows "{n} selected" once any option is picked, with
+ * the comma-separated label list mirrored into the `title` attribute for
+ * pointer/screen-reader fallback. Each option is announced with `aria-selected`.
+ * @returns A trigger button that opens a multi-select option list.
+ */
+declare function MultiCombobox({ options, value, onChange, placeholder, searchPlaceholder, emptyText, maxSelected, closeOnSelect, disabled, className, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, }: MultiComboboxProps): JSX.Element;
+
+declare namespace MultiCombobox {
+    var displayName: string;
+}
+export { MultiCombobox }
+export { MultiCombobox as MultiCombobox_alias_1 }
+
+declare interface MultiComboboxOption {
+    /** The value returned in the onChange array (stable, unique). */
+    value: string;
+    /** The display label shown in the list and the trigger. */
+    label: string;
+    /** Mark as non-selectable. */
+    disabled?: boolean;
+}
+export { MultiComboboxOption }
+export { MultiComboboxOption as MultiComboboxOption_alias_1 }
+
+declare interface MultiComboboxProps {
+    /** The list of selectable options. */
+    options: MultiComboboxOption[];
+    /** Controlled selected values. */
+    value?: string[];
+    /** Fired when the user toggles an option: (values: string[]) => void */
+    onChange?: (values: string[]) => void;
+    /** Text shown on the trigger when nothing is selected. */
+    placeholder?: string;
+    /** Input placeholder inside the popover list. */
+    searchPlaceholder?: string;
+    /** Text shown when no options match the search. */
+    emptyText?: string;
+    /** Soft cap on selections. Once reached, unselected options become non-selectable. */
+    maxSelected?: number;
+    /** Close the popover after every pick. Default false (multi-select UX expects staying open). */
+    closeOnSelect?: boolean;
+    /** Disable the trigger. */
+    disabled?: boolean;
+    /** Extra class names on the trigger button. */
+    className?: string;
+    /** Accessible label for the trigger (required when no adjacent visible label). */
+    "aria-label"?: string;
+    /** Id of an external visible label that names this combobox. */
+    "aria-labelledby"?: string;
+}
+export { MultiComboboxProps }
+export { MultiComboboxProps as MultiComboboxProps_alias_1 }
+
+declare const multiComboboxSchema: ComponentSchemaDefinition;
+export { multiComboboxSchema }
+export { multiComboboxSchema as multiComboboxSchema_alias_1 }
+
+/** Root container for a navigation menu. Renders a viewport for content panels. */
+declare const NavigationMenu: React_2.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuProps & React_2.RefAttributes<HTMLElement>, "ref"> & React_2.RefAttributes<HTMLElement>>;
+export { NavigationMenu }
+export { NavigationMenu as NavigationMenu_alias_1 }
+
+/** The content panel (e.g. mega-menu). */
+declare const NavigationMenuContent: React_2.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { NavigationMenuContent }
+export { NavigationMenuContent as NavigationMenuContent_alias_1 }
+
+/** Visual indicator (arrow) pointing at the active trigger. */
+declare const NavigationMenuIndicator: React_2.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuIndicatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { NavigationMenuIndicator }
+export { NavigationMenuIndicator as NavigationMenuIndicator_alias_1 }
+
+/** A single top-level item (wraps trigger + content). */
+declare const NavigationMenuItem: React_2.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuItemProps & React_2.RefAttributes<HTMLLIElement>>;
+export { NavigationMenuItem }
+export { NavigationMenuItem as NavigationMenuItem_alias_1 }
+
+/** A direct link (no content panel). */
+declare const NavigationMenuLink: React_2.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuLinkProps & React_2.RefAttributes<HTMLAnchorElement>>;
+export { NavigationMenuLink }
+export { NavigationMenuLink as NavigationMenuLink_alias_1 }
+
+/** List of top-level NavigationMenu items. */
+declare const NavigationMenuList: React_2.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuListProps & React_2.RefAttributes<HTMLUListElement>, "ref"> & React_2.RefAttributes<HTMLUListElement>>;
+export { NavigationMenuList }
+export { NavigationMenuList as NavigationMenuList_alias_1 }
+
+declare const navigationMenuSchema: ComponentSchemaDefinition;
+export { navigationMenuSchema }
+export { navigationMenuSchema as navigationMenuSchema_alias_1 }
+
+/** The clickable trigger that opens a nav-menu content panel. */
+declare const NavigationMenuTrigger: React_2.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuTriggerProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+export { NavigationMenuTrigger }
+export { NavigationMenuTrigger as NavigationMenuTrigger_alias_1 }
+
+declare const navigationMenuTriggerStyle: (props?: ClassProp | undefined) => string;
+export { navigationMenuTriggerStyle }
+export { navigationMenuTriggerStyle as navigationMenuTriggerStyle_alias_1 }
+
+/** The viewport that hosts the active content panel. Rendered inside NavigationMenu. */
+declare const NavigationMenuViewport: React_2.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuViewportProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { NavigationMenuViewport }
+export { NavigationMenuViewport as NavigationMenuViewport_alias_1 }
+
+/**
+ * Root nav landmark for pagination controls.
+ * @returns A centered nav element with aria-label='pagination'
+ */
+declare function Pagination({ className, ...props }: React_2.ComponentProps<"nav">): JSX.Element;
+export { Pagination }
+export { Pagination as Pagination_alias_1 }
+
+/** Ordered list wrapper for pagination links. */
+declare const PaginationContent: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React_2.RefAttributes<HTMLUListElement>>;
+export { PaginationContent }
+export { PaginationContent as PaginationContent_alias_1 }
+
+/**
+ * Ellipsis placeholder for truncated page ranges (e.g. 1 … 5 6 7 … 99).
+ * @returns A span containing a decorative SVG (aria-hidden) plus a sr-only "More pages" label for AT.
+ */
+declare function PaginationEllipsis({ className, ...props }: React_2.ComponentProps<"span">): JSX.Element;
+export { PaginationEllipsis }
+export { PaginationEllipsis as PaginationEllipsis_alias_1 }
+
+/** A pagination list item wrapper. */
+declare const PaginationItem: React_2.ForwardRefExoticComponent<Omit<React_2.DetailedHTMLProps<React_2.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React_2.RefAttributes<HTMLLIElement>>;
+export { PaginationItem }
+export { PaginationItem as PaginationItem_alias_1 }
+
+/**
+ * A pagination link styled as a button. Mark the current page with isActive.
+ * @returns An anchor element styled via buttonVariants
+ */
+declare function PaginationLink({ className, isActive, size, ...props }: PaginationLinkProps): JSX.Element;
+export { PaginationLink }
+export { PaginationLink as PaginationLink_alias_1 }
+
+declare type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<ButtonVariantsProps, "size"> & React_2.ComponentProps<"a">;
+
+/**
+ * Next-page link with chevron-right icon.
+ * @returns A PaginationLink with aria-label='Go to next page'
+ */
+declare function PaginationNext({ className, ...props }: React_2.ComponentProps<typeof PaginationLink>): JSX.Element;
+export { PaginationNext }
+export { PaginationNext as PaginationNext_alias_1 }
+
+/**
+ * Previous-page link with chevron-left icon.
+ * @returns A PaginationLink with aria-label='Go to previous page'
+ */
+declare function PaginationPrevious({ className, ...props }: React_2.ComponentProps<typeof PaginationLink>): JSX.Element;
+export { PaginationPrevious }
+export { PaginationPrevious as PaginationPrevious_alias_1 }
+
+declare const paginationSchema: ComponentSchemaDefinition;
+export { paginationSchema }
+export { paginationSchema as paginationSchema_alias_1 }
+
+/**
+ * Parse an HSL triplet string into numeric components.
+ *
+ * Note: malformed input silently coerces to `{0,0,0}` (pure black) rather than
+ * returning an error signal. Callers that need to distinguish "user typed
+ * black" from "user typed garbage" should validate the input format first.
+ * `hexToHslTriplet` returns `null` for malformed hex; this asymmetry is
+ * intentional — triplets feed CSS variables where any non-color value would
+ * already break rendering.
+ *
+ * @param triplet - String in the form `"<H> <S>% <L>%"` (e.g. `"240 5.9% 10%"`).
+ * @returns Numeric components, or `{0,0,0}` if the input is malformed.
+ */
+declare function parseHslTriplet(triplet: string): HslTriplet;
+export { parseHslTriplet }
+export { parseHslTriplet as parseHslTriplet_alias_1 }
+
+/** Root container for a popover. */
+declare const Popover: React_2.FC<PopoverPrimitive.PopoverProps>;
+export { Popover }
+export { Popover as Popover_alias_1 }
+
+/** Helper to explicitly anchor the popover to a different element. */
+declare const PopoverAnchor: React_2.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React_2.RefAttributes<HTMLDivElement>>;
+export { PopoverAnchor }
+export { PopoverAnchor as PopoverAnchor_alias_1 }
+
+/** The floating popover content panel. */
+declare const PopoverContent: React_2.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { PopoverContent }
+export { PopoverContent as PopoverContent_alias_1 }
+
+declare const popoverSchema: ComponentSchemaDefinition;
+export { popoverSchema }
+export { popoverSchema as popoverSchema_alias_1 }
+
+/** The element that anchors and opens the popover. */
+declare const PopoverTrigger: React_2.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+export { PopoverTrigger }
+export { PopoverTrigger as PopoverTrigger_alias_1 }
+
+/**
+ * A horizontal progress bar from 0–100%.
+ * Built on Radix UI Progress for aria-valuenow/max wiring.
+ */
+declare const Progress: React_2.ForwardRefExoticComponent<Omit<ProgressPrimitive.ProgressProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { Progress }
+export { Progress as Progress_alias_1 }
+
+declare const progressSchema: ComponentSchemaDefinition;
+export { progressSchema }
+export { progressSchema as progressSchema_alias_1 }
+
+/** Root container for a radio group. Pair with one or more RadioGroupItem. */
+declare const RadioGroup: React_2.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { RadioGroup }
+export { RadioGroup as RadioGroup_alias_1 }
+
+/** A single radio option within a RadioGroup. */
+declare const RadioGroupItem: React_2.ForwardRefExoticComponent<Omit<RadioGroupPrimitive.RadioGroupItemProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+export { RadioGroupItem }
+export { RadioGroupItem as RadioGroupItem_alias_1 }
+
+declare const radioGroupSchema: ComponentSchemaDefinition;
+export { radioGroupSchema }
+export { radioGroupSchema as radioGroupSchema_alias_1 }
+
+/**
+ * Renders a collapsible thinking-trace block.
+ * @param props - children + optional duration
+ * @returns A Collapsible with a labelled header and content body
+ */
+declare function Reasoning({ children, defaultOpen, durationMs, label, className, }: ReasoningProps): JSX.Element;
+export { Reasoning }
+export { Reasoning as Reasoning_alias_1 }
+
+/**
+ * Collapsible "thinking" block. Designed for Anthropic-style reasoning
+ * traces or Chain-of-Thought scratchpads — content the user can optionally
+ * inspect without it dominating the response. Header shows a label and the
+ * thinking duration if provided.
+ *
+ * Headless on content: pass any `children`. Pair with `Markdown` if the
+ * reasoning is markdown-formatted.
+ *
+ * @example
+ * <Reasoning durationMs={4200}>
+ *   <Markdown>{thinking}</Markdown>
+ * </Reasoning>
+ */
+declare interface ReasoningProps {
+    children: React_2.ReactNode;
+    defaultOpen?: boolean;
+    /** Time spent thinking, in milliseconds. Renders as "Thought for 4.2s". */
+    durationMs?: number;
+    /** Override the default "Thinking" / "Thought for X" label. */
+    label?: string;
+    className?: string;
+}
+export { ReasoningProps }
+export { ReasoningProps as ReasoningProps_alias_1 }
+
+declare const reasoningSchema: ComponentSchemaDefinition;
+export { reasoningSchema }
+export { reasoningSchema as reasoningSchema_alias_1 }
+
+/**
+ * Draggable separator between panels. Optionally renders a grab-grip dot.
+ * @returns A slim, focusable resize handle.
+ */
+declare function ResizableHandle({ withHandle, className, ...props }: ResizableHandleProps): JSX.Element;
+
+declare namespace ResizableHandle {
+    var displayName: string;
+}
+export { ResizableHandle }
+export { ResizableHandle as ResizableHandle_alias_1 }
+
+declare interface ResizableHandleProps extends React_2.ComponentPropsWithoutRef<typeof Separator_2> {
+    /** Show a grab-grip on the handle for affordance. */
+    withHandle?: boolean;
+}
+
+/** A single resizable panel. Configure via defaultSize, minSize, maxSize. */
+declare const ResizablePanel: typeof Panel;
+export { ResizablePanel }
+export { ResizablePanel as ResizablePanel_alias_1 }
+
+/**
+ * Root container for a group of resizable panels.
+ * @returns A flex container that coordinates panel sizing.
+ */
+declare function ResizablePanelGroup({ className, ...props }: React_2.ComponentPropsWithoutRef<typeof Group>): JSX.Element;
+
+declare namespace ResizablePanelGroup {
+    var displayName: string;
+}
+export { ResizablePanelGroup }
+export { ResizablePanelGroup as ResizablePanelGroup_alias_1 }
+
+declare const resizableSchema: ComponentSchemaDefinition;
+export { resizableSchema }
+export { resizableSchema as resizableSchema_alias_1 }
+
+/** Parsed RGB components. Each channel is 0–255. */
+declare interface RgbColor {
+    r: number;
+    g: number;
+    b: number;
+}
+export { RgbColor }
+export { RgbColor as RgbColor_alias_1 }
+
+/**
+ * Convert RGB components to HSL.
+ * @param r - Red (0–255).
+ * @param g - Green (0–255).
+ * @param b - Blue (0–255).
+ * @returns HSL components (h: 0–360, s: 0–100, l: 0–100).
+ */
+declare function rgbToHsl(r: number, g: number, b: number): HslTriplet;
+export { rgbToHsl }
+export { rgbToHsl as rgbToHsl_alias_1 }
+
+/**
+ * Shared type primitives for the `ai` component category. Kept SDK-agnostic
+ * so a single `MessageProps`/`ToolCallProps` shape adapts to AI SDK
+ * (`UIMessage.parts`), LangChain (`BaseMessage`), Mastra agent outputs, and
+ * any custom backend with a thin caller-side mapping function.
+ */
+/** Speaker of a message. Matches AI SDK + LangChain role conventions. */
+declare type Role = "user" | "assistant" | "system" | "tool";
+export { Role }
+export { Role as Role_alias_1 }
+export { Role as Role_alias_2 }
+
+/** A scrollable area with custom-styled scrollbars. Content must be explicitly sized. */
+declare const ScrollArea: React_2.ForwardRefExoticComponent<ScrollAreaProps & React_2.RefAttributes<HTMLDivElement>>;
+export { ScrollArea }
+export { ScrollArea as ScrollArea_alias_1 }
+
+export declare interface ScrollAreaProps extends React_2.ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.Root> {
+    /**
+     * tabIndex applied to the scroll viewport so keyboard users can scroll
+     * without a pointer. Defaults to `0` (focusable) — pass `-1` to skip the
+     * viewport in the tab order when ScrollArea wraps purely decorative or
+     * already-keyboard-reachable content.
+     */
+    viewportTabIndex?: number;
+}
+
+declare const scrollAreaSchema: ComponentSchemaDefinition;
+export { scrollAreaSchema }
+export { scrollAreaSchema as scrollAreaSchema_alias_1 }
+
+/** Styled scrollbar track + thumb. Rendered inside ScrollArea automatically. */
+declare const ScrollBar: React_2.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { ScrollBar }
+export { ScrollBar as ScrollBar_alias_1 }
+
+/** Root container controlling the select's state. */
+declare const Select: React_2.FC<SelectPrimitive.SelectProps>;
+export { Select }
+export { Select as Select_alias_1 }
+
+/** The dropdown panel containing selectable options. */
+declare const SelectContent: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { SelectContent }
+export { SelectContent as SelectContent_alias_1 }
+
+/** Groups a set of related SelectItem elements. */
+declare const SelectGroup: React_2.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React_2.RefAttributes<HTMLDivElement>>;
+export { SelectGroup }
+export { SelectGroup as SelectGroup_alias_1 }
+
+/** A selectable option. */
+declare const SelectItem: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { SelectItem }
+export { SelectItem as SelectItem_alias_1 }
+
+/** A non-interactive label within a SelectGroup. */
+declare const SelectLabel: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { SelectLabel }
+export { SelectLabel as SelectLabel_alias_1 }
+
+declare const selectSchema: ComponentSchemaDefinition;
+export { selectSchema }
+export { selectSchema as selectSchema_alias_1 }
+
+/** Horizontal divider between groups inside SelectContent. */
+declare const SelectSeparator: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { SelectSeparator }
+export { SelectSeparator as SelectSeparator_alias_1 }
+
+/** The button users click to open the dropdown. */
+declare const SelectTrigger: React_2.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+export { SelectTrigger }
+export { SelectTrigger as SelectTrigger_alias_1 }
+
+/** Renders the selected value (or placeholder) inside the trigger. */
+declare const SelectValue: React_2.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React_2.RefAttributes<HTMLSpanElement>>;
+export { SelectValue }
+export { SelectValue as SelectValue_alias_1 }
+
+declare const Separator: React_2.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { Separator }
+export { Separator as Separator_alias_1 }
+
+/**
+ * A visual divider between content sections.
+ * Built on Radix UI Separator for proper accessibility semantics.
+ */
+declare type SeparatorProps = React_2.ComponentPropsWithoutRef<typeof SeparatorPrimitive.Root>;
+export { SeparatorProps }
+export { SeparatorProps as SeparatorProps_alias_1 }
+
+declare const separatorSchema: ComponentSchemaDefinition;
+export { separatorSchema }
+export { separatorSchema as separatorSchema_alias_1 }
+
+/** Root container controlling open state of a side sheet. */
+declare const Sheet: React_2.FC<DialogPrimitive.DialogProps>;
+export { Sheet }
+export { Sheet as Sheet_alias_1 }
+
+/** Closes the sheet when rendered inside SheetContent. */
+declare const SheetClose: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React_2.RefAttributes<HTMLButtonElement>>;
+export { SheetClose }
+export { SheetClose as SheetClose_alias_1 }
+
+/** The sheet content panel that slides in from a side of the viewport. */
+declare const SheetContent: React_2.ForwardRefExoticComponent<SheetContentProps & React_2.RefAttributes<HTMLDivElement>>;
+export { SheetContent }
+export { SheetContent as SheetContent_alias_1 }
+
+declare interface SheetContentProps extends React_2.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, VariantProps<typeof sheetVariants> {
+}
+
+/** Accessible sheet description; Radix wires it to aria-describedby automatically. */
+declare const SheetDescription: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React_2.RefAttributes<HTMLParagraphElement>, "ref"> & React_2.RefAttributes<HTMLParagraphElement>>;
+export { SheetDescription }
+export { SheetDescription as SheetDescription_alias_1 }
+
+/**
+ * Footer container inside SheetContent; aligns action buttons.
+ * @returns A div that stacks buttons on mobile and right-aligns on desktop.
+ */
+declare function SheetFooter({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { SheetFooter }
+export { SheetFooter as SheetFooter_alias_1 }
+
+/**
+ * Header container inside SheetContent; stacks title and description.
+ * @returns A div with vertical rhythm.
+ */
+declare function SheetHeader({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { SheetHeader }
+export { SheetHeader as SheetHeader_alias_1 }
+
+/** Dimmed backdrop rendered behind the sheet content. */
+declare const SheetOverlay: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { SheetOverlay }
+export { SheetOverlay as SheetOverlay_alias_1 }
+
+/** Portals the sheet overlay and content into the body. */
+declare const SheetPortal: React_2.FC<DialogPrimitive.DialogPortalProps>;
+export { SheetPortal }
+export { SheetPortal as SheetPortal_alias_1 }
+
+declare const sheetSchema: ComponentSchemaDefinition;
+export { sheetSchema }
+export { sheetSchema as sheetSchema_alias_1 }
+
+/** Accessible sheet title; Radix wires it to aria-labelledby automatically. */
+declare const SheetTitle: React_2.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React_2.RefAttributes<HTMLHeadingElement>, "ref"> & React_2.RefAttributes<HTMLHeadingElement>>;
+export { SheetTitle }
+export { SheetTitle as SheetTitle_alias_1 }
+
+/** The element (usually a button) that opens the sheet. */
+declare const SheetTrigger: React_2.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+export { SheetTrigger }
+export { SheetTrigger as SheetTrigger_alias_1 }
+
+declare const sheetVariants: (props?: ({
+    side?: "top" | "right" | "bottom" | "left" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+/**
+ * App-shell sidebar. Reads open state from SidebarProvider and animates width.
+ * @returns An aside element that expands/collapses.
+ */
+declare const Sidebar: React_2.ForwardRefExoticComponent<SidebarProps & React_2.RefAttributes<HTMLElement>>;
+export { Sidebar }
+export { Sidebar as Sidebar_alias_1 }
+
+/** Scrollable main area of the sidebar. */
+declare const SidebarContent: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+export { SidebarContent }
+export { SidebarContent as SidebarContent_alias_1 }
+
+declare interface SidebarContextValue {
+    /** Current open/collapsed state. */
+    open: boolean;
+    /** Toggle or set open state. */
+    setOpen: (open: boolean) => void;
+}
+
+/** Footer container at the bottom of the sidebar. */
+declare const SidebarFooter: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+export { SidebarFooter }
+export { SidebarFooter as SidebarFooter_alias_1 }
+
+/** Header container at the top of the sidebar. */
+declare const SidebarHeader: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLDivElement> & React_2.RefAttributes<HTMLDivElement>>;
+export { SidebarHeader }
+export { SidebarHeader as SidebarHeader_alias_1 }
+
+/**
+ * Single selectable row inside SidebarContent. Compose icon + label in children.
+ * @returns An accessible button (or Slot) styled as a sidebar row.
+ */
+declare const SidebarItem: React_2.ForwardRefExoticComponent<SidebarItemProps & React_2.RefAttributes<HTMLButtonElement>>;
+export { SidebarItem }
+export { SidebarItem as SidebarItem_alias_1 }
+
+declare interface SidebarItemProps extends React_2.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Render as the child element (next/link, etc.) via Slot. */
+    asChild?: boolean;
+    /** Mark as the current/selected item. */
+    active?: boolean;
+}
+
+declare interface SidebarProps extends React_2.HTMLAttributes<HTMLElement>, Pick<VariantProps<typeof sidebarVariants>, "side"> {
+}
+
+/**
+ * Hosts sidebar state. Wrap your app shell (Sidebar + main content) in this.
+ * @returns A flex container with a SidebarContext provider.
+ */
+declare function SidebarProvider({ open: openProp, defaultOpen, onOpenChange, children, className, }: SidebarProviderProps): JSX.Element;
+
+declare namespace SidebarProvider {
+    var displayName: string;
+}
+export { SidebarProvider }
+export { SidebarProvider as SidebarProvider_alias_1 }
+
+declare interface SidebarProviderProps {
+    /** Controlled open state. */
+    open?: boolean;
+    /** Uncontrolled initial open state (defaults to true). */
+    defaultOpen?: boolean;
+    /** Callback fired when open state changes. */
+    onOpenChange?: (open: boolean) => void;
+    /** Children — typically a Sidebar + app content sibling. */
+    children: React_2.ReactNode;
+    /** Extra class names on the provider wrapper. */
+    className?: string;
+}
+
+declare const sidebarSchema: ComponentSchemaDefinition;
+export { sidebarSchema }
+export { sidebarSchema as sidebarSchema_alias_1 }
+
+/**
+ * Toggles the sidebar open/closed. Renders a button by default; use asChild to style.
+ * @returns A button that flips SidebarProvider state.
+ */
+declare const SidebarTrigger: React_2.ForwardRefExoticComponent<SidebarTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+export { SidebarTrigger }
+export { SidebarTrigger as SidebarTrigger_alias_1 }
+
+declare interface SidebarTriggerProps extends React_2.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Render as the child element (Button, etc.) using Radix Slot. */
+    asChild?: boolean;
+}
+
+declare const sidebarVariants: (props?: ({
+    side?: "right" | "left" | null | undefined;
+    state?: "closed" | "open" | null | undefined;
+} & ClassProp) | undefined) => string;
+
+/**
+ * A placeholder shimmer element shown while content is loading.
+ * Pair with explicit width/height via className.
+ * @returns A div with pulsing muted background
+ */
+declare function Skeleton({ className, ...props }: React_2.HTMLAttributes<HTMLDivElement>): JSX.Element;
+export { Skeleton }
+export { Skeleton as Skeleton_alias_1 }
+
+declare const skeletonSchema: ComponentSchemaDefinition;
+export { skeletonSchema }
+export { skeletonSchema as skeletonSchema_alias_1 }
+
+/**
+ * A range input with one or more draggable thumbs.
+ * Built on Radix UI Slider with keyboard controls (arrows, Home, End, PageUp/Down).
+ */
+declare const Slider: React_2.ForwardRefExoticComponent<SliderProps & React_2.RefAttributes<HTMLSpanElement>>;
+export { Slider }
+export { Slider as Slider_alias_1 }
+
+export declare interface SliderProps extends React_2.ComponentPropsWithoutRef<typeof SliderPrimitive.Root> {
+    /**
+     * Per-thumb accessible labels. When the slider has multiple thumbs, pass
+     * one entry per thumb (e.g. ["Minimum", "Maximum"]). For a single-thumb
+     * slider, the Root's `aria-label` / `aria-labelledby` is mirrored onto
+     * the thumb automatically — pass `thumbLabels` only when those defaults
+     * are insufficient.
+     */
+    thumbLabels?: string[];
+}
+
+declare const sliderSchema: ComponentSchemaDefinition;
+export { sliderSchema }
+export { sliderSchema as sliderSchema_alias_1 }
+
+declare const sonnerSchema: ComponentSchemaDefinition;
+export { sonnerSchema }
+export { sonnerSchema as sonnerSchema_alias_1 }
+
+/**
+ * A declarative whitespace block. Use when you want to insert space between two
+ * siblings without relying on margin or gap (e.g. inside a flex container that
+ * doesn't own the spacing decision).
+ *
+ * Renders an empty `<div>` with `aria-hidden` since it has no semantic content.
+ *
+ * @param props - Spacer props including `size` and `axis` variant keys.
+ * @returns An empty div with the requested dimension.
+ * @example
+ * ```tsx
+ * <h1>Title</h1>
+ * <Spacer size="lg" />
+ * <p>Body</p>
+ * ```
+ */
+declare function Spacer({ className, size, axis, ...props }: SpacerProps): JSX.Element;
+export { Spacer }
+export { Spacer as Spacer_alias_1 }
+
+/** Props for the Spacer component. */
+declare interface SpacerProps extends Omit<React_2.HTMLAttributes<HTMLDivElement>, "children">, VariantProps<typeof spacerVariants> {
+}
+export { SpacerProps }
+export { SpacerProps as SpacerProps_alias_1 }
+
+declare const spacerSchema: ComponentSchemaDefinition;
+export { spacerSchema }
+export { spacerSchema as spacerSchema_alias_1 }
+
+/**
+ * CVA variants for Spacer — declarative whitespace.
+ * `size` sets `--spacer-size` to a `--space-*` token (with inline fallback);
+ * `axis` consumes that var via the bracket form used everywhere else in the
+ * package, so the height or width can never collapse to zero if the size
+ * variant is dropped.
+ */
+declare const spacerVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | "xl" | "xs" | null | undefined;
+    axis?: "both" | "horizontal" | "vertical" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { spacerVariants }
+export { spacerVariants as spacerVariants_alias_1 }
+
+/**
+ * Vertical flex flow with token-bound gap. Children stack top-to-bottom.
+ * @param props - Stack props including `gap`, `align`, and `justify` variant keys.
+ * @returns A flex column with consistent vertical spacing.
+ * @example
+ * ```tsx
+ * <Stack gap="lg">
+ *   <h2>Section title</h2>
+ *   <p>Paragraph one.</p>
+ *   <p>Paragraph two.</p>
+ * </Stack>
+ * ```
+ */
+declare function Stack({ className, gap, align, justify, ...props }: StackProps): JSX.Element;
+export { Stack }
+export { Stack as Stack_alias_1 }
+
+/** Props for the Stack component. */
+declare interface StackProps extends React_2.HTMLAttributes<HTMLDivElement>, VariantProps<typeof stackVariants> {
+}
+export { StackProps }
+export { StackProps as StackProps_alias_1 }
+
+declare const stackSchema: ComponentSchemaDefinition;
+export { stackSchema }
+export { stackSchema as stackSchema_alias_1 }
+
+/**
+ * CVA variants for Stack — vertical flex flow. `gap`, `align`, and `justify`
+ * pull from the shared layout-variant maps so any change to the gap scale
+ * propagates to Cluster and Grid simultaneously.
+ */
+declare const stackVariants: (props?: ({
+    gap?: "sm" | "lg" | "md" | "xl" | "xs" | null | undefined;
+    align?: "center" | "start" | "end" | "stretch" | null | undefined;
+    justify?: "center" | "start" | "end" | "between" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { stackVariants }
+export { stackVariants as stackVariants_alias_1 }
+
+/**
+ * Linear progress indicator for multi-step flows (form wizards, onboarding,
+ * checkout). Pure semantic HTML — `<ol>` of `<li>` with `aria-current="step"`
+ * on the current item; per-step `status` overrides allow marking "error".
+ *
+ * Pass `onStepClick` to make completed/non-disabled steps interactive.
+ * @returns An accessible ordered step list.
+ */
+declare function Stepper({ steps, current, orientation, size, onStepClick, "aria-label": ariaLabel, className, ...rest }: StepperProps): JSX.Element;
+
+declare namespace Stepper {
+    var displayName: string;
+}
+export { Stepper }
+export { Stepper as Stepper_alias_1 }
+
+declare interface StepperProps extends Omit<React_2.HTMLAttributes<HTMLOListElement>, "aria-label" | "onClick"> {
+    /** Ordered list of steps. */
+    steps: StepperStep[];
+    /** Index of the current step (controlled). */
+    current: number;
+    /** Layout direction. */
+    orientation?: "horizontal" | "vertical";
+    /** Indicator size. */
+    size?: "sm" | "md";
+    /** When provided, each step is rendered as a clickable button. */
+    onStepClick?: (index: number) => void;
+    /** Required accessible name for the ordered list. */
+    "aria-label": string;
+}
+export { StepperProps }
+export { StepperProps as StepperProps_alias_1 }
+
+declare const stepperSchema: ComponentSchemaDefinition;
+export { stepperSchema }
+export { stepperSchema as stepperSchema_alias_1 }
+
+declare interface StepperStep {
+    /** Stable unique id used as the React key. */
+    id: string;
+    /** Step name shown next to the indicator. */
+    label: string;
+    /** Optional secondary text under the label. */
+    description?: string;
+    /** Disable the step (only applies when onStepClick is provided). */
+    disabled?: boolean;
+    /**
+     * Override the index-derived status. Use `"error"` to mark a failed step
+     * (e.g. validation failure in a form wizard); `"complete"` / `"current"` /
+     * `"upcoming"` are derived from `current` by default.
+     */
+    status?: StepStatus;
+}
+export { StepperStep }
+export { StepperStep as StepperStep_alias_1 }
+
+declare type StepStatus = "complete" | "current" | "upcoming" | "error";
+export { StepStatus }
+export { StepStatus as StepStatus_alias_1 }
+
+/**
+ * Renders a clickable suggestion chip.
+ * @param props - value/onSelect + children
+ * @returns A styled button element
+ */
+declare function Suggestion({ value, onSelect, children, className, type, onClick, ...props }: SuggestionProps): JSX.Element;
+export { Suggestion }
+export { Suggestion as Suggestion_alias_1 }
+
+/**
+ * Prompt pill / quick-action chip. Click forwards `value` (or the rendered
+ * string children) to `onSelect` — typically wired to drop the suggestion
+ * into a `Composer` or fire it directly through `useChat.append`.
+ *
+ * Stateless: no submission logic, no networking. Composer (or its parent)
+ * decides whether `onSelect` populates the input or auto-sends.
+ *
+ * @example
+ * <Cluster gap="sm">
+ *   {prompts.map((p) => (
+ *     <Suggestion key={p} value={p} onSelect={setInput}>{p}</Suggestion>
+ *   ))}
+ * </Cluster>
+ */
+declare interface SuggestionProps extends Omit<React_2.ButtonHTMLAttributes<HTMLButtonElement>, "onSelect" | "value"> {
+    /** Payload passed to `onSelect`. Defaults to the rendered children if a string. */
+    value?: string;
+    onSelect: (value: string) => void;
+    children: React_2.ReactNode;
+}
+export { SuggestionProps }
+export { SuggestionProps as SuggestionProps_alias_1 }
+
+declare const suggestionSchema: ComponentSchemaDefinition;
+export { suggestionSchema }
+export { suggestionSchema as suggestionSchema_alias_1 }
+
+/**
+ * Languages we surface in the prop type. Plain literal union of real
+ * Shiki grammar IDs — kept literal (not `Extract<BundledLanguage, …>`)
+ * because Shiki's full bundled-language union is 600+ literals, and
+ * deriving from it forced the rollup-dts pass past a 4GB heap. The
+ * literals here are all standard Shiki grammar IDs; if Shiki removes
+ * one upstream, `codeToHtml` will throw at runtime — acceptable trade.
+ */
+declare type SupportedLang = "bash" | "ts" | "tsx" | "js" | "jsx" | "json" | "css" | "html" | "md" | "py" | "text";
+export { SupportedLang }
+export { SupportedLang as SupportedLang_alias_1 }
+
+declare const Switch: React_2.ForwardRefExoticComponent<Omit<SwitchPrimitive.SwitchProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+export { Switch }
+export { Switch as Switch_alias_1 }
+
+/**
+ * An accessible toggle switch built on Radix UI.
+ * Use for instant on/off settings that take effect immediately.
+ */
+declare type SwitchProps = React_2.ComponentPropsWithoutRef<typeof SwitchPrimitive.Root>;
+export { SwitchProps }
+export { SwitchProps as SwitchProps_alias_1 }
+
+declare const switchSchema: ComponentSchemaDefinition;
+export { switchSchema }
+export { switchSchema as switchSchema_alias_1 }
+
+/** A responsive container + styled HTML table. */
+declare const Table: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableElement> & React_2.RefAttributes<HTMLTableElement>>;
+export { Table }
+export { Table as Table_alias_1 }
+
+/** `<tbody>` wrapper removing bottom border on last row. */
+declare const TableBody: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;
+export { TableBody }
+export { TableBody as TableBody_alias_1 }
+
+/**
+ * Visible `<caption>` rendered below the table. The parent `<Table>` sets
+ * `caption-bottom`, so the caption is announced first by screen readers when
+ * entering the table, then visually placed below the rows.
+ */
+declare const TableCaption: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableCaptionElement> & React_2.RefAttributes<HTMLTableCaptionElement>>;
+export { TableCaption }
+export { TableCaption as TableCaption_alias_1 }
+
+/** `<td>` with consistent padding. */
+declare const TableCell: React_2.ForwardRefExoticComponent<React_2.TdHTMLAttributes<HTMLTableCellElement> & React_2.RefAttributes<HTMLTableCellElement>>;
+export { TableCell }
+export { TableCell as TableCell_alias_1 }
+
+/** `<tfoot>` wrapper with muted background. */
+declare const TableFooter: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;
+export { TableFooter }
+export { TableFooter as TableFooter_alias_1 }
+
+/** `<th>` with left-aligned muted text. */
+declare const TableHead: React_2.ForwardRefExoticComponent<React_2.ThHTMLAttributes<HTMLTableCellElement> & React_2.RefAttributes<HTMLTableCellElement>>;
+export { TableHead }
+export { TableHead as TableHead_alias_1 }
+
+/** `<thead>` wrapper with bottom border. */
+declare const TableHeader: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableSectionElement> & React_2.RefAttributes<HTMLTableSectionElement>>;
+export { TableHeader }
+export { TableHeader as TableHeader_alias_1 }
+
+/** `<tr>` with hover + selected states. */
+declare const TableRow: React_2.ForwardRefExoticComponent<React_2.HTMLAttributes<HTMLTableRowElement> & React_2.RefAttributes<HTMLTableRowElement>>;
+export { TableRow }
+export { TableRow as TableRow_alias_1 }
+
+declare const tableSchema: ComponentSchemaDefinition;
+export { tableSchema }
+export { tableSchema as tableSchema_alias_1 }
+
+/** Root container for a tabbed interface. */
+declare const Tabs: React_2.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React_2.RefAttributes<HTMLDivElement>>;
+export { Tabs }
+export { Tabs as Tabs_alias_1 }
+
+/** The content panel associated with a tab trigger. */
+declare const TabsContent: React_2.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { TabsContent }
+export { TabsContent as TabsContent_alias_1 }
+
+/** A horizontal list of tab triggers. */
+declare const TabsList: React_2.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { TabsList }
+export { TabsList as TabsList_alias_1 }
+
+declare const tabsSchema: ComponentSchemaDefinition;
+export { tabsSchema }
+export { tabsSchema as tabsSchema_alias_1 }
+
+/** A clickable tab trigger that activates its associated content panel. */
+declare const TabsTrigger: React_2.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & React_2.RefAttributes<HTMLButtonElement>>;
+export { TabsTrigger }
+export { TabsTrigger as TabsTrigger_alias_1 }
+
+/**
+ * An interactive tag / chip primitive — Badge with an optional dismiss
+ * affordance. Mirrors {@link Badge}'s CVA variants so the visual sibling
+ * is obvious; adds a built-in close button when `onRemove` is provided.
+ *
+ * For non-interactive labels (status indicators, counts) use {@link Badge}
+ * directly. For "click to filter" state-bearing chips, use Toggle or
+ * ToggleGroup — Tag is for "this token represents a value the user can
+ * dismiss" (filters, multi-select selections, draft attachments).
+ *
+ * @example
+ * ```tsx
+ * <Tag variant="secondary" onRemove={() => removeFilter("urgent")}>
+ *   Urgent
+ * </Tag>
+ * ```
+ *
+ * @returns A span containing the label + optional icon + optional close button.
+ */
+declare function Tag({ className, variant, icon, onRemove, removeLabel, children, ref, ...props }: TagProps): JSX.Element;
+export { Tag }
+export { Tag as Tag_alias_1 }
+
+declare interface TagProps extends Omit<React_2.HTMLAttributes<HTMLSpanElement>, "onRemove">, VariantProps<typeof tagVariants> {
+    /** Forwarded ref onto the root span element. */
+    ref?: React_2.Ref<HTMLSpanElement>;
+    /** Optional leading icon (`<svg>` or component). Sized 12×12. */
+    icon?: React_2.ReactNode;
+    /**
+     * Click handler for the close button. When provided, an inline ✕ button
+     * is rendered after the children with an `aria-label` derived from the
+     * children's string content (or a generic "Remove" if no string can be
+     * extracted). Pass undefined for a non-interactive Tag — at that point,
+     * prefer Badge directly.
+     */
+    onRemove?: () => void;
+    /** Override the auto-derived `aria-label` on the close button. */
+    removeLabel?: string;
+}
+export { TagProps }
+export { TagProps as TagProps_alias_1 }
+
+declare const tagSchema: ComponentSchemaDefinition;
+export { tagSchema }
+export { tagSchema as tagSchema_alias_1 }
+
+declare const tagVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { tagVariants }
+export { tagVariants as tagVariants_alias_1 }
+
+declare const Textarea: React_2.ForwardRefExoticComponent<TextareaProps & React_2.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea }
+export { Textarea as Textarea_alias_1 }
+
+/**
+ * A styled multi-line text input with smooth focus transitions and shadow effects.
+ * Extends the native HTML textarea element with Hex UI styling.
+ */
+declare type TextareaProps = React_2.TextareaHTMLAttributes<HTMLTextAreaElement>;
+export { TextareaProps }
+export { TextareaProps as TextareaProps_alias_1 }
+
+declare const textareaSchema: ComponentSchemaDefinition;
+export { textareaSchema }
+export { textareaSchema as textareaSchema_alias_1 }
+
+/**
+ * Vertical chronological event feed (activity log, audit trail, release notes).
+ * Pure semantic HTML — `<ol>` of `<li>`. Events expose an optional icon, a
+ * status color, a timestamp, and a description; status is purely visual, no
+ * aria-current is set since events are historical, not navigational.
+ *
+ * For Gantt-style project timelines, build a custom layout — Timeline is for
+ * event feeds, not scheduling.
+ * @returns An accessible vertical event list.
+ */
+declare function Timeline({ events, size, "aria-label": ariaLabel, className, ...rest }: TimelineProps): JSX.Element;
+
+declare namespace Timeline {
+    var displayName: string;
+}
+export { Timeline }
+export { Timeline as Timeline_alias_1 }
+
+declare interface TimelineEvent {
+    /** Stable unique id used as the React key. */
+    id: string;
+    /** Headline for the event. */
+    title: string;
+    /** Optional timestamp/metadata (e.g. "2 hours ago", "2026-04-27 14:30"). */
+    timestamp?: React_2.ReactNode;
+    /** Optional secondary text/body. */
+    description?: React_2.ReactNode;
+    /** Optional icon override for the indicator. Replaces the default dot. */
+    icon?: React_2.ReactNode;
+    /** Color variant for the indicator. */
+    status?: TimelineStatus;
+}
+export { TimelineEvent }
+export { TimelineEvent as TimelineEvent_alias_1 }
+
+declare interface TimelineProps extends Omit<React_2.HTMLAttributes<HTMLOListElement>, "aria-label"> {
+    /** Ordered list of chronological events. */
+    events: TimelineEvent[];
+    /** Indicator size — `"md"` by default. */
+    size?: "sm" | "md";
+    /** Required accessible name for the ordered list. */
+    "aria-label": string;
+}
+export { TimelineProps }
+export { TimelineProps as TimelineProps_alias_1 }
+
+declare const timelineSchema: ComponentSchemaDefinition;
+export { timelineSchema }
+export { timelineSchema as timelineSchema_alias_1 }
+
+declare type TimelineStatus = "default" | "success" | "warning" | "error" | "info";
+export { TimelineStatus }
+export { TimelineStatus as TimelineStatus_alias_1 }
+
+/**
+ * Time input — styled wrapper around the native `<input type="time">` so the
+ * browser handles 12/24-hour locale, keyboard arrow stepping, and screen-reader
+ * announcement. Value is a `"HH:MM"` (or `"HH:MM:SS"` when `step={1}`) string.
+ *
+ * For free-form composite hour/minute fields with explicit AM/PM segments,
+ * compose Input + Select yourself — the native input covers ~95% of TimePicker
+ * use cases with full a11y, including keyboard-driven hour/minute spinning.
+ * @returns A token-styled native time input.
+ */
+declare const TimePicker: React_2.ForwardRefExoticComponent<TimePickerProps & React_2.RefAttributes<HTMLInputElement>>;
+export { TimePicker }
+export { TimePicker as TimePicker_alias_1 }
+
+declare interface TimePickerProps extends Omit<React_2.InputHTMLAttributes<HTMLInputElement>, "type" | "value" | "onChange" | "size"> {
+    /** Controlled time value as `"HH:MM"` or `"HH:MM:SS"` (24-hour). */
+    value?: string;
+    /** Fired with the new `"HH:MM"` (or `"HH:MM:SS"`) string when the user picks a time. */
+    onChange?: (value: string) => void;
+    /**
+     * Step in seconds — `60` shows HH:MM only (default), `1` shows HH:MM:SS.
+     * Smaller values change the spinner increment in supported browsers.
+     */
+    step?: number;
+    /** Earliest selectable time as `"HH:MM"`. */
+    min?: string;
+    /** Latest selectable time as `"HH:MM"`. */
+    max?: string;
+    /** Disable the input. */
+    disabled?: boolean;
+    /** Accessible label for the trigger (required when no adjacent visible <label>). */
+    "aria-label"?: string;
+}
+export { TimePickerProps }
+export { TimePickerProps as TimePickerProps_alias_1 }
+
+declare const timePickerSchema: ComponentSchemaDefinition;
+export { timePickerSchema }
+export { timePickerSchema as timePickerSchema_alias_1 }
+
+export { toast }
+export { toast as toast_alias_1 }
+
+/**
+ * The global toast container. Render once in your app root.
+ * Re-export of Sonner's Toaster styled to use Hex UI theme tokens.
+ * @param props - Sonner Toaster props (position, richColors, etc.)
+ * @returns A styled portal container for toast notifications
+ */
+declare function Toaster({ ...props }: ToasterProps): JSX.Element;
+export { Toaster }
+export { Toaster as Toaster_alias_1 }
+
+declare type ToasterProps = React.ComponentProps<typeof Toaster_2>;
+
+/**
+ * A two-state button. Stays pressed when toggled on.
+ * @returns A styled Radix Toggle root
+ */
+declare const Toggle: React_2.ForwardRefExoticComponent<Omit<TogglePrimitive.ToggleProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLButtonElement>>;
+export { Toggle }
+export { Toggle as Toggle_alias_1 }
+
+/** Root container for a set of toggles (single-select or multi-select). */
+declare const ToggleGroup: React_2.ForwardRefExoticComponent<((Omit<ToggleGroupPrimitive.ToggleGroupSingleProps & React_2.RefAttributes<HTMLDivElement>, "ref"> | Omit<ToggleGroupPrimitive.ToggleGroupMultipleProps & React_2.RefAttributes<HTMLDivElement>, "ref">) & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string>) & React_2.RefAttributes<HTMLDivElement>>;
+export { ToggleGroup }
+export { ToggleGroup as ToggleGroup_alias_1 }
+
+/** A single toggle option within a ToggleGroup. Inherits variant/size from context. */
+declare const ToggleGroupItem: React_2.ForwardRefExoticComponent<Omit<ToggleGroupPrimitive.ToggleGroupItemProps & React_2.RefAttributes<HTMLButtonElement>, "ref"> & VariantProps<(props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string> & React_2.RefAttributes<HTMLButtonElement>>;
+export { ToggleGroupItem }
+export { ToggleGroupItem as ToggleGroupItem_alias_1 }
+
+declare const toggleGroupSchema: ComponentSchemaDefinition;
+export { toggleGroupSchema }
+export { toggleGroupSchema as toggleGroupSchema_alias_1 }
+
+declare const toggleSchema: ComponentSchemaDefinition;
+export { toggleSchema }
+export { toggleSchema as toggleSchema_alias_1 }
+
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { toggleVariants }
+export { toggleVariants as toggleVariants_alias_1 }
+
+/**
+ * Root toolbar element. Wraps Radix `Toolbar.Root` with the canonical
+ * Hex Core token + visual styling. Pass children consisting of
+ * `ToolbarButton`, `ToolbarToggleGroup`, `ToolbarSeparator`, and
+ * `ToolbarLink` — Radix handles arrow-key roving focus across them
+ * automatically.
+ *
+ * @example
+ * ```tsx
+ * <Toolbar aria-label="Editor controls">
+ *   <ToolbarButton onClick={onUndo}>Undo</ToolbarButton>
+ *   <ToolbarButton onClick={onRedo}>Redo</ToolbarButton>
+ *   <ToolbarSeparator />
+ *   <ToolbarToggleGroup type="single" defaultValue="left">
+ *     <ToolbarToggleItem value="left">Left</ToolbarToggleItem>
+ *     <ToolbarToggleItem value="center">Center</ToolbarToggleItem>
+ *     <ToolbarToggleItem value="right">Right</ToolbarToggleItem>
+ *   </ToolbarToggleGroup>
+ * </Toolbar>
+ * ```
+ */
+declare function Toolbar({ className, orientation, ref, ...props }: ToolbarProps): JSX.Element;
+export { Toolbar }
+export { Toolbar as Toolbar_alias_1 }
+
+/** A push button inside the toolbar. */
+declare function ToolbarButton({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof ToolbarPrimitive.Button> & {
+    ref?: React_2.Ref<React_2.ElementRef<typeof ToolbarPrimitive.Button>>;
+}): JSX.Element;
+export { ToolbarButton }
+export { ToolbarButton as ToolbarButton_alias_1 }
+
+/** A link inside the toolbar — renders an `<a>` with toolbar focus semantics. */
+declare function ToolbarLink({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof ToolbarPrimitive.Link> & {
+    ref?: React_2.Ref<React_2.ElementRef<typeof ToolbarPrimitive.Link>>;
+}): JSX.Element;
+export { ToolbarLink }
+export { ToolbarLink as ToolbarLink_alias_1 }
+
+/**
+ * Toolbar root props. `aria-label` is required — Radix Toolbar.Root
+ * mounts as a `role="toolbar"` landmark, and AT users will hear an
+ * unlabelled "toolbar" landmark when no visible heading sits adjacent.
+ * If a visible heading IS present, pair it via `aria-labelledby` instead.
+ */
+declare interface ToolbarProps extends Omit<React_2.ComponentPropsWithoutRef<typeof ToolbarPrimitive.Root>, "aria-label"> {
+    /** Forwarded ref onto the Radix `Toolbar.Root`. */
+    ref?: React_2.Ref<React_2.ElementRef<typeof ToolbarPrimitive.Root>>;
+    /** Required accessible name for the toolbar landmark. */
+    "aria-label": string;
+}
+export { ToolbarProps }
+export { ToolbarProps as ToolbarProps_alias_1 }
+
+declare const toolbarSchema: ComponentSchemaDefinition;
+export { toolbarSchema }
+export { toolbarSchema as toolbarSchema_alias_1 }
+
+/** A vertical (or horizontal, in vertical toolbars) divider. */
+declare function ToolbarSeparator({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof ToolbarPrimitive.Separator> & {
+    ref?: React_2.Ref<React_2.ElementRef<typeof ToolbarPrimitive.Separator>>;
+}): JSX.Element;
+export { ToolbarSeparator }
+export { ToolbarSeparator as ToolbarSeparator_alias_1 }
+
+/** A group of mutually-exclusive (`type='single'`) or independent (`type='multiple'`) toggle items. */
+declare function ToolbarToggleGroup({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof ToolbarPrimitive.ToggleGroup> & {
+    ref?: React_2.Ref<React_2.ElementRef<typeof ToolbarPrimitive.ToggleGroup>>;
+}): JSX.Element;
+export { ToolbarToggleGroup }
+export { ToolbarToggleGroup as ToolbarToggleGroup_alias_1 }
+
+/** Individual toggle item — exposes `data-state="on"` for the on style. */
+declare function ToolbarToggleItem({ className, ref, ...props }: React_2.ComponentPropsWithoutRef<typeof ToolbarPrimitive.ToggleItem> & {
+    ref?: React_2.Ref<React_2.ElementRef<typeof ToolbarPrimitive.ToggleItem>>;
+}): JSX.Element;
+export { ToolbarToggleItem }
+export { ToolbarToggleItem as ToolbarToggleItem_alias_1 }
+
+declare const toolbarVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & ClassProp) | undefined) => string;
+export { toolbarVariants }
+export { toolbarVariants as toolbarVariants_alias_1 }
+
+/**
+ * Renders a tool-invocation card with collapsible details.
+ * @param props - tool name, state, optional args/result
+ * @returns A Collapsible wrapping a header + JSON body
+ */
+declare function ToolCall({ name, state, args, result, defaultOpen, className, }: ToolCallProps): JSX.Element;
+export { ToolCall }
+export { ToolCall as ToolCall_alias_1 }
+
+/**
+ * Collapsible card displaying a tool / function invocation. Header shows the
+ * tool name and lifecycle state badge; body reveals the JSON-stringified
+ * arguments and result on expand.
+ *
+ * Display-only — the component does not run the tool. Wire it up in the
+ * consumer (AI SDK `tool-*` parts → ToolCall props, LangChain
+ * `AIMessage.tool_calls` → ToolCall props).
+ *
+ * @example
+ * <ToolCall
+ *   name="searchDocs"
+ *   state="result"
+ *   args={{ query: "auth" }}
+ *   result={{ hits: 12 }}
+ * />
+ */
+declare interface ToolCallProps {
+    name: string;
+    state: ToolCallState;
+    args?: unknown;
+    result?: unknown;
+    defaultOpen?: boolean;
+    className?: string;
+}
+export { ToolCallProps }
+export { ToolCallProps as ToolCallProps_alias_1 }
+
+declare const toolCallSchema: ComponentSchemaDefinition;
+export { toolCallSchema }
+export { toolCallSchema as toolCallSchema_alias_1 }
+
+/**
+ * Lifecycle of a tool/function invocation, surfaced as the `state` prop on
+ * `ToolCall`. `pending` = queued, `running` = executing, `result` = returned
+ * a value, `error` = threw. Picked to align with AI SDK v5 `tool-*` parts.
+ */
+declare type ToolCallState = "pending" | "running" | "result" | "error";
+export { ToolCallState }
+export { ToolCallState as ToolCallState_alias_1 }
+export { ToolCallState as ToolCallState_alias_2 }
+
+/** Root container for a single tooltip. */
+declare const Tooltip: React_2.FC<TooltipPrimitive.TooltipProps>;
+export { Tooltip }
+export { Tooltip as Tooltip_alias_1 }
+
+/** The floating tooltip content (small, hover-reveal info). */
+declare const TooltipContent: React_2.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React_2.RefAttributes<HTMLDivElement>, "ref"> & React_2.RefAttributes<HTMLDivElement>>;
+export { TooltipContent }
+export { TooltipContent as TooltipContent_alias_1 }
+
+/** Provider required at the root of the app or tree where tooltips are used. */
+declare const TooltipProvider: React_2.FC<TooltipPrimitive.TooltipProviderProps>;
+export { TooltipProvider }
+export { TooltipProvider as TooltipProvider_alias_1 }
+
+declare const tooltipSchema: ComponentSchemaDefinition;
+export { tooltipSchema }
+export { tooltipSchema as tooltipSchema_alias_1 }
+
+/** The element that shows the tooltip on hover/focus. */
+declare const TooltipTrigger: React_2.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React_2.RefAttributes<HTMLButtonElement>>;
+export { TooltipTrigger }
+export { TooltipTrigger as TooltipTrigger_alias_1 }
+
+/**
+ * Generic hierarchical list with roving-tabindex keyboard navigation —
+ * arrow keys move focus, → expands, ← collapses, Home / End jump to
+ * first / last visible row, Enter / Space activates the focused node.
+ *
+ * Distinct from {@link FileTree} (which adds folder/file icon-by-extension
+ * logic baked in) and {@link Accordion} (two-level groupings without
+ * item-selection semantics).
+ *
+ * @example
+ * ```tsx
+ * <Tree
+ *   aria-label="Org chart"
+ *   data={[
+ *     { id: "ceo", label: "CEO", children: [
+ *       { id: "cto", label: "CTO", children: [
+ *         { id: "eng-lead", label: "Eng Lead" },
+ *       ]},
+ *       { id: "cmo", label: "CMO" },
+ *     ]},
+ *   ]}
+ *   defaultExpanded={["ceo"]}
+ *   onSelect={(id) => console.log(id)}
+ * />
+ * ```
+ */
+declare function Tree({ data, defaultExpanded, expanded: expandedProp, onExpandedChange, selected: selectedProp, onSelect, "aria-label": ariaLabel, className, ref, }: TreeProps): JSX.Element;
+export { Tree }
+export { Tree as Tree_alias_1 }
+
+/**
+ * One node in a Tree. Generic — the shape is content-agnostic so consumers
+ * can render org charts, taxonomy pickers, navigation trees, etc.
+ *
+ * For filesystem-shaped data (with file-extension icon logic baked in),
+ * prefer {@link FileTree} instead.
+ */
+declare interface TreeNode {
+    /** Stable unique id used as React key + ARIA target. */
+    id: string;
+    /** Display name. */
+    label: React_2.ReactNode;
+    /** Nested children. Presence (even empty array) marks the node as a parent. */
+    children?: TreeNode[];
+    /** Optional icon (default: a chevron + dot). */
+    icon?: React_2.ReactNode;
+    /** Disable selection + expand toggle. */
+    disabled?: boolean;
+}
+export { TreeNode }
+export { TreeNode as TreeNode_alias_1 }
+
+declare interface TreeProps {
+    /** Forwarded ref onto the root `<ul role="tree">`. */
+    ref?: React_2.Ref<HTMLUListElement>;
+    /** Root nodes. */
+    data: TreeNode[];
+    /** Uncontrolled initial expanded ids. */
+    defaultExpanded?: string[];
+    /** Controlled expanded ids. */
+    expanded?: string[];
+    /** Fired when expanded set changes (array of ids). */
+    onExpandedChange?: (ids: string[]) => void;
+    /** Controlled selected node id. */
+    selected?: string;
+    /** Fired when the user activates a node (click, Enter, or Space). */
+    onSelect?: (id: string) => void;
+    /** Required accessible name. */
+    "aria-label": string;
+    /** Optional additional class names. */
+    className?: string;
+}
+export { TreeProps }
+export { TreeProps as TreeProps_alias_1 }
+
+declare const treeSchema: ComponentSchemaDefinition;
+export { treeSchema }
+export { treeSchema as treeSchema_alias_1 }
+
+/**
+ * Hook that returns the current field's id, name, error, and derived aria ids.
+ * Must be called inside a FormField + FormItem subtree.
+ * @returns Field state + aria descriptors
+ */
+declare function useFormField(): {
+    invalid: boolean;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+    error?: FieldError;
+    id: string;
+    name: string;
+    formItemId: string;
+    formDescriptionId: string;
+    formMessageId: string;
+};
+export { useFormField }
+export { useFormField as useFormField_alias_1 }
+
+/**
+ * Reads sidebar state from context. Throws if used outside SidebarProvider.
+ * @returns `{ open, setOpen }` bound to the nearest SidebarProvider.
+ */
+declare function useSidebar(): SidebarContextValue;
+export { useSidebar }
+export { useSidebar as useSidebar_alias_1 }
+
+export { }