@umami/react-zen 0.113.0 → 0.115.0

package/dist/index.d.mts

@@ -0,0 +1,707 @@
+import { ButtonProps as ButtonProps$1, DisclosureGroupProps, DisclosureProps, DialogProps as DialogProps$1, BreadcrumbsProps, BreadcrumbProps, CalendarProps as CalendarProps$1, CheckboxProps as CheckboxProps$1, TableProps, TooltipProps as TooltipProps$1, LabelProps as LabelProps$1, ListBoxProps, ListBoxItemProps, SeparatorProps, ListBoxSectionProps, MenuProps as MenuProps$1, MenuItemProps, MenuSectionProps, ModalOverlayProps, ModalRenderProps, TextFieldProps as TextFieldProps$1, PopoverProps, ProgressBarProps as ProgressBarProps$1, RadioProps, RadioGroupProps as RadioGroupProps$1, SearchFieldProps as SearchFieldProps$1, SelectProps as SelectProps$1, SelectValueRenderProps, SliderProps as SliderProps$1, SwitchProps as SwitchProps$1, TableHeaderProps, TableBodyProps, RowProps as RowProps$1, ColumnProps as ColumnProps$1, CellProps, TabsProps, TabListProps, TabProps, TabPanelProps, ToggleButtonProps, TagGroupProps, TagProps } from 'react-aria-components';
+export { DialogTrigger, FileTrigger, Focusable, MenuTrigger, Pressable, RouterProvider, Selection, SubmenuTrigger, TooltipTrigger } from 'react-aria-components';
+import * as react from 'react';
+import { HTMLAttributes, ReactNode, ReactElement, Dispatch, SetStateAction } from 'react';
+import { UseFormProps, SubmitHandler, UseFormReturn, RegisterOptions, FieldValues } from 'react-hook-form';
+import * as react_icons_lib from 'react-icons/lib';
+
+declare const Breakpoints: readonly ["", "xs", "sm", "md", "lg", "xl"];
+type Breakpoint = (typeof Breakpoints)[number];
+type Responsive<T> = T | Partial<Record<Breakpoint, T>>;
+type BaseColor = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12';
+type AccentColor = 'gray' | 'gold' | 'bronze' | 'brown' | 'yellow' | 'amber' | 'orange' | 'tomato' | 'red' | 'ruby' | 'crimson' | 'pink' | 'plum' | 'purple' | 'violet' | 'iris' | 'indigo' | 'blue' | 'cyan' | 'teal' | 'jade' | 'green' | 'grass' | 'lime' | 'mint' | 'sky';
+type FontColor = BaseColor | AccentColor | 'primary' | 'muted' | 'disabled' | true;
+type BackgroundColor = BaseColor | AccentColor | 'primary' | 'transparent' | true;
+type BorderColor = BaseColor | AccentColor | 'primary' | 'muted' | 'disabled' | 'transparent' | true;
+type HoverColor = FontColor;
+type Spacing = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12';
+type NegativeSpacing = '-1' | '-2' | '-3' | '-4' | '-5' | '-6' | '-7' | '-8' | '-9' | '-10' | '-11' | '-12';
+type Padding = Spacing | NegativeSpacing | true;
+type Position = 'static' | 'relative' | 'absolute' | 'fixed' | 'sticky';
+type Top = Spacing | NegativeSpacing | string;
+type Right = Spacing | NegativeSpacing | string;
+type Bottom = Spacing | NegativeSpacing | string;
+type Left = Spacing | NegativeSpacing | string;
+type Overflow = 'visible' | 'hidden' | 'clip' | 'scroll' | 'auto';
+type Display = 'none' | 'inline' | 'inline-block' | 'block';
+type BorderPosition = true | 'top' | 'right' | 'bottom' | 'left';
+type BorderRadius = true | '1' | '2' | '3' | '4' | 'full';
+type BoxShadow = '1' | '2' | '3' | '4' | '5' | '6';
+type FontSize = '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12';
+type FontWeight = 'thin' | 'extra-light' | 'light' | 'regular' | 'medium' | 'semi-bold' | 'bold' | 'extra-bold' | 'black';
+type TextWrap = 'wrap' | 'nowrap' | 'pretty' | 'balance';
+type TextAlign = 'left' | 'center' | 'right';
+type TextTransform = 'capitalize' | 'uppercase' | 'lowercase' | 'none';
+type LetterSpacing = '1' | '2' | '3' | '4' | '5';
+type FlexDisplay = 'none' | 'flex' | 'inline-flex';
+type FlexDirection = 'column' | 'row' | 'row-reverse' | 'column-reverse';
+type FlexWrap = 'wrap' | 'nowrap' | 'wrap-reverse';
+type FlexGrow = string | number;
+type FlexShrink = string | number;
+type GridDisplay = 'none' | 'grid' | 'inline-grid';
+type GridAutoFlow = 'row' | 'column' | 'dense' | 'row-dense' | 'column-dense';
+type GridTemplateRows = string;
+type GridTemplateColumns = string;
+type GridTemplateAreas = string;
+type JustifyContent = 'center' | 'start' | 'end' | 'flex-start' | 'flex-end' | 'left' | 'right' | 'space-between' | 'space-around' | 'space-evenly' | 'stretch';
+type JustifyItems = 'stretch' | 'center' | 'start' | 'end' | 'flex-start' | 'flex-end' | 'self-start' | 'self-end' | 'left' | 'right' | 'baseline';
+type JustifySelf = 'center' | 'start' | 'end' | 'self-start' | 'self-end' | 'flex-start' | 'flex-end' | 'baseline' | 'stretch';
+type AlignContent = 'center' | 'start' | 'end' | 'flex-start' | 'flex-end' | 'baseline' | 'space-between' | 'space-around' | 'space-evenly' | 'stretch';
+type AlignItems = 'center' | 'start' | 'end' | 'flex-start' | 'flex-end' | 'self-start' | 'self-end' | 'stretch' | 'baseline';
+type AlignSelf = 'center' | 'start' | 'end' | 'self-start' | 'self-end' | 'flex-start' | 'flex-end' | 'baseline' | 'stretch';
+type ObjectFit = 'fill' | 'contain' | 'cover' | 'scale-down' | 'none';
+
+interface FormProps extends UseFormProps, Omit<HTMLAttributes<HTMLFormElement>, 'children'> {
+    gap?: Responsive<Spacing>;
+    autoComplete?: string;
+    onSubmit?: SubmitHandler<any>;
+    error?: ReactNode | Error;
+    preventSubmit?: boolean;
+    children?: ReactNode | ((e: UseFormReturn) => ReactNode);
+}
+declare function Form({ gap, autoComplete, onSubmit, error, preventSubmit, mode, disabled, reValidateMode, defaultValues, values, errors, resetOptions, resolver, context, shouldFocusError, shouldUnregister, shouldUseNativeValidation, progressive, criteriaMode, delayError, className, children, ...props }: FormProps): react.JSX.Element;
+
+interface BoxProps extends Omit<HTMLAttributes<HTMLElement>, 'color'> {
+    display?: Responsive<Display>;
+    color?: FontColor;
+    backgroundColor?: BackgroundColor;
+    hoverColor?: HoverColor;
+    hoverBackgroundColor?: HoverColor;
+    hoverBorderColor?: HoverColor;
+    fontSize?: Responsive<FontSize>;
+    fontWeight?: Responsive<FontWeight>;
+    border?: Responsive<BorderPosition>;
+    borderColor?: BorderColor;
+    borderRadius?: Responsive<BorderRadius>;
+    shadow?: Responsive<BoxShadow>;
+    padding?: Responsive<Padding>;
+    paddingX?: Responsive<Padding>;
+    paddingY?: Responsive<Padding>;
+    paddingTop?: Responsive<Padding>;
+    paddingRight?: Responsive<Padding>;
+    paddingBottom?: Responsive<Padding>;
+    paddingLeft?: Responsive<Padding>;
+    margin?: Responsive<Spacing>;
+    marginX?: Responsive<Spacing>;
+    marginY?: Responsive<Spacing>;
+    marginTop?: Responsive<Spacing>;
+    marginRight?: Responsive<Spacing>;
+    marginBottom?: Responsive<Spacing>;
+    marginLeft?: Responsive<Spacing>;
+    width?: Responsive<string>;
+    minWidth?: Responsive<string>;
+    maxWidth?: Responsive<string>;
+    height?: Responsive<string>;
+    minHeight?: Responsive<string>;
+    maxHeight?: Responsive<string>;
+    position?: Responsive<Position>;
+    textAlign?: Responsive<TextAlign>;
+    top?: Responsive<Top>;
+    right?: Responsive<Right>;
+    bottom?: Responsive<Bottom>;
+    left?: Responsive<Left>;
+    overflow?: Responsive<Overflow>;
+    overflowX?: Responsive<Overflow>;
+    overflowY?: Responsive<Overflow>;
+    alignSelf?: Responsive<AlignSelf>;
+    justifySelf?: Responsive<JustifySelf>;
+    flexBasis?: Responsive<string>;
+    flexGrow?: Responsive<FlexGrow>;
+    flexShrink?: Responsive<FlexShrink>;
+    gridArea?: Responsive<string>;
+    gridRow?: Responsive<string>;
+    gridColumn?: Responsive<string>;
+    order?: Responsive<number>;
+    theme?: string;
+    as?: string;
+    asChild?: boolean;
+}
+declare function Box({ display, color, backgroundColor, hoverColor, hoverBackgroundColor, hoverBorderColor, fontSize, fontWeight, border, borderColor, borderRadius, shadow, padding, paddingX, paddingY, paddingTop, paddingRight, paddingBottom, paddingLeft, margin, marginX, marginY, marginTop, marginRight, marginBottom, marginLeft, width, minWidth, maxWidth, height, minHeight, maxHeight, position, textAlign, top, right, bottom, left, overflow, overflowX, overflowY, alignSelf, justifySelf, flexBasis, flexGrow, flexShrink, gridArea, gridRow, gridColumn, order, theme, as, asChild, className, style, children, ...props }: BoxProps): react.JSX.Element;
+
+interface FlexboxProps extends Omit<BoxProps, 'display'> {
+    display?: Responsive<FlexDisplay>;
+    direction?: Responsive<FlexDirection>;
+    wrap?: Responsive<FlexWrap>;
+    justifyContent?: Responsive<JustifyContent>;
+    justifyItems?: Responsive<JustifyItems>;
+    alignContent?: AlignContent;
+    alignItems?: AlignItems;
+    gap?: Responsive<Spacing | true>;
+    gapX?: Responsive<Spacing | true>;
+    gapY?: Responsive<Spacing | true>;
+}
+declare function Flexbox({ display, direction, wrap, justifyContent, justifyItems, alignContent, alignItems, gap, gapX, gapY, className, style, children, ...props }: FlexboxProps): react.JSX.Element;
+
+interface RowProps extends FlexboxProps {
+    reverse?: boolean;
+}
+declare function Row({ reverse, children, ...props }: RowProps): react.JSX.Element;
+
+interface FormButtonsProps extends RowProps {
+    fill?: boolean;
+}
+declare function FormButtons({ fill, children, ...props }: FormButtonsProps): react.JSX.Element;
+
+interface FormFieldProps extends HTMLAttributes<HTMLDivElement>, Partial<UseFormReturn> {
+    name: string;
+    description?: string;
+    label?: string;
+    rules?: RegisterOptions<FieldValues, string>;
+    children: any;
+}
+declare const FormField: react.ForwardRefExoticComponent<FormFieldProps & react.RefAttributes<any>>;
+
+interface ButtonProps extends ButtonProps$1 {
+    variant?: 'primary' | 'secondary' | 'outline' | 'quiet' | 'danger' | 'zero';
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    asChild?: boolean;
+    slot?: string;
+    children?: ReactNode;
+}
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<any>>;
+
+interface FormResetButtonProps extends ButtonProps {
+    values?: FieldValues | {
+        [p: string]: any;
+    };
+}
+declare function FormResetButton({ values, children, onPress, ...props }: FormResetButtonProps): react.JSX.Element;
+
+interface LoadingButtonProps extends ButtonProps {
+    isDisabled?: boolean;
+    isLoading?: boolean;
+    showText?: boolean;
+}
+declare function LoadingButton({ isLoading, isDisabled, showText, children, ...props }: LoadingButtonProps): react.JSX.Element;
+
+declare function FormSubmitButton({ variant, isDisabled, isLoading, children, ...props }: LoadingButtonProps): react.JSX.Element;
+
+interface ToastProps extends HTMLAttributes<HTMLDivElement> {
+    id: string;
+    message: string;
+    title?: string;
+    actions?: string[];
+    allowClose?: boolean;
+    variant?: 'info' | 'error';
+    onClose?: (action?: string) => void;
+}
+declare function Toast({ id, message, title, actions, allowClose, variant, className, children, onClose, ...props }: ToastProps): react.JSX.Element;
+
+type ToastPosition = 'top-left' | 'top' | 'top-right' | 'bottom-left' | 'bottom' | 'bottom-right' | 'left' | 'right';
+interface ToasterProps {
+    duration?: number;
+    position?: ToastPosition;
+}
+declare function Toaster({ duration, position }: ToasterProps): react.JSX.Element;
+
+interface ToastProviderProps extends ToasterProps {
+    children: ReactNode;
+}
+declare function ToastProvider({ children, ...props }: ToastProviderProps): react.JSX.Element;
+
+declare function useDebounce(value: string, delay: number): string;
+
+declare function setTheme(theme: string): void;
+declare function useTheme(defaultTheme?: string): {
+    theme: string;
+    setTheme: typeof setTheme;
+};
+
+interface ToastOptions {
+    duration?: number;
+    title?: string;
+    actions?: string[];
+    allowClose?: boolean;
+    variant?: 'info' | 'error';
+    onClose?: (action?: string) => void;
+}
+interface ToastState extends ToastOptions {
+    id: string;
+    message: string;
+    timestamp: number;
+}
+declare function useToast(): {
+    toast: (message: string, options?: ToastOptions) => void;
+    toasts: ToastState[];
+};
+
+interface AccordionProps extends DisclosureGroupProps {
+    type: 'single' | 'multiple';
+    className?: string;
+    children?: ReactNode;
+}
+interface AccordionItemProps extends DisclosureProps {
+}
+declare function Accordion({ className, children, ...props }: AccordionProps): react.JSX.Element;
+declare function AccordionItem({ defaultExpanded, className, children, ...props }: AccordionItemProps): react.JSX.Element;
+
+interface AlertBannerProps {
+    title?: ReactNode;
+    description?: ReactNode;
+    icon?: ReactNode;
+    variant?: 'error';
+    align?: 'start' | 'center' | 'end';
+    allowClose?: boolean;
+    onClose?: () => void;
+    className?: string;
+    children?: ReactNode;
+}
+declare function AlertBanner({ title, description, icon, variant, align, allowClose, onClose, children, className, ...props }: AlertBannerProps): react.JSX.Element;
+
+interface DialogProps extends DialogProps$1 {
+    title?: ReactNode;
+    variant?: 'modal' | 'menu' | 'sheet' | 'none';
+}
+declare function Dialog({ title, variant, children, className, ...props }: DialogProps): react.JSX.Element;
+
+interface AlertDialogProps extends DialogProps {
+    title?: ReactNode;
+    description?: ReactNode;
+    isDanger?: boolean;
+    isConfirmDisabled?: boolean;
+    confirmLabel?: ReactNode;
+    cancelLabel?: ReactNode;
+    onConfirm?: () => void;
+    onCancel?: () => void;
+}
+declare function AlertDialog({ title, description, isDanger, isConfirmDisabled, confirmLabel, cancelLabel, onConfirm, onCancel, className, children, ...props }: AlertDialogProps): react.JSX.Element;
+
+interface BlockquoteProps extends HTMLAttributes<HTMLElement> {
+    asChild?: boolean;
+    weight?: Responsive<FontWeight>;
+    wrap?: Responsive<TextWrap>;
+}
+declare function Blockquote({ asChild, children }: BlockquoteProps): react.JSX.Element;
+
+declare function Breadcrumbs({ children, className, ...props }: BreadcrumbsProps<any>): react.JSX.Element;
+declare function Breadcrumb({ children, className, ...props }: BreadcrumbProps): react.JSX.Element;
+
+interface CalendarProps extends Omit<CalendarProps$1<any>, 'value' | 'minValue' | 'maxValue' | 'defaultValue' | 'onChange'> {
+    value: Date;
+    minValue?: Date;
+    maxValue?: Date;
+    defaultValue?: Date;
+    onChange?: (date: Date) => void;
+}
+declare function Calendar({ className, value, minValue, maxValue, defaultValue, onChange, ...props }: CalendarProps): react.JSX.Element;
+
+interface CheckboxProps extends CheckboxProps$1 {
+    label?: string;
+}
+declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<any>>;
+
+interface CodeProps extends HTMLAttributes<HTMLElement> {
+    asChild?: boolean;
+    weight?: Responsive<FontWeight>;
+    wrap?: Responsive<TextWrap>;
+}
+declare function Code({ asChild, children }: CodeProps): react.JSX.Element;
+
+interface ColumnProps extends FlexboxProps {
+    reverse?: boolean;
+}
+declare function Column({ reverse, children, ...props }: ColumnProps): react.JSX.Element;
+
+interface ContainerProps extends BoxProps {
+    isFluid?: boolean;
+    isCentered?: boolean;
+}
+declare function Container({ isCentered, isFluid, className, children, ...props }: ContainerProps): react.JSX.Element;
+
+interface ConfirmationDialogProps extends AlertDialogProps {
+    value?: string;
+    confirmMessage?: ReactNode;
+}
+declare function ConfirmationDialog({ value, confirmMessage, className, children, ...props }: ConfirmationDialogProps): react.JSX.Element;
+
+interface DataTableProps extends TableProps {
+    data?: any[];
+}
+declare function DataTable({ data, className, children, ...props }: DataTableProps): react.JSX.Element;
+interface DataColumnProps extends Omit<HTMLAttributes<any>, 'children'> {
+    id: string;
+    label?: ReactNode;
+    align?: 'start' | 'center' | 'end';
+    width?: string;
+    as?: string;
+    hidden?: boolean;
+    children?: ReactNode | ((props: DataColumnProps) => void);
+}
+declare function DataColumn(props: DataColumnProps): null;
+
+interface DotsProps {
+    className?: string;
+}
+declare function Dots({ className, ...props }: DotsProps): react.JSX.Element;
+
+interface TooltipProps extends TooltipProps$1 {
+    showArrow?: boolean;
+}
+declare function Tooltip({ children, className, showArrow, ...props }: TooltipProps): react.JSX.Element;
+interface TooltipBubbleProps extends HTMLAttributes<HTMLDivElement> {
+    showArrow?: boolean;
+}
+declare function TooltipBubble({ showArrow, children, ...props }: TooltipBubbleProps): react.JSX.Element;
+
+interface FloatingTooltipProps extends TooltipBubbleProps {
+}
+declare function FloatingTooltip({ className, style, children, ...props }: FloatingTooltipProps): react.JSX.Element;
+
+interface GridProps extends Omit<BoxProps, 'display'> {
+    display?: Responsive<GridDisplay>;
+    justifyContent?: Responsive<JustifyContent>;
+    justifyItems?: Responsive<JustifyItems>;
+    alignContent?: AlignContent;
+    alignItems?: AlignItems;
+    gap?: Responsive<Spacing>;
+    gapX?: Responsive<Spacing>;
+    gapY?: Responsive<Spacing>;
+    autoFlow?: Responsive<GridAutoFlow>;
+    rows?: Responsive<GridTemplateRows>;
+    columns?: Responsive<GridTemplateColumns>;
+    areas?: Responsive<GridTemplateAreas>;
+}
+declare function Grid({ display, justifyContent, justifyItems, alignContent, alignItems, gap, gapX, gapY, autoFlow, rows, columns, areas, className, style, children, ...props }: GridProps): react.JSX.Element;
+
+interface HeadingProps extends BoxProps {
+    size?: Responsive<FontSize>;
+    weight?: Responsive<FontWeight>;
+    spacing?: Responsive<LetterSpacing>;
+    align?: Responsive<TextAlign>;
+}
+declare function Heading({ size, weight, align, spacing, className, style, children, ...props }: HeadingProps): react.JSX.Element;
+
+interface HoverButtonProps {
+    isOpen?: boolean;
+    onHoverStart?: () => void;
+    onHoverEnd?: () => void;
+    closeDelay?: number;
+    children: ReactElement[];
+}
+declare function HoverTrigger({ isOpen, onHoverStart, onHoverEnd, closeDelay, children, }: HoverButtonProps): react.JSX.Element;
+
+interface IconProps extends Omit<HTMLAttributes<HTMLElement>, 'color'> {
+    color?: FontColor;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    variant?: 'input';
+    rotate?: number;
+    strokeWidth?: string;
+    strokeColor?: FontColor;
+    fillColor?: FontColor;
+}
+declare function Icon({ color, size, variant, rotate, strokeWidth, strokeColor, fillColor, style, className, children, ...props }: IconProps & HTMLAttributes<HTMLElement>): react.JSX.Element;
+
+declare const Icons: {
+    Moon: react_icons_lib.IconType;
+    Sun: react_icons_lib.IconType;
+    Alert: react_icons_lib.IconType;
+    Arrow: react_icons_lib.IconType;
+    Check: react_icons_lib.IconType;
+    Chevron: react_icons_lib.IconType;
+    Close: react_icons_lib.IconType;
+    Copy: react_icons_lib.IconType;
+    Edit: react_icons_lib.IconType;
+    ExternalLink: react_icons_lib.IconType;
+    Eye: react_icons_lib.IconType;
+    EyeSlash: react_icons_lib.IconType;
+    Info: react_icons_lib.IconType;
+    Logout: react_icons_lib.IconType;
+    MagnifyingGlass: react_icons_lib.IconType;
+    Menu: react_icons_lib.IconType;
+    Minus: react_icons_lib.IconType;
+    More: react_icons_lib.IconType;
+    PanelLeft: react_icons_lib.IconType;
+    Plus: react_icons_lib.IconType;
+    Refresh: react_icons_lib.IconType;
+    Trash: react_icons_lib.IconType;
+};
+
+interface ImageProps extends HTMLAttributes<HTMLImageElement> {
+    src: string;
+    alt?: string;
+    objectFit?: ObjectFit;
+    isCentered?: boolean;
+    borderRadius?: Responsive<BorderRadius>;
+    shadow?: Responsive<BoxShadow>;
+}
+declare function Image({ src, alt, objectFit, isCentered, borderRadius, shadow, className, style, ...props }: ImageProps): react.JSX.Element;
+
+interface InlineEditFieldProps extends HTMLAttributes<HTMLDivElement> {
+    name?: string;
+    value: string;
+    defaultEdit?: boolean;
+    onChange?: (value: any) => void;
+    onCommit?: (value: any) => void;
+    onCancel?: () => void;
+}
+declare function InlineEditField({ name, value: defaultValue, defaultEdit, className, children, onChange, onCommit, onCancel, ...props }: InlineEditFieldProps): react.JSX.Element;
+
+interface LabelProps extends LabelProps$1 {
+    className?: string;
+}
+declare function Label({ className, ...props }: LabelProps): react.JSX.Element;
+
+interface ListProps extends ListBoxProps<any> {
+    items?: any[];
+    idProperty?: string;
+    labelProperty?: string;
+    separatorProperty?: string;
+    highlightColor?: string;
+    showCheckmark?: boolean;
+}
+declare function List({ items, idProperty, labelProperty, separatorProperty, highlightColor, showCheckmark, className, style, children, ...props }: ListProps): react.JSX.Element;
+interface ListItemProps extends ListBoxItemProps<any> {
+    showCheckmark?: boolean;
+}
+declare function ListItem({ id, children, className, showCheckmark, ...props }: ListItemProps): react.JSX.Element;
+declare function ListSeparator({ className, ...props }: SeparatorProps): react.JSX.Element;
+interface ListSectionProps extends ListBoxSectionProps<any> {
+    title?: string;
+}
+declare function ListSection({ title, className, children, ...props }: ListSectionProps): react.JSX.Element;
+
+interface LoadingProps {
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    icon?: 'dots' | 'spinner';
+    position?: 'page' | 'center' | 'inline';
+    className?: string;
+}
+declare function Loading(props: LoadingProps): react.JSX.Element;
+
+interface MenuProps extends MenuProps$1<any> {
+    className?: string;
+    children?: ReactNode;
+}
+declare function Menu({ className, children, ...props }: MenuProps): react.JSX.Element;
+declare function MenuItem({ children, className, ...props }: MenuItemProps<any>): react.JSX.Element;
+declare function MenuSeparator({ className, ...props }: SeparatorProps): react.JSX.Element;
+declare function MenuSection({ title, className, children, ...props }: MenuSectionProps<any> & {
+    title?: string;
+}): react.JSX.Element;
+
+interface ModalProps extends ModalOverlayProps {
+    position?: 'center' | 'top' | 'bottom' | 'left' | 'right' | 'fullscreen';
+    offset?: string;
+    children?: ReactNode | ((values: ModalRenderProps & {
+        defaultChildren: ReactNode;
+    }) => ReactNode);
+}
+declare function Modal({ position, offset, children, className, style, ...props }: ModalProps): react.JSX.Element;
+
+type NavigationContext = {
+    activeMenu: string;
+    setActiveMenu: Dispatch<SetStateAction<string>>;
+};
+declare const NavbarContext: react.Context<NavigationContext | undefined>;
+interface NavbarProps extends HTMLAttributes<HTMLElement> {
+    showArrow?: boolean;
+}
+declare const useNavigationContext: () => NavigationContext;
+declare function Navbar({ showArrow, className, children, ...props }: NavbarProps): react.JSX.Element;
+interface NavbarItemProps extends HTMLAttributes<HTMLElement> {
+    label?: string;
+    children?: ReactNode;
+}
+declare function NavbarItem({ label, children, className, ...props }: NavbarItemProps): react.JSX.Element;
+
+interface NavMenuProps extends ColumnProps {
+    highlightColor?: string;
+}
+declare function NavMenu({ highlightColor, className, style, children, ...props }: NavMenuProps): react.JSX.Element;
+interface NavMenuItemProps extends RowProps {
+    isSelected?: boolean;
+}
+declare function NavMenuItem({ isSelected, className, children, ...props }: NavMenuItemProps): react.JSX.Element;
+
+interface PasswordFieldProps extends TextFieldProps$1 {
+    label?: string;
+}
+declare const PasswordField: react.ForwardRefExoticComponent<PasswordFieldProps & react.RefAttributes<any>>;
+
+declare function Popover({ children, className, ...props }: PopoverProps): react.JSX.Element;
+
+interface ProgressBarProps extends ProgressBarProps$1 {
+    showValue?: boolean;
+}
+declare function ProgressBar({ className, showValue, ...props }: ProgressBarProps): react.JSX.Element;
+
+interface ProgressCircleProps extends ProgressBarProps$1 {
+    showValue?: boolean;
+}
+declare function ProgressCircle({ className, showValue, ...props }: ProgressCircleProps): react.JSX.Element;
+
+interface RadioGroupProps extends RadioGroupProps$1 {
+    label?: string;
+}
+declare const RadioGroup: react.ForwardRefExoticComponent<RadioGroupProps & react.RefAttributes<any>>;
+declare function Radio({ children, className, ...props }: RadioProps): react.JSX.Element;
+
+interface SearchFieldProps extends SearchFieldProps$1 {
+    label?: string;
+    placeholder?: string;
+    value?: string;
+    delay?: number;
+    onSearch?: (value: string) => void;
+}
+declare const SearchField: react.ForwardRefExoticComponent<SearchFieldProps & react.RefAttributes<any>>;
+
+interface SelectProps extends SelectProps$1<HTMLSelectElement> {
+    items?: any[];
+    value?: string;
+    defaultValue?: string;
+    label?: string;
+    isLoading?: boolean;
+    allowSearch?: boolean;
+    searchValue?: string;
+    searchDelay?: number;
+    onSearch?: (value: string) => void;
+    onChange?: (e: any) => void;
+    buttonProps?: ButtonProps;
+    listProps?: ListProps;
+    popoverProps?: PopoverProps;
+    renderValue?: ReactNode | ((values: SelectValueRenderProps<object> & {
+        defaultChildren: ReactNode;
+    }) => ReactNode);
+}
+declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<any>>;
+
+interface SidebarProps extends ColumnProps {
+    variant?: '1' | '2' | '3' | 'quiet';
+    isCollapsed?: boolean;
+    muteItems?: boolean;
+    showBorder?: boolean;
+    children?: ReactNode;
+}
+declare function Sidebar({ variant, isCollapsed, muteItems, showBorder, className, children, ...props }: SidebarProps): react.JSX.Element;
+declare function SidebarSection({ title, children, }: {
+    title?: string;
+    children: ReactNode;
+} & ColumnProps): react.JSX.Element;
+declare function SidebarHeader({ label, icon, className, children, ...props }: {
+    label: string;
+    icon?: ReactNode;
+    children?: ReactNode;
+} & RowProps): react.JSX.Element;
+interface SidebarItemProps extends RowProps {
+    isSelected?: boolean;
+}
+declare function SidebarItem({ label, icon, isSelected, className, children, ...props }: {
+    label?: string;
+    icon?: ReactNode;
+} & SidebarItemProps): react.JSX.Element;
+
+interface SliderProps extends SliderProps$1 {
+    label?: ReactNode;
+    showValue?: boolean;
+}
+declare const Slider: react.ForwardRefExoticComponent<SliderProps & react.RefAttributes<any>>;
+
+declare function Slot({ children, ...props }: {
+    children: ReactElement | ReactNode;
+    [key: string]: any;
+}): ReactElement<unknown, string | react.JSXElementConstructor<any>> | null;
+
+interface SpinnerProps {
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    quiet?: boolean;
+    className?: string;
+    isDisabled?: boolean;
+}
+declare function Spinner(props: SpinnerProps): react.JSX.Element;
+
+interface StatusLightProps {
+    color?: string;
+    variant?: 'success' | 'warning' | 'error' | 'active' | 'inactive' | 'none';
+    className?: string;
+    children?: ReactNode;
+}
+declare function StatusLight(props: StatusLightProps): react.JSX.Element;
+
+interface SwitchProps extends SwitchProps$1 {
+    label?: string;
+}
+declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<any>>;
+
+interface TableColumnProps extends ColumnProps$1 {
+    align?: 'start' | 'center' | 'end';
+}
+interface TableCellProps extends CellProps {
+    align?: 'start' | 'center' | 'end';
+}
+declare function Table({ children, className, ...props }: TableProps): react.JSX.Element;
+declare function TableHeader({ children, className, style, ...props }: TableHeaderProps<any>): react.JSX.Element;
+declare function TableBody({ children, className, ...props }: TableBodyProps<any>): react.JSX.Element;
+declare function TableRow({ children, className, style, ...props }: RowProps$1<any>): react.JSX.Element;
+declare function TableColumn({ children, className, align, ...props }: TableColumnProps): react.JSX.Element;
+declare function TableCell({ children, className, align, ...props }: TableCellProps): react.JSX.Element;
+
+declare function Tabs({ children, ...props }: TabsProps): react.JSX.Element;
+declare function TabList({ children, ...props }: TabListProps<any>): react.JSX.Element;
+declare function Tab({ children, ...props }: TabProps): react.JSX.Element;
+declare function TabPanel({ children, ...props }: TabPanelProps): react.JSX.Element;
+
+interface TextProps extends Omit<HTMLAttributes<HTMLElement>, 'color'> {
+    color?: FontColor;
+    size?: Responsive<FontSize>;
+    spacing?: Responsive<LetterSpacing>;
+    weight?: Responsive<FontWeight>;
+    align?: Responsive<TextAlign>;
+    wrap?: Responsive<TextWrap>;
+    transform?: Responsive<TextTransform>;
+    truncate?: Responsive<boolean>;
+    italic?: Responsive<boolean>;
+    underline?: Responsive<boolean>;
+    strikethrough?: Responsive<boolean>;
+    as?: 'span' | 'div' | 'label' | 'p';
+    asChild?: boolean;
+}
+declare function Text({ color, size, spacing, weight, align, wrap, transform, truncate, italic, underline, strikethrough, as, asChild, className, style, children, ...props }: TextProps): react.JSX.Element;
+
+interface TextFieldProps extends TextFieldProps$1 {
+    label?: string;
+    placeholder?: string;
+    allowCopy?: boolean;
+    asChild?: boolean;
+    onChange?: (e: any) => void;
+}
+declare const TextField: react.ForwardRefExoticComponent<TextFieldProps & react.RefAttributes<HTMLInputElement>>;
+
+interface TextAreaProps extends TextFieldProps {
+    rows?: number;
+    cols?: number;
+    resize?: 'none' | 'vertical' | 'horizontal';
+    children?: React.ReactNode;
+}
+declare const TextArea: react.ForwardRefExoticComponent<TextAreaProps & react.RefAttributes<any>>;
+
+interface ThemeButtonProps extends ButtonProps {
+    defaultTheme?: string;
+}
+declare function ThemeButton({ className, variant, defaultTheme, onPress, ...props }: ThemeButtonProps): react.JSX.Element;
+
+interface ToggleProps extends ToggleButtonProps {
+    label?: string;
+    value?: string;
+}
+declare const Toggle: react.ForwardRefExoticComponent<ToggleProps & react.RefAttributes<any>>;
+
+interface ToggleGroupProps extends TagGroupProps {
+    label?: string;
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (value: string[]) => void;
+}
+declare function ToggleGroup({ label, value, defaultValue, onChange, className, children, selectionMode, selectedKeys, defaultSelectedKeys, onSelectionChange, ...props }: ToggleGroupProps): react.JSX.Element;
+interface ToggleGroupItemProps extends TagProps {
+}
+declare function ToggleGroupItem({ className, children, ...props }: ToggleGroupItemProps): react.JSX.Element;
+
+interface ZenProviderProps {
+    theme?: string;
+    colorScheme?: 'light' | 'dark' | 'system';
+    toast?: ToasterProps;
+    children: ReactNode;
+}
+declare function ZenProvider({ children, ...props }: ZenProviderProps): react.JSX.Element;
+
+export { Accordion, AccordionItem, AlertBanner, AlertDialog, Blockquote, Box, Breadcrumb, Breadcrumbs, Button, Calendar, Checkbox, Code, Column, ConfirmationDialog, Container, DataColumn, DataTable, Dialog, Dots, Flexbox, FloatingTooltip, Form, FormButtons, FormField, FormResetButton, FormSubmitButton, Grid, Heading, HoverTrigger, Icon, Icons, Image, InlineEditField, Label, List, ListItem, ListSection, ListSeparator, Loading, LoadingButton, Menu, MenuItem, MenuSection, MenuSeparator, Modal, NavMenu, NavMenuItem, Navbar, NavbarContext, NavbarItem, PasswordField, Popover, ProgressBar, ProgressCircle, Radio, RadioGroup, Row, SearchField, Select, Sidebar, SidebarHeader, SidebarItem, SidebarSection, Slider, Slot, Spinner, StatusLight, Switch, Tab, TabList, TabPanel, Table, TableBody, TableCell, TableColumn, TableHeader, TableRow, Tabs, Text, TextArea, TextField, ThemeButton, Toast, ToastProvider, Toaster, Toggle, ToggleGroup, ToggleGroupItem, Tooltip, TooltipBubble, ZenProvider, useDebounce, useNavigationContext, useTheme, useToast };