@alexgorbatchev/shadcn 0.0.0-stage → 0.0.12

package/dist/components/Avatar.d.ts

@@ -0,0 +1,19 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { Avatar as AvatarPrimitive } from "@base-ui/react/avatar";
+type AvatarProps = AvatarPrimitive.Root.Props & {
+    size?: "default" | "sm" | "lg" | "preview";
+    shape?: "circle" | "square";
+} & IDensityProps;
+declare function Avatar({ density, className, size, shape, ...props }: AvatarProps): ReactElement;
+type AvatarImageProps = AvatarPrimitive.Image.Props & IDensityProps;
+declare function AvatarImage({ density, className, ...props }: AvatarImageProps): ReactElement;
+type AvatarFallbackProps = AvatarPrimitive.Fallback.Props & IDensityProps;
+declare function AvatarFallback({ density, className, ...props }: AvatarFallbackProps): ReactElement;
+type AvatarBadgeProps = ComponentProps<"span"> & IDensityProps;
+declare function AvatarBadge({ density, className, ...props }: AvatarBadgeProps): ReactElement;
+type AvatarGroupProps = ComponentProps<"div"> & IDensityProps;
+declare function AvatarGroup({ density, className, ...props }: AvatarGroupProps): ReactElement;
+type AvatarGroupCountProps = ComponentProps<"div"> & IDensityProps;
+declare function AvatarGroupCount({ density, className, ...props }: AvatarGroupCountProps): ReactElement;
+export { Avatar, AvatarImage, AvatarFallback, AvatarGroup, AvatarGroupCount, AvatarBadge };

package/dist/components/Badge.d.ts

@@ -0,0 +1,15 @@
+import type { Density, IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "class-variance-authority";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "ghost" | "link" | "outline" | "secondary" | "success" | "warning" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type BadgeState = {
+    slot: "badge";
+    variant: VariantProps<typeof badgeVariants>["variant"];
+    density?: Density;
+};
+type BadgeProps = useRender.ComponentProps<"span", BadgeState> & VariantProps<typeof badgeVariants> & IDensityProps;
+declare function Badge({ density, className, variant, render, ...props }: BadgeProps): ReactElement;
+export { Badge, badgeVariants };

package/dist/components/Breadcrumb.d.ts

@@ -0,0 +1,18 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { useRender } from "@base-ui/react/use-render";
+type BreadcrumbProps = ComponentProps<"nav"> & IDensityProps;
+declare function Breadcrumb({ density, className, ...props }: BreadcrumbProps): ReactElement;
+type BreadcrumbListProps = ComponentProps<"ol"> & IDensityProps;
+declare function BreadcrumbList({ density, className, ...props }: BreadcrumbListProps): ReactElement;
+type BreadcrumbItemProps = ComponentProps<"li"> & IDensityProps;
+declare function BreadcrumbItem({ density, className, ...props }: BreadcrumbItemProps): ReactElement;
+type BreadcrumbLinkProps = useRender.ComponentProps<"a"> & IDensityProps;
+declare function BreadcrumbLink({ density, className, render, ...props }: BreadcrumbLinkProps): ReactElement;
+type BreadcrumbPageProps = ComponentProps<"span"> & IDensityProps;
+declare function BreadcrumbPage({ density, className, ...props }: BreadcrumbPageProps): ReactElement;
+type BreadcrumbSeparatorProps = ComponentProps<"li"> & IDensityProps;
+declare function BreadcrumbSeparator({ density, children, className, ...props }: BreadcrumbSeparatorProps): ReactElement;
+type BreadcrumbEllipsisProps = ComponentProps<"span"> & IDensityProps;
+declare function BreadcrumbEllipsis({ density, className, ...props }: BreadcrumbEllipsisProps): ReactElement;
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, };

package/dist/components/Bubble.d.ts

@@ -0,0 +1,25 @@
+import type { ComponentProps, ReactElement } from "react";
+import type { Density, IDensityProps } from "../density/types.js";
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "class-variance-authority";
+type BubbleGroupProps = ComponentProps<"div"> & IDensityProps;
+declare function BubbleGroup({ density, className, ...props }: BubbleGroupProps): ReactElement;
+declare const bubbleVariants: (props?: ({
+    variant?: "default" | "destructive" | "ghost" | "muted" | "outline" | "secondary" | "tinted" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type BubbleProps = ComponentProps<"div"> & VariantProps<typeof bubbleVariants> & IDensityProps & {
+    align?: "start" | "end";
+};
+declare function Bubble({ density, variant, align, className, ...props }: BubbleProps): ReactElement;
+type BubbleContentState = {
+    slot: "bubble-content";
+    density?: Density;
+};
+type BubbleContentProps = useRender.ComponentProps<"div", BubbleContentState> & IDensityProps;
+declare function BubbleContent({ density, className, render, ...props }: BubbleContentProps): ReactElement;
+type BubbleReactionsProps = ComponentProps<"div"> & IDensityProps & {
+    align?: "start" | "end";
+    side?: "top" | "bottom";
+};
+declare function BubbleReactions({ density, side, align, className, ...props }: BubbleReactionsProps): ReactElement;
+export { BubbleGroup, Bubble, BubbleContent, BubbleReactions };

package/dist/components/Button.d.ts

@@ -0,0 +1,13 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { Button as ButtonPrimitive } from "@base-ui/react/button";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    truncate?: boolean | null | undefined;
+    align?: "center" | "end" | "start" | null | undefined;
+    variant?: "default" | "destructive" | "ghost" | "link" | "outline" | "secondary" | "success" | "warning" | null | undefined;
+    size?: "default" | "icon" | "icon-lg" | "icon-sm" | "icon-xs" | "inline" | "lg" | "sm" | "xs" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type ButtonProps = ButtonPrimitive.Props & VariantProps<typeof buttonVariants> & IDensityProps;
+declare function Button({ density, className, variant, size, align, truncate, children, ...props }: ButtonProps): ReactElement;
+export { Button, buttonVariants };

package/dist/components/ButtonGroup.d.ts

@@ -0,0 +1,14 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "class-variance-authority";
+import { Separator } from "./Separator.js";
+declare const buttonGroupVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type ButtonGroupProps = ComponentProps<"div"> & VariantProps<typeof buttonGroupVariants> & IDensityProps;
+declare function ButtonGroup({ density, className, orientation, ...props }: ButtonGroupProps): ReactElement;
+type ButtonGroupTextProps = useRender.ComponentProps<"div"> & IDensityProps;
+declare function ButtonGroupText({ density, className, render, ...props }: ButtonGroupTextProps): ReactElement;
+declare function ButtonGroupSeparator({ density, className, orientation, ...props }: ComponentProps<typeof Separator>): ReactElement;
+export { ButtonGroup, ButtonGroupSeparator, ButtonGroupText, buttonGroupVariants };

package/dist/components/Card.d.ts

@@ -0,0 +1,19 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+type CardProps = ComponentProps<"div"> & {
+    size?: "default" | "sm";
+} & IDensityProps;
+declare function Card({ density, className, size, ...props }: CardProps): ReactElement;
+type CardHeaderProps = ComponentProps<"div"> & IDensityProps;
+declare function CardHeader({ density, className, ...props }: CardHeaderProps): ReactElement;
+type CardTitleProps = ComponentProps<"div"> & IDensityProps;
+declare function CardTitle({ density, className, ...props }: CardTitleProps): ReactElement;
+type CardDescriptionProps = ComponentProps<"div"> & IDensityProps;
+declare function CardDescription({ density, className, ...props }: CardDescriptionProps): ReactElement;
+type CardActionProps = ComponentProps<"div"> & IDensityProps;
+declare function CardAction({ density, className, ...props }: CardActionProps): ReactElement;
+type CardContentProps = ComponentProps<"div"> & IDensityProps;
+declare function CardContent({ density, className, ...props }: CardContentProps): ReactElement;
+type CardFooterProps = ComponentProps<"div"> & IDensityProps;
+declare function CardFooter({ density, className, ...props }: CardFooterProps): ReactElement;
+export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent };

package/dist/components/Checkbox.d.ts

@@ -0,0 +1,6 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { Checkbox as CheckboxPrimitive } from "@base-ui/react/checkbox";
+type CheckboxProps = CheckboxPrimitive.Root.Props & IDensityProps;
+declare function Checkbox({ density, className, ...props }: CheckboxProps): ReactElement;
+export { Checkbox };

package/dist/components/Collapsible.d.ts

@@ -0,0 +1,6 @@
+import type { ReactElement } from "react";
+import { Collapsible as CollapsiblePrimitive } from "@base-ui/react/collapsible";
+declare function Collapsible({ ...props }: CollapsiblePrimitive.Root.Props): ReactElement;
+declare function CollapsibleTrigger({ ...props }: CollapsiblePrimitive.Trigger.Props): ReactElement;
+declare function CollapsibleContent({ ...props }: CollapsiblePrimitive.Panel.Props): ReactElement;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };

package/dist/components/Combobox.d.ts

@@ -0,0 +1,39 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentPropsWithRef, ReactElement } from "react";
+import { Combobox as ComboboxPrimitive } from "@base-ui/react/combobox";
+declare const Combobox: typeof ComboboxPrimitive.Root;
+declare function ComboboxValue({ ...props }: ComboboxPrimitive.Value.Props): ReactElement;
+type ComboboxTriggerProps = ComboboxPrimitive.Trigger.Props & IDensityProps;
+declare function ComboboxTrigger({ density, className, children, ...props }: ComboboxTriggerProps): ReactElement;
+type ComboboxInputProps = ComboboxPrimitive.Input.Props & {
+    showTrigger?: boolean;
+    showClear?: boolean;
+    frameClassName?: string;
+    triggerLabel?: string;
+    clearLabel?: string;
+} & IDensityProps;
+declare function ComboboxInput({ density, className, children, disabled, showTrigger, showClear, frameClassName, triggerLabel, clearLabel, ...props }: ComboboxInputProps): ReactElement;
+type ComboboxContentProps = ComboboxPrimitive.Popup.Props & Pick<ComboboxPrimitive.Positioner.Props, "side" | "align" | "sideOffset" | "alignOffset" | "anchor"> & IDensityProps;
+declare function ComboboxContent({ density, className, side, sideOffset, align, alignOffset, anchor, ...props }: ComboboxContentProps): ReactElement;
+type ComboboxListProps = ComboboxPrimitive.List.Props & IDensityProps;
+declare function ComboboxList({ density, className, ...props }: ComboboxListProps): ReactElement;
+type ComboboxItemProps = ComboboxPrimitive.Item.Props & IDensityProps;
+declare function ComboboxItem({ density, className, children, ...props }: ComboboxItemProps): ReactElement;
+type ComboboxGroupProps = ComboboxPrimitive.Group.Props & IDensityProps;
+declare function ComboboxGroup({ density, className, ...props }: ComboboxGroupProps): ReactElement;
+type ComboboxLabelProps = ComboboxPrimitive.GroupLabel.Props & IDensityProps;
+declare function ComboboxLabel({ density, className, ...props }: ComboboxLabelProps): ReactElement;
+declare function ComboboxCollection({ ...props }: ComboboxPrimitive.Collection.Props): ReactElement;
+type ComboboxEmptyProps = ComboboxPrimitive.Empty.Props & IDensityProps;
+declare function ComboboxEmpty({ density, className, ...props }: ComboboxEmptyProps): ReactElement;
+type ComboboxSeparatorProps = ComboboxPrimitive.Separator.Props & IDensityProps;
+declare function ComboboxSeparator({ density, className, ...props }: ComboboxSeparatorProps): ReactElement;
+type ComboboxChipsProps = ComponentPropsWithRef<typeof ComboboxPrimitive.Chips> & ComboboxPrimitive.Chips.Props & IDensityProps;
+declare function ComboboxChips({ density, className, ...props }: ComboboxChipsProps): ReactElement;
+type ComboboxChipProps = ComboboxPrimitive.Chip.Props & {
+    showRemove?: boolean;
+} & IDensityProps;
+declare function ComboboxChip({ density, className, children, showRemove, ...props }: ComboboxChipProps): ReactElement;
+type ComboboxChipsInputProps = ComboboxPrimitive.Input.Props & IDensityProps;
+declare function ComboboxChipsInput({ density, className, ...props }: ComboboxChipsInputProps): ReactElement;
+export { Combobox, ComboboxInput, ComboboxContent, ComboboxList, ComboboxItem, ComboboxGroup, ComboboxLabel, ComboboxCollection, ComboboxEmpty, ComboboxSeparator, ComboboxChips, ComboboxChip, ComboboxChipsInput, ComboboxTrigger, ComboboxValue, };

package/dist/components/ConfirmationDialog.d.ts

@@ -0,0 +1,11 @@
+import { type ReactElement } from "react";
+interface IConfirmationDialogProps {
+    open: boolean;
+    title: string;
+    description: string;
+    confirmLabel: string;
+    onOpenChange: (open: boolean) => void;
+    onConfirm: () => void | Promise<void>;
+}
+export declare function ConfirmationDialog({ open, title, description, confirmLabel, onOpenChange, onConfirm, }: IConfirmationDialogProps): ReactElement;
+export {};

package/dist/components/ContextMenu.d.ts

@@ -0,0 +1,24 @@
+import type { MenuLabelProps, MenuItemProps, MenuSubTriggerProps, MenuCheckboxItemProps, MenuRadioItemProps } from "../menu/types.js";
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { ContextMenu as ContextMenuPrimitive } from "@base-ui/react/context-menu";
+declare function ContextMenu({ ...props }: ContextMenuPrimitive.Root.Props): ReactElement;
+declare function ContextMenuPortal({ ...props }: ContextMenuPrimitive.Portal.Props): ReactElement;
+type ContextMenuTriggerProps = ContextMenuPrimitive.Trigger.Props & IDensityProps;
+declare function ContextMenuTrigger({ density, className, ...props }: ContextMenuTriggerProps): ReactElement;
+type ContextMenuContentProps = ContextMenuPrimitive.Popup.Props & Pick<ContextMenuPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset"> & IDensityProps;
+declare function ContextMenuContent({ density, className, align, alignOffset, side, sideOffset, ...props }: ContextMenuContentProps): ReactElement;
+declare function ContextMenuGroup({ ...props }: ContextMenuPrimitive.Group.Props): ReactElement;
+declare function ContextMenuLabel({ density, className, inset, ...props }: MenuLabelProps): ReactElement;
+declare function ContextMenuItem({ density, className, inset, variant, ...props }: MenuItemProps): ReactElement;
+declare function ContextMenuSub({ ...props }: ContextMenuPrimitive.SubmenuRoot.Props): ReactElement;
+declare function ContextMenuSubTrigger({ density, className, inset, children, ...props }: MenuSubTriggerProps): ReactElement;
+declare function ContextMenuSubContent({ ...props }: ComponentProps<typeof ContextMenuContent>): ReactElement;
+declare function ContextMenuCheckboxItem({ density, className, children, checked, inset, ...props }: MenuCheckboxItemProps): ReactElement;
+declare function ContextMenuRadioGroup({ ...props }: ContextMenuPrimitive.RadioGroup.Props): ReactElement;
+declare function ContextMenuRadioItem({ density, className, children, inset, ...props }: MenuRadioItemProps): ReactElement;
+type ContextMenuSeparatorProps = ContextMenuPrimitive.Separator.Props & IDensityProps;
+declare function ContextMenuSeparator({ density, className, ...props }: ContextMenuSeparatorProps): ReactElement;
+type ContextMenuShortcutProps = ComponentProps<"span"> & IDensityProps;
+declare function ContextMenuShortcut({ density, className, ...props }: ContextMenuShortcutProps): ReactElement;
+export { ContextMenu, ContextMenuTrigger, ContextMenuContent, ContextMenuItem, ContextMenuCheckboxItem, ContextMenuRadioItem, ContextMenuLabel, ContextMenuSeparator, ContextMenuShortcut, ContextMenuGroup, ContextMenuPortal, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuRadioGroup, };

package/dist/components/DensityProvider.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode, ReactElement } from "react";
+import type { Density } from "../density/types.js";
+export interface IDensityProviderProps {
+    children: ReactNode;
+    density?: Density;
+}
+export declare function DensityProvider({ children, density }: IDensityProviderProps): ReactElement;

package/dist/components/Dialog.d.ts

@@ -0,0 +1,25 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { Dialog as DialogPrimitive } from "@base-ui/react/dialog";
+declare function Dialog<Payload>({ ...props }: DialogPrimitive.Root.Props<Payload>): ReactElement;
+declare function DialogTrigger<Payload>({ ...props }: DialogPrimitive.Trigger.Props<Payload>): ReactElement;
+declare function DialogPortal({ ...props }: DialogPrimitive.Portal.Props): ReactElement;
+declare function DialogClose({ ...props }: DialogPrimitive.Close.Props): ReactElement;
+type DialogOverlayProps = DialogPrimitive.Backdrop.Props & IDensityProps;
+declare function DialogOverlay({ density, className, ...props }: DialogOverlayProps): ReactElement;
+type DialogContentProps = DialogPrimitive.Popup.Props & {
+    showCloseButton?: boolean;
+    size?: "default" | "wide" | "narrow";
+} & IDensityProps;
+declare function DialogContent({ density, className, children, showCloseButton, size, ...props }: DialogContentProps): ReactElement;
+type DialogHeaderProps = ComponentProps<"div"> & IDensityProps;
+declare function DialogHeader({ density, className, ...props }: DialogHeaderProps): ReactElement;
+type DialogFooterProps = ComponentProps<"div"> & {
+    showCloseButton?: boolean;
+} & IDensityProps;
+declare function DialogFooter({ density, className, showCloseButton, children, ...props }: DialogFooterProps): ReactElement;
+type DialogTitleProps = DialogPrimitive.Title.Props & IDensityProps;
+declare function DialogTitle({ density, className, ...props }: DialogTitleProps): ReactElement;
+type DialogDescriptionProps = DialogPrimitive.Description.Props & IDensityProps;
+declare function DialogDescription({ density, className, ...props }: DialogDescriptionProps): ReactElement;
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, };

package/dist/components/DirectionProvider.d.ts

@@ -0,0 +1 @@
+export { DirectionProvider, useDirection } from "@base-ui/react/direction-provider";

package/dist/components/DragDropPreview.d.ts

@@ -0,0 +1,7 @@
+import type { ReactElement } from "react";
+interface IDragDropPreviewProps {
+    labels: readonly string[];
+    maxItems?: number;
+}
+export declare function DragDropPreview({ labels, maxItems }: IDragDropPreviewProps): ReactElement;
+export {};

package/dist/components/DragDropProvider.d.ts

@@ -0,0 +1,6 @@
+import { type PropsWithChildren, type ReactElement } from "react";
+interface IDragDropProviderProps extends PropsWithChildren {
+    maxPreviewItems?: number;
+}
+export declare function DragDropProvider({ children, maxPreviewItems }: IDragDropProviderProps): ReactElement;
+export {};

package/dist/components/DragSource.d.ts

@@ -0,0 +1,10 @@
+import { useRender } from "@base-ui/react/use-render";
+import type { ReactElement } from "react";
+import type { IDragSourceOptions } from "../drag-drop/types.js";
+type DragSourceState = {
+    slot: "drag-source";
+    dragging: boolean;
+};
+type DragSourceProps = Omit<useRender.ComponentProps<"div", DragSourceState>, "onDragStart" | "onDragEnd"> & IDragSourceOptions;
+export declare function DragSource({ type, data, labels, effectAllowed, disabled, render, ...props }: DragSourceProps): ReactElement;
+export {};

package/dist/components/Drawer.d.ts

@@ -0,0 +1,25 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { Drawer as DrawerPrimitive } from "@base-ui/react/drawer";
+type DrawerProps<Payload> = DrawerPrimitive.Root.Props<Payload> & {
+    showSwipeHandle?: boolean;
+};
+declare function Drawer<Payload>({ modal, showSwipeHandle, snapPoints, swipeDirection, ...props }: DrawerProps<Payload>): ReactElement;
+declare function DrawerTrigger<Payload>({ ...props }: DrawerPrimitive.Trigger.Props<Payload>): ReactElement;
+declare function DrawerPortal({ ...props }: DrawerPrimitive.Portal.Props): ReactElement;
+declare function DrawerClose({ ...props }: DrawerPrimitive.Close.Props): ReactElement;
+type DrawerOverlayProps = DrawerPrimitive.Backdrop.Props & IDensityProps;
+declare function DrawerOverlay({ density, className, ...props }: DrawerOverlayProps): ReactElement;
+type DrawerSwipeHandleProps = ComponentProps<"div"> & IDensityProps;
+declare function DrawerSwipeHandle({ density, className, ...props }: DrawerSwipeHandleProps): ReactElement;
+type DrawerContentProps = DrawerPrimitive.Popup.Props & IDensityProps;
+declare function DrawerContent({ density, className, children, ...props }: DrawerContentProps): ReactElement;
+type DrawerHeaderProps = ComponentProps<"div"> & IDensityProps;
+declare function DrawerHeader({ density, className, ...props }: DrawerHeaderProps): ReactElement;
+type DrawerFooterProps = ComponentProps<"div"> & IDensityProps;
+declare function DrawerFooter({ density, className, ...props }: DrawerFooterProps): ReactElement;
+type DrawerTitleProps = DrawerPrimitive.Title.Props & IDensityProps;
+declare function DrawerTitle({ density, className, ...props }: DrawerTitleProps): ReactElement;
+type DrawerDescriptionProps = DrawerPrimitive.Description.Props & IDensityProps;
+declare function DrawerDescription({ density, className, ...props }: DrawerDescriptionProps): ReactElement;
+export { Drawer, DrawerPortal, DrawerOverlay, DrawerSwipeHandle, DrawerTrigger, DrawerClose, DrawerContent, DrawerHeader, DrawerFooter, DrawerTitle, DrawerDescription, };

package/dist/components/DropTarget.d.ts

@@ -0,0 +1,11 @@
+import { useRender } from "@base-ui/react/use-render";
+import type { ReactElement } from "react";
+import type { IDropTargetOptions } from "../drag-drop/types.js";
+type DropTargetState = {
+    slot: "drop-target";
+    over: boolean;
+    effect: DataTransfer["dropEffect"];
+};
+type DropTargetProps = Omit<useRender.ComponentProps<"div", DropTargetState>, "onDrop"> & IDropTargetOptions;
+export declare function DropTarget({ accept, canDrop, getDropEffect, onDrop, render, ...props }: DropTargetProps): ReactElement;
+export {};

package/dist/components/DropdownMenu.d.ts

@@ -0,0 +1,26 @@
+import type { MenuLabelProps, MenuItemProps, MenuSubTriggerProps, MenuCheckboxItemProps, MenuRadioItemProps } from "../menu/types.js";
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { Menu as MenuPrimitive } from "@base-ui/react/menu";
+declare function DropdownMenu<Payload>({ ...props }: MenuPrimitive.Root.Props<Payload>): ReactElement;
+declare function DropdownMenuPortal({ ...props }: MenuPrimitive.Portal.Props): ReactElement;
+declare function DropdownMenuTrigger<Payload>({ ...props }: MenuPrimitive.Trigger.Props<Payload>): ReactElement;
+type DropdownMenuContentProps = MenuPrimitive.Popup.Props & Pick<MenuPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset"> & IDensityProps & {
+    width?: "content" | "anchor";
+};
+declare function DropdownMenuContent({ density, width, align, alignOffset, side, sideOffset, className, ...props }: DropdownMenuContentProps): ReactElement;
+declare function DropdownMenuGroup({ ...props }: MenuPrimitive.Group.Props): ReactElement;
+declare function DropdownMenuLabel({ density, className, inset, ...props }: MenuLabelProps): ReactElement;
+declare function DropdownMenuItem({ density, className, inset, variant, ...props }: MenuItemProps): ReactElement;
+declare function DropdownMenuSub({ ...props }: MenuPrimitive.SubmenuRoot.Props): ReactElement;
+declare function DropdownMenuSubTrigger({ density, className, inset, children, ...props }: MenuSubTriggerProps): ReactElement;
+type DropdownMenuSubContentProps = ComponentProps<typeof DropdownMenuContent> & IDensityProps;
+declare function DropdownMenuSubContent({ density, align, alignOffset, side, sideOffset, className, ...props }: DropdownMenuSubContentProps): ReactElement;
+declare function DropdownMenuCheckboxItem({ density, className, children, checked, inset, ...props }: MenuCheckboxItemProps): ReactElement;
+declare function DropdownMenuRadioGroup({ ...props }: MenuPrimitive.RadioGroup.Props): ReactElement;
+declare function DropdownMenuRadioItem({ density, className, children, inset, ...props }: MenuRadioItemProps): ReactElement;
+type DropdownMenuSeparatorProps = MenuPrimitive.Separator.Props & IDensityProps;
+declare function DropdownMenuSeparator({ density, className, ...props }: DropdownMenuSeparatorProps): ReactElement;
+type DropdownMenuShortcutProps = ComponentProps<"span"> & IDensityProps;
+declare function DropdownMenuShortcut({ density, className, ...props }: DropdownMenuShortcutProps): ReactElement;
+export { DropdownMenu, DropdownMenuPortal, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, };

package/dist/components/Empty.d.ts

@@ -0,0 +1,19 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { type VariantProps } from "class-variance-authority";
+type EmptyProps = ComponentProps<"div"> & IDensityProps;
+declare function Empty({ density, className, ...props }: EmptyProps): ReactElement;
+type EmptyHeaderProps = ComponentProps<"div"> & IDensityProps;
+declare function EmptyHeader({ density, className, ...props }: EmptyHeaderProps): ReactElement;
+declare const emptyMediaVariants: (props?: ({
+    variant?: "default" | "icon" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type EmptyMediaProps = ComponentProps<"div"> & VariantProps<typeof emptyMediaVariants> & IDensityProps;
+declare function EmptyMedia({ density, className, variant, ...props }: EmptyMediaProps): ReactElement;
+type EmptyTitleProps = ComponentProps<"div"> & IDensityProps;
+declare function EmptyTitle({ density, className, ...props }: EmptyTitleProps): ReactElement;
+type EmptyDescriptionProps = ComponentProps<"div"> & IDensityProps;
+declare function EmptyDescription({ density, className, ...props }: EmptyDescriptionProps): ReactElement;
+type EmptyContentProps = ComponentProps<"div"> & IDensityProps;
+declare function EmptyContent({ density, className, ...props }: EmptyContentProps): ReactElement;
+export { Empty, EmptyHeader, EmptyTitle, EmptyDescription, EmptyContent, EmptyMedia };

package/dist/components/EmptyState.d.ts

@@ -0,0 +1,8 @@
+import type { ReactElement, ReactNode } from "react";
+interface IEmptyStateProps {
+    title: ReactNode;
+    description: ReactNode;
+    children?: ReactNode;
+}
+export declare function EmptyState({ title, description, children }: IEmptyStateProps): ReactElement;
+export {};

package/dist/components/Field.d.ts

@@ -0,0 +1,36 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { type VariantProps } from "class-variance-authority";
+import { Label } from "./Label.js";
+type FieldSetProps = ComponentProps<"fieldset"> & IDensityProps;
+declare function FieldSet({ density, className, ...props }: FieldSetProps): ReactElement;
+type FieldLegendProps = ComponentProps<"legend"> & {
+    variant?: "legend" | "label";
+} & IDensityProps;
+declare function FieldLegend({ density, className, variant, ...props }: FieldLegendProps): ReactElement;
+type FieldGroupProps = ComponentProps<"div"> & IDensityProps & {
+    columns?: 1 | 2;
+};
+declare function FieldGroup({ density, className, columns, ...props }: FieldGroupProps): ReactElement;
+declare const fieldVariants: (props?: ({
+    orientation?: "horizontal" | "responsive" | "vertical" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type FieldProps = ComponentProps<"div"> & VariantProps<typeof fieldVariants> & IDensityProps;
+declare function Field({ density, className, orientation, ...props }: FieldProps): ReactElement;
+type FieldContentProps = ComponentProps<"div"> & IDensityProps;
+declare function FieldContent({ density, className, ...props }: FieldContentProps): ReactElement;
+type FieldLabelProps = ComponentProps<typeof Label> & IDensityProps;
+declare function FieldLabel({ density, className, ...props }: FieldLabelProps): ReactElement;
+type FieldTitleProps = ComponentProps<"div"> & IDensityProps;
+declare function FieldTitle({ density, className, ...props }: FieldTitleProps): ReactElement;
+type FieldDescriptionProps = ComponentProps<"p"> & IDensityProps;
+declare function FieldDescription({ density, className, ...props }: FieldDescriptionProps): ReactElement;
+type FieldSeparatorProps = ComponentProps<"div"> & IDensityProps;
+declare function FieldSeparator({ density, children, className, ...props }: FieldSeparatorProps): ReactElement;
+type FieldErrorProps = ComponentProps<"div"> & {
+    errors?: ReadonlyArray<{
+        message?: string;
+    } | undefined>;
+} & IDensityProps;
+declare function FieldError({ density, className, children, errors, ...props }: FieldErrorProps): ReactElement | null;
+export { Field, FieldLabel, FieldDescription, FieldError, FieldGroup, FieldLegend, FieldSeparator, FieldSet, FieldContent, FieldTitle, };

package/dist/components/HoverCard.d.ts

@@ -0,0 +1,8 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { PreviewCard as PreviewCardPrimitive } from "@base-ui/react/preview-card";
+declare function HoverCard<Payload>({ ...props }: PreviewCardPrimitive.Root.Props<Payload>): ReactElement;
+declare function HoverCardTrigger<Payload>({ ...props }: PreviewCardPrimitive.Trigger.Props<Payload>): ReactElement;
+type HoverCardContentProps = PreviewCardPrimitive.Popup.Props & Pick<PreviewCardPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset"> & IDensityProps;
+declare function HoverCardContent({ density, className, side, sideOffset, align, alignOffset, ...props }: HoverCardContentProps): ReactElement;
+export { HoverCard, HoverCardTrigger, HoverCardContent };

package/dist/components/ImagePicker.d.ts

@@ -0,0 +1,11 @@
+import { type ReactElement } from "react";
+interface IImagePickerProps {
+    src?: string;
+    file?: File | null;
+    label: string;
+    disabled?: boolean;
+    onFileChange: (file: File) => void;
+    onClear: () => void;
+}
+export declare function ImagePicker({ src, file, label, disabled, onFileChange, onClear }: IImagePickerProps): ReactElement;
+export {};

package/dist/components/InlineEdit.d.ts

@@ -0,0 +1,14 @@
+import { type ReactElement } from "react";
+import type { IDensityProps } from "../density/types.js";
+interface IInlineEditProps extends IDensityProps {
+    label: string;
+    value: string;
+    isDisabled?: boolean;
+    shouldSelectOnMount?: boolean;
+    onValueChange: (value: string) => void;
+    onCommit: (value: string) => void | Promise<void>;
+    onCancel: () => void;
+}
+/** A mounted edit session. The consumer replaces its display with this field while editing. */
+export declare function InlineEdit({ label, value, density, isDisabled, shouldSelectOnMount, onValueChange, onCommit, onCancel, }: IInlineEditProps): ReactElement;
+export {};

package/dist/components/Input.d.ts

@@ -0,0 +1,6 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { Input as InputPrimitive } from "@base-ui/react/input";
+type InputProps = InputPrimitive.Props & IDensityProps;
+declare function Input({ density, className, type, ...props }: InputProps): ReactElement;
+export { Input };

package/dist/components/InputGroup.d.ts

@@ -0,0 +1,26 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { type VariantProps } from "class-variance-authority";
+import { Button } from "./Button.js";
+import { Input } from "./Input.js";
+type InputGroupProps = ComponentProps<"div"> & IDensityProps;
+declare function InputGroup({ density, className, ...props }: InputGroupProps): ReactElement;
+declare const inputGroupAddonVariants: (props?: ({
+    align?: "block-end" | "block-start" | "inline-end" | "inline-start" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type InputGroupAddonProps = ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants> & IDensityProps;
+declare function InputGroupAddon({ density, className, align, ...props }: InputGroupAddonProps): ReactElement;
+declare const inputGroupButtonVariants: (props?: ({
+    size?: "icon-sm" | "icon-xs" | "sm" | "xs" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type InputGroupButtonProps = Omit<ComponentProps<typeof Button>, "size" | "type"> & VariantProps<typeof inputGroupButtonVariants> & {
+    type?: "button" | "submit" | "reset";
+} & IDensityProps;
+declare function InputGroupButton({ density, className, type, variant, size, ...props }: InputGroupButtonProps): ReactElement;
+type InputGroupTextProps = ComponentProps<"span"> & IDensityProps;
+declare function InputGroupText({ density, className, ...props }: InputGroupTextProps): ReactElement;
+type InputGroupInputProps = ComponentProps<typeof Input>;
+declare function InputGroupInput({ density, className, ...props }: InputGroupInputProps): ReactElement;
+type InputGroupTextareaProps = ComponentProps<"textarea"> & IDensityProps;
+declare function InputGroupTextarea({ density, className, ...props }: InputGroupTextareaProps): ReactElement;
+export { InputGroup, InputGroupAddon, InputGroupButton, InputGroupText, InputGroupInput, InputGroupTextarea };

package/dist/components/Item.d.ts

@@ -0,0 +1,32 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "class-variance-authority";
+import { Separator } from "./Separator.js";
+type ItemGroupProps = ComponentProps<"div"> & IDensityProps;
+declare function ItemGroup({ density, className, ...props }: ItemGroupProps): ReactElement;
+declare function ItemSeparator({ density, className, ...props }: ComponentProps<typeof Separator>): ReactElement;
+declare const itemVariants: (props?: ({
+    variant?: "default" | "muted" | "outline" | null | undefined;
+    size?: "default" | "sm" | "xs" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type ItemProps = useRender.ComponentProps<"div"> & VariantProps<typeof itemVariants> & IDensityProps;
+declare function Item({ density, className, variant, size, render, ...props }: ItemProps): ReactElement;
+declare const itemMediaVariants: (props?: ({
+    variant?: "default" | "icon" | "image" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type ItemMediaProps = ComponentProps<"div"> & VariantProps<typeof itemMediaVariants> & IDensityProps;
+declare function ItemMedia({ density, className, variant, ...props }: ItemMediaProps): ReactElement;
+type ItemContentProps = ComponentProps<"div"> & IDensityProps;
+declare function ItemContent({ density, className, ...props }: ItemContentProps): ReactElement;
+type ItemTitleProps = ComponentProps<"div"> & IDensityProps;
+declare function ItemTitle({ density, className, ...props }: ItemTitleProps): ReactElement;
+type ItemDescriptionProps = ComponentProps<"p"> & IDensityProps;
+declare function ItemDescription({ density, className, ...props }: ItemDescriptionProps): ReactElement;
+type ItemActionsProps = ComponentProps<"div"> & IDensityProps;
+declare function ItemActions({ density, className, ...props }: ItemActionsProps): ReactElement;
+type ItemHeaderProps = ComponentProps<"div"> & IDensityProps;
+declare function ItemHeader({ density, className, ...props }: ItemHeaderProps): ReactElement;
+type ItemFooterProps = ComponentProps<"div"> & IDensityProps;
+declare function ItemFooter({ density, className, ...props }: ItemFooterProps): ReactElement;
+export { Item, ItemMedia, ItemContent, ItemActions, ItemGroup, ItemSeparator, ItemTitle, ItemDescription, ItemHeader, ItemFooter, };

package/dist/components/JsonViewer.d.ts

@@ -0,0 +1,8 @@
+import type { ReactElement } from "react";
+interface IJsonViewerProps {
+    value: unknown;
+    label?: string;
+    rows?: number;
+}
+export declare function JsonViewer({ value, label, rows }: IJsonViewerProps): ReactElement;
+export {};

package/dist/components/Kbd.d.ts

@@ -0,0 +1,7 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+type KbdProps = ComponentProps<"kbd"> & IDensityProps;
+declare function Kbd({ density, className, ...props }: KbdProps): ReactElement;
+type KbdGroupProps = ComponentProps<"kbd"> & IDensityProps;
+declare function KbdGroup({ density, className, ...props }: KbdGroupProps): ReactElement;
+export { Kbd, KbdGroup };

package/dist/components/Label.d.ts

@@ -0,0 +1,5 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+type LabelProps = ComponentProps<"label"> & IDensityProps;
+declare function Label({ density, className, ...props }: LabelProps): ReactElement;
+export { Label };

package/dist/components/Marker.d.ts

@@ -0,0 +1,19 @@
+import type { ComponentProps, ReactElement } from "react";
+import type { Density, IDensityProps } from "../density/types.js";
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "class-variance-authority";
+declare const markerVariants: (props?: ({
+    variant?: "border" | "default" | "separator" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type MarkerState = {
+    slot: "marker";
+    variant: VariantProps<typeof markerVariants>["variant"];
+    density?: Density;
+};
+type MarkerProps = useRender.ComponentProps<"div", MarkerState> & VariantProps<typeof markerVariants> & IDensityProps;
+declare function Marker({ density, className, variant, render, ...props }: MarkerProps): ReactElement;
+type MarkerIconProps = ComponentProps<"span"> & IDensityProps;
+declare function MarkerIcon({ density, className, ...props }: MarkerIconProps): ReactElement;
+type MarkerContentProps = ComponentProps<"span"> & IDensityProps;
+declare function MarkerContent({ density, className, ...props }: MarkerContentProps): ReactElement;
+export { Marker, MarkerIcon, MarkerContent, markerVariants };