@xploreu/components 0.4.47 → 0.4.48

package/dist/primitives/combobox.d.ts

@@ -0,0 +1,79 @@
+import * as React from 'react';
+import { Combobox as Combobox$1 } from '@base-ui/react/combobox';
+import { HTMLMotionProps } from 'motion/react';
+import { HighlightProps, HighlightItemProps } from '../effects/highlight.js';
+
+type ComboboxContextType = {
+    open: boolean;
+    setOpen: (open: boolean, eventDetails: Combobox$1.Root.ChangeEventDetails) => void;
+    inputValue: string;
+    setInputValue: (inputValue: string, eventDetails: Combobox$1.Root.ChangeEventDetails) => void;
+};
+type ComboboxActiveValueContextType = {
+    highlightedValue: string | null;
+    setHighlightedValue: (value: string | null) => void;
+};
+declare const useCombobox: () => ComboboxContextType;
+declare const useComboboxActiveValue: () => ComboboxActiveValueContextType;
+type ComboboxProps<Value, Multiple extends boolean | undefined = false> = Combobox$1.Root.Props<Value, Multiple> & {
+    behavior?: "default" | "chip-outside";
+};
+declare function Combobox<Value, Multiple extends boolean | undefined = false>({ behavior, ...props }: ComboboxProps<Value, Multiple>): React.JSX.Element;
+type ComboboxTriggerProps = Combobox$1.Trigger.Props;
+declare function ComboboxTrigger(props: ComboboxTriggerProps): React.JSX.Element;
+type ComboboxLabelProps = Combobox$1.Label.Props;
+declare function ComboboxLabel(props: ComboboxLabelProps): React.JSX.Element;
+type ComboboxInputGroupProps = Combobox$1.InputGroup.Props;
+declare function ComboboxInputGroup(props: ComboboxInputGroupProps): React.JSX.Element;
+type ComboboxInputProps = Combobox$1.Input.Props;
+declare function ComboboxInput(props: ComboboxInputProps): React.JSX.Element;
+type ComboboxIconProps = Combobox$1.Icon.Props;
+declare function ComboboxIcon(props: ComboboxIconProps): React.JSX.Element;
+type ComboboxClearProps = Combobox$1.Clear.Props;
+declare function ComboboxClear(props: ComboboxClearProps): React.JSX.Element;
+type ComboboxValueProps = Combobox$1.Value.Props;
+declare function ComboboxValue(props: ComboboxValueProps): React.JSX.Element;
+type ComboboxChipsProps = Combobox$1.Chips.Props;
+declare function ComboboxChips(props: ComboboxChipsProps): React.JSX.Element;
+type ComboboxChipProps = Combobox$1.Chip.Props;
+declare function ComboboxChip(props: ComboboxChipProps): React.JSX.Element;
+type ComboboxChipRemoveProps = Combobox$1.ChipRemove.Props;
+declare function ComboboxChipRemove(props: ComboboxChipRemoveProps): React.JSX.Element;
+type ComboboxPortalProps = Omit<Combobox$1.Portal.Props, "keepMounted">;
+declare function ComboboxPortal(props: ComboboxPortalProps): React.JSX.Element;
+type ComboboxPositionerProps = Combobox$1.Positioner.Props;
+declare function ComboboxPositioner(props: ComboboxPositionerProps): React.JSX.Element;
+type ComboboxPopupProps = Omit<Combobox$1.Popup.Props, "render"> & HTMLMotionProps<"div">;
+declare function ComboboxPopup({ initialFocus, finalFocus, transition, ...props }: ComboboxPopupProps): React.JSX.Element;
+type ComboboxBackdropProps = Combobox$1.Backdrop.Props;
+declare function ComboboxBackdrop(props: ComboboxBackdropProps): React.JSX.Element;
+type ComboboxStatusProps = Combobox$1.Status.Props;
+declare function ComboboxStatus(props: ComboboxStatusProps): React.JSX.Element;
+type ComboboxEmptyProps = Combobox$1.Empty.Props;
+declare function ComboboxEmpty(props: ComboboxEmptyProps): React.JSX.Element;
+type ComboboxListProps = Combobox$1.List.Props;
+declare function ComboboxList(props: ComboboxListProps): React.JSX.Element;
+type ComboboxHighlightProps = Omit<HighlightProps, "controlledItems" | "enabled" | "hover">;
+declare function ComboboxHighlight({ transition, ...props }: ComboboxHighlightProps): React.JSX.Element;
+type ComboboxHighlightItemProps = HighlightItemProps;
+declare function ComboboxHighlightItem(props: ComboboxHighlightItemProps): React.JSX.Element;
+type ComboboxRowProps = Combobox$1.Row.Props;
+declare function ComboboxRow(props: ComboboxRowProps): React.JSX.Element;
+type ComboboxItemProps = Combobox$1.Item.Props;
+declare function ComboboxItem(props: ComboboxItemProps): React.JSX.Element;
+type ComboboxItemIndicatorProps = Combobox$1.ItemIndicator.Props;
+declare function ComboboxItemIndicator(props: ComboboxItemIndicatorProps): React.JSX.Element;
+type ComboboxSeparatorProps = Combobox$1.Separator.Props;
+declare function ComboboxSeparator(props: ComboboxSeparatorProps): React.JSX.Element;
+type ComboboxGroupProps = Combobox$1.Group.Props;
+declare function ComboboxGroup(props: ComboboxGroupProps): React.JSX.Element;
+type ComboboxGroupLabelProps = Combobox$1.GroupLabel.Props;
+declare function ComboboxGroupLabel(props: ComboboxGroupLabelProps): React.JSX.Element;
+type ComboboxCollectionProps = Combobox$1.Collection.Props;
+declare function ComboboxCollection(props: ComboboxCollectionProps): React.JSX.Element;
+type ComboboxArrowProps = Combobox$1.Arrow.Props;
+declare function ComboboxArrow(props: ComboboxArrowProps): React.JSX.Element;
+declare const useFilteredItems: typeof Combobox$1.useFilteredItems;
+declare const useFilter: typeof Combobox$1.useFilter;
+
+export { Combobox, type ComboboxActiveValueContextType, ComboboxArrow, type ComboboxArrowProps, ComboboxBackdrop, type ComboboxBackdropProps, ComboboxChip, type ComboboxChipProps, ComboboxChipRemove, type ComboboxChipRemoveProps, ComboboxChips, type ComboboxChipsProps, ComboboxClear, type ComboboxClearProps, ComboboxCollection, type ComboboxCollectionProps, type ComboboxContextType, ComboboxEmpty, type ComboboxEmptyProps, ComboboxGroup, ComboboxGroupLabel, type ComboboxGroupLabelProps, type ComboboxGroupProps, ComboboxHighlight, ComboboxHighlightItem, type ComboboxHighlightItemProps, type ComboboxHighlightProps, ComboboxIcon, type ComboboxIconProps, ComboboxInput, ComboboxInputGroup, type ComboboxInputGroupProps, type ComboboxInputProps, ComboboxItem, ComboboxItemIndicator, type ComboboxItemIndicatorProps, type ComboboxItemProps, ComboboxLabel, type ComboboxLabelProps, ComboboxList, type ComboboxListProps, ComboboxPopup, type ComboboxPopupProps, ComboboxPortal, type ComboboxPortalProps, ComboboxPositioner, type ComboboxPositionerProps, type ComboboxProps, ComboboxRow, type ComboboxRowProps, ComboboxSeparator, type ComboboxSeparatorProps, ComboboxStatus, type ComboboxStatusProps, ComboboxTrigger, type ComboboxTriggerProps, ComboboxValue, type ComboboxValueProps, useCombobox, useComboboxActiveValue, useFilter, useFilteredItems };

package/dist/primitives/dialog.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import { Dialog as Dialog$1 } from '@base-ui/react/dialog';
+import { HTMLMotionProps } from 'motion/react';
+
+type DialogContextType = {
+    open: boolean;
+    setOpen: DialogProps['onOpenChange'];
+};
+declare const useDialog: () => DialogContextType;
+type DialogProps = React.ComponentProps<typeof Dialog$1.Root>;
+declare function Dialog({ open: openProp, defaultOpen, onOpenChange, ...props }: DialogProps): React.JSX.Element;
+type DialogTriggerProps = React.ComponentProps<typeof Dialog$1.Trigger>;
+declare function DialogTrigger(props: DialogTriggerProps): React.JSX.Element;
+type DialogPortalProps = Omit<React.ComponentProps<typeof Dialog$1.Portal>, 'keepMounted'>;
+declare function DialogPortal(props: DialogPortalProps): React.JSX.Element;
+type DialogBackdropProps = Omit<React.ComponentProps<typeof Dialog$1.Backdrop>, 'render'> & HTMLMotionProps<'div'>;
+declare function DialogBackdrop({ transition, ...props }: DialogBackdropProps): React.JSX.Element;
+type DialogFlipDirection = 'top' | 'bottom' | 'left' | 'right';
+type DialogPopupProps = Omit<React.ComponentProps<typeof Dialog$1.Popup>, 'render'> & HTMLMotionProps<'div'> & {
+    from?: DialogFlipDirection;
+};
+declare function DialogPopup({ from, initialFocus, finalFocus, transition, className, ...props }: DialogPopupProps): React.JSX.Element;
+type DialogCloseProps = React.ComponentProps<typeof Dialog$1.Close>;
+declare function DialogClose(props: DialogCloseProps): React.JSX.Element;
+type DialogHeaderProps = React.ComponentProps<'div'>;
+declare function DialogHeader(props: DialogHeaderProps): React.JSX.Element;
+type DialogFooterProps = React.ComponentProps<'div'>;
+declare function DialogFooter(props: DialogFooterProps): React.JSX.Element;
+type DialogTitleProps = React.ComponentProps<typeof Dialog$1.Title>;
+declare function DialogTitle(props: DialogTitleProps): React.JSX.Element;
+type DialogDescriptionProps = React.ComponentProps<typeof Dialog$1.Description>;
+declare function DialogDescription(props: DialogDescriptionProps): React.JSX.Element;
+
+export { Dialog, DialogBackdrop, type DialogBackdropProps, DialogClose, type DialogCloseProps, type DialogContextType, DialogDescription, type DialogDescriptionProps, type DialogFlipDirection, DialogFooter, type DialogFooterProps, DialogHeader, type DialogHeaderProps, DialogPopup, type DialogPopupProps, DialogPortal, type DialogPortalProps, type DialogProps, DialogTitle, type DialogTitleProps, DialogTrigger, type DialogTriggerProps, useDialog };

package/dist/primitives/index.d.ts

@@ -0,0 +1,47 @@
+export { Combobox, ComboboxActiveValueContextType, ComboboxArrow, ComboboxArrowProps, ComboboxBackdrop, ComboboxBackdropProps, ComboboxChip, ComboboxChipProps, ComboboxChipRemove, ComboboxChipRemoveProps, ComboboxChips, ComboboxChipsProps, ComboboxClear, ComboboxClearProps, ComboboxCollection, ComboboxCollectionProps, ComboboxContextType, ComboboxEmpty, ComboboxEmptyProps, ComboboxGroup, ComboboxGroupLabel, ComboboxGroupLabelProps, ComboboxGroupProps, ComboboxHighlight, ComboboxHighlightItem, ComboboxHighlightItemProps, ComboboxHighlightProps, ComboboxIcon, ComboboxIconProps, ComboboxInput, ComboboxInputGroup, ComboboxInputGroupProps, ComboboxInputProps, ComboboxItem, ComboboxItemIndicator, ComboboxItemIndicatorProps, ComboboxItemProps, ComboboxLabel, ComboboxLabelProps, ComboboxList, ComboboxListProps, ComboboxPopup, ComboboxPopupProps, ComboboxPortal, ComboboxPortalProps, ComboboxPositioner, ComboboxPositionerProps, ComboboxProps, ComboboxRow, ComboboxRowProps, ComboboxSeparator, ComboboxSeparatorProps, ComboboxStatus, ComboboxStatusProps, ComboboxTrigger, ComboboxTriggerProps, ComboboxValue, ComboboxValueProps, useCombobox, useComboboxActiveValue, useFilter, useFilteredItems } from './combobox.js';
+export { AnyProps, DOMMotionProps, Slot, SlotProps, WithAsChild } from './slot.js';
+export { Dialog, DialogBackdrop, DialogBackdropProps, DialogClose, DialogCloseProps, DialogContextType, DialogDescription, DialogDescriptionProps, DialogFlipDirection, DialogFooter, DialogFooterProps, DialogHeader, DialogHeaderProps, DialogPopup, DialogPopupProps, DialogPortal, DialogPortalProps, DialogProps, DialogTitle, DialogTitleProps, DialogTrigger, DialogTriggerProps, useDialog } from './dialog.js';
+export { AlertDialog, AlertDialogBackdrop, AlertDialogBackdropProps, AlertDialogClose, AlertDialogCloseProps, AlertDialogDescription, AlertDialogDescriptionProps, AlertDialogFooter, AlertDialogFooterProps, AlertDialogHeader, AlertDialogHeaderProps, AlertDialogPopup, AlertDialogPopupProps, AlertDialogPortal, AlertDialogPortalProps, AlertDialogProps, AlertDialogTitle, AlertDialogTitleProps, AlertDialogTrigger, AlertDialogTriggerProps, useAlertDialog } from './alert-dialog.js';
+export { Sheet, SheetClose, SheetCloseProps, SheetContent, SheetContentProps, SheetDescription, SheetDescriptionProps, SheetFooter, SheetFooterProps, SheetHeader, SheetHeaderProps, SheetOverlay, SheetOverlayProps, SheetPopup, SheetPopupProps, SheetPortal, SheetPortalProps, SheetProps, SheetSide, SheetTitle, SheetTitleProps, SheetTrigger, SheetTriggerProps, useSheet } from './sheet.js';
+export { Popover, PopoverArrow, PopoverArrowProps, PopoverBackdrop, PopoverBackdropProps, PopoverClose, PopoverCloseProps, PopoverContextType, PopoverDescription, PopoverDescriptionProps, PopoverPopup, PopoverPopupProps, PopoverPortal, PopoverPortalProps, PopoverPositioner, PopoverPositionerProps, PopoverProps, PopoverTitle, PopoverTitleProps, PopoverTrigger, PopoverTriggerProps, usePopover } from './popover.js';
+export { Menu, MenuActiveValueContextType, MenuArrow, MenuArrowProps, MenuCheckboxItem, MenuCheckboxItemIndicator, MenuCheckboxItemIndicatorProps, MenuCheckboxItemProps, MenuContextType, MenuGroup, MenuGroupLabel, MenuGroupLabelProps, MenuGroupProps, MenuHighlight, MenuHighlightItem, MenuHighlightItemProps, MenuHighlightProps, MenuItem, MenuItemProps, MenuPopup, MenuPopupProps, MenuPortal, MenuPortalProps, MenuPositioner, MenuPositionerProps, MenuProps, MenuRadioGroup, MenuRadioGroupProps, MenuRadioItem, MenuRadioItemIndicator, MenuRadioItemIndicatorProps, MenuRadioItemProps, MenuSeparator, MenuSeparatorProps, MenuShortcut, MenuShortcutProps, MenuSubmenu, MenuSubmenuProps, MenuSubmenuTrigger, MenuSubmenuTriggerProps, MenuTrigger, MenuTriggerProps, useMenu, useMenuActiveValue } from './menu.js';
+export { Tabs, TabsHighlight, TabsHighlightItem, TabsHighlightItemProps, TabsHighlightProps, TabsList, TabsListProps, TabsPanel, TabsPanelProps, TabsPanels, TabsPanelsProps, TabsProps, TabsTab, TabsTabProps } from './tabs.js';
+export { Tooltip, TooltipArrow, TooltipArrowProps, TooltipContextType, TooltipPopup, TooltipPopupProps, TooltipPortal, TooltipPortalProps, TooltipPositioner, TooltipPositionerProps, TooltipProps, TooltipProvider, TooltipProviderProps, TooltipTrigger, TooltipTriggerProps, useTooltip } from './tooltip.js';
+export { SliderControlPrimitive, SliderControlPrimitiveProps, SliderIndicatorPrimitive, SliderIndicatorPrimitiveProps, SliderPrimitive, SliderPrimitiveProps, SliderThumbPrimitive, SliderThumbPrimitiveProps, SliderTrackPrimitive, SliderTrackPrimitiveProps, SliderValuePrimitive, SliderValuePrimitiveProps } from './slider.js';
+export { Accordion, AccordionContextType, AccordionHeader, AccordionHeaderProps, AccordionItem, AccordionItemContextType, AccordionItemProps, AccordionPanel, AccordionPanelProps, AccordionProps, AccordionTrigger, AccordionTriggerProps, useAccordion, useAccordionItem } from './accordion.js';
+export { Collapsible, CollapsibleContextType, CollapsiblePanel, CollapsiblePanelProps, CollapsibleProps, CollapsibleTrigger, CollapsibleTriggerProps, useCollapsible } from './collapsible.js';
+export { Toast, ToastAction, ToastActionProps, ToastClose, ToastCloseProps, ToastContent, ToastContentProps, ToastDescription, ToastDescriptionProps, ToastPortal, ToastPortalProps, ToastProps, ToastProvider, ToastProviderProps, ToastTitle, ToastTitleProps, ToastViewport, ToastViewportProps, createToastManager, toast, useToastManager } from './toast.js';
+export { Avatar, AvatarFallback, AvatarFallbackProps, AvatarImage, AvatarImageProps, AvatarProps } from './avatar.js';
+import * as React from 'react';
+import { ScrollArea as ScrollArea$1 } from '@base-ui/react/scroll-area';
+import '@base-ui/react/combobox';
+import 'motion/react';
+import '../effects/highlight.js';
+import '@base-ui/react/dialog';
+import '@base-ui/react/alert-dialog';
+import '@base-ui/react/popover';
+import '@base-ui/react/menu';
+import '@base-ui/react/tabs';
+import '../effects/auto-height.js';
+import '@base-ui/react/tooltip';
+import '@base-ui/react/slider';
+import '@base-ui/react/accordion';
+import '@base-ui/react/collapsible';
+import '@base-ui/react';
+import '@base-ui/react/toast';
+import '@base-ui/react/avatar';
+
+type ScrollAreaProps = React.ComponentProps<typeof ScrollArea$1.Root>;
+declare function ScrollArea(props: ScrollAreaProps): React.JSX.Element;
+type ScrollAreaViewportProps = React.ComponentProps<typeof ScrollArea$1.Viewport>;
+declare function ScrollAreaViewport(props: ScrollAreaViewportProps): React.JSX.Element;
+type ScrollAreaContentProps = React.ComponentProps<typeof ScrollArea$1.Content>;
+declare function ScrollAreaContent(props: ScrollAreaContentProps): React.JSX.Element;
+type ScrollAreaScrollbarProps = React.ComponentProps<typeof ScrollArea$1.Scrollbar>;
+declare function ScrollAreaScrollbar(props: ScrollAreaScrollbarProps): React.JSX.Element;
+type ScrollAreaThumbProps = React.ComponentProps<typeof ScrollArea$1.Thumb>;
+declare function ScrollAreaThumb(props: ScrollAreaThumbProps): React.JSX.Element;
+type ScrollAreaCornerProps = React.ComponentProps<typeof ScrollArea$1.Corner>;
+declare function ScrollAreaCorner(props: ScrollAreaCornerProps): React.JSX.Element;
+
+export { ScrollArea, ScrollAreaContent, type ScrollAreaContentProps, ScrollAreaCorner, type ScrollAreaCornerProps, type ScrollAreaProps, ScrollAreaScrollbar, type ScrollAreaScrollbarProps, ScrollAreaThumb, type ScrollAreaThumbProps, ScrollAreaViewport, type ScrollAreaViewportProps };

package/dist/primitives/menu.d.ts

@@ -0,0 +1,61 @@
+import * as React from 'react';
+import { Menu as Menu$1 } from '@base-ui/react/menu';
+import { HTMLMotionProps } from 'motion/react';
+import { HighlightProps, HighlightItemProps } from '../effects/highlight.js';
+
+type MenuActiveValueContextType = {
+    highlightedValue: string | null;
+    setHighlightedValue: (value: string | null) => void;
+};
+type MenuContextType = {
+    isOpen: boolean;
+    setIsOpen: MenuProps["onOpenChange"];
+};
+declare const useMenuActiveValue: () => MenuActiveValueContextType;
+declare const useMenu: () => MenuContextType;
+type MenuProps = React.ComponentProps<typeof Menu$1.Root>;
+declare function Menu(props: MenuProps): React.JSX.Element;
+type MenuTriggerProps = React.ComponentProps<typeof Menu$1.Trigger>;
+declare function MenuTrigger(props: MenuTriggerProps): React.JSX.Element;
+type MenuPortalProps = Omit<React.ComponentProps<typeof Menu$1.Portal>, "keepMounted">;
+declare function MenuPortal(props: MenuPortalProps): React.JSX.Element;
+type MenuPositionerProps = React.ComponentProps<typeof Menu$1.Positioner>;
+declare function MenuPositioner(props: MenuPositionerProps): React.JSX.Element;
+type MenuPopupProps = Omit<React.ComponentProps<typeof Menu$1.Popup>, "render"> & HTMLMotionProps<"div">;
+declare function MenuPopup({ finalFocus, id, transition, style, ...props }: MenuPopupProps): React.JSX.Element;
+type MenuGroupProps = React.ComponentProps<typeof Menu$1.Group>;
+declare function MenuGroup(props: MenuGroupProps): React.JSX.Element;
+type MenuGroupLabelProps = React.ComponentProps<typeof Menu$1.GroupLabel>;
+declare function MenuGroupLabel(props: MenuGroupLabelProps): React.JSX.Element;
+type MenuSeparatorProps = React.ComponentProps<typeof Menu$1.Separator>;
+declare function MenuSeparator(props: MenuSeparatorProps): React.JSX.Element;
+type MenuShortcutProps = React.ComponentProps<"span">;
+declare function MenuShortcut(props: MenuShortcutProps): React.JSX.Element;
+type MenuArrowProps = React.ComponentProps<typeof Menu$1.Arrow>;
+declare function MenuArrow(props: MenuArrowProps): React.JSX.Element;
+type MenuHighlightProps = Omit<HighlightProps, "controlledItems" | "enabled" | "hover"> & {
+    animateOnHover?: boolean;
+};
+declare function MenuHighlight({ transition, ...props }: MenuHighlightProps): React.JSX.Element;
+type MenuHighlightItemProps = HighlightItemProps;
+declare function MenuHighlightItem(props: MenuHighlightItemProps): React.JSX.Element;
+type MenuItemProps = Omit<React.ComponentProps<typeof Menu$1.Item>, "render"> & HTMLMotionProps<"div">;
+declare function MenuItem({ disabled, label, closeOnClick, nativeButton, id, ...props }: MenuItemProps): React.JSX.Element;
+type MenuCheckboxItemProps = Omit<React.ComponentProps<typeof Menu$1.CheckboxItem>, "render">;
+declare function MenuCheckboxItem({ label, defaultChecked, checked, onCheckedChange, disabled, closeOnClick, nativeButton, id, ...props }: MenuCheckboxItemProps): React.JSX.Element;
+type MenuCheckboxItemIndicatorProps = Omit<React.ComponentProps<typeof Menu$1.CheckboxItemIndicator>, "render"> & HTMLMotionProps<"div">;
+declare function MenuCheckboxItemIndicator({ keepMounted, ...props }: MenuCheckboxItemIndicatorProps): React.JSX.Element;
+type MenuRadioGroupProps = React.ComponentProps<typeof Menu$1.RadioGroup>;
+declare function MenuRadioGroup(props: MenuRadioGroupProps): React.JSX.Element;
+type MenuRadioItemProps = Omit<React.ComponentProps<typeof Menu$1.RadioItem>, "render">;
+declare function MenuRadioItem({ value, disabled, label, closeOnClick, nativeButton, id, ...props }: MenuRadioItemProps): React.JSX.Element;
+type MenuRadioItemIndicatorProps = Omit<React.ComponentProps<typeof Menu$1.RadioItemIndicator>, "render"> & HTMLMotionProps<"div">;
+declare function MenuRadioItemIndicator({ keepMounted, ...props }: MenuRadioItemIndicatorProps): React.JSX.Element;
+type MenuSubmenuProps = React.ComponentProps<typeof Menu$1.SubmenuRoot>;
+declare function MenuSubmenu(props: MenuSubmenuProps): React.JSX.Element;
+type MenuSubmenuTriggerProps = Omit<React.ComponentProps<typeof Menu$1.SubmenuTrigger>, "render"> & HTMLMotionProps<"div"> & {
+    disabled?: boolean;
+};
+declare function MenuSubmenuTrigger({ label, id, nativeButton, ...props }: MenuSubmenuTriggerProps): React.JSX.Element;
+
+export { Menu, type MenuActiveValueContextType, MenuArrow, type MenuArrowProps, MenuCheckboxItem, MenuCheckboxItemIndicator, type MenuCheckboxItemIndicatorProps, type MenuCheckboxItemProps, type MenuContextType, MenuGroup, MenuGroupLabel, type MenuGroupLabelProps, type MenuGroupProps, MenuHighlight, MenuHighlightItem, type MenuHighlightItemProps, type MenuHighlightProps, MenuItem, type MenuItemProps, MenuPopup, type MenuPopupProps, MenuPortal, type MenuPortalProps, MenuPositioner, type MenuPositionerProps, type MenuProps, MenuRadioGroup, type MenuRadioGroupProps, MenuRadioItem, MenuRadioItemIndicator, type MenuRadioItemIndicatorProps, type MenuRadioItemProps, MenuSeparator, type MenuSeparatorProps, MenuShortcut, type MenuShortcutProps, MenuSubmenu, type MenuSubmenuProps, MenuSubmenuTrigger, type MenuSubmenuTriggerProps, MenuTrigger, type MenuTriggerProps, useMenu, useMenuActiveValue };

package/dist/primitives/popover.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import { Popover as Popover$1 } from '@base-ui/react/popover';
+import { HTMLMotionProps } from 'motion/react';
+
+type PopoverContextType = {
+    open: boolean;
+    setOpen: PopoverProps["onOpenChange"];
+};
+declare const usePopover: () => PopoverContextType;
+type PopoverProps = React.ComponentProps<typeof Popover$1.Root>;
+declare function Popover(props: PopoverProps): React.JSX.Element;
+type PopoverTriggerProps = React.ComponentProps<typeof Popover$1.Trigger>;
+declare function PopoverTrigger(props: PopoverTriggerProps): React.JSX.Element;
+type PopoverPortalProps = Omit<React.ComponentProps<typeof Popover$1.Portal>, "keepMounted">;
+declare function PopoverPortal(props: PopoverPortalProps): React.JSX.Element;
+type PopoverPositionerProps = React.ComponentProps<typeof Popover$1.Positioner>;
+declare function PopoverPositioner(props: PopoverPositionerProps): React.JSX.Element;
+type PopoverPopupProps = Omit<React.ComponentProps<typeof Popover$1.Popup>, "render"> & HTMLMotionProps<"div">;
+declare function PopoverPopup({ initialFocus, finalFocus, transition, ...props }: PopoverPopupProps): React.JSX.Element;
+type PopoverBackdropProps = React.ComponentProps<typeof Popover$1.Backdrop>;
+declare function PopoverBackdrop(props: PopoverBackdropProps): React.JSX.Element;
+type PopoverArrowProps = React.ComponentProps<typeof Popover$1.Arrow>;
+declare function PopoverArrow(props: PopoverArrowProps): React.JSX.Element;
+type PopoverTitleProps = React.ComponentProps<typeof Popover$1.Title>;
+declare function PopoverTitle(props: PopoverTitleProps): React.JSX.Element;
+type PopoverDescriptionProps = React.ComponentProps<typeof Popover$1.Description>;
+declare function PopoverDescription(props: PopoverDescriptionProps): React.JSX.Element;
+type PopoverCloseProps = React.ComponentProps<typeof Popover$1.Close>;
+declare function PopoverClose(props: PopoverCloseProps): React.JSX.Element;
+
+export { Popover, PopoverArrow, type PopoverArrowProps, PopoverBackdrop, type PopoverBackdropProps, PopoverClose, type PopoverCloseProps, type PopoverContextType, PopoverDescription, type PopoverDescriptionProps, PopoverPopup, type PopoverPopupProps, PopoverPortal, type PopoverPortalProps, PopoverPositioner, type PopoverPositionerProps, type PopoverProps, PopoverTitle, type PopoverTitleProps, PopoverTrigger, type PopoverTriggerProps, usePopover };

package/dist/primitives/sheet.d.ts

@@ -0,0 +1,33 @@
+import { DialogProps, DialogCloseProps, DialogDescriptionProps, DialogFooterProps, DialogHeaderProps, DialogBackdropProps, DialogTitleProps, DialogTriggerProps, Dialog as Dialog$1, DialogClose, DialogDescription, DialogFooter, DialogHeader, DialogBackdrop, DialogPortal, DialogPortalProps, DialogTitle, DialogTrigger, DialogContextType } from './dialog.js';
+import * as React from 'react';
+import { Dialog } from '@base-ui/react/dialog';
+import { HTMLMotionProps } from 'motion/react';
+
+declare const Sheet: typeof Dialog$1;
+declare const SheetTrigger: typeof DialogTrigger;
+declare const SheetPortal: typeof DialogPortal;
+declare const SheetOverlay: typeof DialogBackdrop;
+declare const SheetClose: typeof DialogClose;
+declare const SheetHeader: typeof DialogHeader;
+declare const SheetFooter: typeof DialogFooter;
+declare const SheetTitle: typeof DialogTitle;
+declare const SheetDescription: typeof DialogDescription;
+declare const useSheet: () => DialogContextType;
+type SheetSide = 'top' | 'bottom' | 'left' | 'right';
+type SheetPopupProps = Omit<React.ComponentProps<typeof Dialog.Popup>, 'render'> & HTMLMotionProps<'div'> & {
+    side?: SheetSide;
+};
+declare function SheetPopup({ side, initialFocus, finalFocus, transition, className, ...props }: SheetPopupProps): React.JSX.Element;
+type SheetContentProps = React.HTMLAttributes<HTMLDivElement>;
+declare function SheetContent({ className, ...props }: SheetContentProps): React.JSX.Element;
+type SheetProps = DialogProps;
+type SheetTriggerProps = DialogTriggerProps;
+type SheetPortalProps = DialogPortalProps;
+type SheetCloseProps = DialogCloseProps;
+type SheetOverlayProps = DialogBackdropProps;
+type SheetHeaderProps = DialogHeaderProps;
+type SheetFooterProps = DialogFooterProps;
+type SheetTitleProps = DialogTitleProps;
+type SheetDescriptionProps = DialogDescriptionProps;
+
+export { Sheet, SheetClose, type SheetCloseProps, SheetContent, type SheetContentProps, SheetDescription, type SheetDescriptionProps, SheetFooter, type SheetFooterProps, SheetHeader, type SheetHeaderProps, SheetOverlay, type SheetOverlayProps, SheetPopup, type SheetPopupProps, SheetPortal, type SheetPortalProps, type SheetProps, type SheetSide, SheetTitle, type SheetTitleProps, SheetTrigger, type SheetTriggerProps, useSheet };

package/dist/primitives/slider.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { Slider as Slider$1 } from '@base-ui/react/slider';
+
+declare function Slider(props: React.ComponentProps<typeof Slider$1.Root>): React.JSX.Element;
+declare function Control(props: React.ComponentProps<typeof Slider$1.Control>): React.JSX.Element;
+declare function Track(props: React.ComponentProps<typeof Slider$1.Track>): React.JSX.Element;
+declare function Thumb(props: React.ComponentProps<typeof Slider$1.Thumb>): React.JSX.Element;
+declare function Indicator(props: React.ComponentProps<typeof Slider$1.Indicator>): React.JSX.Element;
+declare function Value(props: React.ComponentProps<typeof Slider$1.Value>): React.JSX.Element;
+
+type SliderProps = React.ComponentProps<typeof Slider$1.Root>;
+type SliderControlProps = React.ComponentProps<typeof Slider$1.Control>;
+type SliderTrackProps = React.ComponentProps<typeof Slider$1.Track>;
+type SliderThumbProps = React.ComponentProps<typeof Slider$1.Thumb>;
+type SliderIndicatorProps = React.ComponentProps<typeof Slider$1.Indicator>;
+type SliderValueProps = React.ComponentProps<typeof Slider$1.Value>;
+
+export { Control as SliderControlPrimitive, type SliderControlProps as SliderControlPrimitiveProps, Indicator as SliderIndicatorPrimitive, type SliderIndicatorProps as SliderIndicatorPrimitiveProps, Slider as SliderPrimitive, type SliderProps as SliderPrimitiveProps, Thumb as SliderThumbPrimitive, type SliderThumbProps as SliderThumbPrimitiveProps, Track as SliderTrackPrimitive, type SliderTrackProps as SliderTrackPrimitiveProps, Value as SliderValuePrimitive, type SliderValueProps as SliderValuePrimitiveProps };

package/dist/primitives/slot.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { HTMLMotionProps, motion } from 'motion/react';
+
+type AnyProps = Record<string, unknown>;
+type DOMMotionProps<T extends HTMLElement = HTMLElement> = Omit<HTMLMotionProps<Extract<keyof HTMLElementTagNameMap, keyof typeof motion>>, "ref"> & {
+    ref?: React.Ref<T>;
+};
+type WithAsChild<Base extends object> = (Base & {
+    asChild: true;
+    children: React.ReactElement;
+}) | (Base & {
+    asChild?: false | undefined;
+});
+type SlotProps<T extends HTMLElement = HTMLElement> = {
+    children?: any;
+} & DOMMotionProps<T>;
+declare function Slot<T extends HTMLElement = HTMLElement>({ children, ref, ...props }: SlotProps<T>): React.JSX.Element | null;
+
+export { type AnyProps, type DOMMotionProps, Slot, type SlotProps, type WithAsChild };

package/dist/primitives/tabs.d.ts

@@ -0,0 +1,35 @@
+import * as React from 'react';
+import { Tabs as Tabs$1 } from '@base-ui/react/tabs';
+import { HTMLMotionProps, Transition } from 'motion/react';
+import { HighlightProps, HighlightItemProps } from '../effects/highlight.js';
+import { AutoHeightProps } from '../effects/auto-height.js';
+import './slot.js';
+
+type TabsProps = React.ComponentProps<typeof Tabs$1.Root>;
+declare function Tabs(props: TabsProps): React.JSX.Element;
+type TabsHighlightProps = Omit<HighlightProps, 'controlledItems' | 'value'>;
+declare function TabsHighlight({ transition, ...props }: TabsHighlightProps): React.JSX.Element;
+type TabsListProps = React.ComponentProps<typeof Tabs$1.List>;
+declare function TabsList(props: TabsListProps): React.JSX.Element;
+type TabsHighlightItemProps = HighlightItemProps & {
+    value: string;
+};
+declare function TabsHighlightItem(props: TabsHighlightItemProps): React.JSX.Element;
+type TabsTabProps = React.ComponentProps<typeof Tabs$1.Tab>;
+declare function TabsTab(props: TabsTabProps): React.JSX.Element;
+type TabsPanelProps = React.ComponentProps<typeof Tabs$1.Panel> & HTMLMotionProps<'div'>;
+declare function TabsPanel({ value, keepMounted, transition, ...props }: TabsPanelProps): React.JSX.Element;
+type TabsPanelsAutoProps = Omit<AutoHeightProps, 'children'> & {
+    mode?: 'auto-height';
+    children: React.ReactNode;
+    transition?: Transition;
+};
+type TabsPanelsLayoutProps = Omit<HTMLMotionProps<'div'>, 'children'> & {
+    mode: 'layout';
+    children: React.ReactNode;
+    transition?: Transition;
+};
+type TabsPanelsProps = TabsPanelsAutoProps | TabsPanelsLayoutProps;
+declare function TabsPanels(props: TabsPanelsProps): React.JSX.Element;
+
+export { Tabs, TabsHighlight, TabsHighlightItem, type TabsHighlightItemProps, type TabsHighlightProps, TabsList, type TabsListProps, TabsPanel, type TabsPanelProps, TabsPanels, type TabsPanelsProps, type TabsProps, TabsTab, type TabsTabProps };

package/dist/primitives/toast.d.ts

@@ -0,0 +1,27 @@
+import * as _base_ui_react from '@base-ui/react';
+import * as React from 'react';
+import { Toast as Toast$1 } from '@base-ui/react/toast';
+
+declare const toast: _base_ui_react.ToastManager<any>;
+type ToastProviderProps = React.ComponentProps<typeof Toast$1.Provider>;
+declare function ToastProvider(props: ToastProviderProps): React.JSX.Element;
+type ToastProps = React.ComponentProps<typeof Toast$1.Root>;
+declare function Toast(props: ToastProps): React.JSX.Element;
+type ToastPortalProps = React.ComponentProps<typeof Toast$1.Portal>;
+declare function ToastPortal(props: ToastPortalProps): React.JSX.Element;
+type ToastViewportProps = React.ComponentProps<typeof Toast$1.Viewport>;
+declare function ToastViewport(props: ToastViewportProps): React.JSX.Element;
+type ToastContentProps = React.ComponentProps<typeof Toast$1.Content>;
+declare function ToastContent(props: ToastContentProps): React.JSX.Element;
+type ToastTitleProps = React.ComponentProps<typeof Toast$1.Title>;
+declare function ToastTitle(props: ToastTitleProps): React.JSX.Element;
+type ToastDescriptionProps = React.ComponentProps<typeof Toast$1.Description>;
+declare function ToastDescription(props: ToastDescriptionProps): React.JSX.Element;
+type ToastActionProps = React.ComponentProps<typeof Toast$1.Action>;
+declare function ToastAction(props: ToastActionProps): React.JSX.Element;
+type ToastCloseProps = React.ComponentProps<typeof Toast$1.Close>;
+declare function ToastClose(props: ToastCloseProps): React.JSX.Element;
+declare const createToastManager: typeof Toast$1.createToastManager;
+declare const useToastManager: typeof Toast$1.useToastManager;
+
+export { Toast, ToastAction, type ToastActionProps, ToastClose, type ToastCloseProps, ToastContent, type ToastContentProps, ToastDescription, type ToastDescriptionProps, ToastPortal, type ToastPortalProps, type ToastProps, ToastProvider, type ToastProviderProps, ToastTitle, type ToastTitleProps, ToastViewport, type ToastViewportProps, createToastManager, toast, useToastManager };

package/dist/primitives/tooltip.d.ts

@@ -0,0 +1,32 @@
+import * as React from 'react';
+import { Tooltip as Tooltip$1 } from '@base-ui/react/tooltip';
+import { SpringOptions, HTMLMotionProps, MotionValue } from 'motion/react';
+
+type TooltipContextType = {
+    isOpen: boolean;
+    setIsOpen: TooltipProps['onOpenChange'];
+    x: MotionValue<number>;
+    y: MotionValue<number>;
+    followCursor?: boolean | 'x' | 'y';
+    followCursorSpringOptions?: SpringOptions;
+};
+declare const useTooltip: () => TooltipContextType;
+type TooltipProviderProps = React.ComponentProps<typeof Tooltip$1.Provider>;
+declare function TooltipProvider(props: TooltipProviderProps): React.JSX.Element;
+type TooltipProps = React.ComponentProps<typeof Tooltip$1.Root> & {
+    followCursor?: boolean | 'x' | 'y';
+    followCursorSpringOptions?: SpringOptions;
+};
+declare function Tooltip({ followCursor, followCursorSpringOptions, ...props }: TooltipProps): React.JSX.Element;
+type TooltipTriggerProps = React.ComponentProps<typeof Tooltip$1.Trigger>;
+declare function TooltipTrigger({ onMouseMove, ...props }: TooltipTriggerProps): React.JSX.Element;
+type TooltipPortalProps = Omit<React.ComponentProps<typeof Tooltip$1.Portal>, 'keepMounted'>;
+declare function TooltipPortal(props: TooltipPortalProps): React.JSX.Element;
+type TooltipPositionerProps = React.ComponentProps<typeof Tooltip$1.Positioner>;
+declare function TooltipPositioner(props: TooltipPositionerProps): React.JSX.Element;
+type TooltipPopupProps = Omit<React.ComponentProps<typeof Tooltip$1.Popup>, 'render'> & HTMLMotionProps<'div'>;
+declare function TooltipPopup({ transition, style, ...props }: TooltipPopupProps): React.JSX.Element;
+type TooltipArrowProps = React.ComponentProps<typeof Tooltip$1.Arrow>;
+declare function TooltipArrow(props: TooltipArrowProps): React.JSX.Element;
+
+export { Tooltip, TooltipArrow, type TooltipArrowProps, type TooltipContextType, TooltipPopup, type TooltipPopupProps, TooltipPortal, type TooltipPortalProps, TooltipPositioner, type TooltipPositionerProps, type TooltipProps, TooltipProvider, type TooltipProviderProps, TooltipTrigger, type TooltipTriggerProps, useTooltip };

package/dist/types-BLgXHroz.d.ts

@@ -0,0 +1,6 @@
+type IconProps = React.SVGProps<SVGSVGElement> & {
+    size?: number | string;
+    absoluteStrokeWidth?: boolean;
+};
+
+export type { IconProps as I };

package/dist/ui/accordion.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { AccordionProps as AccordionProps$1, AccordionPanelProps, AccordionItemProps as AccordionItemProps$1, AccordionTriggerProps as AccordionTriggerProps$1 } from '../primitives/accordion.js';
+import '@base-ui/react/accordion';
+import 'motion/react';
+
+type AccordionProps = AccordionProps$1;
+declare function Accordion(props: AccordionProps): React.JSX.Element;
+type AccordionItemProps = AccordionItemProps$1;
+declare function AccordionItem({ className, ...props }: AccordionItemProps): React.JSX.Element;
+type AccordionTriggerProps = AccordionTriggerProps$1 & {
+    /** Whether to show the chevron icon. */
+    showArrow?: boolean;
+};
+declare function AccordionTrigger({ className, children, showArrow, ...props }: AccordionTriggerProps): React.JSX.Element;
+type AccordionContentProps = AccordionPanelProps & {
+    children?: React.ReactNode;
+};
+declare function AccordionContent({ className, children, ...props }: AccordionContentProps): React.JSX.Element;
+
+export { Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, AccordionTrigger, type AccordionTriggerProps };

package/dist/ui/alert-dialog.d.ts

@@ -0,0 +1,39 @@
+import * as React from 'react';
+import { AlertDialogProps as AlertDialogProps$1, AlertDialogBackdropProps as AlertDialogBackdropProps$1, AlertDialogCloseProps as AlertDialogCloseProps$1, AlertDialogDescriptionProps as AlertDialogDescriptionProps$1, AlertDialogFooterProps as AlertDialogFooterProps$1, AlertDialogPopupProps as AlertDialogPopupProps$1, AlertDialogTitleProps as AlertDialogTitleProps$1, AlertDialogTriggerProps as AlertDialogTriggerProps$1 } from '../primitives/alert-dialog.js';
+import { Button } from './button.js';
+import '@base-ui/react/alert-dialog';
+import 'motion/react';
+import 'class-variance-authority/types';
+import 'class-variance-authority';
+import '@base-ui/react/button';
+
+type AlertDialogProps = AlertDialogProps$1;
+declare function AlertDialog(props: AlertDialogProps): React.JSX.Element;
+type AlertDialogTriggerProps = AlertDialogTriggerProps$1;
+declare function AlertDialogTrigger(props: AlertDialogTriggerProps): React.JSX.Element;
+type AlertDialogCloseProps = AlertDialogCloseProps$1;
+declare function AlertDialogClose(props: AlertDialogCloseProps): React.JSX.Element;
+type AlertDialogBackdropProps = AlertDialogBackdropProps$1;
+declare function AlertDialogBackdrop({ className, ...props }: AlertDialogBackdropProps): React.JSX.Element;
+type AlertDialogPopupProps = AlertDialogPopupProps$1;
+declare function AlertDialogPopup({ className, children, ...props }: AlertDialogPopupProps): React.JSX.Element;
+type AlertDialogHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+declare function AlertDialogHeader({ className, ...props }: AlertDialogHeaderProps): React.JSX.Element;
+type AlertDialogContentProps = React.HTMLAttributes<HTMLDivElement>;
+declare function AlertDialogContent({ className, ...props }: AlertDialogContentProps): React.JSX.Element;
+type AlertDialogFooterProps = AlertDialogFooterProps$1;
+declare function AlertDialogFooter({ className, ...props }: AlertDialogFooterProps): React.JSX.Element;
+type AlertDialogTitleProps = AlertDialogTitleProps$1;
+declare function AlertDialogTitle({ className, ...props }: AlertDialogTitleProps): React.JSX.Element;
+type AlertDialogDescriptionProps = AlertDialogDescriptionProps$1;
+declare function AlertDialogDescription({ className, ...props }: AlertDialogDescriptionProps): React.JSX.Element;
+type AlertDialogIconProps = React.ComponentProps<"div"> & {
+    variant?: "brand" | "error";
+};
+declare function AlertDialogIcon({ className, variant, ...props }: AlertDialogIconProps): React.JSX.Element;
+type AlertDialogActionProps = React.ComponentProps<typeof Button>;
+declare function AlertDialogAction({ color, variant, ...props }: AlertDialogActionProps): React.JSX.Element;
+type AlertDialogCancelProps = AlertDialogCloseProps$1 & Pick<React.ComponentProps<typeof Button>, "color" | "variant" | "size">;
+declare function AlertDialogCancel({ color, variant, size, ...props }: AlertDialogCancelProps): React.JSX.Element;
+
+export { AlertDialog, AlertDialogAction, type AlertDialogActionProps, AlertDialogBackdrop, type AlertDialogBackdropProps, AlertDialogCancel, type AlertDialogCancelProps, AlertDialogClose, type AlertDialogCloseProps, AlertDialogContent, type AlertDialogContentProps, AlertDialogDescription, type AlertDialogDescriptionProps, AlertDialogFooter, type AlertDialogFooterProps, AlertDialogHeader, type AlertDialogHeaderProps, AlertDialogIcon, type AlertDialogIconProps, AlertDialogPopup, type AlertDialogPopupProps, type AlertDialogProps, AlertDialogTitle, type AlertDialogTitleProps, AlertDialogTrigger, type AlertDialogTriggerProps };

package/dist/ui/alert.d.ts

@@ -0,0 +1,19 @@
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import * as React from 'react';
+import { VariantProps } from 'class-variance-authority';
+
+declare const alertVariants: (props?: ({
+    variant?: "default" | "error" | "warning" | "success" | "info" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type AlertProps = React.ComponentProps<"div"> & VariantProps<typeof alertVariants>;
+declare function Alert({ className, variant, ...props }: AlertProps): React.JSX.Element;
+type AlertIconProps = React.ComponentProps<"div">;
+declare function AlertIcon({ className, ...props }: AlertIconProps): React.JSX.Element;
+type AlertTitleProps = React.ComponentProps<"div">;
+declare function AlertTitle({ className, ...props }: AlertTitleProps): React.JSX.Element;
+type AlertDescriptionProps = React.ComponentProps<"div">;
+declare function AlertDescription({ className, ...props }: AlertDescriptionProps): React.JSX.Element;
+type AlertActionProps = React.ComponentProps<"div">;
+declare function AlertAction({ className, ...props }: AlertActionProps): React.JSX.Element;
+
+export { Alert, AlertAction, type AlertActionProps, AlertDescription, type AlertDescriptionProps, AlertIcon, type AlertIconProps, type AlertProps, AlertTitle, type AlertTitleProps, alertVariants };

package/dist/ui/alerter.d.ts

@@ -0,0 +1,43 @@
+import * as React from 'react';
+import { AlertDialogActionProps, AlertDialogCancelProps } from './alert-dialog.js';
+import '../primitives/alert-dialog.js';
+import '@base-ui/react/alert-dialog';
+import 'motion/react';
+import './button.js';
+import 'class-variance-authority/types';
+import 'class-variance-authority';
+import '@base-ui/react/button';
+
+type AlertPosition = "top-start" | "top-center" | "top-end" | "bottom-start" | "bottom-center" | "bottom-end" | "center";
+interface AlertOptions {
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    icon?: React.ReactNode;
+    confirmText?: string;
+    cancelText?: string;
+    denyText?: string;
+    variant?: "default" | "destructive";
+    showCancel?: boolean;
+    showDeny?: boolean;
+    position?: AlertPosition;
+    textAlign?: "left" | "center" | "right";
+    footerLayout?: "row" | "col";
+    showCloseButton?: boolean;
+    closeAriaLabel?: string;
+    confirmButtonProps?: AlertDialogActionProps;
+    cancelButtonProps?: AlertDialogCancelProps;
+    denyButtonProps?: AlertDialogActionProps;
+    onConfirm?: () => void | Promise<void>;
+    onCancel?: () => void;
+    onDeny?: () => void | Promise<void>;
+    className?: string;
+    additionalContents?: React.ReactNode;
+}
+type AlertResult = "confirm" | "deny" | "cancel";
+declare const alert: {
+    add: (options: AlertOptions) => void;
+    confirm: (options: AlertOptions) => Promise<AlertResult>;
+};
+declare function Alerter(): React.JSX.Element;
+
+export { type AlertOptions, type AlertPosition, type AlertResult, Alerter, alert };

package/dist/ui/avatar.d.ts

@@ -0,0 +1,17 @@
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import * as React from 'react';
+import { VariantProps } from 'class-variance-authority';
+import { AvatarProps as AvatarProps$1, AvatarFallbackProps as AvatarFallbackProps$1, AvatarImageProps as AvatarImageProps$1 } from '../primitives/avatar.js';
+import '@base-ui/react/avatar';
+
+declare const avatarVariants: (props?: ({
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type AvatarProps = AvatarProps$1 & VariantProps<typeof avatarVariants>;
+declare function Avatar({ className, size, ...props }: AvatarProps): React.JSX.Element;
+type AvatarImageProps = AvatarImageProps$1;
+declare function AvatarImage({ className, alt, ...props }: AvatarImageProps): React.JSX.Element;
+type AvatarFallbackProps = AvatarFallbackProps$1;
+declare function AvatarFallback({ className, ...props }: AvatarFallbackProps): React.JSX.Element;
+
+export { Avatar, AvatarFallback, type AvatarFallbackProps, AvatarImage, type AvatarImageProps, type AvatarProps, avatarVariants };