@nextlyhq/ui 0.0.2-alpha.52 → 0.0.2-alpha.56

package/dist/index.d.ts

@@ -26,6 +26,7 @@ import { ToasterProps } from 'sonner';
 export { ToasterProps, toast } from 'sonner';
 import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
 import * as ResizablePrimitive from 'react-resizable-panels';
+import * as SliderPrimitive from '@radix-ui/react-slider';
 
 /** @public */
 interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
@@ -2453,4 +2454,490 @@ declare const ResizableHandle: ({ withGrip, className, children, ...props }: rea
     withGrip?: boolean;
 }) => react_jsx_runtime.JSX.Element;
 
-export { Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, AccordionTrigger, type AccordionTriggerProps, type ActionCallbacks, Alert, AlertDescription, type AlertDescriptionProps, AlertDialog, AlertDialogAction, type AlertDialogActionProps, AlertDialogCancel, type AlertDialogCancelProps, AlertDialogContent, type AlertDialogContentProps, AlertDialogDescription, type AlertDialogDescriptionProps, AlertDialogFooter, type AlertDialogFooterProps, AlertDialogHeader, type AlertDialogHeaderProps, AlertDialogOverlay, type AlertDialogOverlayProps, AlertDialogPortal, AlertDialogTitle, type AlertDialogTitleProps, AlertDialogTrigger, type AlertProps, AlertTitle, type AlertTitleProps, Avatar, AvatarFallback, type AvatarFallbackProps, AvatarImage, type AvatarImageProps, type AvatarProps, Badge, type BadgeProps, Button, type ButtonProps, Card, CardAction, type CardActionProps, CardContent, type CardContentProps, CardDescription, type CardDescriptionProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, CardTitle, type CardTitleProps, Checkbox, Collapsible, CollapsibleContent, CollapsibleTrigger, Command, CommandDialog, type CommandDialogProps, CommandEmpty, type CommandEmptyProps, CommandGroup, type CommandGroupProps, CommandInput, type CommandInputProps, CommandItem, type CommandItemProps, CommandList, type CommandListProps, type CommandProps, CommandSeparator, type CommandSeparatorProps, CommandShortcut, type CommandShortcutProps, ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, type DataFetcher, Dialog, DialogClose, DialogContent, type DialogContentProps, DialogDescription, type DialogDescriptionProps, DialogFooter, type DialogFooterProps, DialogHeader, type DialogHeaderProps, DialogOverlay, type DialogOverlayProps, DialogPortal, DialogTitle, type DialogTitleProps, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, type DropdownMenuCheckboxItemProps, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuGroup, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, type DropdownMenuLabelProps, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, type DropdownMenuRadioItemProps, DropdownMenuSeparator, type DropdownMenuSeparatorProps, DropdownMenuShortcut, type DropdownMenuShortcutProps, DropdownMenuSub, DropdownMenuSubContent, type DropdownMenuSubContentProps, DropdownMenuSubTrigger, type DropdownMenuSubTriggerProps, DropdownMenuTrigger, type FilterInfo, FormLabelWithTooltip, type FormLabelWithTooltipProps, Grid, type GridProps, Input, type InputProps, Label, type ListResponse, type PaginationConfig, type PaginationMeta, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, PortalProvider, Progress, type ProgressProps, RadioGroup, RadioGroupItem, ResizableHandle, ResizablePanel, ResizablePanelGroup, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, type SelectTriggerProps, SelectValue, Separator, Sheet, SheetClose, type SheetCloseProps, SheetContent, type SheetContentProps, type SheetContentRef, SheetDescription, type SheetDescriptionProps, type SheetDescriptionRef, SheetFooter, type SheetFooterProps, SheetHeader, type SheetHeaderProps, SheetOverlay, type SheetOverlayProps, type SheetOverlayRef, SheetPortal, type SheetProps, SheetTitle, type SheetTitleProps, type SheetTitleRef, SheetTrigger, type SheetTriggerProps, Skeleton, type SkeletonProps, type SortInfo, Spinner, type SpinnerProps, Stack, type StackProps, Stat, type StatProps, Switch, Table, TableBody, TableCaption, TableCell, TableEmpty, type TableEmptyProps, TableError, type TableErrorProps, TableFooter, TableHead, TableHeader, TableLoading, type TableParams, TableRow, TableSearch, type TableSearchProps, TableSkeleton, type TableSkeletonProps, Tabs, TabsContent, type TabsContentProps, TabsList, type TabsListProps, type TabsProps, TabsTrigger, type TabsTriggerProps, Textarea, Toaster, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, alertVariants, avatarVariants, badgeVariants, buttonVariants, cardVariants, dialogContentVariants, inputVariants, progressVariants, selectTriggerVariants, sheetVariants, spinnerVariants, usePortalContainer };
+/**
+ * TreeView
+ *
+ * A keyboard-operable, virtualized tree. The layers panel of an editor is this control: a
+ * hierarchy that can hold thousands of nodes, that someone navigates with arrow keys as much as
+ * with a pointer, and that has to stay responsive while they do.
+ *
+ * **Why virtualized, and why that decides the markup.** A document of a few thousand blocks
+ * renders a few thousand rows, and the cost is not the React work — it is layout and paint on
+ * every expand, scroll and selection. Only the visible window is rendered here.
+ *
+ * That has a consequence the accessibility notes below depend on: with only a window in the DOM,
+ * the nested `role="group"` markup the tree pattern usually uses **cannot be built**, because an
+ * item's children may not be rendered at all. The APG covers this exact case by allowing a FLAT
+ * set of `treeitem`s that describe the hierarchy through `aria-level`, `aria-setsize` and
+ * `aria-posinset` instead of through nesting. A screen reader reads depth and position from those
+ * attributes, so they are not decoration — without them a virtualized tree announces itself as a
+ * flat list of whatever happens to be on screen.
+ *
+ * **Why a headless virtualizer.** The markup above is the requirement, so anything that owns the
+ * DOM is unusable. `@tanstack/react-virtual` computes offsets and renders nothing.
+ *
+ * **State is controllable, not controlled.** `expandedIds`/`selectedId` may be passed with their
+ * `onChange` partners to drive the tree from a store — which an editor will do, since selection is
+ * shared with the canvas and the inspector — or omitted entirely, in which case the tree keeps its
+ * own. Requiring a store for a tree in a settings dialog would be a poor trade.
+ *
+ * **Design specifications**:
+ * - Row height: fixed 28px (`--tree-row`), so the virtualizer needs no measurement pass
+ * - Indent: 12px per level, applied as padding so the whole row stays a hit target
+ * - Selection: `bg-muted`, matching the menu highlight rather than a full-contrast flip
+ * - Focus: `focus-visible` ring in the focus token
+ *
+ * **Accessibility**:
+ * - `role="tree"` with flat `role="treeitem"` children carrying `aria-level`, `aria-setsize`,
+ *   `aria-posinset`, and `aria-expanded` on anything with children
+ * - Roving tabindex: exactly one row is in the tab order, so Tab enters and leaves the tree once
+ *   rather than walking every node
+ * - Arrow keys move and expand, per the APG tree pattern: Right expands then descends, Left
+ *   collapses then ascends, Home/End jump to the ends, `*` expands every sibling
+ * - Typeahead focuses the next row whose label starts with what was typed
+ * - Moving focus scrolls the row into view, which virtualization would otherwise prevent: a row
+ *   outside the window has no element to focus
+ *
+ * @example
+ * ```tsx
+ * <TreeView
+ *   nodes={layers}
+ *   aria-label="Layers"
+ *   selectedId={selected}
+ *   onSelectedChange={setSelected}
+ *   className="h-full"
+ * />
+ * ```
+ *
+ * @module
+ */
+
+/**
+ * One node of the tree. Children are omitted or empty for a leaf.
+ *
+ * @experimental
+ */
+interface TreeNode {
+    /** Stable identity. What selection and expansion are keyed by. */
+    id: string;
+    /** What the row shows. A string also feeds typeahead; anything else needs `textValue`. */
+    label: react.ReactNode;
+    /**
+     * The text typeahead matches on, when `label` is not a string.
+     *
+     * Without it a row rendered as markup cannot be typed to, and a keyboard user loses the fastest
+     * way through a long tree.
+     */
+    textValue?: string;
+    /** Children, if any. An empty array still marks the node as a parent. */
+    children?: readonly TreeNode[];
+    /** Shown before the label, after the twisty. */
+    icon?: react.ReactNode;
+    /** Skipped by every keyboard move and not selectable. */
+    disabled?: boolean;
+}
+/** @experimental */
+interface TreeViewProps extends Omit<react.HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    /** The roots of the tree. */
+    nodes: readonly TreeNode[];
+    /** Expanded node ids, if the caller owns them. */
+    expandedIds?: readonly string[];
+    /** Which ids start expanded when the caller does not own expansion. */
+    defaultExpandedIds?: readonly string[];
+    /** Called with the full next set whenever a branch opens or closes. */
+    onExpandedChange?: (ids: string[]) => void;
+    /** The selected node id, if the caller owns it. */
+    selectedId?: string | null;
+    /** Which id starts selected when the caller does not own selection. */
+    defaultSelectedId?: string | null;
+    /** Called when a row is chosen, by pointer or by Enter. */
+    onSelectedChange?: (id: string) => void;
+    /**
+     * Names the tree for a screen reader. One of this or `aria-labelledby` is required: a tree
+     * announced only as "tree" tells a user nothing about which one they are in.
+     */
+    "aria-label"?: string;
+}
+/**
+ * A virtualized tree.
+ *
+ * @experimental
+ */
+declare const TreeView: react.ForwardRefExoticComponent<TreeViewProps & react.RefAttributes<HTMLDivElement>>;
+
+/**
+ * The assistive-technology attributes a single thumb can carry.
+ *
+ * @experimental
+ */
+interface SliderThumbProps {
+    /** The thumb's accessible name. */
+    "aria-label"?: string;
+    /** An element naming the thumb, when the name is already on screen. */
+    "aria-labelledby"?: string;
+    /**
+     * What the value MEANS, when the number alone does not say it — "40
+     * percent", "Medium". Announced in place of the raw number.
+     */
+    "aria-valuetext"?: string;
+    /** An element carrying help text for this thumb. */
+    "aria-describedby"?: string;
+}
+/**
+ * The slider's props, mirroring the Radix root.
+ *
+ * @experimental
+ */
+type SliderProps = Omit<react.ComponentPropsWithoutRef<typeof SliderPrimitive.Root>, "asChild"> & {
+    /**
+     * Assistive-technology attributes per thumb, in value order.
+     *
+     * The reason this exists at all: the focusable element with the `slider`
+     * role is the THUMB, and none of these attributes are inherited from the
+     * root. Anything a caller puts on the root is therefore announced by
+     * nothing, and the thumbs are generated internally so they cannot be
+     * reached any other way.
+     *
+     * Deliberately a curated set rather than the thumb's full prop type. This
+     * is the surface assistive technology reads; opening it to arbitrary props
+     * would let a caller replace the class names or the role the control
+     * depends on, and every escape hatch in a design system eventually gets
+     * used that way.
+     *
+     * Required for a RANGE: two thumbs sharing one name are announced
+     * identically, so nothing says which end is held. A single thumb falls back
+     * to the root's `aria-label`/`aria-labelledby`, so the one-thumb API stays
+     * as documented.
+     */
+    thumbs?: readonly SliderThumbProps[];
+};
+/**
+ * A bounded numeric value chosen by dragging.
+ *
+ * @experimental
+ */
+declare const Slider: react.ForwardRefExoticComponent<Omit<Omit<SliderPrimitive.SliderProps & react.RefAttributes<HTMLSpanElement>, "ref">, "asChild"> & {
+    /**
+     * Assistive-technology attributes per thumb, in value order.
+     *
+     * The reason this exists at all: the focusable element with the `slider`
+     * role is the THUMB, and none of these attributes are inherited from the
+     * root. Anything a caller puts on the root is therefore announced by
+     * nothing, and the thumbs are generated internally so they cannot be
+     * reached any other way.
+     *
+     * Deliberately a curated set rather than the thumb's full prop type. This
+     * is the surface assistive technology reads; opening it to arbitrary props
+     * would let a caller replace the class names or the role the control
+     * depends on, and every escape hatch in a design system eventually gets
+     * used that way.
+     *
+     * Required for a RANGE: two thumbs sharing one name are announced
+     * identically, so nothing says which end is held. A single thumb falls back
+     * to the root's `aria-label`/`aria-labelledby`, so the one-thumb API stays
+     * as documented.
+     */
+    thumbs?: readonly SliderThumbProps[];
+} & react.RefAttributes<HTMLSpanElement>>;
+
+/**
+ * The single owner of keyboard shortcuts for an application.
+ *
+ * ## Why this exists
+ *
+ * Shortcuts are usually registered by whoever needs them, each component adding its own
+ * `document` listener. That works until two of them want the same key, and then it fails in a way
+ * that is very hard to see: `stopPropagation()` does NOT stop other listeners on the same node —
+ * that requires `stopImmediatePropagation()`, and even then only for listeners registered later.
+ * So every global handler runs, in mount order, and mount order is not something a developer
+ * chose. Pressing Escape during a drag can cancel the drag AND navigate away from the page,
+ * because two independent listeners each believed they owned the key.
+ *
+ * This module replaces that with one listener and an explicit precedence rule.
+ *
+ * ## The model: a stack of layers
+ *
+ * A **layer** is a set of bindings belonging to one interactive context — the application shell,
+ * a dialog, an editor canvas mid-drag. Layers are ordered, the topmost is offered each keystroke
+ * first, and the first binding that matches consumes it.
+ *
+ * Precedence is `(depth, sequence)`: the deeper layer wins, and between layers at equal depth the
+ * more recently registered wins.
+ *
+ * Of those two, **depth is declared and sequence is incidental** — and only declared properties
+ * survive a refactor. A layer that unmounts and remounts takes a fresh sequence number, so a
+ * subtree rebuilt for unrelated reasons can change equal-depth ordering. The guidance that falls
+ * out: if relative order matters to you, express it as depth, because depth is the part of the
+ * tuple you control. Equal-depth ordering is for stacking things that arrive in genuine
+ * mount order, such as one dialog over another. Depth comes from how the application nests, so precedence
+ * follows the component tree rather than a set of coordinated numbers — the z-index problem,
+ * avoided. Equal-depth ordering is what stacks a second dialog above the first.
+ *
+ * A layer may be **blocking**, meaning it also swallows the keys it does NOT bind. That is the
+ * property a drag or a modal needs: while it is up, nothing beneath it can act. This is the same
+ * shape as a window manager's keyboard grab, and as the dismissable-layer stack this kit's
+ * dialogs already sit on.
+ *
+ * ## What it deliberately does not do
+ *
+ * It listens in the BUBBLE phase, so a focused component that handles its own keys and calls
+ * `stopPropagation()` wins without needing to know this module exists. React attaches its
+ * handlers at the app root, below `document`, so an `onKeyDown` prop is a sufficient opt-out.
+ * Capturing instead would make this module outrank every component in the tree, including the
+ * kit's own dialogs, and there would be no way for a component to decline.
+ *
+ * @module lib/shortcuts/manager
+ */
+/**
+ * One shortcut and what it does.
+ *
+ * @experimental
+ */
+interface ShortcutBinding {
+    /** The keys, as understood by `parseKeys` — `"mod+s"`, `"Escape"`, `"g d"`. */
+    keys: string;
+    /**
+     * What this does, in words, for a shortcuts help panel. Required because an undiscoverable
+     * shortcut helps only the person who wrote it.
+     */
+    description: string;
+    /** Runs when the shortcut fires. */
+    run: (event: KeyboardEvent) => void;
+    /** Checked at press time; a binding whose condition is false is skipped and passes the key on. */
+    when?: () => boolean;
+    /**
+     * Whether this fires while the user is typing in a field.
+     *
+     * Defaults to true for bindings whose FIRST chord carries a non-shift modifier or is Escape,
+     * and false otherwise — the rule nearly every application converges on. `mod+s` must save
+     * mid-sentence and Escape must dismiss, while a bare `n` must be able to be the letter n.
+     *
+     * The first chord decides because it is the keystroke that has to be taken from the field.
+     * `mod+k c` is a command from its opening chord, so its bare `c` completes it in an input. A
+     * sequence that OPENS on a plain character cannot fire while typing whatever it ends with:
+     * allowing `g Escape` would mean swallowing the `g` of every word containing one.
+     */
+    whenTyping?: boolean;
+    /** Whether to call `preventDefault()` when it fires. Defaults to true. */
+    preventDefault?: boolean;
+}
+/**
+ * How a layer behaves for keys it does not bind.
+ *
+ * @experimental
+ */
+interface ShortcutLayerOptions {
+    /** Identifies the layer in diagnostics and in a help panel. */
+    name: string;
+    /** Precedence: deeper layers are offered keystrokes first. */
+    depth: number;
+    /**
+     * Whether unmatched keys stop here instead of reaching layers beneath.
+     *
+     * The reason a drag can be interrupted safely: everything below is inert for as long as this
+     * is set, so no other context can act on a keystroke aimed at this one.
+     */
+    blocking?: boolean;
+    /** Whether the layer participates at all. A disabled layer neither matches nor blocks. */
+    enabled?: boolean;
+}
+/**
+ * A layer's registration, held by whoever created it.
+ *
+ * @experimental
+ */
+interface ShortcutRegistration {
+    /** Replace this layer's bindings and options without changing its precedence. */
+    update: (bindings: readonly ShortcutBinding[], options: ShortcutLayerOptions) => void;
+    /** Remove the layer. */
+    dispose: () => void;
+}
+/**
+ * Options for creating a manager.
+ *
+ * @experimental
+ */
+interface ShortcutManagerOptions {
+    /** Whether `mod` means Command. Detected from the platform when omitted. */
+    isApple?: boolean;
+    /** How long a partially typed sequence waits for its next key, in milliseconds. */
+    sequenceTimeoutMs?: number;
+    /** Clock source, for tests that need to control sequence expiry. */
+    now?: () => number;
+}
+/**
+ * A shortcut manager: the registry, the matcher, and the one listener.
+ *
+ * @experimental
+ */
+interface ShortcutManager {
+    /** Add a layer. */
+    register: (bindings: readonly ShortcutBinding[], options: ShortcutLayerOptions) => ShortcutRegistration;
+    /**
+     * Offer a keystroke to the stack. Returns whether it was consumed.
+     *
+     * Public so the behaviour can be tested without a DOM, and so a host that already owns its
+     * event plumbing can drive the manager itself.
+     */
+    handle: (event: KeyboardEvent) => boolean;
+    /** Install the single listener on a target, returning a function that removes it. */
+    attach: (target: Pick<EventTarget, "addEventListener" | "removeEventListener">) => () => void;
+    /**
+     * Every active binding, most-precedent layer first, for a shortcuts help panel.
+     *
+     * The same array is returned until the layer stack changes, so it is safe to use as an external
+     * store snapshot without re-rendering on every read.
+     */
+    activeBindings: () => readonly ActiveShortcut[];
+    /**
+     * Watch for changes to the layer stack.
+     *
+     * A help panel mounting alongside the components that register shortcuts would otherwise read
+     * BEFORE their effects run and show nothing, with no later render to correct it.
+     */
+    subscribe: (onChange: () => void) => () => void;
+}
+/**
+ * A binding as presented to a help panel, with the layer it came from.
+ *
+ * @experimental
+ */
+interface ActiveShortcut {
+    keys: string;
+    description: string;
+    layer: string;
+}
+/**
+ * Create a shortcut manager.
+ *
+ * @experimental
+ */
+declare function createShortcutManager(options?: ShortcutManagerOptions): ShortcutManager;
+
+/**
+ * Props for {@link ShortcutProvider}.
+ *
+ * @experimental
+ */
+interface ShortcutProviderProps extends ShortcutManagerOptions {
+    children?: react.ReactNode;
+    /**
+     * Where the listener is installed. Defaults to `document`.
+     *
+     * The bubble phase is deliberate: a component that handles its own keys and calls
+     * `stopPropagation` wins without knowing this exists, because React attaches its handlers
+     * below `document`.
+     */
+    target?: Pick<EventTarget, "addEventListener" | "removeEventListener"> | null;
+}
+/**
+ * Installs the application's one keydown listener and roots the layer stack.
+ *
+ * @experimental
+ */
+declare function ShortcutProvider({ children, target, ...managerOptions }: ShortcutProviderProps): react.JSX.Element;
+/**
+ * Raises the precedence of everything inside it by one level.
+ *
+ * @experimental
+ */
+declare function ShortcutScope({ children, }: {
+    children?: react.ReactNode;
+}): react.JSX.Element;
+/**
+ * Options for {@link useShortcuts}, minus the depth, which comes from the tree.
+ *
+ * @experimental
+ */
+interface UseShortcutsOptions {
+    /** Identifies this layer in a help panel. */
+    name: string;
+    /** Whether the layer participates. A disabled layer neither matches nor blocks. */
+    enabled?: boolean;
+    /**
+     * Whether unmatched keys stop here rather than reaching layers beneath.
+     *
+     * Set this while a drag or a modal interaction owns the keyboard.
+     */
+    blocking?: boolean;
+}
+/**
+ * Register shortcuts for as long as the calling component is mounted.
+ *
+ * The bindings array may be rebuilt on every render; it is re-read in place rather than
+ * re-registered, so inline closures are fine and the layer keeps its position in the stack.
+ *
+ * @experimental
+ */
+declare function useShortcuts(bindings: readonly ShortcutBinding[], options: UseShortcutsOptions): void;
+/**
+ * The manager itself, for a help panel that lists what is currently bound.
+ *
+ * @experimental
+ */
+declare function useShortcutManager(): ShortcutManager;
+/**
+ * The shortcuts currently in effect, most precedent first.
+ *
+ * SUBSCRIBED rather than read once. A help panel mounting alongside the components that register
+ * shortcuts reads before their effects have run, so a one-time read returns an empty list and no
+ * later render corrects it — the panel simply shows nothing. The same applies whenever a layer is
+ * enabled, disabled or replaced while the panel is open.
+ *
+ * The manager returns the same array until its stack changes, so this re-renders when the
+ * shortcuts change and not on every read.
+ *
+ * @experimental
+ */
+declare function useActiveShortcuts(): readonly ActiveShortcut[];
+
+/**
+ * Parsing and matching for keyboard shortcut specifications.
+ *
+ * A spec is written the way it is spoken: `"mod+s"`, `"Escape"`, `"shift+alt+f"`, and — for a
+ * sequence — `"g d"`, meaning `g` then `d`. Steps are separated by spaces; within a step,
+ * modifiers are joined to the key with `+`.
+ *
+ * The space bar is written `"Space"`, because the character the browser reports for it is `" "`
+ * and a spec split on whitespace has no way to carry that.
+ *
+ * **`mod` is the point of this module.** It resolves to Command on Apple platforms and Control
+ * everywhere else, so a binding is written once. Writing `ctrl` or `meta` explicitly is still
+ * possible and then means exactly that, which is what lets a platform-specific binding coexist
+ * with a portable one — a distinction lost by any implementation that treats the two as
+ * interchangeable.
+ *
+ * @module lib/shortcuts/key-spec
+ */
+/**
+ * One keystroke: a key plus the modifier state required with it.
+ *
+ * @experimental
+ */
+interface KeyChord {
+    /** The `KeyboardEvent.key` value, normalized to lower case for single characters. */
+    readonly key: string;
+    /** Command on Apple platforms, Control elsewhere. */
+    readonly mod: boolean;
+    readonly ctrl: boolean;
+    readonly meta: boolean;
+    readonly alt: boolean;
+    readonly shift: boolean;
+}
+/**
+ * A shortcut: one chord, or several pressed in order.
+ *
+ * @experimental
+ */
+type KeySequence = readonly KeyChord[];
+/**
+ * Parse a spec into the sequence of chords it describes.
+ *
+ * @param spec - For example `"mod+s"`, `"Escape"`, or `"g d"`.
+ * @throws If the spec is empty, or a step names modifiers but no key.
+ *
+ * @experimental
+ */
+declare function parseKeys(spec: string): KeySequence;
+
+export { Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, AccordionTrigger, type AccordionTriggerProps, type ActionCallbacks, type ActiveShortcut, Alert, AlertDescription, type AlertDescriptionProps, AlertDialog, AlertDialogAction, type AlertDialogActionProps, AlertDialogCancel, type AlertDialogCancelProps, AlertDialogContent, type AlertDialogContentProps, AlertDialogDescription, type AlertDialogDescriptionProps, AlertDialogFooter, type AlertDialogFooterProps, AlertDialogHeader, type AlertDialogHeaderProps, AlertDialogOverlay, type AlertDialogOverlayProps, AlertDialogPortal, AlertDialogTitle, type AlertDialogTitleProps, AlertDialogTrigger, type AlertProps, AlertTitle, type AlertTitleProps, Avatar, AvatarFallback, type AvatarFallbackProps, AvatarImage, type AvatarImageProps, type AvatarProps, Badge, type BadgeProps, Button, type ButtonProps, Card, CardAction, type CardActionProps, CardContent, type CardContentProps, CardDescription, type CardDescriptionProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, CardTitle, type CardTitleProps, Checkbox, Collapsible, CollapsibleContent, CollapsibleTrigger, Command, CommandDialog, type CommandDialogProps, CommandEmpty, type CommandEmptyProps, CommandGroup, type CommandGroupProps, CommandInput, type CommandInputProps, CommandItem, type CommandItemProps, CommandList, type CommandListProps, type CommandProps, CommandSeparator, type CommandSeparatorProps, CommandShortcut, type CommandShortcutProps, ContextMenu, ContextMenuCheckboxItem, ContextMenuContent, ContextMenuGroup, ContextMenuItem, ContextMenuLabel, ContextMenuRadioGroup, ContextMenuRadioItem, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, type DataFetcher, Dialog, DialogClose, DialogContent, type DialogContentProps, DialogDescription, type DialogDescriptionProps, DialogFooter, type DialogFooterProps, DialogHeader, type DialogHeaderProps, DialogOverlay, type DialogOverlayProps, DialogPortal, DialogTitle, type DialogTitleProps, DialogTrigger, DropdownMenu, DropdownMenuCheckboxItem, type DropdownMenuCheckboxItemProps, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuGroup, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, type DropdownMenuLabelProps, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, type DropdownMenuRadioItemProps, DropdownMenuSeparator, type DropdownMenuSeparatorProps, DropdownMenuShortcut, type DropdownMenuShortcutProps, DropdownMenuSub, DropdownMenuSubContent, type DropdownMenuSubContentProps, DropdownMenuSubTrigger, type DropdownMenuSubTriggerProps, DropdownMenuTrigger, type FilterInfo, FormLabelWithTooltip, type FormLabelWithTooltipProps, Grid, type GridProps, Input, type InputProps, type KeyChord, type KeySequence, Label, type ListResponse, type PaginationConfig, type PaginationMeta, Popover, PopoverAnchor, PopoverContent, PopoverTrigger, PortalProvider, Progress, type ProgressProps, RadioGroup, RadioGroupItem, ResizableHandle, ResizablePanel, ResizablePanelGroup, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, type SelectTriggerProps, SelectValue, Separator, Sheet, SheetClose, type SheetCloseProps, SheetContent, type SheetContentProps, type SheetContentRef, SheetDescription, type SheetDescriptionProps, type SheetDescriptionRef, SheetFooter, type SheetFooterProps, SheetHeader, type SheetHeaderProps, SheetOverlay, type SheetOverlayProps, type SheetOverlayRef, SheetPortal, type SheetProps, SheetTitle, type SheetTitleProps, type SheetTitleRef, SheetTrigger, type SheetTriggerProps, type ShortcutBinding, type ShortcutLayerOptions, type ShortcutManager, type ShortcutManagerOptions, ShortcutProvider, type ShortcutProviderProps, type ShortcutRegistration, ShortcutScope, Skeleton, type SkeletonProps, Slider, type SliderProps, type SliderThumbProps, type SortInfo, Spinner, type SpinnerProps, Stack, type StackProps, Stat, type StatProps, Switch, Table, TableBody, TableCaption, TableCell, TableEmpty, type TableEmptyProps, TableError, type TableErrorProps, TableFooter, TableHead, TableHeader, TableLoading, type TableParams, TableRow, TableSearch, type TableSearchProps, TableSkeleton, type TableSkeletonProps, Tabs, TabsContent, type TabsContentProps, TabsList, type TabsListProps, type TabsProps, TabsTrigger, type TabsTriggerProps, Textarea, Toaster, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, type TreeNode, TreeView, type TreeViewProps, type UseShortcutsOptions, alertVariants, avatarVariants, badgeVariants, buttonVariants, cardVariants, createShortcutManager, dialogContentVariants, inputVariants, parseKeys, progressVariants, selectTriggerVariants, sheetVariants, spinnerVariants, useActiveShortcuts, usePortalContainer, useShortcutManager, useShortcuts };