@evinvest/uikit 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1183 @@
+import { ClassValue } from 'clsx';
+import * as React from 'react';
+
+/**
+ * Fuses class fragments into one string with real Tailwind conflict resolution:
+ * `clsx` drops falsy fragments and joins the rest, `tailwind-merge` resolves
+ * conflicting utilities so the rightmost wins (`cn("p-4", "p-2") === "p-2"`). A
+ * caller's `className` override, passed last, therefore beats the base classes.
+ *
+ * The Rust mirror is the `cn!` macro in `ev::uikit` (`tailwind_fuse::tw_merge!`).
+ */
+declare function cn(...inputs: ClassValue[]): string;
+
+/**
+ * Minimal `asChild` mechanism — the dep-light replacement for
+ * `@radix-ui/react-slot`. Renders by cloning its single child, merging the
+ * Slot's own props onto it: `className` is fused with `cn`, event handlers are
+ * chained (child's runs first, then ours), and `style` objects are shallow
+ * merged. Refs are composed so both the caller's and the child's ref fire.
+ *
+ * There is no Rust counterpart: Dioxus composition is expressed with `children`
+ * directly, so `asChild` is a TS-only ergonomic.
+ */
+interface SlotProps extends React.HTMLAttributes<HTMLElement> {
+    children?: React.ReactNode;
+}
+declare const Slot: React.ForwardRefExoticComponent<SlotProps & React.RefAttributes<HTMLElement>>;
+
+/**
+ * Controlled/uncontrolled state, the dep-light equivalent of Radix's
+ * `useControllableState`. When `value` is provided the component is controlled
+ * (the hook returns it and routes writes through `onChange`); otherwise it owns
+ * an internal `useState` seeded from `defaultValue`.
+ *
+ * The Rust mirror is `use_controllable_signal` in `ev::uikit`.
+ */
+declare function useControllableState<T>(opts: {
+    value?: T | undefined;
+    defaultValue: T;
+    onChange?: ((value: T) => void) | undefined;
+}): [T, (next: T) => void];
+
+/**
+ * Renders its children into `container` (default `document.body`) via
+ * `react-dom`'s `createPortal` — the dep-light stand-in for
+ * `@radix-ui/react-portal`. SSR-safe: renders nothing until mounted.
+ *
+ * Rust has no portal counterpart (see the README "Limitations"): `ev::uikit`
+ * overlays render inline with fixed positioning instead.
+ */
+interface PortalProps {
+    children: React.ReactNode;
+    container?: Element | null;
+}
+declare function Portal({ children, container }: PortalProps): React.ReactPortal | null;
+
+/**
+ * Calls `onDismiss` on Escape or on a pointer-down outside the layer — the
+ * dep-light core of every overlay's "click away to close". Pass refs to any
+ * nodes that should NOT count as outside (e.g. the trigger), via `exclude`.
+ *
+ * Mirrors the dismiss behaviour Rust expresses with a full-screen backdrop.
+ */
+declare function useDismissableLayer(opts: {
+    enabled: boolean;
+    onDismiss: () => void;
+    exclude?: Array<React.RefObject<Element | null>>;
+}): React.RefObject<HTMLDivElement | null>;
+
+type Side = "top" | "right" | "bottom" | "left";
+type Align = "start" | "center" | "end";
+interface FloatingResult {
+    floatingRef: React.RefObject<HTMLElement | null>;
+    style: React.CSSProperties;
+    side: Side;
+    align: Align;
+}
+/**
+ * Positions a floating element against an anchor with `position: fixed` and
+ * `getBoundingClientRect` — the dep-light stand-in for `@radix-ui/react-popper`
+ * / floating-ui. Supports a preferred `side`/`align`, an `offset`, and a single
+ * collision flip onto the opposite side when the preferred side overflows the
+ * viewport. Recomputes on scroll and resize while `open`.
+ *
+ * Rust's overlays use CSS-only placement (`data-side`) and do not measure; see
+ * the README "Limitations".
+ */
+declare function useFloating(opts: {
+    anchorRef: React.RefObject<Element | null>;
+    open: boolean;
+    side?: Side;
+    align?: Align;
+    offset?: number;
+}): FloatingResult;
+
+/**
+ * Traps Tab focus inside the returned ref's subtree and restores focus to the
+ * previously-focused element on unmount — the dep-light core of dialogs/menus,
+ * replacing `@radix-ui/react-focus-scope`. On mount, focuses the first
+ * focusable (or the container itself).
+ *
+ * Rust dialogs rely on the browser's native focus order within a fixed overlay;
+ * see the README "Limitations".
+ */
+declare function useFocusScope(enabled: boolean): React.RefObject<HTMLDivElement | null>;
+
+/**
+ * Keeps a node mounted through its exit animation — the dep-light core of
+ * `@radix-ui/react-presence`. While `present` is true the node is mounted with
+ * `data-state="open"`; when `present` flips to false the hook switches it to
+ * `data-state="closed"` and unmounts only after the node's CSS
+ * animation/transition ends (or immediately if there is none).
+ *
+ * Usage: spread `{ ref, ...(isPresent ? {} : {}) }` and render only while
+ * `isPresent`. The Rust mirror toggles `data-state` without deferring unmount.
+ */
+declare function usePresence(present: boolean): {
+    isPresent: boolean;
+    ref: React.RefObject<HTMLElement | null>;
+};
+
+/**
+ * Arrow-key roving focus over a set of items — the dep-light core of menus,
+ * tabs, radio-groups and toolbars (replacing `@radix-ui/react-roving-focus`).
+ * Returns an `onKeyDown` to spread on the container and the active index; items
+ * should set `tabIndex={index === activeIndex ? 0 : -1}`.
+ *
+ * Mirrors the keyboard navigation Rust drives with a focused-index signal.
+ */
+declare function useRovingFocus(opts: {
+    count: number;
+    orientation?: "horizontal" | "vertical" | "both";
+    loop?: boolean;
+    initial?: number;
+}): {
+    activeIndex: number;
+    setActiveIndex: (i: number) => void;
+    onKeyDown: (event: React.KeyboardEvent) => void;
+};
+
+/**
+ * Combines several refs into one callback ref so a node can satisfy multiple
+ * consumers at once (e.g. an overlay that is both the floating element and the
+ * dismissable layer). Used throughout the overlay components.
+ */
+declare function mergeRefs<T>(...refs: Array<React.Ref<T> | undefined>): React.RefCallback<T>;
+
+declare const alertVariants: {
+    readonly default: "bg-card text-card-foreground";
+    readonly destructive: "text-destructive bg-card [&>svg]:text-current *:data-[slot=alert-description]:text-destructive/90";
+};
+type AlertVariant = keyof typeof alertVariants;
+interface AlertProps extends React.ComponentProps<"div"> {
+    variant?: AlertVariant;
+}
+declare function Alert({ className, variant, ...props }: AlertProps): React.JSX.Element;
+declare function AlertTitle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function AlertDescription({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+
+interface AspectRatioProps extends React.ComponentProps<"div"> {
+    ratio?: number;
+}
+declare function AspectRatio({ ratio, className, style, ...props }: AspectRatioProps): React.JSX.Element;
+
+declare function Avatar({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function AvatarImage({ className, onError, ...props }: React.ComponentProps<"img">): React.JSX.Element | null;
+declare function AvatarFallback({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+
+declare const badgeVariants: {
+    readonly default: "border-transparent bg-primary text-primary-foreground [a&]:hover:bg-primary/90";
+    readonly secondary: "border-transparent bg-secondary text-secondary-foreground [a&]:hover:bg-secondary/90";
+    readonly destructive: "border-transparent bg-destructive text-white [a&]:hover:bg-destructive/90 focus-visible:ring-destructive/20";
+    readonly outline: "text-foreground [a&]:hover:bg-accent [a&]:hover:text-accent-foreground";
+    readonly success: "border-transparent bg-main-accent-t2/20 text-main-accent-t2";
+};
+type BadgeVariant = keyof typeof badgeVariants;
+interface BadgeProps extends React.ComponentProps<"span"> {
+    variant?: BadgeVariant;
+    asChild?: boolean;
+}
+declare function Badge({ className, variant, asChild, ...props }: BadgeProps): React.JSX.Element;
+
+declare function Breadcrumb({ ...props }: React.ComponentProps<"nav">): React.JSX.Element;
+declare function BreadcrumbList({ className, ...props }: React.ComponentProps<"ol">): React.JSX.Element;
+declare function BreadcrumbItem({ className, ...props }: React.ComponentProps<"li">): React.JSX.Element;
+interface BreadcrumbLinkProps extends React.ComponentProps<"a"> {
+    asChild?: boolean;
+}
+declare function BreadcrumbLink({ asChild, className, ...props }: BreadcrumbLinkProps): React.JSX.Element;
+declare function BreadcrumbPage({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+declare function BreadcrumbSeparator({ children, className, ...props }: React.ComponentProps<"li">): React.JSX.Element;
+declare function BreadcrumbEllipsis({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+
+declare const buttonVariantClasses: {
+    readonly default: "bg-primary text-primary-foreground hover:bg-primary/90";
+    readonly secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80";
+    readonly outline: "border bg-transparent shadow-xs hover:bg-accent hover:text-accent-foreground";
+    readonly ghost: "hover:bg-accent hover:text-accent-foreground";
+    readonly destructive: "bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20";
+    readonly link: "text-primary underline-offset-4 hover:underline";
+};
+declare const buttonSizeClasses: {
+    readonly default: "h-9 px-4 py-2 has-[>svg]:px-3";
+    readonly sm: "h-8 rounded-md gap-1.5 px-3 has-[>svg]:px-2.5";
+    readonly lg: "h-10 rounded-md px-6 has-[>svg]:px-4";
+    readonly icon: "size-9";
+    readonly "icon-sm": "size-8";
+    readonly "icon-lg": "size-10";
+};
+type ButtonVariant = keyof typeof buttonVariantClasses;
+type ButtonSize = keyof typeof buttonSizeClasses;
+interface ButtonVariantsOptions {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    className?: string;
+}
+/**
+ * Returns the fused canonical button class string. Reused by `pagination` so a
+ * non-`Button` element can adopt the same styling, mirroring Rust's
+ * `button_classes`.
+ */
+declare function buttonVariants({ variant, size, className, }?: ButtonVariantsOptions): string;
+interface ButtonProps extends React.ComponentProps<"button"> {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    asChild?: boolean;
+}
+declare function Button({ className, variant, size, asChild, ...props }: ButtonProps): React.JSX.Element;
+
+declare const buttonGroupOrientationClasses: {
+    readonly horizontal: "[&>*:not(:first-child)]:rounded-l-none [&>*:not(:first-child)]:border-l-0 [&>*:not(:last-child)]:rounded-r-none";
+    readonly vertical: "flex-col [&>*:not(:first-child)]:rounded-t-none [&>*:not(:first-child)]:border-t-0 [&>*:not(:last-child)]:rounded-b-none";
+};
+type ButtonGroupOrientation = keyof typeof buttonGroupOrientationClasses;
+interface ButtonGroupProps extends React.ComponentProps<"div"> {
+    orientation?: ButtonGroupOrientation;
+}
+declare function ButtonGroup({ className, orientation, ...props }: ButtonGroupProps): React.JSX.Element;
+interface ButtonGroupTextProps extends React.ComponentProps<"div"> {
+    asChild?: boolean;
+}
+declare function ButtonGroupText({ className, asChild, ...props }: ButtonGroupTextProps): React.JSX.Element;
+declare function ButtonGroupSeparator({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+
+declare function Card({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardTitle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardDescription({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardAction({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+
+declare function Empty({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function EmptyHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare const emptyMediaVariants: {
+    readonly default: "bg-transparent";
+    readonly icon: "bg-muted text-foreground flex size-10 shrink-0 items-center justify-center rounded-lg [&_svg:not([class*='size-'])]:size-6";
+};
+type EmptyMediaVariant = keyof typeof emptyMediaVariants;
+interface EmptyMediaProps extends React.ComponentProps<"div"> {
+    variant?: EmptyMediaVariant;
+}
+declare function EmptyMedia({ className, variant, ...props }: EmptyMediaProps): React.JSX.Element;
+declare function EmptyTitle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function EmptyDescription({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function EmptyContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+
+declare function Label({ className, ...props }: React.ComponentProps<"label">): React.JSX.Element;
+
+declare const fieldOrientation: {
+    readonly vertical: "flex-col [&>*]:w-full [&>.sr-only]:w-auto";
+    readonly horizontal: string;
+    readonly responsive: string;
+};
+type FieldOrientation = keyof typeof fieldOrientation;
+declare function FieldSet({ className, ...props }: React.ComponentProps<"fieldset">): React.JSX.Element;
+declare function FieldLegend({ className, variant, ...props }: React.ComponentProps<"legend"> & {
+    variant?: "legend" | "label";
+}): React.JSX.Element;
+declare function FieldGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function Field({ className, orientation, ...props }: React.ComponentProps<"div"> & {
+    orientation?: FieldOrientation;
+}): React.JSX.Element;
+declare function FieldContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function FieldLabel({ className, ...props }: React.ComponentProps<typeof Label>): React.JSX.Element;
+declare function FieldTitle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function FieldDescription({ className, ...props }: React.ComponentProps<"p">): React.JSX.Element;
+declare function FieldSeparator({ children, className, ...props }: React.ComponentProps<"div"> & {
+    children?: React.ReactNode;
+}): React.JSX.Element;
+declare function FieldError({ className, children, errors, ...props }: React.ComponentProps<"div"> & {
+    errors?: Array<{
+        message?: string;
+    } | undefined>;
+}): React.JSX.Element | null;
+
+declare function Input({ className, type, ...props }: React.ComponentProps<"input">): React.JSX.Element;
+
+declare function Textarea({ className, ...props }: React.ComponentProps<"textarea">): React.JSX.Element;
+
+declare function InputGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare const inputGroupAddonAligns: {
+    readonly "inline-start": "order-first pl-3 has-[>button]:ml-[-0.45rem] has-[>kbd]:ml-[-0.35rem]";
+    readonly "inline-end": "order-last pr-3 has-[>button]:mr-[-0.45rem] has-[>kbd]:mr-[-0.35rem]";
+    readonly "block-start": "order-first w-full justify-start px-3 pt-3 [.border-b]:pb-3 group-has-[>input]/input-group:pt-2.5";
+    readonly "block-end": "order-last w-full justify-start px-3 pb-3 [.border-t]:pt-3 group-has-[>input]/input-group:pb-2.5";
+};
+type InputGroupAddonAlign = keyof typeof inputGroupAddonAligns;
+interface InputGroupAddonProps extends React.ComponentProps<"div"> {
+    align?: InputGroupAddonAlign;
+}
+declare function InputGroupAddon({ className, align, ...props }: InputGroupAddonProps): React.JSX.Element;
+declare const inputGroupButtonSizes: {
+    readonly xs: "h-6 gap-1 px-2 rounded-[calc(var(--radius)-5px)] [&>svg:not([class*='size-'])]:size-3.5 has-[>svg]:px-2";
+    readonly sm: "h-8 px-2.5 gap-1.5 rounded-md has-[>svg]:px-2.5";
+    readonly "icon-xs": "size-6 rounded-[calc(var(--radius)-5px)] p-0 has-[>svg]:p-0";
+    readonly "icon-sm": "size-8 p-0 has-[>svg]:p-0";
+};
+type InputGroupButtonSize = keyof typeof inputGroupButtonSizes;
+interface InputGroupButtonProps extends Omit<ButtonProps, "size"> {
+    size?: InputGroupButtonSize;
+}
+declare function InputGroupButton({ className, type, variant, size, ...props }: InputGroupButtonProps): React.JSX.Element;
+declare function InputGroupText({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+declare function InputGroupInput({ className, ...props }: React.ComponentProps<"input">): React.JSX.Element;
+declare function InputGroupTextarea({ className, ...props }: React.ComponentProps<"textarea">): React.JSX.Element;
+
+declare const separatorOrientations: {
+    readonly horizontal: "data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full";
+    readonly vertical: "data-[orientation=vertical]:h-full data-[orientation=vertical]:w-px";
+};
+type SeparatorOrientation = keyof typeof separatorOrientations;
+interface SeparatorProps extends React.ComponentProps<"div"> {
+    orientation?: SeparatorOrientation;
+}
+declare function Separator({ className, orientation, ...props }: SeparatorProps): React.JSX.Element;
+
+declare function ItemGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function ItemSeparator({ className, ...props }: React.ComponentProps<typeof Separator>): React.JSX.Element;
+declare const itemVariants: {
+    readonly default: "bg-transparent";
+    readonly outline: "border-border";
+    readonly muted: "bg-muted/50";
+};
+declare const itemSizes: {
+    readonly default: "p-4 gap-4 ";
+    readonly sm: "py-3 px-4 gap-2.5";
+};
+type ItemVariant = keyof typeof itemVariants;
+type ItemSize = keyof typeof itemSizes;
+interface ItemProps extends React.ComponentProps<"div"> {
+    variant?: ItemVariant;
+    size?: ItemSize;
+    asChild?: boolean;
+}
+declare function Item({ className, variant, size, asChild, ...props }: ItemProps): React.JSX.Element;
+declare const itemMediaVariants: {
+    readonly default: "bg-transparent";
+    readonly icon: "size-8 border rounded-sm bg-muted [&_svg:not([class*='size-'])]:size-4";
+    readonly image: "size-10 rounded-sm overflow-hidden [&_img]:size-full [&_img]:object-cover";
+};
+type ItemMediaVariant = keyof typeof itemMediaVariants;
+interface ItemMediaProps extends React.ComponentProps<"div"> {
+    variant?: ItemMediaVariant;
+}
+declare function ItemMedia({ className, variant, ...props }: ItemMediaProps): React.JSX.Element;
+declare function ItemContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function ItemTitle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function ItemDescription({ className, ...props }: React.ComponentProps<"p">): React.JSX.Element;
+declare function ItemActions({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function ItemHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function ItemFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+
+declare function Kbd({ className, ...props }: React.ComponentProps<"kbd">): React.JSX.Element;
+declare function KbdGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+
+declare function Pagination({ className, ...props }: React.ComponentProps<"nav">): React.JSX.Element;
+declare function PaginationContent({ className, ...props }: React.ComponentProps<"ul">): React.JSX.Element;
+declare function PaginationItem(props: React.ComponentProps<"li">): React.JSX.Element;
+type PaginationLinkProps = {
+    isActive?: boolean;
+    size?: ButtonSize;
+} & React.ComponentProps<"a">;
+declare function PaginationLink({ className, isActive, size, ...props }: PaginationLinkProps): React.JSX.Element;
+declare function PaginationPrevious({ className, ...props }: React.ComponentProps<typeof PaginationLink>): React.JSX.Element;
+declare function PaginationNext({ className, ...props }: React.ComponentProps<typeof PaginationLink>): React.JSX.Element;
+declare function PaginationEllipsis({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+
+interface ProgressProps extends React.ComponentProps<"div"> {
+    value?: number;
+}
+declare function Progress({ className, value, ...props }: ProgressProps): React.JSX.Element;
+
+declare function Skeleton({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+
+declare function Spinner({ className, ...props }: React.ComponentProps<"svg">): React.JSX.Element;
+
+declare function Table({ className, ...props }: React.ComponentProps<"table">): React.JSX.Element;
+declare function TableHeader({ className, ...props }: React.ComponentProps<"thead">): React.JSX.Element;
+declare function TableBody({ className, ...props }: React.ComponentProps<"tbody">): React.JSX.Element;
+declare function TableFooter({ className, ...props }: React.ComponentProps<"tfoot">): React.JSX.Element;
+declare function TableRow({ className, ...props }: React.ComponentProps<"tr">): React.JSX.Element;
+declare function TableHead({ className, ...props }: React.ComponentProps<"th">): React.JSX.Element;
+declare function TableCell({ className, ...props }: React.ComponentProps<"td">): React.JSX.Element;
+declare function TableCaption({ className, ...props }: React.ComponentProps<"caption">): React.JSX.Element;
+
+type AccordionType = "single" | "multiple";
+interface AccordionProps extends Omit<React.ComponentProps<"div">, "onChange"> {
+    type?: AccordionType;
+    collapsible?: boolean;
+    value?: string[];
+    defaultValue?: string[];
+    onValueChange?: (value: string[]) => void;
+}
+declare function Accordion({ type, collapsible, value, defaultValue, onValueChange, children, ...props }: AccordionProps): React.JSX.Element;
+interface AccordionItemProps extends React.ComponentProps<"div"> {
+    value: string;
+}
+declare function AccordionItem({ className, value, children, ...props }: AccordionItemProps): React.JSX.Element;
+declare function AccordionTrigger({ className, children, onClick, ...props }: React.ComponentProps<"button">): React.JSX.Element;
+declare function AccordionContent({ className, children, ...props }: React.ComponentProps<"div">): React.JSX.Element | null;
+
+interface CollapsibleProps extends React.ComponentProps<"div"> {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare function Collapsible({ open, defaultOpen, onOpenChange, children, ...props }: CollapsibleProps): React.JSX.Element;
+declare function CollapsibleTrigger({ onClick, ...props }: React.ComponentProps<"button">): React.JSX.Element;
+declare function CollapsibleContent({ children, ...props }: React.ComponentProps<"div">): React.JSX.Element | null;
+
+type TabsOrientation = "horizontal" | "vertical";
+interface TabsProps extends Omit<React.ComponentProps<"div">, "onChange"> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    orientation?: TabsOrientation;
+}
+declare function Tabs({ className, value, defaultValue, onValueChange, orientation, children, ...props }: TabsProps): React.JSX.Element;
+declare function TabsList({ className, children, onKeyDown, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+interface TabsTriggerInternal {
+    __index?: number;
+    __isFocusItem?: boolean;
+    __onFocusItem?: () => void;
+}
+interface TabsTriggerProps extends React.ComponentProps<"button">, TabsTriggerInternal {
+    value: string;
+}
+declare function TabsTrigger({ className, value, onClick, onFocus, __isFocusItem, __onFocusItem, ...props }: TabsTriggerProps): React.JSX.Element;
+interface TabsContentProps extends React.ComponentProps<"div"> {
+    value: string;
+}
+declare function TabsContent({ className, value, children, ...props }: TabsContentProps): React.JSX.Element | null;
+
+declare const toggleVariantClasses: {
+    readonly default: "bg-transparent";
+    readonly outline: "border border-input bg-transparent shadow-xs hover:bg-accent hover:text-accent-foreground";
+};
+declare const toggleSizeClasses: {
+    readonly default: "h-9 px-2 min-w-9";
+    readonly sm: "h-8 px-1.5 min-w-8";
+    readonly lg: "h-10 px-2.5 min-w-10";
+};
+type ToggleVariant = keyof typeof toggleVariantClasses;
+type ToggleSize = keyof typeof toggleSizeClasses;
+interface ToggleVariantsOptions {
+    variant?: ToggleVariant;
+    size?: ToggleSize;
+    className?: string;
+}
+/**
+ * Returns the fused canonical toggle class string. Reused by `toggle-group` so
+ * its items adopt the same styling, mirroring Rust's `toggle_classes`.
+ */
+declare function toggleVariants({ variant, size, className, }?: ToggleVariantsOptions): string;
+interface ToggleProps extends Omit<React.ComponentProps<"button">, "onChange"> {
+    variant?: ToggleVariant;
+    size?: ToggleSize;
+    pressed?: boolean;
+    defaultPressed?: boolean;
+    onPressedChange?: (pressed: boolean) => void;
+}
+declare function Toggle({ className, variant, size, pressed, defaultPressed, onPressedChange, onClick, ...props }: ToggleProps): React.JSX.Element;
+
+interface ToggleGroupProps extends Omit<React.ComponentProps<"div">, "onChange"> {
+    variant?: ToggleVariant;
+    size?: ToggleSize;
+    type?: "single" | "multiple";
+    value?: string | string[];
+    defaultValue?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+}
+declare function ToggleGroup({ className, variant, size, type, value, defaultValue, onValueChange, children, ...props }: ToggleGroupProps): React.JSX.Element;
+interface ToggleGroupItemProps extends Omit<React.ComponentProps<"button">, "value" | "onChange"> {
+    value: string;
+    variant?: ToggleVariant;
+    size?: ToggleSize;
+}
+declare function ToggleGroupItem({ className, children, value, variant, size, onClick, ...props }: ToggleGroupItemProps): React.JSX.Element;
+
+interface SwitchProps extends Omit<React.ComponentProps<"button">, "onChange"> {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+}
+declare function Switch({ className, checked, defaultChecked, onCheckedChange, onClick, disabled, ...props }: SwitchProps): React.JSX.Element;
+
+interface CheckboxProps extends Omit<React.ComponentProps<"button">, "onChange"> {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+}
+declare function Checkbox({ className, checked, defaultChecked, onCheckedChange, onClick, disabled, ...props }: CheckboxProps): React.JSX.Element;
+
+interface RadioGroupProps extends Omit<React.ComponentProps<"div">, "onChange"> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+}
+declare function RadioGroup({ className, value, defaultValue, onValueChange, children, onKeyDown, ...props }: RadioGroupProps): React.JSX.Element;
+interface RadioGroupItemProps extends Omit<React.ComponentProps<"button">, "value"> {
+    value: string;
+}
+declare function RadioGroupItem({ className, value, disabled, onClick, ...props }: RadioGroupItemProps): React.JSX.Element;
+
+type Orientation = "horizontal" | "vertical";
+interface SliderProps extends Omit<React.ComponentProps<"span">, "defaultValue" | "onChange"> {
+    value?: number;
+    defaultValue?: number;
+    onValueChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    orientation?: Orientation;
+    disabled?: boolean;
+}
+declare function Slider({ className, value, defaultValue, onValueChange, min, max, step, orientation, disabled, ...props }: SliderProps): React.JSX.Element;
+
+declare function ScrollArea({ className, children, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+interface ScrollBarProps extends React.ComponentProps<"div"> {
+    orientation?: "vertical" | "horizontal";
+}
+declare function ScrollBar({ className, orientation, ...props }: ScrollBarProps): React.JSX.Element;
+
+interface SidebarContextValue {
+    state: "expanded" | "collapsed";
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    toggleSidebar: () => void;
+}
+declare function useSidebar(): SidebarContextValue;
+interface SidebarProviderProps extends React.ComponentProps<"div"> {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare function SidebarProvider({ defaultOpen, open: openProp, onOpenChange, className, style, children, ...props }: SidebarProviderProps): React.JSX.Element;
+interface SidebarProps extends React.ComponentProps<"div"> {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+}
+declare function Sidebar({ side, variant, collapsible, className, children, ...props }: SidebarProps): React.JSX.Element;
+declare function SidebarTrigger({ className, onClick, children, ...props }: React.ComponentProps<"button">): React.JSX.Element;
+declare function SidebarRail({ className, ...props }: React.ComponentProps<"button">): React.JSX.Element;
+declare function SidebarInset({ className, ...props }: React.ComponentProps<"main">): React.JSX.Element;
+declare function SidebarHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarSeparator({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+interface SidebarGroupLabelProps extends React.ComponentProps<"div"> {
+    asChild?: boolean;
+}
+declare function SidebarGroupLabel({ className, asChild, ...props }: SidebarGroupLabelProps): React.JSX.Element;
+declare function SidebarGroupContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarMenu({ className, ...props }: React.ComponentProps<"ul">): React.JSX.Element;
+declare function SidebarMenuItem({ className, ...props }: React.ComponentProps<"li">): React.JSX.Element;
+declare const sidebarMenuButtonVariantClasses: {
+    readonly default: "hover:bg-sidebar-accent hover:text-sidebar-accent-foreground";
+    readonly outline: "bg-background shadow-[0_0_0_1px_hsl(var(--sidebar-border))] hover:bg-sidebar-accent hover:text-sidebar-accent-foreground hover:shadow-[0_0_0_1px_hsl(var(--sidebar-accent))]";
+};
+declare const sidebarMenuButtonSizeClasses: {
+    readonly default: "h-8 text-sm";
+    readonly sm: "h-7 text-xs";
+    readonly lg: "h-12 text-sm group-data-[collapsible=icon]:p-0!";
+};
+type SidebarMenuButtonVariant = keyof typeof sidebarMenuButtonVariantClasses;
+type SidebarMenuButtonSize = keyof typeof sidebarMenuButtonSizeClasses;
+interface SidebarMenuButtonProps extends React.ComponentProps<"button"> {
+    asChild?: boolean;
+    isActive?: boolean;
+    variant?: SidebarMenuButtonVariant;
+    size?: SidebarMenuButtonSize;
+}
+declare function SidebarMenuButton({ asChild, isActive, variant, size, className, ...props }: SidebarMenuButtonProps): React.JSX.Element;
+
+type CarouselOrientation = "horizontal" | "vertical";
+interface CarouselProps extends React.ComponentProps<"div"> {
+    orientation?: CarouselOrientation;
+    index?: number;
+    defaultIndex?: number;
+    onIndexChange?: (index: number) => void;
+}
+declare function Carousel({ orientation, index: indexProp, defaultIndex, onIndexChange, className, children, onKeyDown, ...props }: CarouselProps): React.JSX.Element;
+declare function CarouselContent({ className, children, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CarouselItem({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CarouselPrevious({ className, variant, size, ...props }: ButtonProps): React.JSX.Element;
+declare function CarouselNext({ className, variant, size, ...props }: ButtonProps): React.JSX.Element;
+
+interface InputOTPProps extends Omit<React.ComponentProps<"input">, "value" | "defaultValue" | "onChange"> {
+    maxLength: number;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    containerClassName?: string;
+    children?: React.ReactNode;
+}
+declare function InputOTP({ maxLength, value: valueProp, defaultValue, onChange, className, containerClassName, children, disabled, ...props }: InputOTPProps): React.JSX.Element;
+declare function InputOTPGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+interface InputOTPSlotProps extends React.ComponentProps<"div"> {
+    index: number;
+}
+declare function InputOTPSlot({ index, className, ...props }: InputOTPSlotProps): React.JSX.Element;
+declare function InputOTPSeparator({ ...props }: React.ComponentProps<"div">): React.JSX.Element;
+
+interface TooltipProviderProps {
+    children?: React.ReactNode;
+}
+declare function TooltipProvider({ children }: TooltipProviderProps): React.JSX.Element;
+interface TooltipProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+declare function Tooltip({ open, defaultOpen, onOpenChange, children }: TooltipProps): React.JSX.Element;
+interface TooltipTriggerProps extends React.ComponentProps<"button"> {
+    asChild?: boolean;
+}
+declare function TooltipTrigger({ asChild, onPointerEnter, onPointerLeave, onFocus, onBlur, ...props }: TooltipTriggerProps): React.JSX.Element;
+interface TooltipContentProps extends React.ComponentProps<"div"> {
+    side?: "top" | "right" | "bottom" | "left";
+    sideOffset?: number;
+}
+declare function TooltipContent({ className, side: sideProp, sideOffset, children, ...props }: TooltipContentProps): React.JSX.Element | null;
+
+interface PopoverProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+declare function Popover({ open, defaultOpen, onOpenChange, children }: PopoverProps): React.JSX.Element;
+interface PopoverTriggerProps extends React.ComponentProps<"button"> {
+    asChild?: boolean;
+}
+declare function PopoverTrigger({ asChild, onClick, ...props }: PopoverTriggerProps): React.JSX.Element;
+interface PopoverAnchorProps extends React.ComponentProps<"div"> {
+    asChild?: boolean;
+}
+declare function PopoverAnchor({ asChild, ...props }: PopoverAnchorProps): React.JSX.Element;
+interface PopoverContentProps extends React.ComponentProps<"div"> {
+    side?: "top" | "right" | "bottom" | "left";
+    align?: "start" | "center" | "end";
+    sideOffset?: number;
+}
+declare function PopoverContent({ className, side: sideProp, align, sideOffset, children, ...props }: PopoverContentProps): React.JSX.Element | null;
+
+interface HoverCardProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+declare function HoverCard({ open, defaultOpen, onOpenChange, children }: HoverCardProps): React.JSX.Element;
+interface HoverCardTriggerProps extends React.ComponentProps<"a"> {
+    asChild?: boolean;
+}
+declare function HoverCardTrigger({ asChild, onPointerEnter, onPointerLeave, ...props }: HoverCardTriggerProps): React.JSX.Element;
+interface HoverCardContentProps extends React.ComponentProps<"div"> {
+    side?: "top" | "right" | "bottom" | "left";
+    align?: "start" | "center" | "end";
+    sideOffset?: number;
+}
+declare function HoverCardContent({ className, side: sideProp, align, sideOffset, children, ...props }: HoverCardContentProps): React.JSX.Element | null;
+
+interface DropdownMenuProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+declare function DropdownMenu({ open, defaultOpen, onOpenChange, children }: DropdownMenuProps): React.JSX.Element;
+declare function DropdownMenuPortal({ children }: {
+    children?: React.ReactNode;
+}): React.JSX.Element;
+interface DropdownMenuTriggerProps extends React.ComponentProps<"button"> {
+    asChild?: boolean;
+}
+declare function DropdownMenuTrigger({ asChild, onClick, ...props }: DropdownMenuTriggerProps): React.JSX.Element;
+interface DropdownMenuContentProps extends React.ComponentProps<"div"> {
+    sideOffset?: number;
+}
+declare function DropdownMenuContent({ className, sideOffset, children, ...props }: DropdownMenuContentProps): React.JSX.Element | null;
+declare function DropdownMenuGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+interface DropdownMenuItemProps extends React.ComponentProps<"div"> {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+    disabled?: boolean;
+}
+declare function DropdownMenuItem({ className, inset, variant, disabled, onClick, onKeyDown, ...props }: DropdownMenuItemProps): React.JSX.Element;
+interface DropdownMenuCheckboxItemProps extends React.ComponentProps<"div"> {
+    checked?: boolean;
+    disabled?: boolean;
+}
+declare function DropdownMenuCheckboxItem({ className, children, checked, disabled, onClick, ...props }: DropdownMenuCheckboxItemProps): React.JSX.Element;
+interface DropdownMenuRadioGroupProps extends Omit<React.ComponentProps<"div">, "onChange"> {
+    value?: string;
+    onValueChange?: (value: string) => void;
+}
+declare function DropdownMenuRadioGroup({ className, value, onValueChange, children, ...props }: DropdownMenuRadioGroupProps): React.JSX.Element;
+interface DropdownMenuRadioItemProps extends React.ComponentProps<"div"> {
+    value: string;
+    disabled?: boolean;
+}
+declare function DropdownMenuRadioItem({ className, children, value, disabled, onClick, ...props }: DropdownMenuRadioItemProps): React.JSX.Element;
+interface DropdownMenuLabelProps extends React.ComponentProps<"div"> {
+    inset?: boolean;
+}
+declare function DropdownMenuLabel({ className, inset, ...props }: DropdownMenuLabelProps): React.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+interface DropdownMenuSubProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+declare function DropdownMenuSub({ open, defaultOpen, onOpenChange, children }: DropdownMenuSubProps): React.JSX.Element;
+interface DropdownMenuSubTriggerProps extends React.ComponentProps<"div"> {
+    inset?: boolean;
+}
+declare function DropdownMenuSubTrigger({ className, inset, children, onClick, ...props }: DropdownMenuSubTriggerProps): React.JSX.Element;
+declare function DropdownMenuSubContent({ className, children, ...props }: React.ComponentProps<"div">): React.JSX.Element | null;
+
+interface ContextMenuProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+declare function ContextMenu({ open, defaultOpen, onOpenChange, children }: ContextMenuProps): React.JSX.Element;
+declare function ContextMenuPortal({ children }: {
+    children?: React.ReactNode;
+}): React.JSX.Element;
+interface ContextMenuTriggerProps extends React.ComponentProps<"div"> {
+    asChild?: boolean;
+}
+declare function ContextMenuTrigger({ asChild, onContextMenu, ...props }: ContextMenuTriggerProps): React.JSX.Element;
+declare function ContextMenuGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function ContextMenuContent({ className, children, ...props }: React.ComponentProps<"div">): React.JSX.Element | null;
+interface ContextMenuItemProps extends React.ComponentProps<"div"> {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+    disabled?: boolean;
+}
+declare function ContextMenuItem({ className, inset, variant, disabled, onClick, onKeyDown, ...props }: ContextMenuItemProps): React.JSX.Element;
+interface ContextMenuCheckboxItemProps extends React.ComponentProps<"div"> {
+    checked?: boolean;
+    disabled?: boolean;
+}
+declare function ContextMenuCheckboxItem({ className, children, checked, disabled, onClick, ...props }: ContextMenuCheckboxItemProps): React.JSX.Element;
+interface ContextMenuRadioGroupProps extends Omit<React.ComponentProps<"div">, "onChange"> {
+    value?: string;
+    onValueChange?: (value: string) => void;
+}
+declare function ContextMenuRadioGroup({ className, value, onValueChange, children, ...props }: ContextMenuRadioGroupProps): React.JSX.Element;
+interface ContextMenuRadioItemProps extends React.ComponentProps<"div"> {
+    value: string;
+    disabled?: boolean;
+}
+declare function ContextMenuRadioItem({ className, children, value, disabled, onClick, ...props }: ContextMenuRadioItemProps): React.JSX.Element;
+interface ContextMenuLabelProps extends React.ComponentProps<"div"> {
+    inset?: boolean;
+}
+declare function ContextMenuLabel({ className, inset, ...props }: ContextMenuLabelProps): React.JSX.Element;
+declare function ContextMenuSeparator({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function ContextMenuShortcut({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+interface ContextMenuSubProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+declare function ContextMenuSub({ open, defaultOpen, onOpenChange, children }: ContextMenuSubProps): React.JSX.Element;
+interface ContextMenuSubTriggerProps extends React.ComponentProps<"div"> {
+    inset?: boolean;
+}
+declare function ContextMenuSubTrigger({ className, inset, children, onClick, ...props }: ContextMenuSubTriggerProps): React.JSX.Element;
+declare function ContextMenuSubContent({ className, children, ...props }: React.ComponentProps<"div">): React.JSX.Element | null;
+
+declare function Menubar({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+interface MenubarMenuProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+declare function MenubarMenu({ open, defaultOpen, onOpenChange, children }: MenubarMenuProps): React.JSX.Element;
+declare function MenubarTrigger({ className, onClick, ...props }: React.ComponentProps<"button">): React.JSX.Element;
+declare function MenubarContent({ className, children, align, ...props }: React.ComponentProps<"div"> & {
+    align?: "start" | "center" | "end";
+}): React.JSX.Element | null;
+declare function MenubarGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function MenubarItem({ className, inset, variant, ...props }: React.ComponentProps<"div"> & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): React.JSX.Element;
+declare function MenubarCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<"div"> & {
+    checked?: boolean;
+}): React.JSX.Element;
+interface MenubarRadioGroupProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    className?: string;
+    children?: React.ReactNode;
+}
+declare function MenubarRadioGroup({ value, defaultValue, onValueChange, className, children, }: MenubarRadioGroupProps): React.JSX.Element;
+declare function MenubarRadioItem({ className, children, value, ...props }: React.ComponentProps<"div"> & {
+    value: string;
+}): React.JSX.Element;
+declare function MenubarLabel({ className, inset, ...props }: React.ComponentProps<"div"> & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function MenubarSeparator({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function MenubarShortcut({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+interface MenubarSubProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+declare function MenubarSub({ open, defaultOpen, onOpenChange, children }: MenubarSubProps): React.JSX.Element;
+declare function MenubarSubTrigger({ className, inset, children, onClick, ...props }: React.ComponentProps<"div"> & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function MenubarSubContent({ className, children, ...props }: React.ComponentProps<"div">): React.JSX.Element | null;
+
+/**
+ * Fused canonical trigger class string, the mirror of Rust's
+ * `navigation_menu_trigger_style()`. Reuse it to style a plain link the same way
+ * a `NavigationMenuTrigger` is styled.
+ */
+declare function navigationMenuTriggerStyle(): string;
+declare function NavigationMenu({ className, children, viewport, ...props }: React.ComponentProps<"nav"> & {
+    viewport?: boolean;
+}): React.JSX.Element;
+declare function NavigationMenuList({ className, ...props }: React.ComponentProps<"ul">): React.JSX.Element;
+interface NavigationMenuItemProps extends React.ComponentProps<"li"> {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare function NavigationMenuItem({ className, open, defaultOpen, onOpenChange, children, ...props }: NavigationMenuItemProps): React.JSX.Element;
+declare function NavigationMenuTrigger({ className, children, onClick, ...props }: React.ComponentProps<"button">): React.JSX.Element;
+declare function NavigationMenuContent({ className, children, ...props }: React.ComponentProps<"div">): React.JSX.Element | null;
+declare function NavigationMenuViewport({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function NavigationMenuLink({ className, asChild, ...props }: React.ComponentProps<"a"> & {
+    asChild?: boolean;
+}): React.JSX.Element;
+declare function NavigationMenuIndicator({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+
+interface DialogProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+declare function Dialog({ open, defaultOpen, onOpenChange, children }: DialogProps): React.JSX.Element;
+interface DialogTriggerProps extends React.ComponentProps<"button"> {
+    asChild?: boolean;
+}
+declare function DialogTrigger({ asChild, onClick, ...props }: DialogTriggerProps): React.JSX.Element;
+type DialogPortalProps = {
+    children?: React.ReactNode;
+};
+declare function DialogPortal({ children }: DialogPortalProps): React.JSX.Element;
+interface DialogOverlayProps extends React.ComponentProps<"div"> {
+}
+declare function DialogOverlay({ className, ...props }: DialogOverlayProps): React.JSX.Element;
+interface DialogContentProps extends React.ComponentProps<"div"> {
+    showCloseButton?: boolean;
+}
+declare function DialogContent({ className, children, showCloseButton, ...props }: DialogContentProps): React.JSX.Element | null;
+interface DialogCloseProps extends React.ComponentProps<"button"> {
+    asChild?: boolean;
+}
+declare function DialogClose({ asChild, onClick, ...props }: DialogCloseProps): React.JSX.Element;
+declare function DialogHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DialogFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DialogTitle({ className, ...props }: React.ComponentProps<"h2">): React.JSX.Element;
+declare function DialogDescription({ className, ...props }: React.ComponentProps<"p">): React.JSX.Element;
+
+interface AlertDialogProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+declare function AlertDialog({ open, defaultOpen, onOpenChange, children }: AlertDialogProps): React.JSX.Element;
+interface AlertDialogTriggerProps extends React.ComponentProps<"button"> {
+    asChild?: boolean;
+}
+declare function AlertDialogTrigger({ asChild, onClick, ...props }: AlertDialogTriggerProps): React.JSX.Element;
+interface AlertDialogOverlayProps extends React.ComponentProps<"div"> {
+}
+declare function AlertDialogOverlay({ className, ...props }: AlertDialogOverlayProps): React.JSX.Element;
+interface AlertDialogContentProps extends React.ComponentProps<"div"> {
+}
+declare function AlertDialogContent({ className, children, ...props }: AlertDialogContentProps): React.JSX.Element | null;
+declare function AlertDialogHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function AlertDialogFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function AlertDialogTitle({ className, ...props }: React.ComponentProps<"h2">): React.JSX.Element;
+declare function AlertDialogDescription({ className, ...props }: React.ComponentProps<"p">): React.JSX.Element;
+interface AlertDialogActionProps extends React.ComponentProps<"button"> {
+}
+declare function AlertDialogAction({ className, onClick, ...props }: AlertDialogActionProps): React.JSX.Element;
+interface AlertDialogCancelProps extends React.ComponentProps<"button"> {
+}
+declare function AlertDialogCancel({ className, onClick, ...props }: AlertDialogCancelProps): React.JSX.Element;
+
+interface SheetProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+declare function Sheet({ open, defaultOpen, onOpenChange, children }: SheetProps): React.JSX.Element;
+interface SheetTriggerProps extends React.ComponentProps<"button"> {
+    asChild?: boolean;
+}
+declare function SheetTrigger({ asChild, onClick, ...props }: SheetTriggerProps): React.JSX.Element;
+interface SheetOverlayProps extends React.ComponentProps<"div"> {
+}
+declare function SheetOverlay({ className, ...props }: SheetOverlayProps): React.JSX.Element;
+interface SheetContentProps extends React.ComponentProps<"div"> {
+    side?: "top" | "right" | "bottom" | "left";
+}
+declare function SheetContent({ className, children, side, ...props }: SheetContentProps): React.JSX.Element | null;
+interface SheetCloseProps extends React.ComponentProps<"button"> {
+    asChild?: boolean;
+}
+declare function SheetClose({ asChild, onClick, ...props }: SheetCloseProps): React.JSX.Element;
+declare function SheetHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SheetFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SheetTitle({ className, ...props }: React.ComponentProps<"h2">): React.JSX.Element;
+declare function SheetDescription({ className, ...props }: React.ComponentProps<"p">): React.JSX.Element;
+
+type DrawerDirection = "top" | "bottom" | "left" | "right";
+interface DrawerProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    direction?: DrawerDirection;
+    children?: React.ReactNode;
+}
+declare function Drawer({ open, defaultOpen, onOpenChange, direction, children, }: DrawerProps): React.JSX.Element;
+interface DrawerTriggerProps extends React.ComponentProps<"button"> {
+    asChild?: boolean;
+}
+declare function DrawerTrigger({ asChild, onClick, ...props }: DrawerTriggerProps): React.JSX.Element;
+interface DrawerCloseProps extends React.ComponentProps<"button"> {
+    asChild?: boolean;
+}
+declare function DrawerClose({ asChild, onClick, ...props }: DrawerCloseProps): React.JSX.Element;
+declare function DrawerOverlay({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element | null;
+declare function DrawerContent({ className, children, ...props }: React.ComponentProps<"div">): React.JSX.Element | null;
+declare function DrawerHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DrawerFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DrawerTitle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DrawerDescription({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+
+interface SelectProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+declare function Select({ value, defaultValue, onValueChange, open, defaultOpen, onOpenChange, children, }: SelectProps): React.JSX.Element;
+interface SelectTriggerProps extends React.ComponentProps<"button"> {
+    size?: "sm" | "default";
+}
+declare function SelectTrigger({ className, size, onClick, children, ...props }: SelectTriggerProps): React.JSX.Element;
+interface SelectValueProps extends React.ComponentProps<"span"> {
+    placeholder?: string;
+}
+declare function SelectValue({ className, placeholder, ...props }: SelectValueProps): React.JSX.Element;
+interface SelectContentProps extends React.ComponentProps<"div"> {
+    side?: "top" | "right" | "bottom" | "left";
+    align?: "start" | "center" | "end";
+    sideOffset?: number;
+}
+declare function SelectContent({ className, side: sideProp, align, sideOffset, children, ...props }: SelectContentProps): React.JSX.Element | null;
+interface SelectItemContext {
+    __index?: number;
+    __active?: boolean;
+    __setActive?: (i: number) => void;
+}
+interface SelectItemProps extends React.ComponentProps<"div">, SelectItemContext {
+    value: string;
+}
+declare function SelectItem({ className, value, children, __index, __active, __setActive, ...props }: SelectItemProps): React.JSX.Element;
+declare function SelectGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SelectLabel({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SelectSeparator({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+
+interface CommandProps extends React.ComponentProps<"div"> {
+    search?: string;
+    defaultSearch?: string;
+    onSearchChange?: (search: string) => void;
+}
+declare function Command({ className, search, defaultSearch, onSearchChange, children, ...props }: CommandProps): React.JSX.Element;
+interface CommandDialogProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    className?: string;
+    children?: React.ReactNode;
+}
+declare function CommandDialog({ open, defaultOpen, onOpenChange, className, children, }: CommandDialogProps): React.JSX.Element | null;
+declare function CommandInput({ className, ...props }: React.ComponentProps<"input">): React.JSX.Element;
+declare function CommandList({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CommandEmpty({ className, children, ...props }: React.ComponentProps<"div">): React.JSX.Element | null;
+interface CommandGroupProps extends React.ComponentProps<"div"> {
+    heading?: string;
+}
+declare function CommandGroup({ className, heading, children, ...props }: CommandGroupProps): React.JSX.Element;
+interface CommandItemProps extends Omit<React.ComponentProps<"div">, "onSelect"> {
+    value: string;
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+}
+declare function CommandItem({ className, value, disabled, onSelect, children, ...props }: CommandItemProps): React.JSX.Element | null;
+declare function CommandSeparator({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CommandShortcut({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+
+type ChartConfig = {
+    [k in string]: {
+        label?: React.ReactNode;
+        color?: string;
+    };
+};
+declare function ChartContainer({ id, className, children, config, ...props }: React.ComponentProps<"div"> & {
+    config: ChartConfig;
+}): React.JSX.Element;
+declare const ChartStyle: ({ id, config }: {
+    id: string;
+    config: ChartConfig;
+}) => React.JSX.Element | null;
+type ChartItem = {
+    label?: React.ReactNode;
+    value?: React.ReactNode;
+    color?: string;
+};
+declare const ChartTooltip: ({ children }: {
+    children?: React.ReactNode;
+}) => React.JSX.Element;
+declare function ChartTooltipContent({ className, items, label, hideLabel, hideIndicator, labelClassName, }: React.ComponentProps<"div"> & {
+    items?: ChartItem[];
+    label?: React.ReactNode;
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    labelClassName?: string;
+}): React.JSX.Element | null;
+declare const ChartLegend: ({ children }: {
+    children?: React.ReactNode;
+}) => React.JSX.Element;
+declare function ChartLegendContent({ className, hideIcon, items, }: React.ComponentProps<"div"> & {
+    hideIcon?: boolean;
+    items?: ChartItem[];
+}): React.JSX.Element | null;
+
+interface CalendarProps {
+    /** The currently selected day, if any. */
+    selected?: Date;
+    /** Fired with the day a user activates. */
+    onSelect?: (date: Date) => void;
+    /** Controlled displayed month (any day in it is fine). */
+    month?: Date;
+    /** Uncontrolled initial displayed month. */
+    defaultMonth?: Date;
+    /** Fired when the displayed month changes via the nav buttons. */
+    onMonthChange?: (month: Date) => void;
+    /** "Today", highlighted in the grid; defaults to the real current date. */
+    today?: Date;
+    className?: string;
+}
+/**
+ * A dep-light single-month, single-date picker. Mirrors the landing `Calendar`'s
+ * class names while replacing `react-day-picker` with a hand-rolled month grid.
+ * Uses the built-in `Date` (a language built-in, not a dependency) for the date
+ * math; the Rust mirror does the same math by hand.
+ *
+ * Simplifications versus the source: one month only (no multi-month), a single
+ * selected date (no range/multi), and none of the locale/dropdown/caption
+ * features — see the package README.
+ */
+declare function Calendar({ selected, onSelect, month, defaultMonth, onMonthChange, today, className, }: CalendarProps): React.JSX.Element;
+
+type ToastVariant = "default" | "success" | "error" | "info" | "warning";
+type ToastPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right";
+interface ToastOptions {
+    description?: React.ReactNode;
+    duration?: number;
+    variant?: ToastVariant;
+}
+interface Toast {
+    id: number;
+    message: React.ReactNode;
+    description?: React.ReactNode;
+    duration: number;
+    variant: ToastVariant;
+}
+interface ToastFn {
+    (message: React.ReactNode, opts?: ToastOptions): number;
+    success: (message: React.ReactNode, opts?: ToastOptions) => number;
+    error: (message: React.ReactNode, opts?: ToastOptions) => number;
+    info: (message: React.ReactNode, opts?: ToastOptions) => number;
+    warning: (message: React.ReactNode, opts?: ToastOptions) => number;
+    dismiss: (id: number) => void;
+}
+/**
+ * Global toast handle. `toast(msg)` enqueues a neutral toast; the `.success`,
+ * `.error`, `.info` and `.warning` helpers pin the variant; `toast.dismiss(id)`
+ * removes one early. Mirrors Rust's `use_toaster()` handle methods.
+ */
+declare const toast: ToastFn;
+interface ToasterProps extends React.ComponentProps<"ol"> {
+    position?: ToastPosition;
+}
+/**
+ * Renders the live toast stack from the module store. Fixed-positioned per
+ * `position` (default `bottom-right`); each toast auto-dismisses after its
+ * `duration` (default 4000ms) via `setTimeout`. Single dark palette — no theme
+ * switching (the upstream `next-themes` dependency is dropped).
+ */
+declare function Toaster({ position, className, ...props }: ToasterProps): React.JSX.Element;
+
+declare function Form({ ...props }: React.ComponentProps<"form">): React.JSX.Element;
+declare function FormItem({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function FormLabel({ className, error, ...props }: React.ComponentProps<typeof Label> & {
+    error?: boolean;
+}): React.JSX.Element;
+declare function FormControl({ error, ...props }: React.ComponentProps<typeof Slot> & {
+    error?: boolean;
+}): React.JSX.Element;
+declare function FormDescription({ className, ...props }: React.ComponentProps<"p">): React.JSX.Element;
+declare function FormMessage({ className, children, ...props }: React.ComponentProps<"p">): React.JSX.Element | null;
+
+type ResizableDirection = "horizontal" | "vertical";
+interface ResizablePanelGroupProps extends React.ComponentProps<"div"> {
+    direction?: ResizableDirection;
+    keyboardStep?: number;
+    onLayout?: (sizes: number[]) => void;
+}
+declare function ResizablePanelGroup({ className, direction, keyboardStep, onLayout, children, ...props }: ResizablePanelGroupProps): React.JSX.Element;
+interface ResizablePanelProps extends React.ComponentProps<"div"> {
+    index: number;
+    defaultSize?: number;
+}
+declare function ResizablePanel({ className, index, defaultSize, style, children, ...props }: ResizablePanelProps): React.JSX.Element;
+interface ResizableHandleProps extends React.ComponentProps<"div"> {
+    index: number;
+    withHandle?: boolean;
+}
+declare function ResizableHandle({ className, index, withHandle, children, ...props }: ResizableHandleProps): React.JSX.Element;
+
+export { Accordion, AccordionContent, AccordionItem, type AccordionItemProps, type AccordionProps, AccordionTrigger, Alert, AlertDescription, AlertDialog, AlertDialogAction, type AlertDialogActionProps, AlertDialogCancel, type AlertDialogCancelProps, AlertDialogContent, type AlertDialogContentProps, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogOverlay, type AlertDialogOverlayProps, type AlertDialogProps, AlertDialogTitle, AlertDialogTrigger, type AlertDialogTriggerProps, type AlertProps, AlertTitle, type AlertVariant, type Align, AspectRatio, type AspectRatioProps, Avatar, AvatarFallback, AvatarImage, Badge, type BadgeProps, type BadgeVariant, Breadcrumb, BreadcrumbEllipsis, BreadcrumbItem, BreadcrumbLink, type BreadcrumbLinkProps, BreadcrumbList, BreadcrumbPage, BreadcrumbSeparator, Button, ButtonGroup, type ButtonGroupOrientation, type ButtonGroupProps, ButtonGroupSeparator, ButtonGroupText, type ButtonGroupTextProps, type ButtonProps, type ButtonSize, type ButtonVariant, type ButtonVariantsOptions, Calendar, type CalendarProps, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Carousel, CarouselContent, CarouselItem, CarouselNext, CarouselPrevious, type CarouselProps, type ChartConfig, ChartContainer, type ChartItem, ChartLegend, ChartLegendContent, ChartStyle, ChartTooltip, ChartTooltipContent, Checkbox, type CheckboxProps, Collapsible, CollapsibleContent, type CollapsibleProps, CollapsibleTrigger, Command, CommandDialog, type CommandDialogProps, CommandEmpty, CommandGroup, type CommandGroupProps, CommandInput, CommandItem, type CommandItemProps, CommandList, type CommandProps, CommandSeparator, CommandShortcut, ContextMenu, ContextMenuCheckboxItem, type ContextMenuCheckboxItemProps, ContextMenuContent, ContextMenuGroup, ContextMenuItem, type ContextMenuItemProps, ContextMenuLabel, type ContextMenuLabelProps, ContextMenuPortal, type ContextMenuProps, ContextMenuRadioGroup, type ContextMenuRadioGroupProps, ContextMenuRadioItem, type ContextMenuRadioItemProps, ContextMenuSeparator, ContextMenuShortcut, ContextMenuSub, ContextMenuSubContent, type ContextMenuSubProps, ContextMenuSubTrigger, type ContextMenuSubTriggerProps, ContextMenuTrigger, type ContextMenuTriggerProps, Dialog, DialogClose, type DialogCloseProps, DialogContent, type DialogContentProps, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, type DialogOverlayProps, DialogPortal, type DialogPortalProps, type DialogProps, DialogTitle, DialogTrigger, type DialogTriggerProps, Drawer, DrawerClose, type DrawerCloseProps, DrawerContent, DrawerDescription, DrawerFooter, DrawerHeader, DrawerOverlay, type DrawerProps, DrawerTitle, DrawerTrigger, type DrawerTriggerProps, DropdownMenu, DropdownMenuCheckboxItem, type DropdownMenuCheckboxItemProps, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuGroup, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, type DropdownMenuLabelProps, DropdownMenuPortal, type DropdownMenuProps, DropdownMenuRadioGroup, type DropdownMenuRadioGroupProps, DropdownMenuRadioItem, type DropdownMenuRadioItemProps, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, type DropdownMenuSubProps, DropdownMenuSubTrigger, type DropdownMenuSubTriggerProps, DropdownMenuTrigger, type DropdownMenuTriggerProps, Empty, EmptyContent, EmptyDescription, EmptyHeader, EmptyMedia, type EmptyMediaProps, type EmptyMediaVariant, EmptyTitle, Field, FieldContent, FieldDescription, FieldError, FieldGroup, FieldLabel, FieldLegend, type FieldOrientation, FieldSeparator, FieldSet, FieldTitle, type FloatingResult, Form, FormControl, FormDescription, FormItem, FormLabel, FormMessage, HoverCard, HoverCardContent, type HoverCardContentProps, type HoverCardProps, HoverCardTrigger, type HoverCardTriggerProps, Input, InputGroup, InputGroupAddon, type InputGroupAddonAlign, type InputGroupAddonProps, InputGroupButton, type InputGroupButtonProps, type InputGroupButtonSize, InputGroupInput, InputGroupText, InputGroupTextarea, InputOTP, InputOTPGroup, type InputOTPProps, InputOTPSeparator, InputOTPSlot, type InputOTPSlotProps, Item, ItemActions, ItemContent, ItemDescription, ItemFooter, ItemGroup, ItemHeader, ItemMedia, type ItemMediaProps, type ItemMediaVariant, type ItemProps, ItemSeparator, type ItemSize, ItemTitle, type ItemVariant, Kbd, KbdGroup, Label, Menubar, MenubarCheckboxItem, MenubarContent, MenubarGroup, MenubarItem, MenubarLabel, MenubarMenu, type MenubarMenuProps, MenubarRadioGroup, type MenubarRadioGroupProps, MenubarRadioItem, MenubarSeparator, MenubarShortcut, MenubarSub, MenubarSubContent, type MenubarSubProps, MenubarSubTrigger, MenubarTrigger, NavigationMenu, NavigationMenuContent, NavigationMenuIndicator, NavigationMenuItem, type NavigationMenuItemProps, NavigationMenuLink, NavigationMenuList, NavigationMenuTrigger, NavigationMenuViewport, Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, type PaginationLinkProps, PaginationNext, PaginationPrevious, Popover, PopoverAnchor, type PopoverAnchorProps, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type PopoverTriggerProps, Portal, type PortalProps, Progress, type ProgressProps, RadioGroup, RadioGroupItem, type RadioGroupItemProps, type RadioGroupProps, type ResizableDirection, ResizableHandle, type ResizableHandleProps, ResizablePanel, ResizablePanelGroup, type ResizablePanelGroupProps, type ResizablePanelProps, ScrollArea, ScrollBar, type ScrollBarProps, Select, SelectContent, type SelectContentProps, SelectGroup, SelectItem, type SelectItemProps, SelectLabel, type SelectProps, SelectSeparator, SelectTrigger, type SelectTriggerProps, SelectValue, type SelectValueProps, Separator, type SeparatorOrientation, type SeparatorProps, Sheet, SheetClose, type SheetCloseProps, SheetContent, type SheetContentProps, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, type SheetOverlayProps, type SheetProps, SheetTitle, SheetTrigger, type SheetTriggerProps, type Side, Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupContent, SidebarGroupLabel, type SidebarGroupLabelProps, SidebarHeader, SidebarInset, SidebarMenu, SidebarMenuButton, type SidebarMenuButtonProps, type SidebarMenuButtonSize, type SidebarMenuButtonVariant, SidebarMenuItem, type SidebarProps, SidebarProvider, type SidebarProviderProps, SidebarRail, SidebarSeparator, SidebarTrigger, Skeleton, Slider, type SliderProps, Slot, type SlotProps, Spinner, Switch, type SwitchProps, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, Tabs, TabsContent, type TabsContentProps, TabsList, type TabsProps, TabsTrigger, type TabsTriggerProps, Textarea, type Toast, type ToastFn, type ToastOptions, type ToastPosition, type ToastVariant, Toaster, type ToasterProps, Toggle, ToggleGroup, ToggleGroupItem, type ToggleGroupItemProps, type ToggleGroupProps, type ToggleProps, type ToggleSize, type ToggleVariant, type ToggleVariantsOptions, Tooltip, TooltipContent, type TooltipContentProps, type TooltipProps, TooltipProvider, type TooltipProviderProps, TooltipTrigger, type TooltipTriggerProps, buttonVariants, cn, mergeRefs, navigationMenuTriggerStyle, toast, toggleVariants, useControllableState, useDismissableLayer, useFloating, useFocusScope, usePresence, useRovingFocus, useSidebar };