atomos_next_genesis 0.0.3-alpha → 0.0.5

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import * as React from 'react';
-import React__default, { ButtonHTMLAttributes, ReactNode, HTMLAttributes, InputHTMLAttributes, LabelHTMLAttributes, TableHTMLAttributes, ThHTMLAttributes, TdHTMLAttributes, TextareaHTMLAttributes } from 'react';
+import React, { ButtonHTMLAttributes, ReactNode, HTMLAttributes, FC, Dispatch, SetStateAction, InputHTMLAttributes, LabelHTMLAttributes, TableHTMLAttributes, ThHTMLAttributes, TdHTMLAttributes, TextareaHTMLAttributes, ElementType } from 'react';
 import * as class_variance_authority_types from 'class-variance-authority/types';
 import { VariantProps } from 'class-variance-authority';
 
@@ -7,28 +6,31 @@ type AccordionProps = {
     type?: "single" | "multiple";
     collapsible?: boolean;
     className?: string;
-    children: React__default.ReactNode;
+    children: React.ReactNode;
+    expanded?: boolean;
 };
-declare function Accordion({ type, collapsible, className, children, }: AccordionProps): React__default.JSX.Element;
+declare function Accordion({ type, collapsible, className, children, expanded, }: AccordionProps): React.JSX.Element;
 type AccordionItemProps = {
     value: string;
     disabled?: boolean;
     openItems?: string[];
     handleToggle?: (value: string) => void;
-    children: React__default.ReactNode;
+    children: React.ReactNode;
     className?: string;
 };
-declare function AccordionItem({ value, disabled, openItems, handleToggle, children, className, }: AccordionItemProps): React__default.JSX.Element;
+declare function AccordionItem({ value, disabled, openItems, handleToggle, children, className, }: AccordionItemProps): React.JSX.Element;
 type AccordionTriggerProps = {
     isOpen?: boolean;
-    children: React__default.ReactNode;
+    children: React.ReactNode;
+    defaultOpen?: boolean;
+    className?: string;
+    triggerIcon?: React.ReactNode;
 };
-declare function AccordionTrigger({ isOpen, children }: AccordionTriggerProps): React__default.JSX.Element;
+declare function AccordionTrigger({ isOpen, children, className, triggerIcon, }: AccordionTriggerProps): React.JSX.Element;
 type AccordionContentProps = {
-    isOpen?: boolean;
-    children: React__default.ReactNode;
+    children: React.ReactNode;
 };
-declare function AccordionContent({ isOpen, children }: AccordionContentProps): React__default.JSX.Element;
+declare function AccordionContent({ children }: AccordionContentProps): React.JSX.Element;
 
 interface BaseProps$1 {
     type: "image" | "icon" | "text";
@@ -58,7 +60,7 @@ interface TextProps extends BaseProps$1 {
     text: string;
 }
 type AvatarProps = ImageProps | IconProps | TextProps;
-declare const Avatar: React__default.ForwardRefExoticComponent<AvatarProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const Avatar: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLDivElement>>;
 
 type AvatarItemProps = Omit<ImageProps, "size"> | Omit<IconProps, "size"> | Omit<TextProps, "size">;
 interface AvatarGroupProps {
@@ -67,15 +69,15 @@ interface AvatarGroupProps {
     max?: number;
     className?: string;
 }
-declare const AvatarGroup: React__default.ForwardRefExoticComponent<AvatarGroupProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const AvatarGroup: React.ForwardRefExoticComponent<AvatarGroupProps & React.RefAttributes<HTMLDivElement>>;
 
 type BreadcrumbsProps = {
-    children: React__default.ReactNode;
-    separator?: React__default.ReactNode;
+    children: React.ReactNode;
+    separator?: React.ReactNode;
     'aria-label': string;
     containerClasses?: string;
 };
-declare const Breadcrumbs: ({ children, separator, "aria-label": ariaLabel, containerClasses }: BreadcrumbsProps) => React__default.JSX.Element;
+declare const Breadcrumbs: ({ children, separator, "aria-label": ariaLabel, containerClasses }: BreadcrumbsProps) => React.JSX.Element;
 
 interface ButtonProps$1 extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
     children?: ReactNode;
@@ -83,35 +85,87 @@ interface ButtonProps$1 extends ButtonHTMLAttributes<HTMLButtonElement>, Variant
     endIcon?: JSX.Element;
     disabled?: boolean;
     fullWidth?: boolean;
+    type?: "submit" | "reset" | "button";
 }
 declare const buttonVariants: (props?: ({
     variant?: "filled" | "outlined" | null | undefined;
-    intent?: "primary" | "success" | "error" | "warning" | "default" | "primary-outlined" | "success-outlined" | "error-outlined" | "warning-outlined" | "default-outlined" | null | undefined;
+    intent?: "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "primary" | "success" | "error" | "warning" | "default" | "bluegray" | "bluelight" | "rose" | "primary-outlined" | "success-outlined" | "error-outlined" | "warning-outlined" | "default-outlined" | "blue-outlined" | "bluegray-outlined" | "bluelight-outlined" | "indigo-outlined" | "purple-outlined" | "violet-outlined" | "pink-outlined" | "rose-outlined" | "orange-outlined" | null | undefined;
     size?: "sm" | "md" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare const Button: ({ children, className, variant, intent, fullWidth, startIcon, disabled, endIcon, size, ...props }: ButtonProps$1) => React__default.JSX.Element;
+declare const Button: ({ children, className, variant, intent, fullWidth, startIcon, disabled, endIcon, size, type, ...props }: ButtonProps$1) => React.JSX.Element;
+
+declare const calloutVariants: (props?: ({
+    variant?: "filled" | "outlined" | null | undefined;
+    intent?: "primary" | "success" | "error" | "warning" | "default" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xs" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface CalloutProps extends VariantProps<typeof calloutVariants> {
+    children: ReactNode;
+    startIcon?: JSX.Element;
+    endIcon?: JSX.Element;
+    className?: string;
+}
+declare const Callout: React.FC<CalloutProps>;
+
+interface CardProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface CardHeaderProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface CardTitleProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface CardDescriptionProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface CardActionProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface CardContentProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface CardFooterProps {
+    children: React.ReactNode;
+    className?: string;
+}
+declare function export_default({ children, className }: CardProps): React.JSX.Element;
+declare const CardHeader: React.FC<CardHeaderProps>;
+declare const CardTitle: React.FC<CardTitleProps>;
+declare const CardDescription: React.FC<CardDescriptionProps>;
+declare const CardAction: React.FC<CardActionProps>;
+declare const CardContent: React.FC<CardContentProps>;
+declare const CardFooter: React.FC<CardFooterProps>;
 
 interface CheckboxProps extends Omit<HTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof checkboxVariant> {
-    size?: "sm" | "lg";
+    size?: "sm" | "lg" | "xl";
     disabled?: boolean;
     checked?: boolean;
     children?: never;
 }
 declare const checkboxVariant: (props?: ({
-    size?: "sm" | "lg" | null | undefined;
+    size?: "sm" | "lg" | "xl" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare const Checkbox: React__default.ForwardRefExoticComponent<CheckboxProps & React__default.RefAttributes<HTMLInputElement>>;
+declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLInputElement>>;
 
-declare const chipVariants: (props?: ({
-    intent?: "indigo" | "orange" | "pink" | "purple" | "violet" | "primary" | "success" | "error" | "warning" | "default" | "bluegray" | "bluelight" | "rose" | null | undefined;
-    size?: "sm" | "md" | "lg" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-interface ChipProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof chipVariants> {
+interface ChipProps extends HTMLAttributes<HTMLSpanElement>, VariantProps<typeof chipVariants> {
     children: ReactNode;
     dot?: boolean;
     dotColor?: string;
+    startIcon?: JSX.Element;
+    endIcon?: JSX.Element;
 }
-declare const Chip: ({ children, className, size, intent, dot, dotColor, }: ChipProps) => React__default.JSX.Element;
+declare const chipVariants: (props?: ({
+    intent?: "blue" | "indigo" | "orange" | "pink" | "purple" | "violet" | "primary" | "success" | "error" | "warning" | "default" | "bluegray" | "bluelight" | "rose" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const Chip: ({ children, className, size, intent, dot, dotColor, startIcon, endIcon, ...rest }: ChipProps) => React.JSX.Element;
 
 interface CircularProgressBarProps {
     strokeWidth?: number;
@@ -128,56 +182,99 @@ interface DividerProps {
     position?: "horizontal" | "vertical";
     className?: string;
 }
-declare const Divider: ({ width, height, position, className, }: DividerProps) => React__default.JSX.Element;
+declare const Divider: ({ width, height, position, className, }: DividerProps) => React.JSX.Element;
+
+interface DrawerProps {
+    isOpen: boolean;
+    setIsOpen: Dispatch<SetStateAction<boolean>>;
+    children: ReactNode;
+    position?: "left" | "right" | "top" | "bottom";
+    width?: string;
+    height?: string;
+    className?: string;
+    showCloseButton?: boolean;
+    closeOnOutsideClick?: boolean;
+}
+declare const Drawer: FC<DrawerProps>;
 
 type Option$1 = {
-    label: string;
-    value: string;
+    label: string | number;
+    value: string | number;
     info?: string;
     addInfo?: string;
     tooltipContent?: string;
+    disabledOption?: boolean;
+    labelTextColor?: string;
 };
 interface DropdownProps$1 {
+    id?: string;
     icon?: JSX.Element;
     options: Option$1[];
     selected?: Option$1[];
-    setSelected?: React__default.Dispatch<React__default.SetStateAction<Option$1[]>>;
+    setSelected?: React.Dispatch<React.SetStateAction<Option$1[]>>;
     onApply?: () => void;
     onReset?: () => void;
     dropdownText?: string;
     search?: boolean;
     multiple?: boolean;
-    renderItem?: (option: Option$1) => React__default.ReactNode;
-    children?: React__default.ReactNode;
+    renderItem?: (option: Option$1) => React.ReactNode;
+    children?: React.ReactNode;
     position?: "top" | "bottom";
     info?: string | number;
     addInfo?: string | number;
     tooltipContent?: string;
     width?: string;
-    dropDownTooltip?: boolean | undefined;
     dropdownFooter?: boolean | undefined;
     disabled?: boolean;
+    labelTextColor?: string;
+    footerAction?: React.ReactNode;
 }
-declare const Dropdown: React__default.ForwardRefExoticComponent<DropdownProps$1 & React__default.RefAttributes<HTMLDivElement>>;
+declare const Dropdown: React.ForwardRefExoticComponent<DropdownProps$1 & React.RefAttributes<HTMLDivElement>>;
+
+type DropdownAlignment = "left" | "right" | "top" | "bottom" | "center" | "start" | "end";
+declare function DropdownMenu({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+declare function DropdownMenuTrigger({ children, isOpen, setIsOpen, }: {
+    children: React.ReactNode;
+    isOpen?: boolean;
+    setIsOpen?: (open: boolean) => void;
+}): React.JSX.Element;
+declare function DropdownMenuContent({ children, isOpen, align, className, }: {
+    children: React.ReactNode;
+    isOpen?: boolean;
+    className?: string;
+    align?: DropdownAlignment;
+}): React.JSX.Element | null;
+declare function DropdownMenuItem({ children, className, onClick, disabled, shortcut, }: any): React.JSX.Element;
+declare function DropdownMenuLabel({ children }: any): React.JSX.Element;
+declare function DropdownMenuSeparator(): React.JSX.Element;
+declare function DropdownMenuSub({ children }: any): React.JSX.Element;
+declare function DropdownMenuSubTrigger({ children }: any): React.JSX.Element;
+declare function DropdownMenuSubContent({ children }: any): React.JSX.Element;
 
 type Option = {
-    label: string;
-    value: string;
+    label: string | number;
+    value: string | number;
     info?: string;
     addInfo?: string;
     tooltipContent?: string;
+    disabledOption?: boolean;
+    labelTextColor?: string;
 };
 interface DropdownProps {
+    id?: string;
     options: Option[];
     selected?: Option[];
-    setSelected?: React__default.Dispatch<React__default.SetStateAction<Option[]>>;
+    setSelected?: React.Dispatch<React.SetStateAction<Option[]>>;
     onApply?: () => void;
     onReset?: () => void;
+    dropdownText?: string;
     search?: boolean;
     multiple?: boolean;
-    renderItem?: (option: Option) => React__default.ReactNode;
-    children?: React__default.ReactNode;
-    trigger?: React__default.ReactNode;
+    renderItem?: (option: Option) => React.ReactNode;
+    children?: React.ReactNode;
+    trigger?: React.ReactNode;
     dropdownMenu?: boolean;
     position?: "top" | "bottom" | "left" | "right";
     setDropdownMenu?: (value: boolean) => void;
@@ -185,55 +282,82 @@ interface DropdownProps {
     addInfo?: string | number;
     tooltipContent?: string;
     width?: string;
-    dropDownTooltip?: boolean | undefined;
     dropdownFooter?: boolean;
     disabled?: boolean;
+    labelTextColor?: string;
+    footerAction?: React.ReactNode;
 }
-declare const DropdownWithIcon: React__default.ForwardRefExoticComponent<DropdownProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const DropdownWithIcon: React.ForwardRefExoticComponent<DropdownProps & React.RefAttributes<HTMLDivElement>>;
+
+interface FileSelectorProps extends InputHTMLAttributes<HTMLInputElement> {
+    component: JSX.Element;
+}
+declare const FileSelector: React.ForwardRefExoticComponent<FileSelectorProps & React.RefAttributes<HTMLInputElement>>;
 
 interface FileUploadProps extends InputHTMLAttributes<HTMLInputElement> {
     id: string;
     selectedFile?: File[];
     setSelectedFile?: (files: File[]) => void;
     children?: ReactNode;
-    onDelete?: () => void;
+    onDelete?: (index: number) => void;
     title?: string;
     disabled?: boolean;
+    filePreviewClassName?: string;
 }
-declare const FileUpload: React__default.ForwardRefExoticComponent<FileUploadProps & React__default.RefAttributes<HTMLInputElement>>;
+declare const FileUpload: React.ForwardRefExoticComponent<FileUploadProps & React.RefAttributes<HTMLInputElement>>;
+
+interface FileUploadPreviewProps {
+    index: number;
+    file: File;
+    children?: ReactNode;
+    onDelete?: (index: number) => void;
+}
+declare const FileUploadPreview: ({ index, file, children, onDelete, }: FileUploadPreviewProps) => React.JSX.Element;
 
 interface GlobalNavigationProps {
     isOpen: boolean;
     setIsOpen: (isOpen: boolean) => void;
     className?: string;
-    children: React__default.ReactNode;
+    children: React.ReactNode;
     trigger: JSX.Element;
     postion?: "bottom-left" | "bottom-right" | "top-left" | "top-right";
 }
-declare const GlobalNavigation: React__default.ForwardRefExoticComponent<GlobalNavigationProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const GlobalNavigation: React.ForwardRefExoticComponent<GlobalNavigationProps & React.RefAttributes<HTMLDivElement>>;
 
 interface HelperTextProps extends HTMLAttributes<HTMLSpanElement> {
     children: ReactNode;
     size?: "sm" | "lg";
     error?: boolean;
 }
-declare const HelperText: ({ children, className, size, error }: HelperTextProps) => React__default.JSX.Element;
+declare const HelperText: ({ children, className, size, error }: HelperTextProps) => React.JSX.Element;
 
 interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
     size?: "sm" | "lg";
     startIcon?: JSX.Element;
     endIcon?: JSX.Element;
     disabled?: boolean;
+    error?: boolean;
     type: "text" | "url" | "email" | "password" | "number" | "tel" | "search" | "time";
 }
-declare const Input: React__default.ForwardRefExoticComponent<InputProps & React__default.RefAttributes<HTMLInputElement>>;
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+
+interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement>, VariantProps<typeof labelVariants> {
+    htmlFor?: string;
+    children: ReactNode;
+    required?: boolean;
+    disabled?: boolean;
+}
+declare const labelVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const Label: ({ children, htmlFor, size, required, disabled, className, ...props }: LabelProps) => React.JSX.Element;
 
 interface BaseProps {
     className?: string;
-    children?: React__default.ReactNode;
+    children?: React.ReactNode;
     title: string;
     as?: "link" | "button";
-    icon?: React__default.ReactNode;
+    icon?: React.ReactNode;
 }
 type LinkProps = BaseProps & {
     as: "link";
@@ -248,18 +372,16 @@ type ButtonProps = BaseProps & {
     className?: string;
 };
 type ListItemProps = LinkProps | ButtonProps;
-declare const ListItem: React__default.ForwardRefExoticComponent<ListItemProps & React__default.RefAttributes<HTMLButtonElement | HTMLAnchorElement>>;
+declare const ListItem: React.ForwardRefExoticComponent<ListItemProps & React.RefAttributes<HTMLButtonElement | HTMLAnchorElement>>;
 
-interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement>, VariantProps<typeof labelVariants> {
-    htmlFor?: string;
-    children: ReactNode;
-    required?: boolean;
-    disabled?: boolean;
+interface ListPaginationProps {
+    count: number;
+    page: number;
+    rowsPerPage: number;
+    onPageChange: (newPage: number) => void;
+    className?: string;
 }
-declare const labelVariants: (props?: ({
-    size?: "sm" | "md" | "lg" | null | undefined;
-} & class_variance_authority_types.ClassProp) | undefined) => string;
-declare const Label: ({ children, htmlFor, size, required, disabled, className, ...props }: LabelProps) => React__default.JSX.Element;
+declare const ListPagination: React.FC<ListPaginationProps>;
 
 interface LoadingProps {
     width?: string;
@@ -267,7 +389,7 @@ interface LoadingProps {
     loaderColor?: string;
     variant?: "light" | "heavy";
 }
-declare const Loading: ({ width, height, loaderColor, variant }: LoadingProps) => React__default.JSX.Element;
+declare const Loading: ({ width, height, loaderColor, variant }: LoadingProps) => React.JSX.Element;
 
 interface ModalProps {
     children?: ReactNode;
@@ -276,51 +398,35 @@ interface ModalProps {
     setShowModal: (value: boolean) => void;
     closeOnOutsideClick?: boolean;
     className?: string;
-}
-declare function Modal({ children, showModal, setShowModal, closeModal, closeOnOutsideClick, className, }: ModalProps): React__default.JSX.Element;
-
-interface MenuDropdownProps {
-    trigger: JSX.Element;
-    children: React__default.ReactNode;
     width?: string;
-    className?: string;
-}
-declare function MenuDropdown({ trigger, children, width, className, }: MenuDropdownProps): React__default.JSX.Element;
-interface MenuSubItemProps {
-    label: string;
-    onClick?: () => void;
-    disabled?: boolean;
-    children?: React__default.ReactNode;
-    className?: string;
-}
-declare const MenuSubItem: React__default.FC<MenuSubItemProps>;
-interface MenuItemProps {
-    content: React__default.ReactNode;
-    children: React__default.ReactNode;
-    label?: string;
-    className?: string;
-    sectionClassName?: string;
-    menuClassName?: string;
 }
-declare const MenuItem: React__default.FC<MenuItemProps>;
+declare function Modal({ children, showModal, setShowModal, closeModal, closeOnOutsideClick, className, width, }: ModalProps): React.JSX.Element;
 
 interface NoticeProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof noticeVariants> {
     children?: ReactNode;
     noticeTitle?: string;
     variant: "success" | "warning" | "info" | "error" | "default";
-    position?: "top" | "bottom";
+    position?: "top" | "bottom" | "center";
     showIcon?: boolean;
     open: boolean;
     setOpen: (value: boolean) => void;
 }
 declare const noticeVariants: (props?: ({
     variant?: "success" | "error" | "warning" | "default" | "info" | null | undefined;
-    position?: "top" | "bottom" | null | undefined;
+    position?: "center" | "top" | "bottom" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare const Notice: ({ children, variant, position, noticeTitle, open, setOpen, showIcon, }: NoticeProps) => React__default.JSX.Element;
+declare const Notice: ({ children, variant, position, noticeTitle, open, setOpen, showIcon, }: NoticeProps) => React.JSX.Element;
+
+interface OTPInputProps {
+    length: number;
+    onChange: (otp: string) => void;
+    type?: "text" | "password" | "number";
+}
+declare const OTPInput: React.FC<OTPInputProps>;
 
 type TablePaginationProps = {
     count: number;
+    countVariable?: string;
     page: number;
     rowsPerPage: number;
     rowsPerPageOptions: (number | {
@@ -330,8 +436,10 @@ type TablePaginationProps = {
     onPageChange: (newPage: number) => void;
     onRowsPerPageChange: (newRowsPerPage: number) => void;
     className?: string;
+    variant?: "primary" | "secondary";
+    itemsPerPage?: boolean;
 };
-declare const Pagination: React__default.FC<TablePaginationProps>;
+declare const Pagination: React.FC<TablePaginationProps>;
 
 type ProgressBarProps = {
     progress: number;
@@ -339,7 +447,7 @@ type ProgressBarProps = {
     progressColor: string;
     progressTextPosition?: "top" | "bottom" | "left" | "right";
 };
-declare const ProgressBar: ({ progress, progressText, progressColor, progressTextPosition, }: ProgressBarProps) => React__default.JSX.Element;
+declare const ProgressBar: ({ progress, progressText, progressColor, progressTextPosition, }: ProgressBarProps) => React.JSX.Element;
 
 interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof radioVariants> {
     size?: "sm" | "lg";
@@ -350,78 +458,120 @@ interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size">
 declare const radioVariants: (props?: ({
     size?: "sm" | "lg" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare const Radio: React__default.ForwardRefExoticComponent<RadioProps & React__default.RefAttributes<HTMLInputElement>>;
+declare const Radio: React.ForwardRefExoticComponent<RadioProps & React.RefAttributes<HTMLInputElement>>;
+
+type UploadStatus = "idle" | "uploading" | "success" | "error";
+interface UploadItem {
+    id: string;
+    file?: File;
+    name?: string;
+    size?: number;
+    progress?: number;
+    status?: UploadStatus;
+    previewUrl?: string;
+}
+interface ImageUploadControlledProps {
+    items: UploadItem[];
+    onAddFiles: (files: File[]) => void;
+    onUpdateItem?: (id: string, updates: Partial<UploadItem>) => void;
+    onDelete?: (id: string) => void;
+    onRetry?: (id: string) => void;
+    onPreview?: (id: string) => void;
+    onUpload?: (file: File, onProgress: (progress: number) => void) => Promise<string>;
+    multiple?: boolean;
+    accept?: string;
+    maxSizeMB?: number;
+    className?: string;
+    hintText?: React.ReactNode;
+    showSizeText?: boolean;
+    getFileIcon?: (fileName: string, fileType: string) => React.ReactNode;
+    autoUpload?: boolean;
+    disabled?: boolean;
+}
+declare const defaultGetFileIcon: (fileName: string, fileType: string) => React.JSX.Element;
+declare function ImageUploadControlled({ items, onAddFiles, onUpdateItem, onDelete, onRetry, onPreview, onUpload, multiple, accept, maxSizeMB, className, hintText, showSizeText, getFileIcon, autoUpload, disabled, }: ImageUploadControlledProps): React.JSX.Element;
 
+interface NavItem {
+    label: string;
+    href?: string;
+    icon?: React.ReactElement;
+    subItems?: NavItem[];
+}
 interface SidebarProps {
-    children: React__default.ReactNode;
+    children: React.ReactNode;
     collapsed: boolean;
     setCollapsed: (collapsed: boolean) => void;
     scroll?: boolean;
+    dense?: boolean;
     navItems?: {
         label: string;
-        items: {
-            label: string;
-            href: string;
-            icon?: React__default.ReactElement;
-        }[];
+        items: NavItem[];
     }[];
 }
 interface SidebarHeaderProps {
-    collapsed: boolean;
-    setCollapsed: (collapsed: boolean) => void;
     children: ReactNode;
+    dense?: boolean;
 }
 interface SidebarMenuProps {
     collapsed: boolean;
-    setCollapsed: (collapsed: boolean) => void;
-    scroll?: boolean;
     navItems?: {
         label: string;
-        items: {
-            label: string;
-            href: string;
-            icon?: React__default.ReactElement;
-        }[];
+        items: NavItem[];
     }[];
+    scroll?: boolean;
+    dense?: boolean;
 }
 interface FooterProps {
-    children: React__default.ReactNode;
+    children: React.ReactNode;
     collapsed: boolean;
     setCollapsed: (collapsed: boolean) => void;
     navItems?: {
         label: string;
-        items: {
-            label: string;
-            href: string;
-            icon?: React__default.ReactElement;
-        }[];
+        items: NavItem[];
     }[];
+    dense?: boolean;
 }
-declare const Sidebar: React__default.FC<SidebarProps> & {
-    Header: React__default.FC<SidebarHeaderProps>;
-    Menu: React__default.FC<SidebarMenuProps>;
-    Footer: React__default.FC<FooterProps>;
+declare const Sidebar: React.FC<SidebarProps> & {
+    Header: React.FC<SidebarHeaderProps>;
+    Menu: React.FC<SidebarMenuProps>;
+    Footer: React.FC<FooterProps>;
 };
 
+interface SkeletonProps {
+    width?: string | number;
+    height?: string | number;
+    circle?: boolean;
+    animation?: "wave" | "pulse" | "shimmer";
+}
+declare const Skeleton: React.FC<SkeletonProps>;
+
 interface SliderProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
     value: number;
     min?: number;
     max?: number;
     size?: "sm" | "lg";
 }
-declare const Slider: React__default.ForwardRefExoticComponent<SliderProps & React__default.RefAttributes<HTMLInputElement>>;
+declare const Slider: React.ForwardRefExoticComponent<SliderProps & React.RefAttributes<HTMLInputElement>>;
 
-interface SkeletonProps {
-    width?: string | number;
-    height?: string | number;
-    circle?: boolean;
+interface SpinnerProps {
+    size?: "xs" | "sm" | "md" | "lg";
+    color?: "primary" | "black" | "gray" | string;
 }
-declare const Skeleton: React__default.FC<SkeletonProps>;
+declare const Spinner: ({ size, color }: SpinnerProps) => React.JSX.Element;
+
+interface SplitButtonProps {
+    children: React.ReactNode;
+    className?: string;
+    size?: 'sm' | 'md' | 'lg';
+    appearance?: 'primary' | 'secondary' | 'warning' | 'danger';
+    compact?: boolean;
+}
+declare const SplitButton: React.ForwardRefExoticComponent<SplitButtonProps & React.RefAttributes<HTMLDivElement>>;
 
 interface StepConfig {
     name: string;
     helperName?: string;
-    Component: React__default.ComponentType<any>;
+    Component: React.ComponentType<any>;
 }
 interface CheckoutStepperProps {
     stepsConfig: StepConfig[];
@@ -431,7 +581,7 @@ interface CheckoutStepperProps {
     setIsComplete: (complete: boolean) => void;
     position?: string;
 }
-declare const Stepper: ({ stepsConfig, currentStep, setCurrentStep, isComplete, setIsComplete, position, }: CheckoutStepperProps) => React__default.JSX.Element | null;
+declare const Stepper: ({ stepsConfig, currentStep, setCurrentStep, isComplete, setIsComplete, position, }: CheckoutStepperProps) => React.JSX.Element | null;
 
 interface TableProps extends TableHTMLAttributes<HTMLTableElement> {
     children?: ReactNode;
@@ -449,22 +599,26 @@ interface TableHeadCellProps extends ThHTMLAttributes<HTMLTableCellElement> {
     icon?: JSX.Element;
     sticky?: boolean;
     left?: string;
+    right?: string;
     stickyIcon?: JSX.Element;
     shadow?: boolean;
+    shadowRight?: boolean;
 }
 interface TableCellProps extends TdHTMLAttributes<HTMLTableCellElement> {
     children?: ReactNode;
     icon?: JSX.Element;
     sticky?: boolean;
     left?: string;
+    right?: string;
     shadow?: boolean;
+    shadowRight?: boolean;
 }
-declare const Table: ({ children, className, dense, ...props }: TableProps) => React__default.JSX.Element;
-declare const TableHead: ({ children, className, ...props }: TableHeadProps) => React__default.JSX.Element;
-declare const TableBody: ({ children, className, ...props }: TableHeadProps) => React__default.JSX.Element;
-declare const TableRow: ({ children, className, indent, ...props }: TableRowProps) => React__default.JSX.Element;
-declare const TableHeadCell: ({ children, className, icon, sticky, shadow, left, ...props }: TableHeadCellProps) => React__default.JSX.Element;
-declare const TableDataCell: ({ children, className, icon, sticky, shadow, left, ...props }: TableCellProps) => React__default.JSX.Element;
+declare const Table: ({ children, className, dense, ...props }: TableProps) => React.JSX.Element;
+declare const TableHead: ({ children, className, ...props }: TableHeadProps) => React.JSX.Element;
+declare const TableBody: ({ children, className, ...props }: TableHeadProps) => React.JSX.Element;
+declare const TableRow: ({ children, className, indent, ...props }: TableRowProps) => React.JSX.Element;
+declare const TableHeadCell: ({ children, className, icon, sticky, shadow, left, shadowRight, right, ...props }: TableHeadCellProps) => React.JSX.Element;
+declare const TableDataCell: ({ children, className, icon, sticky, shadow, shadowRight, left, right, ...props }: TableCellProps) => React.JSX.Element;
 
 interface TabItem {
     label: string;
@@ -472,43 +626,62 @@ interface TabItem {
 }
 interface TabsContainerProps {
     value: string;
-    children: React__default.ReactNode;
+    children: React.ReactNode;
     className?: string;
+    position?: "horizontal" | "vertical";
 }
 interface TabListProps extends Partial<TabItem> {
     onChange: (value: string) => void;
     ariaLabel?: string;
-    children: React__default.ReactNode;
+    children: React.ReactNode;
     box?: boolean;
+    pill?: boolean;
     className?: string;
+    position?: "horizontal" | "vertical";
 }
 interface TabProps extends TabItem {
     onChange: (value: string) => void;
     box?: boolean;
-    content?: React__default.ReactNode;
+    pill?: boolean;
+    content?: React.ReactNode;
     selectedTabValue: string;
     icon?: JSX.Element;
     className?: string;
+    tabIndex?: number;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLButtonElement>) => void;
+    position?: "horizontal" | "vertical";
+    ref?: React.Ref<HTMLButtonElement>;
 }
 interface TabPanelProps {
     value: string;
     currentValue: string;
-    children: React__default.ReactNode;
+    children: React.ReactNode;
     className?: string;
 }
-declare const TabsContainer: React__default.FC<TabsContainerProps>;
-declare const TabList: React__default.FC<TabListProps>;
-declare const Tab: React__default.FC<TabProps>;
-declare const TabPanel: React__default.FC<TabPanelProps>;
+declare const TabsContainer: React.FC<TabsContainerProps>;
+declare const TabList: React.FC<TabListProps>;
+declare const Tab: React.ForwardRefExoticComponent<Omit<TabProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabPanel: React.FC<TabPanelProps>;
 
 interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "size"> {
     size?: "sm" | "lg";
     disabled?: boolean;
     rows?: number;
     cols?: number;
+    error?: boolean;
     children?: ReactNode;
 }
-declare const Textarea: React__default.ForwardRefExoticComponent<TextareaProps & React__default.RefAttributes<HTMLTextAreaElement>>;
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+
+interface TextInputWithLabelProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
+    intent?: "error" | "default" | "success" | "warning" | "blue" | "primary" | "bluegray" | "bluelight" | "violet" | "indigo" | "purple" | "pink" | "rose" | "orange";
+    placeholder?: string;
+    size?: "sm" | "lg";
+    type?: "number" | "search" | "text" | "url" | "email" | "password" | "tel" | "time";
+    tags: string[];
+    setTags: (tags: string[]) => void;
+}
+declare const TextInputWithLabel: React.FC<TextInputWithLabelProps>;
 
 interface ToggleProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof toggleVariants> {
     size?: "sm" | "md" | "lg";
@@ -519,16 +692,80 @@ declare const toggleVariants: (props?: ({
     size?: "sm" | "md" | "lg" | null | undefined;
     intent?: "primary" | "success" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
-declare const Toggle: React__default.ForwardRefExoticComponent<ToggleProps & React__default.RefAttributes<HTMLInputElement>>;
+declare const Toggle: React.ForwardRefExoticComponent<ToggleProps & React.RefAttributes<HTMLInputElement>>;
 
 declare const tooltipVariants: (props?: ({
-    position?: "top" | "right" | "bottom" | "left" | null | undefined;
+    position?: "left" | "right" | "top" | "bottom" | null | undefined;
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 interface TooltipProps extends Omit<HTMLAttributes<HTMLDivElement>, "content">, VariantProps<typeof tooltipVariants> {
     children: ReactNode;
     position: "top" | "right" | "bottom" | "left";
     content: JSX.Element | string;
 }
-declare const Tooltip: React__default.FC<TooltipProps>;
+declare const Tooltip: React.FC<TooltipProps>;
+
+interface TreeViewProps {
+    children: React.ReactNode;
+    "aria-label": string;
+    flat?: boolean;
+    className?: string;
+    /** Optional array of IDs to expand initially */
+    defaultExpandedIds?: string[];
+    /** Controlled expansion (useful if parent manages state externally) */
+    expandedIds?: string[];
+    /** Callback for when expanded nodes change */
+    onExpandedChange?: (expanded: string[]) => void;
+    /** Allow multiple nodes to be expanded simultaneously */
+    allowMultiple?: boolean;
+    /** Automatically expand all top-level items by default */
+    expandTopLevelByDefault?: boolean;
+}
+interface TreeViewItemProps {
+    id: string;
+    children: React.ReactNode;
+    current?: boolean;
+    className?: string;
+    onSelect?: (id: string) => void;
+    level?: number;
+    expanded?: boolean;
+    onToggle?: (id: string) => void;
+    selected?: boolean;
+    flat?: boolean;
+}
+interface TreeViewSubTreeProps {
+    children: React.ReactNode;
+    state?: "loading";
+    count?: number;
+    className?: string;
+    expanded?: boolean;
+    flat?: boolean;
+}
+declare const TreeView: React.FC<TreeViewProps> & {
+    Item: React.FC<TreeViewItemProps>;
+    SubTree: typeof TreeViewSubTree;
+    LeadingVisual: typeof TreeViewLeadingVisual;
+    TrailingVisual: typeof TreeViewTrailingVisual;
+};
+declare const TreeViewSubTree: React.FC<TreeViewSubTreeProps>;
+declare const TreeViewLeadingVisual: React.FC<{
+    children: React.ReactNode;
+    className?: string;
+}>;
+declare const TreeViewTrailingVisual: React.FC<{
+    children: React.ReactNode;
+    label?: string;
+    className?: string;
+}>;
+
+interface TypographyProps extends HTMLAttributes<HTMLHeadingElement | HTMLParagraphElement>, VariantProps<typeof typographyVariant> {
+    as?: ElementType;
+    children: ReactNode;
+    intent?: "primary" | "success" | "error" | "warning" | "default";
+}
+declare const typographyVariant: (props?: ({
+    variant?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "b1" | "b2" | "b3" | "b4" | "b5" | null | undefined;
+    intent?: "primary" | "success" | "error" | "warning" | "default" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const Typography: ({ as, variant, intent, children, className, ...props }: TypographyProps) => React.JSX.Element;
 
-export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, Avatar, AvatarGroup, Breadcrumbs as BreadCrumb, Button, Checkbox, Chip, CircularProgressBar as CircularProgress, Divider, Dropdown, DropdownWithIcon, FileUpload, GlobalNavigation, HelperText, Input, Label, ListItem, Loading, MenuDropdown, MenuItem, MenuSubItem, Modal, Notice, Pagination, ProgressBar, Radio, Sidebar, Skeleton, Slider, Stepper, Tab, TabList, TabPanel, Table, TableBody, TableDataCell, TableHead, TableHeadCell, TableRow, TabsContainer, Textarea, Toggle, Tooltip };
+export { Accordion, AccordionContent, AccordionItem, AccordionTrigger, Avatar, AvatarGroup, Breadcrumbs as BreadCrumb, Button, Callout, export_default as Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, Checkbox, Chip, CircularProgressBar as CircularProgress, Divider, Drawer, Dropdown, DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuTrigger, DropdownWithIcon, FileSelector, FileUpload, FileUploadPreview, GlobalNavigation, HelperText, Input, Label, ListItem, ListPagination, Loading, Modal, Notice, OTPInput, Pagination, ProgressBar, Radio, ImageUploadControlled as RazorPayFileUpload, Sidebar, Skeleton, Slider, Spinner, SplitButton, Stepper, Tab, TabList, TabPanel, Table, TableBody, TableDataCell, TableHead, TableHeadCell, TableRow, TabsContainer, TextInputWithLabel, Textarea, Toggle, Tooltip, TreeView, Typography, defaultGetFileIcon };