@alexgorbatchev/shadcn 0.0.0-stage → 0.0.12

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/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/Progress.d.ts

@@ -0,0 +1,14 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { Progress as ProgressPrimitive } from "@base-ui/react/progress";
+type ProgressProps = ProgressPrimitive.Root.Props & IDensityProps;
+declare function Progress({ density, className, children, value, ...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, ...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" | "lg" | "sm" | 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 };

package/dist/components/Table.d.ts

@@ -0,0 +1,28 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ComponentProps, ReactElement } from "react";
+type TableProps = ComponentProps<"table"> & IDensityProps & {
+    layout?: "auto" | "fixed";
+};
+declare function Table({ density, className, dir, layout, ...props }: TableProps): ReactElement;
+type TableHeaderProps = ComponentProps<"thead"> & IDensityProps;
+declare function TableHeader({ density, className, ...props }: TableHeaderProps): ReactElement;
+type TableBodyProps = ComponentProps<"tbody"> & IDensityProps;
+declare function TableBody({ density, className, ...props }: TableBodyProps): ReactElement;
+type TableFooterProps = ComponentProps<"tfoot"> & IDensityProps;
+declare function TableFooter({ density, className, ...props }: TableFooterProps): ReactElement;
+type TableRowProps = ComponentProps<"tr"> & IDensityProps;
+declare function TableRow({ density, className, ...props }: TableRowProps): ReactElement;
+type TableTextAlign = "start" | "center" | "end";
+type TableVisibility = "sm" | "lg" | "container-sm" | "container-md";
+interface ITableCellOptions {
+    truncate?: boolean;
+    textAlign?: TableTextAlign;
+    visibleFrom?: TableVisibility;
+}
+type TableHeadProps = ComponentProps<"th"> & IDensityProps & ITableCellOptions;
+declare function TableHead({ density, className, truncate, textAlign, visibleFrom, ...props }: TableHeadProps): ReactElement;
+type TableCellProps = ComponentProps<"td"> & IDensityProps & ITableCellOptions;
+declare function TableCell({ density, className, truncate, textAlign, visibleFrom, ...props }: TableCellProps): ReactElement;
+type TableCaptionProps = ComponentProps<"caption"> & IDensityProps;
+declare function TableCaption({ density, className, ...props }: TableCaptionProps): ReactElement;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption };

package/dist/components/Tabs.d.ts

@@ -0,0 +1,16 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { Tabs as TabsPrimitive } from "@base-ui/react/tabs";
+import { type VariantProps } from "class-variance-authority";
+type TabsProps = TabsPrimitive.Root.Props & IDensityProps;
+declare function Tabs({ density, className, orientation, ...props }: TabsProps): ReactElement;
+declare const tabsListVariants: (props?: ({
+    variant?: "default" | "line" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type TabsListProps = TabsPrimitive.List.Props & VariantProps<typeof tabsListVariants> & IDensityProps;
+declare function TabsList({ density, className, variant, ...props }: TabsListProps): ReactElement;
+type TabsTriggerProps = TabsPrimitive.Tab.Props & IDensityProps;
+declare function TabsTrigger({ density, className, ...props }: TabsTriggerProps): ReactElement;
+type TabsContentProps = TabsPrimitive.Panel.Props & IDensityProps;
+declare function TabsContent({ density, className, ...props }: TabsContentProps): ReactElement;
+export { Tabs, TabsList, TabsTrigger, TabsContent, tabsListVariants };

package/dist/components/Textarea.d.ts

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

package/dist/components/ThemeProvider.d.ts

@@ -0,0 +1,9 @@
+import { type ReactElement, type ReactNode } from "react";
+import type { ResolvedTheme, ThemeMode } from "../theme/types.js";
+export interface IThemeProviderProps {
+    children: ReactNode;
+    defaultTheme?: ThemeMode;
+    storageKey?: string;
+    forcedTheme?: ResolvedTheme;
+}
+export declare function ThemeProvider({ children, defaultTheme, storageKey, forcedTheme, }: IThemeProviderProps): ReactElement;

package/dist/components/Toast.d.ts

@@ -0,0 +1,18 @@
+import type { ReactElement } from "react";
+import type { IDensityProps } from "../density/types.js";
+import { Toast as ToastPrimitive } from "@base-ui/react/toast";
+declare function ToastProvider(props: ToastPrimitive.Provider.Props): ReactElement;
+declare function ToastPortal(props: ToastPrimitive.Portal.Props): ReactElement;
+type ToastViewportProps = ToastPrimitive.Viewport.Props & IDensityProps;
+declare function ToastViewport({ density, dir, className, ...props }: ToastViewportProps): ReactElement;
+type ToastProps = ToastPrimitive.Root.Props & IDensityProps;
+declare function Toast({ density, className, ...props }: ToastProps): ReactElement;
+declare function ToastContent({ className, ...props }: ToastPrimitive.Content.Props): ReactElement;
+declare function ToastTitle({ className, ...props }: ToastPrimitive.Title.Props): ReactElement;
+declare function ToastDescription({ className, ...props }: ToastPrimitive.Description.Props): ReactElement;
+declare function ToastAction({ className, render, ...props }: ToastPrimitive.Action.Props): ReactElement;
+declare function ToastClose({ className, children, render, ...props }: ToastPrimitive.Close.Props): ReactElement;
+type ToastToasterProps = ToastPrimitive.Provider.Props & IDensityProps;
+declare function ToastToaster({ children, density, ...props }: ToastToasterProps): ReactElement;
+declare const createToastManager: typeof ToastPrimitive.createToastManager;
+export { Toast, ToastToaster, ToastProvider, ToastPortal, ToastViewport, ToastContent, ToastTitle, ToastDescription, ToastAction, ToastClose, createToastManager, };

package/dist/components/Toggle.d.ts

@@ -0,0 +1,11 @@
+import type { ReactElement } from "react";
+import type { IDensityProps } from "../density/types.js";
+import { Toggle as TogglePrimitive } from "@base-ui/react/toggle";
+import { type VariantProps } from "class-variance-authority";
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "lg" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ToggleProps = TogglePrimitive.Props & VariantProps<typeof toggleVariants> & IDensityProps;
+declare function Toggle({ density, className, variant, size, ...props }: ToggleProps): ReactElement;
+export { Toggle, toggleVariants };

package/dist/components/ToggleGroup.d.ts

@@ -0,0 +1,12 @@
+import { type ReactElement } from "react";
+import { ToggleGroup as ToggleGroupPrimitive } from "@base-ui/react/toggle-group";
+import type { VariantProps } from "class-variance-authority";
+import type { IDensityProps } from "../density/types.js";
+import { toggleVariants, type ToggleProps } from "./Toggle.js";
+export type ToggleGroupProps = ToggleGroupPrimitive.Props & VariantProps<typeof toggleVariants> & IDensityProps & IToggleGroupLayout;
+interface IToggleGroupLayout {
+    spacing?: number;
+}
+export declare function ToggleGroup({ density, className, variant, size, spacing, orientation, children, style, ...props }: ToggleGroupProps): ReactElement;
+export declare function ToggleGroupItem({ density, className, variant, size, ...props }: ToggleProps): ReactElement;
+export {};

package/dist/components/Tooltip.d.ts

@@ -0,0 +1,9 @@
+import type { IDensityProps } from "../density/types.js";
+import type { ReactElement } from "react";
+import { Tooltip as TooltipPrimitive } from "@base-ui/react/tooltip";
+declare function TooltipProvider({ delay, ...props }: TooltipPrimitive.Provider.Props): ReactElement;
+declare function Tooltip<Payload>({ ...props }: TooltipPrimitive.Root.Props<Payload>): ReactElement;
+declare function TooltipTrigger<Payload>({ ...props }: TooltipPrimitive.Trigger.Props<Payload>): ReactElement;
+type TooltipContentProps = TooltipPrimitive.Popup.Props & Pick<TooltipPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset"> & IDensityProps;
+declare function TooltipContent({ density, className, side, sideOffset, align, alignOffset, children, ...props }: TooltipContentProps): ReactElement;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/components/calendar/Calendar.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentProps, ReactElement } from "react";
+import type { CalendarProps } from "./types.js";
+import { DayButton } from "@daypicker/react";
+declare function Calendar({ density, className, classNames, showOutsideDays, captionLayout, buttonVariant, locale, formatters, components, ...props }: CalendarProps): ReactElement;
+declare function CalendarDayButton({ className, day, modifiers, ...props }: ComponentProps<typeof DayButton>): ReactElement;
+export { Calendar, CalendarDayButton };

package/dist/components/calendar/getCalendarClassNames.d.ts

@@ -0,0 +1,3 @@
+import type { CalendarProps } from "./types.js";
+declare function getCalendarClassNames({ buttonVariant, classNames, }: CalendarProps): NonNullable<CalendarProps["classNames"]>;
+export { getCalendarClassNames };

package/dist/components/calendar/index.d.ts

@@ -0,0 +1 @@
+export { Calendar, CalendarDayButton } from "./Calendar.js";

package/dist/components/calendar/index.js

@@ -0,0 +1,10 @@
+import"../../chunk-cp2m7y7v.js";
+import"../../chunk-tnktkgvp.js";
+import {
+  Calendar2,
+  CalendarDayButton2
+} from "../../chunk-8a7dn9ps.js";
+export {
+  Calendar2 as Calendar,
+  CalendarDayButton2 as CalendarDayButton
+};

package/dist/components/calendar/types.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentProps } from "react";
+import type { DayPicker } from "@daypicker/react";
+import type { IDensityProps } from "../../density/types.js";
+import type { VariantProps } from "class-variance-authority";
+import type { buttonVariants } from "../Button.js";
+type CalendarProps = ComponentProps<typeof DayPicker> & IDensityProps & {
+    buttonVariant?: VariantProps<typeof buttonVariants>["variant"];
+};
+export type { CalendarProps };

package/dist/components/carousel/Carousel.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentProps, ReactElement } from "react";
+import type { CarouselProps } from "./types.js";
+import { Button } from "../Button.js";
+declare function Carousel({ density, orientation, opts, setApi, plugins, className, children, onKeyDown, ...props }: CarouselProps): ReactElement;
+declare function CarouselContent({ className, ...props }: ComponentProps<"div">): ReactElement;
+declare function CarouselItem({ className, ...props }: ComponentProps<"div">): ReactElement;
+declare function CarouselPrevious({ className, variant, size, disabled, onClick, children, ...props }: ComponentProps<typeof Button>): ReactElement;
+declare function CarouselNext({ className, variant, size, disabled, onClick, children, ...props }: ComponentProps<typeof Button>): ReactElement;
+export { Carousel, CarouselContent, CarouselItem, CarouselPrevious, CarouselNext };

package/dist/components/carousel/CarouselContext.d.ts

@@ -0,0 +1,2 @@
+import type { ICarouselContextValue } from "./types.js";
+export declare const CarouselContext: import("react").Context<ICarouselContextValue | null>;

package/dist/components/carousel/hooks/useCarousel.d.ts

@@ -0,0 +1,2 @@
+import type { ICarouselContextValue } from "../types.js";
+export declare function useCarousel(): ICarouselContextValue;

package/dist/components/carousel/index.d.ts

@@ -0,0 +1,3 @@
+export { Carousel, CarouselContent, CarouselItem, CarouselPrevious, CarouselNext } from "./Carousel.js";
+export type { CarouselApi, CarouselOptions, CarouselPlugins, CarouselProps } from "./types.js";
+export { useCarousel } from "./hooks/useCarousel.js";