chesai-ui 0.1.0

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

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import * as AccordionPrimitive from "@radix-ui/react-accordion";
+type AccordionRootProps = React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Root> & {
+    variant?: "primary" | "secondary";
+    shape?: "full" | "minimal" | "sharp";
+    layout?: "integrated" | "separated";
+};
+export declare const Accordion: React.ForwardRefExoticComponent<AccordionRootProps & React.RefAttributes<HTMLDivElement>> & {
+    Item: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Trigger: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+        /** If true, the ripple effect on click will be disabled. */
+        disableRipple?: boolean;
+    } & React.RefAttributes<HTMLButtonElement>>;
+    Content: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+};
+export {};

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

@@ -0,0 +1,32 @@
+import { VariantProps } from 'class-variance-authority';
+import { HTMLMotionProps } from 'framer-motion';
+import { default as React } from 'react';
+declare const appBarVariants: (props?: {
+    appBarColor?: "background" | "card" | "primary" | "secondary";
+    shadow?: "md" | "none";
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+export interface AppBarSharedProps {
+    scrollBehavior?: "sticky" | "conditionally-sticky";
+    animatedBehavior?: Array<"none" | "appbar-color" | "fold" | "shadow">;
+    animatedColor?: "background" | "card" | "primary" | "secondary";
+    size?: "md" | "lg";
+    largeHeaderContent?: React.ReactNode;
+    smallHeaderContent?: React.ReactNode;
+    stickyHideTarget?: "main-row" | "full-appbar";
+    scrollContainerRef?: React.RefObject<HTMLElement | null>;
+    /** The height of the main app bar row in its normal (md) or collapsed state. @default 64 */
+    normalHeaderRowHeight?: number;
+    /** The height of the main app bar row in its large (lg) expanded state. @default 96 */
+    largeHeaderRowHeight?: number;
+    /** The scroll distance over which the "fold" animation occurs. @default 50 */
+    foldAnimationDistance?: number;
+    /** The border-radius applied at the end of the "fold" animation. @default 24 */
+    foldBorderRadius?: number;
+}
+export interface AppBarProps extends Omit<HTMLMotionProps<"header">, "color" | "size">, VariantProps<typeof appBarVariants>, AppBarSharedProps {
+    startAdornment?: React.ReactNode;
+    centerAdornment?: React.ReactNode;
+    endAdornments?: React.ReactNode[];
+}
+export declare const AppBar: React.ForwardRefExoticComponent<Omit<AppBarProps, "ref"> & React.RefAttributes<HTMLElement>>;
+export {};

package/dist/components/avatar/AvatarGroup.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+export interface AvatarGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    /** The maximum number of avatars to display before showing an overflow count. */
+    max?: number;
+}
+export declare const AvatarGroup: React.FC<AvatarGroupProps>;

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

@@ -0,0 +1,14 @@
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+import * as RadixAvatar from "@radix-ui/react-avatar";
+declare const avatarVariants: (props?: {
+    size?: "md" | "lg" | "xs" | "sm" | "xl";
+    shape?: "full" | "minimal" | "sharp";
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+export interface AvatarProps extends React.ComponentPropsWithoutRef<typeof RadixAvatar.Root>, VariantProps<typeof avatarVariants> {
+    src?: string;
+    fallback?: string;
+    variant?: "default" | "count";
+}
+export declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLSpanElement>>;
+export {};

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

@@ -0,0 +1,10 @@
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+declare const badgeVariants: (props?: {
+    variant?: "primary" | "secondary" | "outline" | "destructive";
+    shape?: "full" | "minimal" | "sharp";
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+}
+export declare const Badge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/bottom-tabs/index.d.ts

@@ -0,0 +1,31 @@
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+export interface ScreenProps {
+    /** A unique name for the screen. */
+    name: string;
+    /** The text label to display. */
+    label: React.ReactNode;
+    /** A function that returns the icon element, receiving active state. */
+    icon: (props: {
+        isActive: boolean;
+    }) => React.ReactNode;
+    /** Overrides the shape of this specific tab item, indicator, and ripple effect. */
+    shape?: "full" | "minimal" | "sharp";
+}
+declare const navigatorVariants: (props?: {
+    mode?: "detached" | "attached";
+    shape?: "full" | "minimal" | "sharp";
+    bordered?: boolean;
+    shadow?: "md" | "lg" | "none" | "sm";
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+interface NavigatorProps extends React.HTMLAttributes<HTMLElement>, VariantProps<typeof navigatorVariants> {
+    children: React.ReactElement<ScreenProps> | React.ReactElement<ScreenProps>[];
+    activeTab: string;
+    onTabPress: (name: string) => void;
+    itemLayout?: "stacked" | "inline";
+}
+export declare const BottomTabs: {
+    Navigator: React.FC<NavigatorProps>;
+    Screen: React.FC<ScreenProps>;
+};
+export {};

package/dist/components/bouncy-box/index.d.ts

@@ -0,0 +1,7 @@
+import { HTMLMotionProps } from 'framer-motion';
+import { default as React } from 'react';
+export interface BouncyBoxProps extends HTMLMotionProps<"div"> {
+    /** The amount to scale down on press. 1 is no scale, 0.9 is 90%. */
+    scaleAmount?: number;
+}
+export declare const BouncyBox: React.ForwardRefExoticComponent<Omit<BouncyBoxProps, "ref"> & React.RefAttributes<HTMLDivElement>>;

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

@@ -0,0 +1,14 @@
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+export declare const buttonVariants: (props?: {
+    variant?: "primary" | "secondary" | "link" | "destructive" | "ghost";
+    size?: "md" | "lg" | "xs" | "sm";
+    shape?: "full" | "minimal" | "sharp";
+    isLoading?: boolean;
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    startIcon?: React.ReactNode;
+    endIcon?: React.ReactNode;
+    isLoading?: boolean;
+}
+export declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/button-group/index.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+type ButtonShape = "full" | "minimal" | "sharp";
+interface ButtonGroupProps extends React.HTMLAttributes<HTMLFieldSetElement> {
+    children: React.ReactNode;
+    shape?: ButtonShape;
+}
+export declare const ButtonGroup: {
+    ({ children, className, shape, ...props }: ButtonGroupProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export {};

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

@@ -0,0 +1,8 @@
+import { DayPicker } from 'react-day-picker';
+import * as React from "react";
+export type CalendarProps = React.ComponentProps<typeof DayPicker>;
+declare function Calendar({ className, classNames, showOutsideDays, ...props }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+export { Calendar };

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

@@ -0,0 +1,12 @@
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+declare const cardVariants: (props?: {
+    variant?: "primary" | "secondary" | "glass";
+    shape?: "full" | "minimal" | "sharp";
+    padding?: "md" | "lg" | "none" | "sm";
+    isSelected?: boolean;
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+export interface CardProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof cardVariants> {
+}
+export declare const Card: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>>;
+export {};

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

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export interface CheckboxProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    label?: string;
+}
+export declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLInputElement>>;

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

@@ -0,0 +1,11 @@
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+declare const chipVariants: (props?: {
+    selected?: boolean;
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+export interface ChipProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof chipVariants> {
+    startIcon?: React.ReactNode;
+    endIcon?: React.ReactNode;
+}
+export declare const Chip: React.ForwardRefExoticComponent<ChipProps & React.RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/components/context-menu/index.d.ts

@@ -0,0 +1,34 @@
+import { default as React } from 'react';
+import * as RadixContextMenu from "@radix-ui/react-context-menu";
+type ContextMenuShape = "full" | "minimal" | "sharp";
+type ContextMenuSize = "sm" | "md" | "lg";
+interface ContextMenuProps extends RadixContextMenu.ContextMenuProps {
+    shape?: ContextMenuShape;
+    size?: ContextMenuSize;
+}
+export declare const ContextMenu: React.FC<ContextMenuProps> & {
+    Trigger: React.ForwardRefExoticComponent<RadixContextMenu.ContextMenuTriggerProps & React.RefAttributes<HTMLSpanElement>>;
+    Content: React.ForwardRefExoticComponent<Omit<RadixContextMenu.ContextMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Item: React.ForwardRefExoticComponent<Omit<RadixContextMenu.ContextMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+        inset?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+    CheckboxItem: React.ForwardRefExoticComponent<Omit<RadixContextMenu.ContextMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    RadioGroup: React.ForwardRefExoticComponent<RadixContextMenu.ContextMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+    RadioItem: React.ForwardRefExoticComponent<Omit<RadixContextMenu.ContextMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Label: React.ForwardRefExoticComponent<Omit<RadixContextMenu.ContextMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+        inset?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+    Separator: React.ForwardRefExoticComponent<Omit<RadixContextMenu.ContextMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Shortcut: {
+        ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Group: React.ForwardRefExoticComponent<RadixContextMenu.ContextMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+    Portal: React.FC<RadixContextMenu.ContextMenuPortalProps>;
+    Sub: React.FC<RadixContextMenu.ContextMenuSubProps>;
+    SubContent: React.ForwardRefExoticComponent<Omit<RadixContextMenu.ContextMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    SubTrigger: React.ForwardRefExoticComponent<Omit<RadixContextMenu.ContextMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+        inset?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+};
+export {};

package/dist/components/date-picker/header.d.ts

@@ -0,0 +1,9 @@
+import { DateRange } from 'react-day-picker';
+interface DatePickerHeaderProps {
+    mode: "single" | "range";
+    selectedDate?: Date;
+    selectedRange?: DateRange;
+    onEditClick: () => void;
+}
+export declare const DatePickerHeader: ({ mode, selectedDate, selectedRange, onEditClick, }: DatePickerHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/date-picker/index.d.ts

@@ -0,0 +1,10 @@
+import { DateRange } from 'react-day-picker';
+import { InputProps } from '../input';
+type DatePickerProps = Omit<InputProps, "value" | "onChange" | "readOnly" | "endAdornment"> & {
+    value?: Date | DateRange;
+    onChange?: (value?: Date | DateRange) => void;
+    mode?: "single" | "range";
+    variant?: "docked" | "modal" | "fullscreen";
+};
+export declare const DatePicker: ({ value, onChange, mode, placeholder, variant: explicitVariant, ...inputProps }: DatePickerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/date-picker/input-view.d.ts

@@ -0,0 +1,9 @@
+import { DateRange } from 'react-day-picker';
+interface DateInputViewProps {
+    mode: "single" | "range";
+    value: Date | DateRange | undefined;
+    onValueChange: (value: Date | DateRange | undefined) => void;
+    onCalendarClick: () => void;
+}
+export declare const DateInputView: ({ mode, value, onValueChange, onCalendarClick, }: DateInputViewProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/date-picker/paginated-calendar.d.ts

@@ -0,0 +1,8 @@
+import { DateRange } from 'react-day-picker';
+interface CalendarProps {
+    mode: "single" | "range";
+    value?: Date | DateRange;
+    onSelect: (value?: Date | DateRange) => void;
+}
+export declare const PaginatedCalendar: ({ mode, value, onSelect }: CalendarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,37 @@
+import { FC, HTMLAttributes, ReactNode, ButtonHTMLAttributes } from 'react';
+import { CardProps } from '../card';
+import { ElasticScrollAreaProps } from '../elastic-scroll-area';
+type DialogVariant = "basic" | "fullscreen";
+export interface DialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    children: ReactNode;
+    variant?: DialogVariant;
+}
+declare const Dialog: FC<DialogProps>;
+interface DialogTriggerProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+declare const DialogTrigger: import('react').ForwardRefExoticComponent<DialogTriggerProps & import('react').RefAttributes<HTMLButtonElement>>;
+export interface DialogContentProps extends HTMLAttributes<HTMLDivElement> {
+    shape?: CardProps["shape"];
+}
+declare const DialogContent: import('react').ForwardRefExoticComponent<DialogContentProps & import('react').RefAttributes<HTMLDivElement>>;
+interface DialogCloseProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+}
+declare const DialogClose: import('react').ForwardRefExoticComponent<DialogCloseProps & import('react').RefAttributes<HTMLButtonElement>>;
+declare const DialogHeader: {
+    (props: HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    (props: HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLHeadingElement> & import('react').RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: import('react').ForwardRefExoticComponent<HTMLAttributes<HTMLParagraphElement> & import('react').RefAttributes<HTMLParagraphElement>>;
+export interface DialogBodyProps extends Omit<HTMLAttributes<HTMLDivElement>, "dir">, Omit<ElasticScrollAreaProps, "children" | "className" | "ref"> {
+}
+declare const DialogBody: import('react').ForwardRefExoticComponent<DialogBodyProps & import('react').RefAttributes<HTMLDivElement>>;
+export { Dialog, DialogBody, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, DialogTrigger, };

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

@@ -0,0 +1,31 @@
+import { default as React } from 'react';
+import * as RadixDropdownMenu from "@radix-ui/react-dropdown-menu";
+type DropdownMenuShape = "full" | "minimal" | "sharp";
+interface DropdownMenuProps extends RadixDropdownMenu.DropdownMenuProps {
+    shape?: DropdownMenuShape;
+}
+declare const DropdownMenu: React.FC<DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<RadixDropdownMenu.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<RadixDropdownMenu.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<RadixDropdownMenu.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<RadixDropdownMenu.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<RadixDropdownMenu.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<RadixDropdownMenu.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<RadixDropdownMenu.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<RadixDropdownMenu.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<RadixDropdownMenu.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<RadixDropdownMenu.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<RadixDropdownMenu.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<RadixDropdownMenu.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<RadixDropdownMenu.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuGroup, DropdownMenuItem, DropdownMenuLabel, DropdownMenuPortal, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, };

package/dist/components/elastic-scroll-area/index.d.ts

@@ -0,0 +1,24 @@
+import { MotionValue } from 'framer-motion';
+import { ComponentPropsWithoutRef, ComponentType } from 'react';
+import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
+interface RefreshIndicatorProps {
+    pullProgress: MotionValue<number>;
+    isRefreshing: boolean;
+}
+export interface ElasticScrollAreaProps extends ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.Root> {
+    /** The primary scrolling direction of the content. @default "vertical" */
+    orientation?: "vertical" | "horizontal";
+    elasticity?: boolean;
+    dampingFactor?: number;
+    scrollbarVisibility?: "auto" | "always" | "scroll";
+    pullToRefresh?: boolean;
+    onRefresh?: () => Promise<unknown>;
+    pullThreshold?: number;
+    RefreshIndicatorComponent?: ComponentType<RefreshIndicatorProps>;
+}
+export declare const ElasticScrollArea: import('react').ForwardRefExoticComponent<ElasticScrollAreaProps & import('react').RefAttributes<HTMLDivElement>> & {
+    ScrollBar: import('react').ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & import('react').RefAttributes<HTMLDivElement>, "ref"> & {
+        scrollbarVisibility?: ElasticScrollAreaProps["scrollbarVisibility"];
+    } & import('react').RefAttributes<HTMLDivElement>>;
+};
+export {};

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

@@ -0,0 +1,15 @@
+import { VariantProps } from 'class-variance-authority';
+import { HTMLMotionProps } from 'framer-motion';
+import { default as React } from 'react';
+declare const fabVariants: (props?: {
+    variant?: "primary" | "secondary";
+    size?: "md" | "lg" | "sm";
+    shape?: "full" | "minimal" | "sharp";
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+export interface FABProps extends Omit<HTMLMotionProps<"button">, "children" | "ref">, VariantProps<typeof fabVariants> {
+    icon: React.ReactNode;
+    isExtended?: boolean;
+    children?: React.ReactNode;
+}
+export declare const FAB: React.ForwardRefExoticComponent<FABProps & React.RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/components/icon-button/index.d.ts

@@ -0,0 +1,12 @@
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+export declare const iconButtonVariants: (props?: {
+    variant?: "primary" | "secondary" | "link" | "destructive" | "ghost";
+    size?: "md" | "lg" | "xs" | "sm";
+    shape?: "full" | "minimal" | "sharp";
+    isLoading?: boolean;
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+export interface IconButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof iconButtonVariants> {
+    isLoading?: boolean;
+}
+export declare const IconButton: React.ForwardRefExoticComponent<IconButtonProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/index.d.ts

@@ -0,0 +1,28 @@
+export * from './appbar';
+export * from './avatar';
+export * from './badge';
+export * from './bouncy-box';
+export * from './button';
+export * from './button-group';
+export * from './calendar';
+export * from './card';
+export * from './checkbox';
+export * from './chip';
+export * from './date-picker';
+export * from './dialog';
+export * from './dropdown-menu';
+export * from './elastic-scroll-area';
+export * from './fab';
+export * from './icon-button';
+export * from './input';
+export * from './item';
+export * from './radio-group';
+export * from './select';
+export * from './shallow-router';
+export * from './sheet';
+export * from './split-button';
+export * from './switch';
+export * from './tabs';
+export * from './textarea';
+export * from './tooltip';
+export * from './typography';

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

@@ -0,0 +1,18 @@
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+export declare const inputWrapperVariants: (props?: {
+    variant?: "primary" | "secondary" | "minimal";
+    shape?: "full" | "minimal" | "sharp";
+    size?: "md" | "lg" | "sm";
+    isErrored?: boolean;
+    isFocused?: boolean;
+    disabled?: boolean;
+} & import('class-variance-authority/dist/types').ClassProp) => string;
+export interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof inputWrapperVariants> {
+    label?: string;
+    startAdornment?: React.ReactNode;
+    endAdornment?: React.ReactNode;
+    error?: string;
+    wrapperClassName?: string;
+}
+export declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;

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

@@ -0,0 +1,30 @@
+import { VariantProps } from 'class-variance-authority';
+import * as React from "react";
+declare const ItemGroup: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const ItemSeparator: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const Item: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: {
+    variant?: "primary" | "secondary" | "ghost";
+    size?: "md" | "lg" | "sm";
+    padding?: "md" | "lg" | "none" | "sm";
+    shape?: "full" | "minimal" | "sharp";
+    direction?: "horizontal" | "vertical";
+} & import('class-variance-authority/dist/types').ClassProp) => string> & {
+    asChild?: boolean;
+    disabled?: boolean;
+    /** If true, the ripple effect on click will be disabled. */
+    disableRipple?: boolean;
+    /** Callback fired when the item is pressed for 500ms. */
+    onLongPress?: (event: React.PointerEvent<HTMLDivElement> | React.MouseEvent<HTMLDivElement>) => void;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ItemMedia: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & VariantProps<(props?: {
+    variant?: "default" | "icon" | "avatar";
+    size?: "md" | "lg" | "sm";
+    shape?: "full" | "minimal" | "sharp";
+} & import('class-variance-authority/dist/types').ClassProp) => string> & React.RefAttributes<HTMLDivElement>>;
+declare const ItemContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const ItemTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const ItemDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+declare const ItemActions: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const ItemHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const ItemFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Item, ItemActions, ItemContent, ItemDescription, ItemFooter, ItemGroup, ItemHeader, ItemMedia, ItemSeparator, ItemTitle, };

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

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+import * as RadixMenubar from "@radix-ui/react-menubar";
+type MenubarShape = "full" | "minimal" | "sharp";
+interface MenubarProps extends RadixMenubar.MenubarProps {
+    shape?: MenubarShape;
+}
+export declare const Menubar: React.FC<MenubarProps> & {
+    Menu: {
+        (props: RadixMenubar.MenubarMenuProps & {
+            __scopeMenubar?: import('@radix-ui/react-context').Scope;
+        }): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Trigger: React.ForwardRefExoticComponent<Omit<RadixMenubar.MenubarTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    Content: React.ForwardRefExoticComponent<Omit<RadixMenubar.MenubarContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Item: React.ForwardRefExoticComponent<Omit<RadixMenubar.MenubarItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+        inset?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+    Separator: React.ForwardRefExoticComponent<Omit<RadixMenubar.MenubarSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Label: React.ForwardRefExoticComponent<Omit<RadixMenubar.MenubarLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+        inset?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+    CheckboxItem: React.ForwardRefExoticComponent<Omit<RadixMenubar.MenubarCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    RadioGroup: React.ForwardRefExoticComponent<RadixMenubar.MenubarRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+    RadioItem: React.ForwardRefExoticComponent<Omit<RadixMenubar.MenubarRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Portal: React.FC<RadixMenubar.MenubarPortalProps>;
+    Group: React.ForwardRefExoticComponent<RadixMenubar.MenubarGroupProps & React.RefAttributes<HTMLDivElement>>;
+    Sub: React.FC<RadixMenubar.MenubarSubProps>;
+    SubContent: React.ForwardRefExoticComponent<Omit<RadixMenubar.MenubarSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    SubTrigger: React.ForwardRefExoticComponent<Omit<RadixMenubar.MenubarSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+        inset?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+    Shortcut: {
+        ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};
+export {};

package/dist/components/navigation-menu/index.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import * as RadixNavigationMenu from "@radix-ui/react-navigation-menu";
+export declare const navigationMenuTriggerStyle: (props?: import('class-variance-authority/dist/types').ClassProp) => string;
+declare const NavigationMenuLink: React.ForwardRefExoticComponent<RadixNavigationMenu.NavigationMenuLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+interface ContentItemProps extends Omit<React.ComponentPropsWithoutRef<typeof NavigationMenuLink>, "title"> {
+    title: React.ReactNode;
+    startIcon?: React.ReactNode;
+    endAdornment?: React.ReactNode;
+}
+export declare const NavigationMenu: React.ForwardRefExoticComponent<Omit<RadixNavigationMenu.NavigationMenuProps & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>> & {
+    List: React.ForwardRefExoticComponent<Omit<RadixNavigationMenu.NavigationMenuListProps & React.RefAttributes<HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+    Item: React.ForwardRefExoticComponent<RadixNavigationMenu.NavigationMenuItemProps & React.RefAttributes<HTMLLIElement>>;
+    Content: React.ForwardRefExoticComponent<Omit<RadixNavigationMenu.NavigationMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Trigger: React.ForwardRefExoticComponent<Omit<RadixNavigationMenu.NavigationMenuTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    Link: React.ForwardRefExoticComponent<RadixNavigationMenu.NavigationMenuLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+    Indicator: React.ForwardRefExoticComponent<Omit<RadixNavigationMenu.NavigationMenuIndicatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    Viewport: React.ForwardRefExoticComponent<Omit<RadixNavigationMenu.NavigationMenuViewportProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    ContentList: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLUListElement> & {
+        grid?: "cols-1" | "cols-2" | "cols-3";
+    } & React.RefAttributes<HTMLUListElement>>;
+    ContentItem: React.ForwardRefExoticComponent<ContentItemProps & React.RefAttributes<HTMLAnchorElement>>;
+};
+export {};

package/dist/components/otp-field/index.d.ts

@@ -0,0 +1,34 @@
+import * as React from "react";
+declare const InputOTP: React.ForwardRefExoticComponent<(Omit<Omit<React.InputHTMLAttributes<HTMLInputElement>, "textAlign" | "onChange" | "value" | "containerClassName" | "maxLength" | "onComplete" | "pushPasswordManagerStrategy" | "pasteTransformer" | "noScriptCSSFallback"> & {
+    value?: string;
+    onChange?: (newValue: string) => unknown;
+    maxLength: number;
+    textAlign?: "left" | "center" | "right";
+    onComplete?: (...args: any[]) => unknown;
+    pushPasswordManagerStrategy?: "increase-width" | "none";
+    pasteTransformer?: (pasted: string) => string;
+    containerClassName?: string;
+    noScriptCSSFallback?: string | null;
+} & {
+    render: (props: import('input-otp').RenderProps) => React.ReactNode;
+    children?: never;
+} & React.RefAttributes<HTMLInputElement>, "ref"> | Omit<Omit<React.InputHTMLAttributes<HTMLInputElement>, "textAlign" | "onChange" | "value" | "containerClassName" | "maxLength" | "onComplete" | "pushPasswordManagerStrategy" | "pasteTransformer" | "noScriptCSSFallback"> & {
+    value?: string;
+    onChange?: (newValue: string) => unknown;
+    maxLength: number;
+    textAlign?: "left" | "center" | "right";
+    onComplete?: (...args: any[]) => unknown;
+    pushPasswordManagerStrategy?: "increase-width" | "none";
+    pasteTransformer?: (pasted: string) => string;
+    containerClassName?: string;
+    noScriptCSSFallback?: string | null;
+} & {
+    render?: never;
+    children: React.ReactNode;
+} & React.RefAttributes<HTMLInputElement>, "ref">) & React.RefAttributes<HTMLInputElement>>;
+declare const InputOTPGroup: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const InputOTPSlot: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    index: number;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const InputOTPSeparator: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { InputOTP, InputOTPGroup, InputOTPSeparator, InputOTPSlot };

package/dist/components/pull-to-refresh/index.d.ts

@@ -0,0 +1,17 @@
+import { useMotionValue } from 'framer-motion';
+import { default as React } from 'react';
+interface RefreshIndicatorProps {
+    /** The current pull distance as a motion value. */
+    pullProgress: ReturnType<typeof useMotionValue<number>>;
+    /** Whether the component is in the "refreshing" state. */
+    isRefreshing: boolean;
+}
+export interface PullToRefreshProps {
+    children: React.ReactNode;
+    onRefresh: () => Promise<unknown>;
+    IndicatorComponent?: React.ComponentType<RefreshIndicatorProps>;
+    pullThreshold?: number;
+    className?: string;
+}
+export declare const PullToRefresh: ({ children, onRefresh, IndicatorComponent, pullThreshold, className, }: PullToRefreshProps) => import("react/jsx-runtime").JSX.Element;
+export {};