@hex-core/components 1.5.0 → 1.7.0

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

@@ -51,6 +51,7 @@ 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';
 
@@ -179,6 +180,76 @@ 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 }
@@ -1340,6 +1411,120 @@ 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,
@@ -1665,6 +1850,30 @@ 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
@@ -1701,6 +1910,32 @@ declare const loadingIndicatorVariants: (props?: ({
 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
@@ -2595,6 +2830,42 @@ declare const spacerVariants: (props?: ({
 export { spacerVariants }
 export { spacerVariants as spacerVariants_alias_1 }
 
+/**
+ * Renders a mic toggle button wired to the Web Speech API.
+ * @param props - controlled listening state + transcript callback
+ * @returns A button element that toggles speech recognition
+ */
+declare function SpeechRecognition({ isListening, onListeningChange, onTranscript, onError, lang, continuous, interimResults, startLabel, stopLabel, notSupportedLabel, disabled, className, ...rest }: SpeechRecognitionProps): JSX.Element;
+export { SpeechRecognition }
+export { SpeechRecognition as SpeechRecognition_alias_1 }
+
+declare interface SpeechRecognitionProps extends Omit<React_2.ButtonHTMLAttributes<HTMLButtonElement>, "onError"> {
+    /** Controlled listening state. */
+    isListening: boolean;
+    /** Called when listening starts/stops (user toggle or browser auto-end). */
+    onListeningChange: (listening: boolean) => void;
+    /** Called per transcript chunk. `isFinal` indicates a finalized phrase. */
+    onTranscript: (text: string, isFinal: boolean) => void;
+    /** Called on browser error (e.g. "not-allowed", "no-speech", "network"). */
+    onError?: (error: string, message?: string) => void;
+    /** BCP-47 language tag. Default `"en-US"`. */
+    lang?: string;
+    /** Keep listening across pauses. Default `true`. */
+    continuous?: boolean;
+    /** Emit interim (in-progress) results. Default `true`. */
+    interimResults?: boolean;
+    /** Accessible name when idle. Default `"Start dictation"`. */
+    startLabel?: string;
+    /** Accessible name when listening. Default `"Stop dictation"`. */
+    stopLabel?: string;
+    /** Accessible name + tooltip when the browser lacks the API. */
+    notSupportedLabel?: string;
+}
+export { SpeechRecognitionProps }
+export { SpeechRecognitionProps as SpeechRecognitionProps_alias_1 }
+
+export declare const speechRecognitionSchema: ComponentSchemaDefinition;
+
 /**
  * Vertical flex flow with token-bound gap. Children stack top-to-bottom.
  * @param props - Stack props including `gap`, `align`, and `justify` variant keys.
@@ -2832,6 +3103,58 @@ declare const TabsTrigger: React_2.ForwardRefExoticComponent<Omit<TabsPrimitive.
 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 }
@@ -2999,6 +3322,91 @@ declare const toggleVariants: (props?: ({
 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
@@ -3074,6 +3482,85 @@ declare const TooltipTrigger: React_2.ForwardRefExoticComponent<TooltipPrimitive
 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.

package/dist/attachment.d.ts

@@ -0,0 +1,4 @@
+export { AttachmentFile_alias_1 as AttachmentFile } from './_tsup-dts-rollup.js';
+export { AttachmentProps_alias_1 as AttachmentProps } from './_tsup-dts-rollup.js';
+export { Attachment_alias_1 as Attachment } from './_tsup-dts-rollup.js';
+export { attachmentVariants_alias_1 as attachmentVariants } from './_tsup-dts-rollup.js';