atomos_next_genesis 0.0.4 → 0.0.5

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import React, { 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,8 +7,9 @@ type AccordionProps = {
     collapsible?: boolean;
     className?: string;
     children: React.ReactNode;
+    expanded?: boolean;
 };
-declare function Accordion({ type, collapsible, className, children, }: AccordionProps): React.JSX.Element;
+declare function Accordion({ type, collapsible, className, children, expanded, }: AccordionProps): React.JSX.Element;
 type AccordionItemProps = {
     value: string;
     disabled?: boolean;
@@ -21,13 +22,15 @@ declare function AccordionItem({ value, disabled, openItems, handleToggle, child
 type AccordionTriggerProps = {
     isOpen?: boolean;
     children: React.ReactNode;
+    defaultOpen?: boolean;
+    className?: string;
+    triggerIcon?: React.ReactNode;
 };
-declare function AccordionTrigger({ isOpen, children }: AccordionTriggerProps): React.JSX.Element;
+declare function AccordionTrigger({ isOpen, children, className, triggerIcon, }: AccordionTriggerProps): React.JSX.Element;
 type AccordionContentProps = {
-    isOpen?: boolean;
     children: React.ReactNode;
 };
-declare function AccordionContent({ isOpen, children }: AccordionContentProps): React.JSX.Element;
+declare function AccordionContent({ children }: AccordionContentProps): React.JSX.Element;
 
 interface BaseProps$1 {
     type: "image" | "icon" | "text";
@@ -82,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.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.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.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;
@@ -129,14 +184,30 @@ interface DividerProps {
 }
 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[];
@@ -153,25 +224,52 @@ interface DropdownProps$1 {
     addInfo?: string | number;
     tooltipContent?: string;
     width?: string;
-    dropDownTooltip?: boolean | undefined;
     dropdownFooter?: boolean | undefined;
     disabled?: boolean;
+    labelTextColor?: string;
+    footerAction?: React.ReactNode;
 }
 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.Dispatch<React.SetStateAction<Option[]>>;
     onApply?: () => void;
     onReset?: () => void;
+    dropdownText?: string;
     search?: boolean;
     multiple?: boolean;
     renderItem?: (option: Option) => React.ReactNode;
@@ -184,23 +282,38 @@ 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.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.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;
@@ -223,10 +336,22 @@ interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size">
     startIcon?: JSX.Element;
     endIcon?: JSX.Element;
     disabled?: boolean;
+    error?: boolean;
     type: "text" | "url" | "email" | "password" | "number" | "tel" | "search" | "time";
 }
 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.ReactNode;
@@ -249,16 +374,14 @@ type ButtonProps = BaseProps & {
 type ListItemProps = LinkProps | ButtonProps;
 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.JSX.Element;
+declare const ListPagination: React.FC<ListPaginationProps>;
 
 interface LoadingProps {
     width?: string;
@@ -275,51 +398,35 @@ interface ModalProps {
     setShowModal: (value: boolean) => void;
     closeOnOutsideClick?: boolean;
     className?: string;
-}
-declare function Modal({ children, showModal, setShowModal, closeModal, closeOnOutsideClick, className, }: ModalProps): React.JSX.Element;
-
-interface MenuDropdownProps {
-    trigger: JSX.Element;
-    children: React.ReactNode;
     width?: string;
-    className?: string;
 }
-declare function MenuDropdown({ trigger, children, width, className, }: MenuDropdownProps): React.JSX.Element;
-interface MenuSubItemProps {
-    label: string;
-    onClick?: () => void;
-    disabled?: boolean;
-    children?: React.ReactNode;
-    className?: string;
-}
-declare const MenuSubItem: React.FC<MenuSubItemProps>;
-interface MenuItemProps {
-    content: React.ReactNode;
-    children: React.ReactNode;
-    label?: string;
-    className?: string;
-    sectionClassName?: string;
-    menuClassName?: string;
-}
-declare const MenuItem: React.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.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 | {
@@ -329,6 +436,8 @@ type TablePaginationProps = {
     onPageChange: (newPage: number) => void;
     onRowsPerPageChange: (newRowsPerPage: number) => void;
     className?: string;
+    variant?: "primary" | "secondary";
+    itemsPerPage?: boolean;
 };
 declare const Pagination: React.FC<TablePaginationProps>;
 
@@ -351,37 +460,66 @@ declare const radioVariants: (props?: ({
 } & class_variance_authority_types.ClassProp) | undefined) => string;
 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.ReactNode;
     collapsed: boolean;
     setCollapsed: (collapsed: boolean) => void;
     scroll?: boolean;
+    dense?: boolean;
     navItems?: {
         label: string;
-        items: {
-            label: string;
-            href: string;
-            icon?: React.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.ReactElement;
-        }[];
+        items: NavItem[];
     }[];
+    scroll?: boolean;
+    dense?: boolean;
 }
 interface FooterProps {
     children: React.ReactNode;
@@ -389,12 +527,9 @@ interface FooterProps {
     setCollapsed: (collapsed: boolean) => void;
     navItems?: {
         label: string;
-        items: {
-            label: string;
-            href: string;
-            icon?: React.ReactElement;
-        }[];
+        items: NavItem[];
     }[];
+    dense?: boolean;
 }
 declare const Sidebar: React.FC<SidebarProps> & {
     Header: React.FC<SidebarHeaderProps>;
@@ -402,6 +537,14 @@ declare const Sidebar: React.FC<SidebarProps> & {
     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;
@@ -410,12 +553,20 @@ interface SliderProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"
 }
 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.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;
@@ -448,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.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, ...props }: TableHeadCellProps) => React.JSX.Element;
-declare const TableDataCell: ({ children, className, icon, sticky, shadow, left, ...props }: TableCellProps) => 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;
@@ -473,21 +628,29 @@ interface TabsContainerProps {
     value: string;
     children: React.ReactNode;
     className?: string;
+    position?: "horizontal" | "vertical";
 }
 interface TabListProps extends Partial<TabItem> {
     onChange: (value: string) => void;
     ariaLabel?: string;
     children: React.ReactNode;
     box?: boolean;
+    pill?: boolean;
     className?: string;
+    position?: "horizontal" | "vertical";
 }
 interface TabProps extends TabItem {
     onChange: (value: string) => void;
     box?: boolean;
+    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;
@@ -497,7 +660,7 @@ interface TabPanelProps {
 }
 declare const TabsContainer: React.FC<TabsContainerProps>;
 declare const TabList: React.FC<TabListProps>;
-declare const Tab: React.FC<TabProps>;
+declare const Tab: React.ForwardRefExoticComponent<Omit<TabProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 declare const TabPanel: React.FC<TabPanelProps>;
 
 interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "size"> {
@@ -505,10 +668,21 @@ interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>
     disabled?: boolean;
     rows?: number;
     cols?: number;
+    error?: boolean;
     children?: ReactNode;
 }
 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";
     disabled?: boolean;
@@ -521,7 +695,7 @@ declare const toggleVariants: (props?: ({
 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;
@@ -530,4 +704,68 @@ interface TooltipProps extends Omit<HTMLAttributes<HTMLDivElement>, "content">,
 }
 declare const Tooltip: React.FC<TooltipProps>;
 
-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 };
+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, 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 };