@alexgorbatchev/shadcn 0.0.0-stage → 0.0.16

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({ container, ...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" | "vertical" | "responsive" | 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?: "inline-end" | "inline-start" | "block-start" | "block-end" | 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?: "xs" | "sm" | "icon-xs" | "icon-sm" | 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" | "outline" | "muted" | null | undefined;
+    size?: "default" | "xs" | "sm" | 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?: "default" | "separator" | "border" | 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 };

package/dist/components/Menubar.d.ts

@@ -0,0 +1,29 @@
+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";
+import { Menubar as MenubarPrimitive } from "@base-ui/react/menubar";
+import { DropdownMenuContent, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent } from "./DropdownMenu.js";
+type MenubarProps = MenubarPrimitive.Props & IDensityProps;
+declare function Menubar({ density, className, ...props }: MenubarProps): ReactElement;
+declare function MenubarMenu<Payload>({ ...props }: MenuPrimitive.Root.Props<Payload>): ReactElement;
+declare function MenubarGroup({ ...props }: ComponentProps<typeof DropdownMenuGroup>): ReactElement;
+declare function MenubarPortal({ ...props }: ComponentProps<typeof DropdownMenuPortal>): ReactElement;
+type MenubarTriggerProps<Payload> = MenuPrimitive.Trigger.Props<Payload> & IDensityProps;
+declare function MenubarTrigger<Payload>({ density, className, ...props }: MenubarTriggerProps<Payload>): ReactElement;
+type MenubarContentProps = ComponentProps<typeof DropdownMenuContent> & IDensityProps;
+declare function MenubarContent({ density, className, align, alignOffset, sideOffset, ...props }: MenubarContentProps): ReactElement;
+declare function MenubarItem({ density, className, inset, variant, ...props }: MenuItemProps): ReactElement;
+declare function MenubarCheckboxItem({ density, className, children, checked, inset, ...props }: MenuCheckboxItemProps): ReactElement;
+declare function MenubarRadioGroup({ ...props }: ComponentProps<typeof DropdownMenuRadioGroup>): ReactElement;
+declare function MenubarRadioItem({ density, className, children, inset, ...props }: MenuRadioItemProps): ReactElement;
+declare function MenubarLabel({ density, className, inset, ...props }: MenuLabelProps): ReactElement;
+type MenubarSeparatorProps = ComponentProps<typeof DropdownMenuSeparator> & IDensityProps;
+declare function MenubarSeparator({ density, className, ...props }: MenubarSeparatorProps): ReactElement;
+type MenubarShortcutProps = ComponentProps<typeof DropdownMenuShortcut> & IDensityProps;
+declare function MenubarShortcut({ density, className, ...props }: MenubarShortcutProps): ReactElement;
+declare function MenubarSub({ ...props }: ComponentProps<typeof DropdownMenuSub>): ReactElement;
+declare function MenubarSubTrigger({ density, className, inset, ...props }: MenuSubTriggerProps): ReactElement;
+type MenubarSubContentProps = ComponentProps<typeof DropdownMenuSubContent> & IDensityProps;
+declare function MenubarSubContent({ density, className, ...props }: MenubarSubContentProps): ReactElement;
+export { Menubar, MenubarPortal, MenubarMenu, MenubarTrigger, MenubarContent, MenubarGroup, MenubarSeparator, MenubarLabel, MenubarItem, MenubarShortcut, MenubarCheckboxItem, MenubarRadioGroup, MenubarRadioItem, MenubarSub, MenubarSubTrigger, MenubarSubContent, };

package/dist/components/Message.d.ts

@@ -0,0 +1,17 @@
+import type { ComponentProps, ReactElement } from "react";
+import type { IDensityProps } from "../density/types.js";
+type MessageGroupProps = ComponentProps<"div"> & IDensityProps;
+declare function MessageGroup({ density, className, ...props }: MessageGroupProps): ReactElement;
+type MessageProps = ComponentProps<"div"> & IDensityProps & {
+    align?: "start" | "end";
+};
+declare function Message({ density, className, align, style, ...props }: MessageProps): ReactElement;
+type MessageAvatarProps = ComponentProps<"div"> & IDensityProps;
+declare function MessageAvatar({ density, className, ...props }: MessageAvatarProps): ReactElement;
+type MessageContentProps = ComponentProps<"div"> & IDensityProps;
+declare function MessageContent({ density, className, ...props }: MessageContentProps): ReactElement;
+type MessageHeaderProps = ComponentProps<"div"> & IDensityProps;
+declare function MessageHeader({ density, className, ...props }: MessageHeaderProps): ReactElement;
+type MessageFooterProps = ComponentProps<"div"> & IDensityProps;
+declare function MessageFooter({ density, className, ...props }: MessageFooterProps): ReactElement;
+export { MessageGroup, Message, MessageAvatar, MessageContent, MessageFooter, MessageHeader };

package/dist/components/NativeSelect.d.ts

@@ -0,0 +1,11 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+type NativeSelectProps = Omit<ComponentProps<"select">, "size"> & {
+    size?: "sm" | "default";
+};
+declare function NativeSelect({ density, className, dir, size, ...props }: NativeSelectProps & IDensityProps): ReactElement;
+type NativeSelectOptionProps = ComponentProps<"option"> & IDensityProps;
+declare function NativeSelectOption({ density, className, ...props }: NativeSelectOptionProps): ReactElement;
+type NativeSelectOptGroupProps = ComponentProps<"optgroup"> & IDensityProps;
+declare function NativeSelectOptGroup({ density, className, ...props }: NativeSelectOptGroupProps): ReactElement;
+export { NativeSelect, NativeSelectOptGroup, NativeSelectOption };

package/dist/components/NavigationMenu.d.ts

@@ -0,0 +1,21 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentPropsWithRef, ReactElement } from "react";
+import { NavigationMenu as NavigationMenuPrimitive } from "@base-ui/react/navigation-menu";
+type NavigationMenuProps<Value> = NavigationMenuPrimitive.Root.Props<Value> & Pick<NavigationMenuPrimitive.Positioner.Props, "align"> & IDensityProps;
+declare function NavigationMenu<Value>({ density, align, className, children, ...props }: NavigationMenuProps<Value>): ReactElement;
+type NavigationMenuListProps = ComponentPropsWithRef<typeof NavigationMenuPrimitive.List> & IDensityProps;
+declare function NavigationMenuList({ density, className, ...props }: NavigationMenuListProps): ReactElement;
+type NavigationMenuItemProps = ComponentPropsWithRef<typeof NavigationMenuPrimitive.Item> & IDensityProps;
+declare function NavigationMenuItem({ density, className, ...props }: NavigationMenuItemProps): ReactElement;
+declare const navigationMenuTriggerStyle: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+type NavigationMenuTriggerProps = NavigationMenuPrimitive.Trigger.Props & IDensityProps;
+declare function NavigationMenuTrigger({ density, className, children, ...props }: NavigationMenuTriggerProps): ReactElement;
+type NavigationMenuContentProps = NavigationMenuPrimitive.Content.Props & IDensityProps;
+declare function NavigationMenuContent({ density, className, ...props }: NavigationMenuContentProps): ReactElement;
+type NavigationMenuPositionerProps = NavigationMenuPrimitive.Positioner.Props & IDensityProps;
+declare function NavigationMenuPositioner({ density, className, side, sideOffset, align, alignOffset, ...props }: NavigationMenuPositionerProps): ReactElement;
+type NavigationMenuLinkProps = NavigationMenuPrimitive.Link.Props & IDensityProps;
+declare function NavigationMenuLink({ density, className, ...props }: NavigationMenuLinkProps): ReactElement;
+type NavigationMenuIndicatorProps = ComponentPropsWithRef<typeof NavigationMenuPrimitive.Icon> & IDensityProps;
+declare function NavigationMenuIndicator({ density, className, children, ...props }: NavigationMenuIndicatorProps): ReactElement;
+export { NavigationMenu, NavigationMenuContent, NavigationMenuIndicator, NavigationMenuItem, NavigationMenuLink, NavigationMenuList, NavigationMenuTrigger, navigationMenuTriggerStyle, NavigationMenuPositioner, };

package/dist/components/PageMessage.d.ts

@@ -0,0 +1,9 @@
+import { type ReactElement, type ReactNode } from "react";
+interface IPageMessageProps {
+    title: ReactNode;
+    description?: ReactNode;
+    children?: ReactNode;
+}
+/** A full-page message for unavailable, empty, or disconnected application screens. */
+export declare function PageMessage({ title, description, children }: IPageMessageProps): ReactElement;
+export {};

package/dist/components/Pagination.d.ts

@@ -0,0 +1,21 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { buttonVariants } from "./Button.js";
+import type { VariantProps } from "class-variance-authority";
+type PaginationProps = ComponentProps<"nav"> & IDensityProps;
+declare function Pagination({ density, className, ...props }: PaginationProps): ReactElement;
+type PaginationContentProps = ComponentProps<"ul"> & IDensityProps;
+declare function PaginationContent({ density, className, ...props }: PaginationContentProps): ReactElement;
+declare function PaginationItem({ ...props }: ComponentProps<"li">): ReactElement;
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<VariantProps<typeof buttonVariants>, "size"> & ComponentProps<"a">;
+declare function PaginationLink({ density, className, isActive, size, ...props }: PaginationLinkProps & IDensityProps): ReactElement;
+type PaginationDirectionProps = ComponentProps<typeof PaginationLink> & {
+    text?: string;
+};
+declare function PaginationPrevious({ density, className, text, ...props }: PaginationDirectionProps): ReactElement;
+declare function PaginationNext({ density, className, text, ...props }: PaginationDirectionProps): ReactElement;
+type PaginationEllipsisProps = ComponentProps<"span"> & IDensityProps;
+declare function PaginationEllipsis({ density, className, ...props }: PaginationEllipsisProps): ReactElement;
+export { Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, };

package/dist/components/Popover.d.ts

@@ -0,0 +1,14 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { Popover as PopoverPrimitive } from "@base-ui/react/popover";
+declare function Popover<Payload>({ ...props }: PopoverPrimitive.Root.Props<Payload>): ReactElement;
+declare function PopoverTrigger<Payload>({ ...props }: PopoverPrimitive.Trigger.Props<Payload>): ReactElement;
+type PopoverContentProps = PopoverPrimitive.Popup.Props & Pick<PopoverPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset"> & IDensityProps;
+declare function PopoverContent({ density, className, align, alignOffset, side, sideOffset, ...props }: PopoverContentProps): ReactElement;
+type PopoverHeaderProps = ComponentProps<"div"> & IDensityProps;
+declare function PopoverHeader({ density, className, ...props }: PopoverHeaderProps): ReactElement;
+type PopoverTitleProps = PopoverPrimitive.Title.Props & IDensityProps;
+declare function PopoverTitle({ density, className, ...props }: PopoverTitleProps): ReactElement;
+type PopoverDescriptionProps = PopoverPrimitive.Description.Props & IDensityProps;
+declare function PopoverDescription({ density, className, ...props }: PopoverDescriptionProps): ReactElement;
+export { Popover, PopoverContent, PopoverDescription, PopoverHeader, PopoverTitle, PopoverTrigger };

package/dist/components/PortalProvider.d.ts

@@ -0,0 +1,7 @@
+import type { ReactElement, ReactNode } from "react";
+import type { PortalContainer } from "../portal/types.js";
+export interface IPortalProviderProps {
+    container: PortalContainer;
+    children: ReactNode;
+}
+export declare function PortalProvider({ container, children }: IPortalProviderProps): ReactElement;

package/dist/components/Progress.d.ts

@@ -0,0 +1,17 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { Progress as ProgressPrimitive } from "@base-ui/react/progress";
+type ProgressTone = "primary" | "success" | "warning" | "destructive" | "muted";
+type ProgressProps = ProgressPrimitive.Root.Props & IDensityProps & {
+    tone?: ProgressTone;
+};
+declare function Progress({ density, className, children, value, tone, ...props }: ProgressProps): ReactElement;
+type ProgressTrackProps = ProgressPrimitive.Track.Props & IDensityProps;
+declare function ProgressTrack({ density, className, ...props }: ProgressTrackProps): ReactElement;
+type ProgressIndicatorProps = ProgressPrimitive.Indicator.Props & IDensityProps;
+declare function ProgressIndicator({ density, className, ...props }: ProgressIndicatorProps): ReactElement;
+type ProgressLabelProps = ProgressPrimitive.Label.Props & IDensityProps;
+declare function ProgressLabel({ density, className, ...props }: ProgressLabelProps): ReactElement;
+type ProgressValueProps = ProgressPrimitive.Value.Props & IDensityProps;
+declare function ProgressValue({ density, className, ...props }: ProgressValueProps): ReactElement;
+export { Progress, ProgressTrack, ProgressIndicator, ProgressLabel, ProgressValue };

package/dist/components/RadioGroup.d.ts

@@ -0,0 +1,9 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { Radio as RadioPrimitive } from "@base-ui/react/radio";
+import { RadioGroup as RadioGroupPrimitive } from "@base-ui/react/radio-group";
+type RadioGroupProps = RadioGroupPrimitive.Props & IDensityProps;
+declare function RadioGroup({ density, className, ...props }: RadioGroupProps): ReactElement;
+type RadioGroupItemProps = RadioPrimitive.Root.Props & IDensityProps;
+declare function RadioGroupItem({ density, className, ...props }: RadioGroupItemProps): ReactElement;
+export { RadioGroup, RadioGroupItem };

package/dist/components/ScrollArea.d.ts

@@ -0,0 +1,10 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ReactElement, ReactNode } from "react";
+import { ScrollArea as ScrollAreaPrimitive } from "@base-ui/react/scroll-area";
+type ScrollAreaProps = ScrollAreaPrimitive.Root.Props & IDensityProps & {
+    scrollbars?: ReactNode;
+};
+declare function ScrollArea({ density, className, children, scrollbars, ...props }: ScrollAreaProps): ReactElement;
+type ScrollBarProps = ScrollAreaPrimitive.Scrollbar.Props & IDensityProps;
+declare function ScrollBar({ density, className, orientation, ...props }: ScrollBarProps): ReactElement;
+export { ScrollArea, ScrollBar };

package/dist/components/Select.d.ts

@@ -0,0 +1,25 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { Select as SelectPrimitive } from "@base-ui/react/select";
+declare const Select: typeof SelectPrimitive.Root;
+type SelectGroupProps = SelectPrimitive.Group.Props & IDensityProps;
+declare function SelectGroup({ density, className, ...props }: SelectGroupProps): ReactElement;
+type SelectValueProps = SelectPrimitive.Value.Props & IDensityProps;
+declare function SelectValue({ density, className, ...props }: SelectValueProps): ReactElement;
+type SelectTriggerProps = SelectPrimitive.Trigger.Props & {
+    size?: "sm" | "default";
+} & IDensityProps;
+declare function SelectTrigger({ density, className, size, children, ...props }: SelectTriggerProps): ReactElement;
+type SelectContentProps = SelectPrimitive.Popup.Props & Pick<SelectPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset" | "alignItemWithTrigger"> & IDensityProps;
+declare function SelectContent({ density, className, children, side, sideOffset, align, alignOffset, alignItemWithTrigger, ...props }: SelectContentProps): ReactElement;
+type SelectLabelProps = SelectPrimitive.GroupLabel.Props & IDensityProps;
+declare function SelectLabel({ density, className, ...props }: SelectLabelProps): ReactElement;
+type SelectItemProps = SelectPrimitive.Item.Props & IDensityProps;
+declare function SelectItem({ density, className, children, ...props }: SelectItemProps): ReactElement;
+type SelectSeparatorProps = SelectPrimitive.Separator.Props & IDensityProps;
+declare function SelectSeparator({ density, className, ...props }: SelectSeparatorProps): ReactElement;
+type SelectScrollUpButtonProps = ComponentProps<typeof SelectPrimitive.ScrollUpArrow> & IDensityProps;
+declare function SelectScrollUpButton({ density, className, ...props }: SelectScrollUpButtonProps): ReactElement;
+type SelectScrollDownButtonProps = ComponentProps<typeof SelectPrimitive.ScrollDownArrow> & IDensityProps;
+declare function SelectScrollDownButton({ density, className, ...props }: SelectScrollDownButtonProps): ReactElement;
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, };

package/dist/components/Separator.d.ts

@@ -0,0 +1,8 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { Separator as SeparatorPrimitive } from "@base-ui/react/separator";
+type SeparatorProps = SeparatorPrimitive.Props & IDensityProps & {
+    thickness?: "default" | "strong";
+};
+declare function Separator({ density, className, thickness, orientation, ...props }: SeparatorProps): ReactElement;
+export { Separator };

package/dist/components/Sheet.d.ts

@@ -0,0 +1,20 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+import { Dialog as SheetPrimitive } from "@base-ui/react/dialog";
+declare function Sheet<Payload>({ ...props }: SheetPrimitive.Root.Props<Payload>): ReactElement;
+declare function SheetTrigger<Payload>({ ...props }: SheetPrimitive.Trigger.Props<Payload>): ReactElement;
+declare function SheetClose({ ...props }: SheetPrimitive.Close.Props): ReactElement;
+type SheetContentProps = SheetPrimitive.Popup.Props & {
+    side?: "top" | "right" | "bottom" | "left";
+    showCloseButton?: boolean;
+} & IDensityProps;
+declare function SheetContent({ density, className, children, side, showCloseButton, ...props }: SheetContentProps): ReactElement;
+type SheetHeaderProps = ComponentProps<"div"> & IDensityProps;
+declare function SheetHeader({ density, className, ...props }: SheetHeaderProps): ReactElement;
+type SheetFooterProps = ComponentProps<"div"> & IDensityProps;
+declare function SheetFooter({ density, className, ...props }: SheetFooterProps): ReactElement;
+type SheetTitleProps = SheetPrimitive.Title.Props & IDensityProps;
+declare function SheetTitle({ density, className, ...props }: SheetTitleProps): ReactElement;
+type SheetDescriptionProps = SheetPrimitive.Description.Props & IDensityProps;
+declare function SheetDescription({ density, className, ...props }: SheetDescriptionProps): ReactElement;
+export { Sheet, SheetTrigger, SheetClose, SheetContent, SheetHeader, SheetFooter, SheetTitle, SheetDescription };

package/dist/components/Sidebar.d.ts

@@ -0,0 +1,60 @@
+import type { ComponentProps, ReactElement, ReactNode } from "react";
+import type { IDensityProps } from "../density/types.js";
+import type { SidebarStyle, SidebarPartState, SidebarMenuButtonState, SidebarMenuSubButtonState } from "../sidebar/types.js";
+import { useRender } from "@base-ui/react/use-render";
+import { type VariantProps } from "class-variance-authority";
+import { Button } from "./Button.js";
+import { Input } from "./Input.js";
+import { Separator } from "./Separator.js";
+import { TooltipContent } from "./Tooltip.js";
+type SidebarProviderProps = Omit<ComponentProps<"div">, "style"> & IDensityProps & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    style?: SidebarStyle;
+};
+declare function SidebarProvider({ density, defaultOpen, open: openProp, onOpenChange, className, style, children, onKeyDown, ...props }: SidebarProviderProps): ReactElement;
+type SidebarProps = Omit<ComponentProps<"aside">, "style"> & IDensityProps & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+    style?: SidebarStyle;
+};
+declare function Sidebar({ density, side, variant, collapsible, className, children, dir, style, ref, ...props }: SidebarProps): ReactElement;
+declare function SidebarTrigger({ density, className, onClick, ...props }: ComponentProps<typeof Button> & IDensityProps): ReactElement;
+declare function SidebarRail({ density, className, onClick, type, ...props }: ComponentProps<"button"> & IDensityProps): ReactElement;
+declare function SidebarInset({ density, className, ...props }: ComponentProps<"main"> & IDensityProps): ReactElement;
+declare function SidebarInput({ density, className, ...props }: ComponentProps<typeof Input> & IDensityProps): ReactElement;
+declare function SidebarHeader({ density, className, ...props }: ComponentProps<"div"> & IDensityProps): ReactElement;
+declare function SidebarFooter({ density, className, ...props }: ComponentProps<"div"> & IDensityProps): ReactElement;
+declare function SidebarSeparator({ density, className, ...props }: ComponentProps<typeof Separator> & IDensityProps): ReactElement;
+declare function SidebarContent({ density, className, ...props }: ComponentProps<"div"> & IDensityProps): ReactElement;
+declare function SidebarGroup({ density, className, ...props }: ComponentProps<"div"> & IDensityProps): ReactElement;
+declare function SidebarGroupLabel({ density, className, render, ...props }: useRender.ComponentProps<"div", SidebarPartState> & ComponentProps<"div"> & IDensityProps): ReactElement;
+declare function SidebarGroupAction({ density, className, render, type, ...props }: useRender.ComponentProps<"button", SidebarPartState> & ComponentProps<"button"> & IDensityProps): ReactElement;
+declare function SidebarGroupContent({ density, className, ...props }: ComponentProps<"div"> & IDensityProps): ReactElement;
+declare function SidebarMenu({ density, className, ...props }: ComponentProps<"ul"> & IDensityProps): ReactElement;
+declare function SidebarMenuItem({ density, className, ...props }: ComponentProps<"li"> & IDensityProps): ReactElement;
+declare const sidebarMenuButtonVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function SidebarMenuButton({ render, isActive, variant, size, tooltip, type, density, className, children, trailing, ...props }: useRender.ComponentProps<"button", SidebarMenuButtonState> & ComponentProps<"button"> & {
+    trailing?: ReactNode;
+    isActive?: boolean;
+    tooltip?: string | ComponentProps<typeof TooltipContent>;
+} & VariantProps<typeof sidebarMenuButtonVariants> & IDensityProps): ReactElement;
+declare function SidebarMenuAction({ density, className, render, type, showOnHover, ...props }: useRender.ComponentProps<"button", SidebarPartState> & ComponentProps<"button"> & {
+    showOnHover?: boolean;
+} & IDensityProps): ReactElement;
+declare function SidebarMenuBadge({ density, className, ...props }: ComponentProps<"div"> & IDensityProps): ReactElement;
+declare function SidebarMenuSkeleton({ density, className, showIcon, ...props }: ComponentProps<"div"> & {
+    showIcon?: boolean;
+} & IDensityProps): ReactElement;
+declare function SidebarMenuSub({ density, className, ...props }: ComponentProps<"ul"> & IDensityProps): ReactElement;
+declare function SidebarMenuSubItem({ density, className, ...props }: ComponentProps<"li"> & IDensityProps): ReactElement;
+declare function SidebarMenuSubButton({ render, size, isActive, density, className, ...props }: useRender.ComponentProps<"a", SidebarMenuSubButtonState> & ComponentProps<"a"> & {
+    size?: "sm" | "md";
+    isActive?: boolean;
+} & IDensityProps): ReactElement;
+export { Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, };

package/dist/components/Skeleton.d.ts

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

package/dist/components/Slider.d.ts

@@ -0,0 +1,6 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { Slider as SliderPrimitive } from "@base-ui/react/slider";
+type SliderProps<Value extends number | readonly number[] = number | readonly number[]> = SliderPrimitive.Root.Props<Value> & IDensityProps & Pick<SliderPrimitive.Thumb.Props, "getAriaLabel" | "getAriaValueText">;
+declare function Slider<Value extends number | readonly number[] = number | readonly number[]>({ density, className, defaultValue, value, min, max, getAriaLabel, getAriaValueText, ...props }: SliderProps<Value>): ReactElement;
+export { Slider };

package/dist/components/Spinner.d.ts

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

package/dist/components/StarRating.d.ts

@@ -0,0 +1,10 @@
+import type { ReactElement } from "react";
+import type { IDensityProps } from "../density/types.js";
+interface IStarRatingProps extends IDensityProps {
+    label: string;
+    value: number;
+    disabled?: boolean;
+    onValueChange: (value: number) => void;
+}
+export declare function StarRating({ label, value, disabled, density, onValueChange }: IStarRatingProps): ReactElement;
+export {};

package/dist/components/Switch.d.ts

@@ -0,0 +1,8 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { Switch as SwitchPrimitive } from "@base-ui/react/switch";
+type SwitchProps = SwitchPrimitive.Root.Props & {
+    size?: "sm" | "default";
+} & IDensityProps;
+declare function Switch({ density, className, size, ...props }: SwitchProps): ReactElement;
+export { Switch };