@pebble-software/bonsai 0.0.3

package/dist/components/ui/dialog.d.ts

@@ -0,0 +1,23 @@
+import { Dialog as DialogPrimitive } from '@base-ui/react/dialog';
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare function Dialog({ ...props }: DialogPrimitive.Root.Props): React.JSX.Element;
+declare function DialogTrigger({ ...props }: DialogPrimitive.Trigger.Props): React.JSX.Element;
+declare function DialogPortal({ ...props }: DialogPrimitive.Portal.Props): React.JSX.Element;
+declare function DialogClose({ className, ...props }: DialogPrimitive.Close.Props): React.JSX.Element;
+declare function DialogOverlay({ className, ...props }: DialogPrimitive.Backdrop.Props): React.JSX.Element;
+declare const dialogContentVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    fullscreen?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function DialogContent({ className, children, showCloseButton, fullscreen, size, ...props }: DialogPrimitive.Popup.Props & {
+    showCloseButton?: boolean;
+} & VariantProps<typeof dialogContentVariants>): React.JSX.Element;
+declare function DialogHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DialogBody({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DialogFooter({ className, showCloseButton, children, ...props }: React.ComponentProps<"div"> & {
+    showCloseButton?: boolean;
+}): React.JSX.Element;
+declare function DialogTitle({ className, ...props }: DialogPrimitive.Title.Props): React.JSX.Element;
+declare function DialogDescription({ className, ...props }: DialogPrimitive.Description.Props): React.JSX.Element;
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogBody, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, dialogContentVariants, };

package/dist/components/ui/drawer.d.ts

@@ -0,0 +1,22 @@
+import { Drawer as DrawerPrimitive } from '@base-ui/react/drawer';
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare function Drawer({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Root>): React.JSX.Element;
+declare function DrawerTrigger({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Trigger>): React.JSX.Element;
+declare function DrawerPortal({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Portal>): React.JSX.Element;
+declare function DrawerClose({ ...props }: React.ComponentProps<typeof DrawerPrimitive.Close>): React.JSX.Element;
+declare function DrawerOverlay({ className, ...props }: React.ComponentProps<typeof DrawerPrimitive.Backdrop>): React.JSX.Element;
+declare const drawerContentVariants: (props?: ({
+    variant?: "default" | "inset" | "unstyled" | null | undefined;
+    side?: "top" | "bottom" | "left" | "right" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+interface DrawerContentProps extends DrawerPrimitive.Popup.Props, VariantProps<typeof drawerContentVariants> {
+    showCloseButton?: boolean;
+}
+declare function DrawerContent({ className, children, side, size, variant, showCloseButton, ...props }: DrawerContentProps): React.JSX.Element;
+declare function DrawerHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DrawerFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DrawerTitle({ className, ...props }: React.ComponentProps<typeof DrawerPrimitive.Title>): React.JSX.Element;
+declare function DrawerDescription({ className, ...props }: React.ComponentProps<typeof DrawerPrimitive.Description>): React.JSX.Element;
+export { Drawer, DrawerPortal, DrawerOverlay, DrawerTrigger, DrawerClose, DrawerContent, DrawerHeader, DrawerFooter, DrawerTitle, DrawerDescription, };

package/dist/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,29 @@
+import { Menu as MenuPrimitive } from '@base-ui/react/menu';
+import * as React from "react";
+declare function DropdownMenu({ ...props }: MenuPrimitive.Root.Props): React.JSX.Element;
+declare function DropdownMenuPortal({ ...props }: MenuPrimitive.Portal.Props): React.JSX.Element;
+declare function DropdownMenuTrigger({ className, ...props }: MenuPrimitive.Trigger.Props): React.JSX.Element;
+declare const dropdownMenuContentVariants: (props?: ({
+    align?: "center" | "end" | "start" | null | undefined;
+    side?: "inline-start" | "inline-end" | "top" | "bottom" | "left" | "right" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function DropdownMenuContent({ alignOffset, sideOffset, align, side, className, ...props }: MenuPrimitive.Popup.Props & Pick<MenuPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): React.JSX.Element;
+declare function DropdownMenuGroup({ ...props }: MenuPrimitive.Group.Props): React.JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: MenuPrimitive.GroupLabel.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, onClick, ...props }: MenuPrimitive.Item.Props & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): React.JSX.Element;
+declare function DropdownMenuSub({ ...props }: MenuPrimitive.SubmenuRoot.Props): React.JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: MenuPrimitive.SubmenuTrigger.Props & {
+    inset?: boolean;
+}): React.JSX.Element;
+declare function DropdownMenuSubContent({ align, alignOffset, side, sideOffset, className, ...props }: React.ComponentProps<typeof DropdownMenuContent>): React.JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: MenuPrimitive.CheckboxItem.Props): React.JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: MenuPrimitive.RadioGroup.Props): React.JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, ...props }: MenuPrimitive.RadioItem.Props): React.JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: MenuPrimitive.Separator.Props): React.JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+export { DropdownMenu, DropdownMenuPortal, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, dropdownMenuContentVariants, };

package/dist/components/ui/form.d.ts

@@ -0,0 +1,24 @@
+import { useRender } from '@base-ui/react/use-render';
+import { ControllerProps, FieldPath, FieldValues } from 'react-hook-form';
+import { Label } from './label';
+import * as React from "react";
+declare const Form: <TFieldValues extends FieldValues, TContext = any, TTransformedValues = TFieldValues>({ children, watch, getValues, getFieldState, setError, clearErrors, setValue, setValues, trigger, formState, resetField, reset, handleSubmit, unregister, control, register, setFocus, subscribe, }: import('react-hook-form').FormProviderProps<TFieldValues, TContext, TTransformedValues>) => React.JSX.Element;
+declare function FormField<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>>({ ...props }: ControllerProps<TFieldValues, TName>): React.JSX.Element;
+declare const useFormField: () => {
+    invalid: boolean;
+    isDirty: boolean;
+    isTouched: boolean;
+    isValidating: boolean;
+    error?: import('react-hook-form').FieldError;
+    id: string;
+    name: string;
+    formItemId: string;
+    formDescriptionId: string;
+    formMessageId: string;
+};
+declare function FormItem({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function FormLabel({ className, ...props }: React.ComponentProps<typeof Label>): React.JSX.Element;
+declare function FormControl({ className, render, ...props }: useRender.ComponentProps<"div">): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+declare function FormDescription({ className, ...props }: React.ComponentProps<"p">): React.JSX.Element;
+declare function FormMessage({ className, ...props }: React.ComponentProps<"p">): React.JSX.Element | null;
+export { useFormField, Form, FormItem, FormLabel, FormControl, FormDescription, FormMessage, FormField, };

package/dist/components/ui/h.d.ts

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const hVariants: (props?: ({
+    variant?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+interface HeadingProps extends React.HTMLAttributes<HTMLHeadingElement>, VariantProps<typeof hVariants> {
+    as?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+}
+declare const H: React.ForwardRefExoticComponent<HeadingProps & React.RefAttributes<HTMLHeadingElement>>;
+export { H, hVariants };

package/dist/components/ui/input-group.d.ts

@@ -0,0 +1,18 @@
+import { Button } from './button';
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare function InputGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare const inputGroupAddonVariants: (props?: ({
+    align?: "inline-start" | "inline-end" | "block-start" | "block-end" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function InputGroupAddon({ className, align, ...props }: React.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>): React.JSX.Element;
+declare const inputGroupButtonVariants: (props?: ({
+    size?: "xs" | "sm" | "icon-xs" | "icon-sm" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function InputGroupButton({ className, type, variant, extrude, size, ...props }: Omit<React.ComponentProps<typeof Button>, "size" | "type"> & VariantProps<typeof inputGroupButtonVariants> & {
+    type?: "button" | "submit" | "reset";
+}): React.JSX.Element;
+declare function InputGroupText({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+declare function InputGroupInput({ className, ...props }: React.ComponentProps<"input">): React.JSX.Element;
+declare function InputGroupTextarea({ className, ...props }: React.ComponentProps<"textarea">): React.JSX.Element;
+export { InputGroup, InputGroupAddon, InputGroupButton, InputGroupText, InputGroupInput, InputGroupTextarea, inputGroupAddonVariants, };

package/dist/components/ui/input-otp.d.ts

@@ -0,0 +1,11 @@
+import { OTPInput } from 'input-otp';
+import * as React from "react";
+declare function InputOTP({ className, containerClassName, ...props }: React.ComponentProps<typeof OTPInput> & {
+    containerClassName?: string;
+}): React.JSX.Element;
+declare function InputOTPGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function InputOTPSlot({ index, className, ...props }: React.ComponentProps<"div"> & {
+    index: number;
+}): React.JSX.Element;
+declare function InputOTPSeparator({ ...props }: React.ComponentProps<"div">): React.JSX.Element;
+export { InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator };

package/dist/components/ui/input.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare function Input({ className, type, ...props }: React.ComponentProps<"input">): React.JSX.Element;
+export { Input };

package/dist/components/ui/label.d.ts

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const labelVariants: (props?: ({
+    variant?: "default" | "destructive" | "underline" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Label({ size, variant, className, htmlFor, ...props }: React.ComponentProps<"label"> & VariantProps<typeof labelVariants> & {
+    htmlFor: string;
+}): React.JSX.Element;
+export { Label, labelVariants };

package/dist/components/ui/loader.d.ts

@@ -0,0 +1,14 @@
+import { IconProps } from '@tabler/icons-react';
+import { VariantProps } from 'class-variance-authority';
+declare const loaderVariants: (props?: ({
+    variant?: "spinner" | "ping" | null | undefined;
+    fill?: "default" | "warning" | "destructive" | "pending" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+interface LoaderProps extends React.ComponentProps<"div">, VariantProps<typeof loaderVariants> {
+    icon?: React.ForwardRefExoticComponent<IconProps & React.RefAttributes<SVGSVGElement>>;
+    pingIcon?: React.ForwardRefExoticComponent<IconProps & React.RefAttributes<SVGSVGElement>>;
+    iconProps?: IconProps;
+}
+declare function Loader({ icon, pingIcon, variant, fill, size, iconProps, className, ...props }: LoaderProps): import("react").JSX.Element;
+export { Loader };

package/dist/components/ui/map.d.ts

@@ -0,0 +1,30 @@
+import { Map as GLMap, Marker, Layer } from 'react-map-gl/maplibre';
+import * as React from "react";
+interface MapPin extends Omit<React.ComponentProps<typeof Marker>, "children">, Coordinates {
+    id: string | number;
+    label?: string;
+    children?: (onDeleteClick: () => void) => React.ReactNode;
+}
+interface Coordinates {
+    latitude: number;
+    longitude: number;
+}
+interface MapProps extends React.ComponentProps<typeof GLMap> {
+    pins?: MapPin[];
+    onChange?: (pins: MapPin[]) => void;
+    readonly?: boolean;
+    fixed?: boolean;
+    allowMultiple?: boolean;
+    className?: string;
+}
+export declare const DEFAULT_CENTER: {
+    id: string;
+    latitude: number;
+    longitude: number;
+};
+declare function Map({ pins, onChange, allowMultiple, readonly, fixed, zoom, pitch, className, children, ...props }: MapProps): React.JSX.Element;
+declare const MAP_LAYERS: Record<string, React.ComponentProps<typeof Layer>>;
+declare function MapLayers({ omit }: {
+    omit?: (keyof typeof MAP_LAYERS)[];
+}): React.JSX.Element;
+export { type MapPin, type Coordinates, Map, MapLayers };

package/dist/components/ui/p.d.ts

@@ -0,0 +1,11 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const pVariants: (props?: ({
+    variant?: "default" | "muted" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+interface ParagraphProps extends React.HTMLAttributes<HTMLParagraphElement>, VariantProps<typeof pVariants> {
+    as?: "p" | "div" | "span";
+}
+declare const P: React.ForwardRefExoticComponent<ParagraphProps & React.RefAttributes<HTMLParagraphElement>>;
+export { P, pVariants };

package/dist/components/ui/popover.d.ts

@@ -0,0 +1,9 @@
+import { Popover as PopoverPrimitive } from '@base-ui/react/popover';
+import * as React from "react";
+declare function Popover({ ...props }: PopoverPrimitive.Root.Props): React.JSX.Element;
+declare function PopoverTrigger({ ...props }: PopoverPrimitive.Trigger.Props): React.JSX.Element;
+declare function PopoverContent({ className, align, alignOffset, side, sideOffset, ...props }: PopoverPrimitive.Popup.Props & Pick<PopoverPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset">): React.JSX.Element;
+declare function PopoverHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function PopoverTitle({ className, ...props }: PopoverPrimitive.Title.Props): React.JSX.Element;
+declare function PopoverDescription({ className, ...props }: PopoverPrimitive.Description.Props): React.JSX.Element;
+export { Popover, PopoverContent, PopoverDescription, PopoverHeader, PopoverTitle, PopoverTrigger, };

package/dist/components/ui/progress.d.ts

@@ -0,0 +1,31 @@
+import { Progress as ProgressPrimitive } from '@base-ui/react/progress';
+import { VariantProps } from 'class-variance-authority';
+declare const progressVariants: (props?: ({
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    raised?: "default" | "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    stacked?: "default" | "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+interface ProgressValue extends ProgressPrimitive.Indicator.Props {
+    name?: string;
+    value: number;
+    className?: string;
+}
+interface ProgressBaseProps extends Omit<ProgressPrimitive.Root.Props, "value">, VariantProps<typeof progressVariants> {
+    className?: string;
+    children?: React.ReactNode;
+}
+type ProgressSingleProps = ProgressBaseProps & {
+    mode?: "single";
+    value: number | null;
+};
+type ProgressMultipleProps = ProgressBaseProps & {
+    mode: "multiple";
+    value: ProgressValue[];
+};
+export type ProgressProps = ProgressSingleProps | ProgressMultipleProps;
+declare function Progress(props: ProgressProps): import("react").JSX.Element;
+declare function ProgressTrack({ className, ...props }: ProgressPrimitive.Track.Props): import("react").JSX.Element;
+declare function ProgressIndicator({ className, ...props }: ProgressPrimitive.Indicator.Props): import("react").JSX.Element;
+declare function ProgressLabel({ className, ...props }: ProgressPrimitive.Label.Props): import("react").JSX.Element;
+declare function ProgressValue({ className, ...props }: ProgressPrimitive.Value.Props): import("react").JSX.Element;
+export { type ProgressSingleProps, type ProgressMultipleProps, Progress, ProgressTrack, ProgressIndicator, ProgressLabel, ProgressValue, progressVariants, };

package/dist/components/ui/scroll-area.d.ts

@@ -0,0 +1,13 @@
+import { ScrollArea as ScrollAreaPrimitive } from '@base-ui/react/scroll-area';
+import { VariantProps } from 'class-variance-authority';
+declare const scrollAreaVariants: (props?: ({
+    variant?: "default" | "ghost" | "solid" | "accent" | null | undefined;
+    orientation?: "auto" | "horizontal" | "vertical" | null | undefined;
+    size?: "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+    rounded?: "xs" | "sm" | "md" | "lg" | "xl" | "none" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+interface ScrollAreaProps extends ScrollAreaPrimitive.Root.Props, VariantProps<typeof scrollAreaVariants> {
+}
+declare function ScrollArea({ className, variant, size, rounded, orientation, children, ...props }: ScrollAreaProps): import("react").JSX.Element;
+declare function ScrollBar({ className, ...props }: ScrollAreaPrimitive.Scrollbar.Props): import("react").JSX.Element;
+export { ScrollArea, ScrollBar, scrollAreaVariants };

package/dist/components/ui/select.d.ts

@@ -0,0 +1,17 @@
+import { Select as SelectPrimitive } from '@base-ui/react/select';
+import { VariantProps } from 'class-variance-authority';
+import { buttonVariants } from './button';
+import * as React from "react";
+declare const Select: typeof SelectPrimitive.Root;
+declare function SelectGroup({ className, ...props }: SelectPrimitive.Group.Props): React.JSX.Element;
+declare function SelectValue({ className, ...props }: SelectPrimitive.Value.Props): React.JSX.Element;
+interface SelectTriggerProps extends SelectPrimitive.Trigger.Props, Omit<VariantProps<typeof buttonVariants>, "icon"> {
+}
+declare function SelectTrigger({ className, size, variant, raised, extrude, children, ...props }: SelectTriggerProps): React.JSX.Element;
+declare function SelectContent({ className, children, side, sideOffset, align, alignOffset, alignItemWithTrigger, ...props }: SelectPrimitive.Popup.Props & Pick<SelectPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset" | "alignItemWithTrigger">): React.JSX.Element;
+declare function SelectLabel({ className, ...props }: SelectPrimitive.GroupLabel.Props): React.JSX.Element;
+declare function SelectItem({ className, children, ...props }: SelectPrimitive.Item.Props): React.JSX.Element;
+declare function SelectSeparator({ className, ...props }: SelectPrimitive.Separator.Props): React.JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpArrow>): React.JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollDownArrow>): React.JSX.Element;
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, };

package/dist/components/ui/separator.d.ts

@@ -0,0 +1,8 @@
+import { Separator as SeparatorPrimitive } from '@base-ui/react/separator';
+import { VariantProps } from 'class-variance-authority';
+declare const separatorVariants: (props?: ({
+    stroke?: "thick" | "thin" | "regular" | null | undefined;
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Separator({ className, orientation, stroke, ...props }: SeparatorPrimitive.Props & VariantProps<typeof separatorVariants>): import("react").JSX.Element;
+export { Separator };

package/dist/components/ui/sidebar.d.ts

@@ -0,0 +1,70 @@
+import { useRender } from '@base-ui/react/use-render';
+import { Button } from './button';
+import { Input } from './input';
+import { Separator } from './separator';
+import { TooltipContent } from './tooltip';
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+export declare const SIDEBAR_COOKIE_NAME = "__pb_ui_sbs";
+type SidebarContextProps = {
+    state: "expanded" | "collapsed";
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openMobile: boolean;
+    setOpenMobile: (open: boolean) => void;
+    isMobile: boolean;
+    toggleSidebar: () => void;
+    side: "left" | "right";
+    shadow: boolean;
+    variant: "default" | "floating" | "inset";
+};
+declare function useSidebar(): SidebarContextProps;
+declare function SidebarProvider({ defaultOpen, open: openProp, onOpenChange: setOpenProp, className, side, withShadow, variant, style, children, ...props }: React.ComponentProps<"div"> & {
+    side: "left" | "right";
+    withShadow: boolean;
+    defaultOpen?: boolean;
+    variant?: "default" | "floating" | "inset";
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}): React.JSX.Element;
+declare const sidebarVariants: (props?: ({
+    variant?: "default" | "inset" | "floating" | null | undefined;
+    collapsible?: "icon" | "none" | "totalCollapse" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+interface SidebarProps extends React.ComponentProps<"div">, VariantProps<typeof sidebarVariants> {
+    side?: "left" | "right";
+}
+declare function Sidebar({ collapsible, className, children, ...props }: SidebarProps): React.JSX.Element;
+declare function SidebarTrigger({ className, onClick, ...props }: React.ComponentProps<typeof Button>): React.JSX.Element;
+declare function SidebarRail({ children, className, ...props }: React.ComponentProps<"button">): React.JSX.Element;
+declare function SidebarInset({ className, ...props }: React.ComponentProps<"main">): React.JSX.Element;
+declare function SidebarInput({ className, ...props }: React.ComponentProps<typeof Input>): React.JSX.Element;
+declare function SidebarHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarSeparator({ className, ...props }: React.ComponentProps<typeof Separator>): React.JSX.Element;
+declare function SidebarContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarGroupLabel({ className, render, ...props }: useRender.ComponentProps<"div"> & React.ComponentProps<"div">): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+declare function SidebarGroupAction({ className, render, ...props }: useRender.ComponentProps<"button"> & React.ComponentProps<"button">): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+declare function SidebarGroupContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarMenu({ className, ...props }: React.ComponentProps<"ul">): React.JSX.Element;
+declare function SidebarMenuItem({ className, ...props }: React.ComponentProps<"li">): React.JSX.Element;
+declare function SidebarMenuButton({ render, isActive, size, tooltip, className, children, ...props }: useRender.ComponentProps<"button"> & React.ComponentProps<"button"> & {
+    isActive?: boolean;
+    size?: "sm" | "md" | "lg";
+    tooltip?: string | React.ComponentProps<typeof TooltipContent>;
+}): React.JSX.Element;
+declare function SidebarMenuAction({ className, render, showOnHover, ...props }: useRender.ComponentProps<"button"> & React.ComponentProps<"button"> & {
+    showOnHover?: boolean;
+}): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+declare function SidebarMenuBadge({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function SidebarMenuSkeleton({ className, showIcon, ...props }: React.ComponentProps<"div"> & {
+    showIcon?: boolean;
+}): React.JSX.Element;
+declare function SidebarMenuSub({ className, ...props }: React.ComponentProps<"ul">): React.JSX.Element;
+declare function SidebarMenuSubItem({ className, ...props }: React.ComponentProps<"li">): React.JSX.Element;
+declare function SidebarMenuSubButton({ render, size, isActive, className, ...props }: useRender.ComponentProps<"a"> & React.ComponentProps<"a"> & {
+    size?: "sm" | "md";
+    isActive?: boolean;
+}): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+export { Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, useSidebar, };

package/dist/components/ui/signature-pad.d.ts

@@ -0,0 +1,7 @@
+export type SignatureProps = {
+    value?: string | null;
+    onChange?: (value: string | null) => void;
+    canvasClassname?: string;
+    imageType?: "image/png" | "image/jpeg" | "image/webp";
+};
+export declare function Signature({ value, onChange, canvasClassname, imageType, }: SignatureProps): import("react").JSX.Element;

package/dist/components/ui/skeleton.d.ts

@@ -0,0 +1,7 @@
+import { VariantProps } from 'class-variance-authority';
+declare const skeletonVariants: (props?: ({
+    variant?: "default" | "circle" | "square" | "text" | null | undefined;
+    animate?: boolean | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Skeleton({ variant, animate, className, ...props }: React.ComponentProps<"div"> & VariantProps<typeof skeletonVariants>): import("react").JSX.Element;
+export { Skeleton, skeletonVariants };

package/dist/components/ui/switch.d.ts

@@ -0,0 +1,8 @@
+import { Switch as SwitchPrimitive } from '@base-ui/react/switch';
+import { VariantProps } from 'class-variance-authority';
+declare const switchVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    rounded?: "sm" | "md" | "lg" | "none" | "full" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Switch({ className, size, rounded, onCheckedChange, ...props }: SwitchPrimitive.Root.Props & VariantProps<typeof switchVariants>): import("react").JSX.Element;
+export { Switch, switchVariants };

package/dist/components/ui/table.d.ts

@@ -0,0 +1,14 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const tableVariants: (props?: ({
+    variant?: "default" | "filled" | "lines" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function Table({ className, variant, ...props }: React.ComponentProps<"table"> & VariantProps<typeof tableVariants>): React.JSX.Element;
+declare function TableHeader({ className, ...props }: React.ComponentProps<"thead">): React.JSX.Element;
+declare function TableBody({ className, ...props }: React.ComponentProps<"tbody">): React.JSX.Element;
+declare function TableFooter({ className, ...props }: React.ComponentProps<"tfoot">): React.JSX.Element;
+declare function TableRow({ className, ...props }: React.ComponentProps<"tr">): React.JSX.Element;
+declare function TableHead({ className, ...props }: React.ComponentProps<"th">): React.JSX.Element;
+declare function TableCell({ className, ...props }: React.ComponentProps<"td">): React.JSX.Element;
+declare function TableCaption({ className, ...props }: React.ComponentProps<"caption">): React.JSX.Element;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, tableVariants, };

package/dist/components/ui/tabs.d.ts

@@ -0,0 +1,15 @@
+import { Tabs as TabsPrimitive } from '@base-ui/react/tabs';
+import { VariantProps } from 'class-variance-authority';
+declare function Tabs({ className, orientation, ...props }: TabsPrimitive.Root.Props): import("react").JSX.Element;
+declare const tabsListVariants: (props?: ({
+    variant?: "default" | "ghost" | "icon" | "contained" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+    extrude?: "default" | "xs" | "sm" | "md" | "lg" | "xl" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function TabsList({ className, variant, size, extrude, ...props }: TabsPrimitive.List.Props & VariantProps<typeof tabsListVariants>): import("react").JSX.Element;
+declare function TabsTrigger({ label, description, children, className, onClick, ...props }: TabsPrimitive.Tab.Props & {
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+}): import("react").JSX.Element;
+declare function TabsContent({ className, ...props }: TabsPrimitive.Panel.Props): import("react").JSX.Element;
+export { Tabs, TabsList, TabsTrigger, TabsContent, tabsListVariants };

package/dist/components/ui/textarea.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+declare function Textarea({ className, onInput, autosize, ...props }: React.ComponentProps<"textarea"> & {
+    autosize?: boolean;
+}): React.JSX.Element;
+export { Textarea };

package/dist/components/ui/toast.d.ts

@@ -0,0 +1,46 @@
+import { IconProps } from '@tabler/icons-react';
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const toastVariants: (props?: ({
+    variant?: "error" | "success" | "default" | "promise" | "warning" | "loading" | "info" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+    raised?: "xs" | "sm" | "md" | "lg" | "xl" | "none" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+interface ToastActions {
+    label: React.ReactNode;
+    onClick: () => void;
+}
+interface ToastOptions extends VariantProps<typeof toastVariants> {
+    description?: React.ReactNode;
+    icon?: React.ElementType<IconProps> | undefined;
+    duration?: number;
+    action?: ToastActions;
+    cancel?: ToastActions;
+    className?: string;
+}
+interface PromiseToastOptions extends ToastOptions {
+    loadingOptions?: ToastOptions;
+    successOptions?: ToastOptions;
+    errorOptions?: ToastOptions;
+}
+declare const toast: ((message: React.ReactNode, options?: ToastOptions) => string) & {
+    success: (message: React.ReactNode, options?: ToastOptions) => string;
+    error: (message: React.ReactNode, options?: ToastOptions) => string;
+    warning: (message: React.ReactNode, options?: ToastOptions) => string;
+    info: (message: React.ReactNode, options?: ToastOptions) => string;
+    loading: (message: React.ReactNode, options?: ToastOptions) => string;
+    promise: <T>(promise: Promise<T> | (() => Promise<T>), messages: {
+        loading: React.ReactNode;
+        success: React.ReactNode | ((data: T) => React.ReactNode);
+        error: React.ReactNode | ((error: unknown) => React.ReactNode);
+    }, options?: PromiseToastOptions) => Promise<T>;
+};
+declare function ToastList({ className, style, }: {
+    className?: string;
+    style?: React.CSSProperties;
+}): React.JSX.Element;
+declare const Toaster: {
+    ({ className, style, ...props }: React.ComponentProps<typeof ToastList>): React.JSX.Element;
+    displayName: string;
+};
+export { Toaster, ToastList, toast };

package/dist/components/ui/tooltip.d.ts

@@ -0,0 +1,15 @@
+import { Tooltip as TooltipPrimitive } from '@base-ui/react/tooltip';
+declare function TooltipProvider({ delay, closeDelay, ...props }: TooltipPrimitive.Provider.Props): import("react").JSX.Element;
+declare function Tooltip({ delay, closeDelay, ...props }: TooltipPrimitive.Root.Props & {
+    delay?: number;
+    closeDelay?: number;
+}): import("react").JSX.Element;
+declare function TooltipTrigger({ ...props }: TooltipPrimitive.Trigger.Props): import("react").JSX.Element;
+declare const tooltipVariants: (props?: ({
+    align?: "center" | "end" | "start" | null | undefined;
+    side?: "inline-start" | "inline-end" | "top" | "bottom" | "left" | "right" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare function TooltipContent({ className, side, sideOffset, align, alignOffset, withArrow, children, ...props }: TooltipPrimitive.Popup.Props & Pick<TooltipPrimitive.Positioner.Props, "align" | "alignOffset" | "side" | "sideOffset"> & {
+    withArrow?: boolean;
+}): import("react").JSX.Element;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider, tooltipVariants, };

package/dist/hooks/haptics.d.ts

@@ -0,0 +1,8 @@
+import { HapticInput } from 'web-haptics';
+export { useWebHaptics as useHaptics } from 'web-haptics/react';
+export declare const HAPTIC_BUTTON: HapticInput;
+export declare const HAPTIC_TAB: HapticInput;
+export declare const HAPTIC_SWITCH: HapticInput;
+export declare const HAPTIC_CHECKBOX: HapticInput;
+export declare const HAPTIC_ACCORDION: HapticInput;
+export declare const HAPTIC_MENU_ITEM: HapticInput;

package/dist/hooks/use-mobile.d.ts

@@ -0,0 +1 @@
+export declare function useIsMobile(): boolean;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { Bonsai, useUpdateData } from './components/core/bonsai';
+export { componentMap, controlledInputMap } from './lib/ui/registry';
+export type { Config } from '../../../library/schemas/src/index.ts';
+export type { SignatureProps } from './components/ui/signature-pad';