chesai-ui 0.9.2 → 0.12.0

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

@@ -5,11 +5,15 @@ type AccordionRootProps = React.ComponentPropsWithoutRef<typeof AccordionPrimiti
     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"> & {
-        disableRipple?: boolean;
-    } & React.RefAttributes<HTMLButtonElement>>;
-    Content: React.ForwardRefExoticComponent<Omit<AccordionPrimitive.AccordionContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const AccordionRoot: React.ForwardRefExoticComponent<AccordionRootProps & React.RefAttributes<never>>;
+declare const AccordionItem: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Item> & React.RefAttributes<React.ElementRef<typeof AccordionPrimitive.Item>>>;
+declare const AccordionTrigger: React.ForwardRefExoticComponent<(React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Trigger> & {
+    disableRipple?: boolean;
+}) & React.RefAttributes<React.ElementRef<typeof AccordionPrimitive.Trigger>>>;
+declare const AccordionContent: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Content> & React.RefAttributes<React.ElementRef<typeof AccordionPrimitive.Content>>>;
+export declare const Accordion: typeof AccordionRoot & {
+    Item: typeof AccordionItem;
+    Trigger: typeof AccordionTrigger;
+    Content: typeof AccordionContent;
 };
 export {};

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

@@ -1,10 +1,7 @@
-import { VariantProps } from 'class-variance-authority';
 import { default as React } from 'react';
-declare const alertVariants: (props?: ({
-    variant?: "error" | "primary" | "secondary" | "tertiary" | "outline" | null | undefined;
-    shape?: "full" | "minimal" | "sharp" | null | undefined;
-} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
-export interface AlertProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof alertVariants> {
+export interface AlertProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: "primary" | "secondary" | "tertiary" | "error" | "outline";
+    shape?: "full" | "minimal" | "sharp";
 }
 declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
 declare const AlertIcon: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;

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

@@ -1,15 +1,12 @@
 import { MotionValue } from 'framer-motion';
 import { default as React } from 'react';
 export interface AppBarContextValue {
-    /** The raw scroll offset of the container */
     scrollY: MotionValue<number>;
-    /** Progress from 0 (fully expanded) to 1 (fully collapsed) */
     collapseProgress: MotionValue<number>;
-    /** The total distance in pixels it takes to fully collapse the header */
     collapseDistance: number;
 }
 export declare const useAppBarContext: () => AppBarContextValue;
-export type AppBarVariant = "small" | "center" | "medium" | "large";
+export type AppBarVariant = "small" | "center" | "medium" | "large" | "custom";
 export type AppBarScrollBehavior = "pinned" | "floating" | "hide";
 export type AppBarColor = "surface" | "surface-container-lowest" | "surface-container-low" | "surface-container" | "surface-container-high" | "surface-container-highest" | "primary" | "secondary" | "transparent";
 export interface AppBarSharedProps {
@@ -49,5 +46,9 @@ export interface AppBarProps extends Omit<React.HTMLAttributes<HTMLElement>, "ti
     expandedHeight?: number;
     effectScrollThreshold?: number;
     collapseScrollDistance?: number;
+    /** Automatically smooth-snaps to fully collapsed or fully expanded state if the user stops scrolling halfway */
+    snap?: boolean;
+    /** Automatically passes mouse wheels and touch drags on the AppBar down to the scroll container */
+    forwardScroll?: boolean;
 }
 export declare const AppBar: React.ForwardRefExoticComponent<AppBarProps & React.RefAttributes<HTMLElement>>;

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

@@ -10,5 +10,5 @@ export interface AvatarProps extends React.ComponentPropsWithoutRef<typeof Radix
     fallback?: string;
     variant?: "default" | "count";
 }
-export declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLSpanElement>>;
+export declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<never>>;
 export {};

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

@@ -24,6 +24,9 @@ interface NavigatorProps extends React.HTMLAttributes<HTMLElement> {
     onTabPress: (name: string) => void;
     itemLayout?: "stacked" | "inline";
     showLabels?: boolean;
+    pillStyle?: "full" | "icon";
+    disableRipple?: boolean;
+    indicatorAnimation?: "slide" | "bloom";
 }
 export declare const BottomTabs: {
     Navigator: React.FC<NavigatorProps>;

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

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

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

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

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

@@ -1,4 +1,3 @@
-import { VariantProps } from 'class-variance-authority';
 import { default as React } from 'react';
 export declare const cardVariants: (props?: ({
     variant?: "primary" | "secondary" | "tertiary" | "ghost" | "high-contrast" | "surface" | "surface-container-lowest" | "surface-container-low" | "surface-container" | "surface-container-high" | "surface-container-highest" | null | undefined;
@@ -6,9 +5,17 @@ export declare const cardVariants: (props?: ({
     shape?: "full" | "minimal" | "sharp" | null | undefined;
     padding?: "sm" | "md" | "lg" | "none" | null | undefined;
     bordered?: boolean | null | undefined;
-    elevation?: 1 | "none" | 2 | 3 | 4 | 5 | null | undefined;
+    elevation?: 1 | "none" | 2 | 5 | 4 | 3 | null | undefined;
+    glass?: boolean | null | undefined;
 } & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
-export interface CardProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof cardVariants> {
+export interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: "primary" | "secondary" | "tertiary" | "high-contrast" | "ghost" | "surface" | "surface-container-lowest" | "surface-container-low" | "surface-container" | "surface-container-high" | "surface-container-highest";
+    hoverEffect?: boolean;
+    shape?: "full" | "minimal" | "sharp";
+    padding?: "none" | "sm" | "md" | "lg";
+    bordered?: boolean;
+    elevation?: "none" | 1 | 2 | 3 | 4 | 5;
     enableRipple?: boolean;
+    glass?: boolean;
 }
 export declare const Card: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/charts/area-chart.d.ts

@@ -8,5 +8,7 @@ export interface ChartProps {
     height?: number | string;
     className?: string;
     valueFormatter?: (value: number) => string;
+    scrollable?: boolean;
+    minWidth?: number | string;
 }
-export declare const AreaChart: ({ data, categories, index, variant, shape, colors, height, className, valueFormatter, }: ChartProps) => import("react/jsx-runtime").JSX.Element;
+export declare const AreaChart: ({ data, categories, index, variant, shape, colors, height, className, valueFormatter, scrollable, minWidth, }: ChartProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/charts/bar-chart.d.ts

@@ -1,2 +1,2 @@
 import { ChartProps } from './area-chart';
-export declare const BarChart: ({ data, categories, index, variant, shape, colors, height, className, valueFormatter, }: ChartProps) => import("react/jsx-runtime").JSX.Element;
+export declare const BarChart: ({ data, categories, index, variant, shape, colors, height, className, valueFormatter, scrollable, minWidth, }: ChartProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/charts/line-chart.d.ts

@@ -1,2 +1,2 @@
 import { ChartProps } from './area-chart';
-export declare const LineChart: ({ data, categories, index, variant, colors, height, className, valueFormatter, }: ChartProps) => import("react/jsx-runtime").JSX.Element;
+export declare const LineChart: ({ data, categories, index, variant, colors, height, className, valueFormatter, scrollable, minWidth, }: ChartProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/code-editor/index.d.ts

@@ -0,0 +1,36 @@
+import { VariantProps } from 'class-variance-authority';
+import { default as React } from 'react';
+declare const codeEditorVariants: (props?: ({
+    variant?: "primary" | "secondary" | "ghost" | "surface" | null | undefined;
+    shape?: "full" | "minimal" | "sharp" | null | undefined;
+    shadow?: "sm" | "md" | "lg" | "none" | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
+export interface CodeEditorAction {
+    id: string;
+    label: string;
+    keybindings?: number[];
+    contextMenuGroupId?: string;
+    contextMenuOrder?: number;
+    run: (editor: any, monaco: any) => void;
+}
+export interface CodeEditorProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange">, VariantProps<typeof codeEditorVariants> {
+    value?: string;
+    original?: string;
+    language?: string;
+    isDiff?: boolean;
+    readOnly?: boolean;
+    height?: string | number;
+    fileName?: string;
+    onChange?: (value: string | undefined) => void;
+    options?: any;
+    collapsible?: boolean;
+    defaultCollapsed?: boolean;
+    enableCopy?: boolean;
+    toolbarSize?: "sm" | "md" | "lg";
+    toolbarContent?: React.ReactNode;
+    hideToolbar?: boolean;
+    disableContextMenu?: boolean;
+    customActions?: CodeEditorAction[];
+}
+export declare const CodeEditor: React.ForwardRefExoticComponent<CodeEditorProps & React.RefAttributes<HTMLDivElement>>;
+export {};

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

@@ -1,12 +1,16 @@
 import { default as React } from 'react';
+import { selectSlots } from '../select/select-styles';
 export interface ComboboxOption {
     value: string;
     label: string;
+    disabled?: boolean;
+    icon?: React.ReactNode;
 }
 export interface ComboboxProps {
     options: ComboboxOption[];
     value?: string;
-    onChange?: (value: string) => void;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
     placeholder?: string;
     searchPlaceholder?: string;
     emptyMessage?: string;
@@ -15,11 +19,15 @@ export interface ComboboxProps {
     errorMessage?: React.ReactNode;
     disabled?: boolean;
     isInvalid?: boolean;
+    isClearable?: boolean;
     shape?: "full" | "minimal" | "sharp";
-    variant?: "flat" | "bordered" | "faded" | "underlined";
+    variant?: "filled" | "filled-inverted" | "outlined" | "outlined-inverted" | "underlined" | "underlined-inverted" | "ghost" | "ghost-inverted";
     size?: "sm" | "md" | "lg";
     labelPlacement?: "inside" | "outside" | "outside-left";
     startContent?: React.ReactNode;
     className?: string;
+    classNames?: Partial<Record<keyof typeof selectSlots, string>>;
+    mobileLayout?: "default" | "bottom-sheet" | "dialog";
+    name?: string;
 }
 export declare const Combobox: React.ForwardRefExoticComponent<ComboboxProps & React.RefAttributes<HTMLButtonElement>>;

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

@@ -1,26 +1,15 @@
+import { Command as CommandPrimitive } from 'cmdk';
 import { default as React } from 'react';
 import { Dialog } from '../dialog';
-declare const Command: React.ForwardRefExoticComponent<Omit<{
-    children?: React.ReactNode;
-} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
-    ref?: React.Ref<HTMLDivElement>;
-} & {
-    asChild?: boolean;
-}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & {
-    label?: string;
-    shouldFilter?: boolean;
-    filter?: (value: string, search: string, keywords?: string[]) => number;
-    defaultValue?: string;
-    value?: string;
-    onValueChange?: (value: string) => void;
-    loop?: boolean;
-    disablePointerSelection?: boolean;
-    vimBindings?: boolean;
-} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export interface CommandProps extends React.ComponentPropsWithoutRef<typeof CommandPrimitive> {
+    glass?: boolean;
+}
+declare const Command: React.ForwardRefExoticComponent<CommandProps & React.RefAttributes<HTMLDivElement>>;
 interface CommandDialogProps extends React.ComponentPropsWithoutRef<typeof Dialog> {
     children: React.ReactNode;
+    glass?: boolean;
 }
-declare const CommandDialog: ({ children, ...props }: CommandDialogProps) => import("react/jsx-runtime").JSX.Element;
+declare const CommandDialog: ({ children, glass, ...props }: CommandDialogProps) => import("react/jsx-runtime").JSX.Element;
 declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React.InputHTMLAttributes<HTMLInputElement>> & {
     ref?: React.Ref<HTMLInputElement>;
 } & {
@@ -76,4 +65,9 @@ declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
     keywords?: string[];
     forceMount?: boolean;
 } & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-export { Command, CommandDialog, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandSeparator, };
+declare const CommandShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+declare const CommandFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Command, CommandDialog, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandSeparator, CommandShortcut, CommandFooter, };

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

@@ -5,30 +5,46 @@ type ContextMenuSize = "sm" | "md" | "lg";
 interface ContextMenuProps extends RadixContextMenu.ContextMenuProps {
     shape?: ContextMenuShape;
     size?: ContextMenuSize;
+    glass?: boolean;
 }
-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>>;
+declare const ContextMenuRoot: React.FC<ContextMenuProps>;
+declare const ContextMenuTrigger: typeof RadixContextMenu.Trigger;
+declare const ContextMenuGroup: typeof RadixContextMenu.Group;
+declare const ContextMenuPortal: typeof RadixContextMenu.Portal;
+declare const ContextMenuSub: typeof RadixContextMenu.Sub;
+declare const ContextMenuRadioGroup: typeof RadixContextMenu.RadioGroup;
+declare const ContextMenuContent: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof RadixContextMenu.Content> & React.RefAttributes<React.ElementRef<typeof RadixContextMenu.Content>>>;
+declare const ContextMenuItem: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof RadixContextMenu.Item> & {
+    inset?: boolean;
+} & React.RefAttributes<React.ElementRef<typeof RadixContextMenu.Item>>>;
+declare const ContextMenuCheckboxItem: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof RadixContextMenu.CheckboxItem> & React.RefAttributes<React.ElementRef<typeof RadixContextMenu.CheckboxItem>>>;
+declare const ContextMenuRadioItem: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof RadixContextMenu.RadioItem> & React.RefAttributes<React.ElementRef<typeof RadixContextMenu.RadioItem>>>;
+declare const ContextMenuSubTrigger: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof RadixContextMenu.SubTrigger> & {
+    inset?: boolean;
+} & React.RefAttributes<React.ElementRef<typeof RadixContextMenu.SubTrigger>>>;
+declare const ContextMenuSubContent: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof RadixContextMenu.SubContent> & React.RefAttributes<React.ElementRef<typeof RadixContextMenu.SubContent>>>;
+declare const ContextMenuLabel: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof RadixContextMenu.Label> & {
+    inset?: boolean;
+} & React.RefAttributes<React.ElementRef<typeof RadixContextMenu.Label>>>;
+declare const ContextMenuSeparator: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof RadixContextMenu.Separator> & React.RefAttributes<React.ElementRef<typeof RadixContextMenu.Separator>>>;
+declare const ContextMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export declare const ContextMenu: typeof ContextMenuRoot & {
+    Trigger: typeof ContextMenuTrigger;
+    Content: typeof ContextMenuContent;
+    Item: typeof ContextMenuItem;
+    CheckboxItem: typeof ContextMenuCheckboxItem;
+    RadioGroup: typeof ContextMenuRadioGroup;
+    RadioItem: typeof ContextMenuRadioItem;
+    Label: typeof ContextMenuLabel;
+    Separator: typeof ContextMenuSeparator;
+    Shortcut: typeof ContextMenuShortcut;
+    Group: typeof ContextMenuGroup;
+    Portal: typeof ContextMenuPortal;
+    Sub: typeof ContextMenuSub;
+    SubContent: typeof ContextMenuSubContent;
+    SubTrigger: typeof ContextMenuSubTrigger;
 };
 export {};

package/dist/components/data-display/index.d.ts

@@ -1,7 +1,7 @@
 import { ColumnDef, ColumnFiltersState, OnChangeFn, PaginationState, Row, SortingState, Table as TanstackTable } from '@tanstack/react-table';
 import { default as React } from 'react';
-import { GridProps } from '../layout/grid';
-import { MasonryProps } from '../layout/masonry';
+import { GridProps } from '../layouts/grid';
+import { MasonryProps } from '../layouts/masonry';
 export type DataDisplayLayout = "grid" | "list" | "masonry";
 export interface DataDisplayProps<TData> {
     data: TData[];

package/dist/components/date-input/date-input-styles.d.ts

@@ -1,6 +1,6 @@
 import { VariantProps } from 'class-variance-authority';
 export declare const dateInputStyles: (props?: ({
-    variant?: "ghost" | "filled" | "filled-inverted" | "outlined" | "outlined-inverted" | "underlined" | "underlined-inverted" | "ghost-inverted" | null | undefined;
+    variant?: "filled" | "ghost" | "filled-inverted" | "outlined" | "outlined-inverted" | "underlined" | "underlined-inverted" | "ghost-inverted" | null | undefined;
     color?: "error" | "primary" | "secondary" | null | undefined;
     size?: "sm" | "md" | "lg" | null | undefined;
     shape?: "full" | "minimal" | "sharp" | null | undefined;

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

@@ -14,6 +14,8 @@ export interface DatePickerProps {
     size?: "sm" | "md" | "lg";
     color?: "primary" | "secondary" | "error";
     itemShape?: Shape;
+    className?: string;
+    classNames?: Partial<Record<"base" | "label" | "inputWrapper" | "innerWrapper", string>>;
 }
-export declare const DatePicker: ({ value, onChange, variant, inputVariant, size, color, label, placeholder, disabled, isInvalid, shape, itemShape, }: DatePickerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DatePicker: ({ value, onChange, variant, inputVariant, size, color, label, placeholder, disabled, isInvalid, shape, itemShape, classNames, }: DatePickerProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -10,6 +10,7 @@ export interface DialogProps {
     variant?: DialogVariant;
     animation?: DialogAnimationType;
     isLocked?: boolean;
+    glass?: boolean;
 }
 declare const Dialog: FC<DialogProps>;
 interface DialogTriggerProps extends ButtonHTMLAttributes<HTMLButtonElement> {
@@ -21,6 +22,7 @@ export interface DialogContentProps extends HTMLAttributes<HTMLDivElement> {
     variant?: CardProps["variant"];
     padding?: CardProps["padding"];
     layout?: boolean | "size" | "position" | "preserve-aspect";
+    glass?: boolean;
 }
 declare const DialogContent: import('react').ForwardRefExoticComponent<DialogContentProps & import('react').RefAttributes<HTMLDivElement>>;
 interface DialogCloseProps extends ButtonHTMLAttributes<HTMLButtonElement> {
@@ -31,7 +33,7 @@ declare const DialogHeader: (props: HTMLAttributes<HTMLDivElement>) => import("r
 declare const DialogFooter: (props: HTMLAttributes<HTMLDivElement>) => import("react/jsx-runtime").JSX.Element;
 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"> {
+export interface DialogBodyProps extends ElasticScrollAreaProps {
 }
 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

@@ -3,27 +3,28 @@ import * as RadixDropdownMenu from "@radix-ui/react-dropdown-menu";
 type DropdownMenuShape = "full" | "minimal" | "sharp";
 interface DropdownMenuProps extends RadixDropdownMenu.DropdownMenuProps {
     shape?: DropdownMenuShape;
+    glass?: boolean;
 }
 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"> & {
+declare const DropdownMenuTrigger: typeof RadixDropdownMenu.Trigger;
+declare const DropdownMenuGroup: typeof RadixDropdownMenu.Group;
+declare const DropdownMenuPortal: typeof RadixDropdownMenu.Portal;
+declare const DropdownMenuSub: typeof RadixDropdownMenu.Sub;
+declare const DropdownMenuRadioGroup: typeof RadixDropdownMenu.RadioGroup;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof RadixDropdownMenu.Content> & React.RefAttributes<React.ElementRef<typeof RadixDropdownMenu.Content>>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof RadixDropdownMenu.Item> & {
     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"> & {
+} & React.RefAttributes<React.ElementRef<typeof RadixDropdownMenu.Item>>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof RadixDropdownMenu.CheckboxItem> & React.RefAttributes<React.ElementRef<typeof RadixDropdownMenu.CheckboxItem>>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof RadixDropdownMenu.RadioItem> & React.RefAttributes<React.ElementRef<typeof RadixDropdownMenu.RadioItem>>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof RadixDropdownMenu.SubTrigger> & {
     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"> & {
+} & React.RefAttributes<React.ElementRef<typeof RadixDropdownMenu.SubTrigger>>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof RadixDropdownMenu.SubContent> & React.RefAttributes<React.ElementRef<typeof RadixDropdownMenu.SubContent>>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof RadixDropdownMenu.Label> & {
     inset?: boolean;
-} & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<RadixDropdownMenu.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+} & React.RefAttributes<React.ElementRef<typeof RadixDropdownMenu.Label>>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<React.ComponentPropsWithoutRef<typeof RadixDropdownMenu.Separator> & React.RefAttributes<React.ElementRef<typeof RadixDropdownMenu.Separator>>>;
 declare const DropdownMenuShortcut: {
     ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
     displayName: string;

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

@@ -1,5 +1,5 @@
 import { MotionValue } from 'framer-motion';
-import { ComponentPropsWithoutRef, ComponentType } from 'react';
+import { ComponentPropsWithoutRef, ComponentType, ElementRef, ForwardRefExoticComponent, RefAttributes } from 'react';
 import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
 interface RefreshIndicatorProps {
     pullProgress: MotionValue<number>;
@@ -17,10 +17,13 @@ export interface ElasticScrollAreaProps extends ComponentPropsWithoutRef<typeof
     onScrollUp?: () => void;
     onScrollDown?: () => void;
     viewportClassName?: string;
+    dimmingEdges?: boolean;
 }
-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>>;
+declare const ElasticScrollAreaRoot: ForwardRefExoticComponent<ElasticScrollAreaProps & RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: ForwardRefExoticComponent<ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.Scrollbar> & {
+    scrollbarVisibility?: ElasticScrollAreaProps["scrollbarVisibility"];
+} & RefAttributes<ElementRef<typeof ScrollAreaPrimitive.Scrollbar>>>;
+export declare const ElasticScrollArea: typeof ElasticScrollAreaRoot & {
+    ScrollBar: typeof ScrollBar;
 };
 export {};

package/dist/components/empty-state/index.d.ts

@@ -1,13 +1,9 @@
-import { VariantProps } from 'class-variance-authority';
 import { default as React } from 'react';
-declare const emptyStateVariants: (props?: ({
-    variant?: "default" | "card" | null | undefined;
-} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;
-export interface EmptyStateProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof emptyStateVariants> {
+export interface EmptyStateProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: "default" | "card";
     icon?: React.ReactNode;
     title: string;
     description?: string;
     action?: React.ReactNode;
 }
 export declare const EmptyState: React.ForwardRefExoticComponent<EmptyStateProps & React.RefAttributes<HTMLDivElement>>;
-export {};

package/dist/components/floating-panel/index.d.ts

@@ -0,0 +1,48 @@
+import { default as React } from 'react';
+export type FloatingPanelPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right" | "left-center" | "right-center" | "center";
+export type FloatingPanelVariant = "primary" | "secondary" | "tertiary" | "surface" | "surface-lowest" | "ghost";
+interface FloatingPanelContextValue {
+    isOpen: boolean;
+    setIsOpen: (val: boolean) => void;
+    triggerVariant: FloatingPanelVariant;
+    panelVariant: FloatingPanelVariant;
+}
+export declare const useFloatingPanel: () => FloatingPanelContextValue;
+export interface FloatingPanelProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children" | "onDrag" | "onDragStart" | "onDragEnd" | "onAnimationStart"> {
+    children: React.ReactNode;
+    position?: FloatingPanelPosition;
+    offset?: number;
+    triggerWidth?: number;
+    triggerHeight?: number;
+    triggerRadius?: number;
+    panelWidth?: number;
+    panelHeight?: number;
+    panelRadius?: number;
+    triggerVariant?: FloatingPanelVariant;
+    panelVariant?: FloatingPanelVariant;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+export declare const FloatingPanel: React.ForwardRefExoticComponent<FloatingPanelProps & React.RefAttributes<HTMLDivElement>> & {
+    Trigger: {
+        ({ children, className, }: {
+            children: React.ReactNode;
+            className?: string;
+        }): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Content: {
+        ({ children, className, }: {
+            children: React.ReactNode;
+            className?: string;
+        }): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    CloseButton: {
+        ({ className }: {
+            className?: string;
+        }): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};
+export {};

package/dist/components/full-calendar/calendar-context.d.ts

@@ -0,0 +1,37 @@
+import { default as React } from 'react';
+import { CalendarEvent, CalendarVariant, CalendarView, FullCalendarProps, PrintSettings } from './types';
+export interface PopoverState {
+    isOpen: boolean;
+    mode: "create" | "edit";
+    anchorRect?: DOMRect;
+}
+interface FullCalendarContextType extends FullCalendarProps {
+    currentDate: Date;
+    view: CalendarView;
+    variant: CalendarVariant;
+    navigateNext: () => void;
+    navigatePrev: () => void;
+    navigateToday: () => void;
+    setView: (view: CalendarView) => void;
+    setCurrentDate: (date: Date) => void;
+    popover: PopoverState;
+    draftEvent: CalendarEvent | null;
+    setDraftEvent: React.Dispatch<React.SetStateAction<CalendarEvent | null>>;
+    openPopover: (mode: "create" | "edit", anchorRect?: DOMRect, initialDate?: Date, event?: CalendarEvent) => void;
+    closePopover: () => void;
+    isPrintPreviewOpen: boolean;
+    setPrintPreviewOpen: (v: boolean) => void;
+    printSettings: PrintSettings;
+    setPrintSettings: React.Dispatch<React.SetStateAction<PrintSettings>>;
+}
+export declare const useFullCalendar: () => FullCalendarContextType;
+export declare const PrintModeContext: React.Context<boolean>;
+export declare const PrintOverrideProvider: ({ children, overrideDate, overrideView, }: {
+    children: React.ReactNode;
+    overrideDate: Date;
+    overrideView: CalendarView;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const FullCalendarProvider: ({ children, initialDate, initialView, variant, events, onEventCreate, onEventUpdate, onEventDelete, onViewChange, onDateRangeChange, renderPopoverCustomFields, renderEventContent, className, ...props }: FullCalendarProps & {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/full-calendar/event-popover.d.ts

@@ -0,0 +1 @@
+export declare const EventPopover: () => import("react/jsx-runtime").JSX.Element | null;