asterui 0.12.13 → 0.12.15

package/dist/components/Autocomplete.d.ts

@@ -2,17 +2,37 @@ import { default as React } from 'react';
 export interface AutocompleteOption {
     value: string;
     label: string;
+    disabled?: boolean;
 }
-export interface AutocompleteProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+export interface AutocompleteProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'onSelect'> {
     value?: string;
     defaultValue?: string;
     onChange?: (value: string) => void;
+    onSelect?: (value: string, option: AutocompleteOption) => void;
+    onSearch?: (value: string) => void;
     options: AutocompleteOption[] | string[];
     placeholder?: string;
     disabled?: boolean;
-    size?: 'xs' | 'sm' | 'md' | 'lg';
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    color?: 'neutral' | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error';
+    /** Validation status */
+    status?: 'error' | 'warning';
     allowCustomValue?: boolean;
     filterOption?: (option: AutocompleteOption, inputValue: string) => boolean;
     notFoundContent?: React.ReactNode;
+    /** Show clear button when input has value */
+    allowClear?: boolean | {
+        clearIcon?: React.ReactNode;
+    };
+    /** Callback when clear button is clicked */
+    onClear?: () => void;
+    /** Controlled open state */
+    open?: boolean;
+    /** Default open state */
+    defaultOpen?: boolean;
+    /** Callback when open state changes */
+    onOpenChange?: (open: boolean) => void;
+    /** Activate first option by default */
+    defaultActiveFirstOption?: boolean;
 }
 export declare const Autocomplete: React.FC<AutocompleteProps>;

package/dist/components/Button.d.ts

@@ -1,20 +1,27 @@
 import { default as React } from 'react';
 type BaseButtonProps = {
-    type?: 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error' | 'neutral' | 'ghost' | 'link';
+    /** Button color */
+    color?: 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error' | 'neutral';
+    /** Button style variant */
+    variant?: 'solid' | 'outline' | 'dash' | 'soft' | 'ghost' | 'link';
+    /** Button size */
     size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
-    outline?: boolean;
-    dash?: boolean;
-    soft?: boolean;
+    /** Active/pressed visual state */
     active?: boolean;
+    /** Show loading spinner and disable button */
     loading?: boolean;
+    /** Button shape */
     shape?: 'square' | 'circle' | 'wide' | 'block' | 'round';
+    /** Disable click animation */
     noAnimation?: boolean;
     /** Icon element to display */
     icon?: React.ReactNode;
     /** Position of the icon */
     iconPosition?: 'start' | 'end';
-    /** Applies error/danger styling (shorthand for type="error") */
+    /** Applies error/danger styling (shorthand for color="error") */
     danger?: boolean;
+    /** Toggle button pressed state (sets aria-pressed) */
+    pressed?: boolean;
 };
 type ButtonAsButton = BaseButtonProps & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'type'> & {
     href?: undefined;
@@ -23,6 +30,8 @@ type ButtonAsButton = BaseButtonProps & Omit<React.ButtonHTMLAttributes<HTMLButt
 type ButtonAsAnchor = BaseButtonProps & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'type'> & {
     href: string;
     htmlType?: undefined;
+    /** Disable the link button */
+    disabled?: boolean;
 };
 export type ButtonProps = ButtonAsButton | ButtonAsAnchor;
 export declare const Button: React.FC<ButtonProps>;

package/dist/components/Drawer.d.ts

@@ -1,10 +1,51 @@
 import { default as React } from 'react';
-export interface DrawerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+export type DrawerPlacement = 'top' | 'right' | 'bottom' | 'left';
+export type DrawerSize = 'default' | 'large' | number;
+export interface DrawerProps {
+    /** Drawer content */
     children: React.ReactNode;
-    sidebar: React.ReactNode;
+    /** Whether the drawer is visible */
     open?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    end?: boolean;
-    sidebarClassName?: string;
+    /** Callback when drawer is closed */
+    onClose?: () => void;
+    /** Drawer title */
+    title?: React.ReactNode;
+    /** Direction drawer slides from */
+    placement?: DrawerPlacement;
+    /** Preset size or custom width/height in pixels */
+    size?: DrawerSize;
+    /** Custom width (overrides size for left/right placement) */
+    width?: number | string;
+    /** Custom height (overrides size for top/bottom placement) */
+    height?: number | string;
+    /** Whether to show close button */
+    closable?: boolean;
+    /** Whether to show mask/backdrop */
+    mask?: boolean;
+    /** Whether clicking mask closes drawer */
+    maskClosable?: boolean;
+    /** Whether ESC closes drawer */
+    keyboard?: boolean;
+    /** Footer content */
+    footer?: React.ReactNode;
+    /** Extra content in header (right side) */
+    extra?: React.ReactNode;
+    /** CSS class for drawer panel */
+    className?: string;
+    /** CSS class for drawer wrapper */
+    rootClassName?: string;
+    /** Style for drawer panel */
+    style?: React.CSSProperties;
+    /** z-index of drawer */
+    zIndex?: number;
+    /** Destroy content when closed */
+    destroyOnClose?: boolean;
+    /** Where to place initial focus */
+    initialFocus?: 'close' | 'content';
 }
-export declare const Drawer: React.FC<DrawerProps>;
+/**
+ * Drawer - A panel that slides in from the edge of the screen.
+ * Use for forms, details, or task panels.
+ * For responsive sidebar navigation, use SidebarDrawer instead.
+ */
+export declare function Drawer({ children, open, onClose, title, placement, size, width, height, closable, mask, maskClosable, keyboard, footer, extra, className, rootClassName, style, zIndex, destroyOnClose, initialFocus, }: DrawerProps): React.ReactPortal | null;

package/dist/components/Dropdown.d.ts

@@ -1,28 +1,67 @@
 import { default as React } from 'react';
-export interface DropdownProps extends React.HTMLAttributes<HTMLDivElement> {
-    children: React.ReactNode;
+export type DropdownTriggerType = 'click' | 'hover' | 'contextMenu';
+export interface DropdownMenuItem {
+    key: string;
+    label: React.ReactNode;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+    danger?: boolean;
+    onClick?: () => void;
+    children?: DropdownMenuItem[];
+}
+export interface DropdownMenuDivider {
+    type: 'divider';
+    key?: string;
+}
+export type DropdownMenuItemType = DropdownMenuItem | DropdownMenuDivider;
+export interface DropdownProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Trigger element and dropdown content (compound pattern) */
+    children?: React.ReactNode;
+    /** Menu items (data-driven pattern) */
+    items?: DropdownMenuItemType[];
+    /** @deprecated Use trigger={['hover']} instead */
     hover?: boolean;
+    /** Trigger mode(s) for dropdown */
+    trigger?: DropdownTriggerType[];
     position?: 'top' | 'bottom' | 'left' | 'right';
     align?: 'start' | 'center' | 'end';
     /** Controlled open state */
     open?: boolean;
     /** Callback when open state changes */
-    onOpenChange?: (open: boolean) => void;
+    onOpenChange?: (open: boolean, info?: {
+        source: 'trigger' | 'menu';
+    }) => void;
     /** Disable the dropdown */
     disabled?: boolean;
     /** Show arrow pointing to trigger */
-    arrow?: boolean;
+    arrow?: boolean | {
+        pointAtCenter?: boolean;
+    };
+    /** Delay before showing dropdown on hover (seconds) */
+    mouseEnterDelay?: number;
+    /** Delay before hiding dropdown on mouse leave (seconds) */
+    mouseLeaveDelay?: number;
+    /** Container for the dropdown menu */
+    getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
+    /** Destroy dropdown when hidden */
+    destroyOnHidden?: boolean;
 }
 export interface DropdownTriggerProps {
     children: React.ReactNode;
     className?: string;
 }
 export interface DropdownMenuProps {
-    children: React.ReactNode;
+    children?: React.ReactNode;
     className?: string;
 }
 export interface DropdownItemProps {
-    children: React.ReactNode;
+    children?: React.ReactNode;
+    /** Unique key for the item */
+    itemKey?: string;
+    /** Icon to display before label */
+    icon?: React.ReactNode;
+    /** Item label (alternative to children) */
+    label?: React.ReactNode;
     onClick?: () => void;
     active?: boolean;
     disabled?: boolean;
@@ -30,18 +69,35 @@ export interface DropdownItemProps {
     className?: string;
     _index?: number;
 }
+export interface DropdownSubMenuProps {
+    children: React.ReactNode;
+    /** Unique key for the submenu */
+    itemKey?: string;
+    /** Submenu title/label */
+    title: React.ReactNode;
+    /** Icon to display before title */
+    icon?: React.ReactNode;
+    disabled?: boolean;
+    className?: string;
+}
 export interface DropdownDividerProps {
     className?: string;
 }
-declare function DropdownRoot({ children, hover, position, align, open: controlledOpen, onOpenChange, disabled, arrow, className, ...rest }: DropdownProps): import("react/jsx-runtime").JSX.Element;
-declare function DropdownTrigger({ children, className }: DropdownTriggerProps): import("react/jsx-runtime").JSX.Element;
+declare function DropdownRoot({ children, items, hover, trigger, position, align, open: controlledOpen, onOpenChange, disabled, arrow, mouseEnterDelay, mouseLeaveDelay, getPopupContainer, destroyOnHidden, className, ...rest }: DropdownProps): import("react/jsx-runtime").JSX.Element;
+declare function DropdownTrigger({ children, className }: DropdownTriggerProps): React.ReactElement<React.HTMLAttributes<HTMLElement> & {
+    onClick?: (e: React.MouseEvent) => void;
+    onKeyDown?: (e: React.KeyboardEvent) => void;
+    className?: string;
+}, string | React.JSXElementConstructor<any>>;
 declare function DropdownMenu({ children, className }: DropdownMenuProps): import("react/jsx-runtime").JSX.Element;
-declare function DropdownItem({ children, onClick, active, disabled, danger, className, }: DropdownItemProps): import("react/jsx-runtime").JSX.Element;
+declare function DropdownItem({ children, itemKey, icon, label, onClick, active, disabled, danger, className, }: DropdownItemProps): import("react/jsx-runtime").JSX.Element;
+declare function DropdownSubMenu({ children, itemKey, title, icon, disabled, className, }: DropdownSubMenuProps): import("react/jsx-runtime").JSX.Element;
 declare function DropdownDivider({ className }: DropdownDividerProps): import("react/jsx-runtime").JSX.Element;
 export declare const Dropdown: typeof DropdownRoot & {
     Trigger: typeof DropdownTrigger;
     Menu: typeof DropdownMenu;
     Item: typeof DropdownItem;
+    SubMenu: typeof DropdownSubMenu;
     Divider: typeof DropdownDivider;
 };
 export {};

package/dist/components/Form.d.ts

@@ -3,11 +3,21 @@ import { UseFormReturn, FieldValues, SubmitHandler, UseFormProps, FieldArrayPath
 export interface FormProps<TFieldValues extends FieldValues = FieldValues> extends Omit<React.FormHTMLAttributes<HTMLFormElement>, 'onSubmit'> {
     form?: UseFormReturn<TFieldValues>;
     onFinish?: SubmitHandler<TFieldValues>;
+    /** Called when form validation fails */
+    onFinishFailed?: (errorInfo: {
+        values: TFieldValues;
+        errorFields: Array<{
+            name: string;
+            errors: string[];
+        }>;
+    }) => void;
     initialValues?: UseFormProps<TFieldValues>['defaultValues'];
     layout?: 'vertical' | 'horizontal' | 'inline';
     /** Label width in pixels for horizontal layout (default: 80) */
     labelWidth?: number;
     size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Disable all form fields */
+    disabled?: boolean;
     children: React.ReactNode;
 }
 export interface FormRule {
@@ -62,7 +72,7 @@ export interface FormListProps<TFieldValues extends FieldValues = FieldValues> {
         move: (from: number, to: number) => void;
     }) => React.ReactNode;
 }
-declare function FormRoot<TFieldValues extends FieldValues = FieldValues>({ form: externalForm, onFinish, initialValues, layout, labelWidth, size, children, className, noValidate, ...props }: FormProps<TFieldValues>): import("react/jsx-runtime").JSX.Element;
+declare function FormRoot<TFieldValues extends FieldValues = FieldValues>({ form: externalForm, onFinish, onFinishFailed, initialValues, layout, labelWidth, size, disabled, children, className, noValidate, ...props }: FormProps<TFieldValues>): import("react/jsx-runtime").JSX.Element;
 declare function FormItem({ name, label, help, required, rules, valuePropName, inline, className, children, tooltip, extra, hasFeedback, dependencies, validateTrigger, initialValue, hidden, }: FormItemProps): import("react/jsx-runtime").JSX.Element;
 declare function FormList<TFieldValues extends FieldValues = FieldValues>({ name, children, }: FormListProps<TFieldValues>): import("react/jsx-runtime").JSX.Element;
 export declare function useFormInstance<TFieldValues extends FieldValues = FieldValues>(): UseFormReturn<TFieldValues, any, TFieldValues> & {

package/dist/components/Input.d.ts

@@ -1,8 +1,10 @@
 import { default as React } from 'react';
-export interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size'> {
+export interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'prefix'> {
     type?: 'text' | 'password' | 'email' | 'number' | 'date' | 'datetime-local' | 'week' | 'month' | 'tel' | 'url' | 'search' | 'time';
     size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
     color?: 'neutral' | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error';
+    /** Validation status */
+    status?: 'error' | 'warning';
     ghost?: boolean;
     bordered?: boolean;
     className?: string;
@@ -10,5 +12,17 @@ export interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElem
     mask?: string;
     /** Placeholder character shown in mask (default: _) */
     maskPlaceholder?: string;
+    /** Show clear button when input has value */
+    allowClear?: boolean | {
+        clearIcon?: React.ReactNode;
+    };
+    /** Callback when clear button is clicked */
+    onClear?: () => void;
+    /** Prefix icon or element */
+    prefix?: React.ReactNode;
+    /** Suffix icon or element */
+    suffix?: React.ReactNode;
+    /** ID for error message element (for aria-describedby) */
+    errorId?: string;
 }
 export declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;

package/dist/components/Modal.d.ts

@@ -23,6 +23,10 @@ export interface ModalProps extends Omit<React.HTMLAttributes<HTMLDialogElement>
     centered?: boolean;
     /** Callback when modal is closed */
     onClose?: () => void;
+    /** Where to place initial focus: 'ok', 'cancel', or 'close' button */
+    initialFocus?: 'ok' | 'cancel' | 'close';
+    /** Use alertdialog role for urgent messages */
+    alertDialog?: boolean;
 }
 export interface ModalFuncProps {
     title?: React.ReactNode;
@@ -33,7 +37,7 @@ export interface ModalFuncProps {
     cancelText?: string;
     type?: 'info' | 'success' | 'warning' | 'error';
 }
-export declare function Modal({ children, title, footer, open, onOk, onCancel, okText, cancelText, maskClosable, closable, position, align, width, centered, onClose, className, ...rest }: ModalProps): import("react/jsx-runtime").JSX.Element;
+export declare function Modal({ children, title, footer, open, onOk, onCancel, okText, cancelText, maskClosable, closable, position, align, width, centered, onClose, initialFocus, alertDialog, className, ...rest }: ModalProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace Modal {
     var confirm: (config: ModalFuncProps) => {
         destroy: () => void;

package/dist/components/Navbar.d.ts

@@ -1,8 +1,22 @@
 import { default as React } from 'react';
-export interface NavbarProps extends React.HTMLAttributes<HTMLDivElement> {
+export type NavbarColor = 'base' | 'neutral' | 'primary' | 'secondary' | 'accent';
+export type NavbarShadow = 'none' | 'sm' | 'md' | 'lg' | 'xl';
+export type NavbarRounded = 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+export interface NavbarProps extends Omit<React.HTMLAttributes<HTMLElement>, 'color'> {
     children?: React.ReactNode;
+    /** Content for the start section of the navbar (typically logo/brand) */
     start?: React.ReactNode;
+    /** Content for the center section of the navbar */
     center?: React.ReactNode;
+    /** Content for the end section of the navbar (typically actions/menu) */
     end?: React.ReactNode;
+    /** Background color variant */
+    color?: NavbarColor;
+    /** Make navbar sticky at the top */
+    sticky?: boolean;
+    /** Shadow depth */
+    shadow?: NavbarShadow;
+    /** Border radius */
+    rounded?: NavbarRounded;
 }
 export declare const Navbar: React.FC<NavbarProps>;

package/dist/components/Rating.d.ts

@@ -1,21 +1,29 @@
 import { default as React } from 'react';
 export interface RatingProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
-    children: React.ReactNode;
+    children?: React.ReactNode;
     value?: number;
     defaultValue?: number;
     onChange?: (value: number) => void;
+    onHoverChange?: (value: number) => void;
+    count?: number;
     size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
-    readOnly?: boolean;
+    gap?: 'none' | 'xs' | 'sm' | 'md' | 'lg';
+    color?: string;
+    mask?: 'star' | 'star-2' | 'heart';
+    allowClear?: boolean;
+    allowHalf?: boolean;
+    disabled?: boolean;
 }
 export interface RatingItemProps {
     value: number;
     mask?: 'star' | 'star-2' | 'heart';
     color?: string;
     hidden?: boolean;
+    half?: 'first' | 'second';
     className?: string;
 }
-declare function RatingRoot({ children, value, defaultValue, onChange, size, readOnly, className, ...rest }: RatingProps): import("react/jsx-runtime").JSX.Element;
-declare function RatingItem({ value, mask, color, hidden, className }: RatingItemProps): import("react/jsx-runtime").JSX.Element;
+declare function RatingRoot({ children, value, defaultValue, onChange, onHoverChange, count, size, gap, color, mask, allowClear, allowHalf, disabled, className, ...rest }: RatingProps): import("react/jsx-runtime").JSX.Element;
+declare function RatingItem({ value, mask, color, hidden, half, className }: RatingItemProps): import("react/jsx-runtime").JSX.Element;
 export declare const Rating: typeof RatingRoot & {
     Item: typeof RatingItem;
 };

package/dist/components/SidebarDrawer.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+export interface SidebarDrawerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    /** Main content area */
+    children: React.ReactNode;
+    /** Sidebar content */
+    sidebar: React.ReactNode;
+    /** Controlled open state */
+    open?: boolean;
+    /** Callback when open state changes */
+    onOpenChange?: (open: boolean) => void;
+    /** Position sidebar on the right side */
+    end?: boolean;
+    /** Additional classes for sidebar container */
+    sidebarClassName?: string;
+}
+/**
+ * SidebarDrawer - A responsive sidebar layout component using DaisyUI's drawer.
+ * Use for navigation sidebars that toggle on mobile.
+ * For overlay panel drawers (forms, details), use the Drawer component instead.
+ */
+export declare const SidebarDrawer: React.FC<SidebarDrawerProps>;

package/dist/components/Tabs.d.ts

@@ -1,19 +1,45 @@
 import { default as React } from 'react';
+export type TabsVariant = 'box' | 'border' | 'lift';
+export type TabsSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type TabsPosition = 'top' | 'bottom';
+export interface TabItem {
+    key: string;
+    label: React.ReactNode;
+    children?: React.ReactNode;
+    disabled?: boolean;
+    icon?: React.ReactNode;
+}
 export interface TabsProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
-    children: React.ReactNode;
+    /** Tab panels (compound pattern) */
+    children?: React.ReactNode;
+    /** Tab items (data-driven pattern) */
+    items?: TabItem[];
+    /** Current active tab key (controlled) */
     activeKey?: string;
+    /** Default active tab key (uncontrolled) */
     defaultActiveKey?: string;
+    /** Callback when tab changes */
     onChange?: (key: string) => void;
-    variant?: 'box' | 'border' | 'lift';
-    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Visual style variant */
+    variant?: TabsVariant;
+    /** Tab size */
+    size?: TabsSize;
+    /** Tab position relative to content */
+    position?: TabsPosition;
 }
 export interface TabPanelProps {
+    /** Tab button label */
     tab: React.ReactNode;
+    /** Unique identifier for the tab */
     tabKey: string;
+    /** Disable the tab */
     disabled?: boolean;
+    /** Tab panel content */
     children?: React.ReactNode;
+    /** Tab icon */
+    icon?: React.ReactNode;
 }
-declare function TabsRoot({ children, activeKey, defaultActiveKey, onChange, variant, size, className, ...rest }: TabsProps): import("react/jsx-runtime").JSX.Element;
+declare function TabsRoot({ children, items, activeKey, defaultActiveKey, onChange, variant, size, position, className, ...rest }: TabsProps): import("react/jsx-runtime").JSX.Element;
 declare function TabPanel({ children }: TabPanelProps): import("react/jsx-runtime").JSX.Element;
 export declare const Tabs: typeof TabsRoot & {
     Panel: typeof TabPanel;

package/dist/index.d.ts

@@ -47,7 +47,9 @@ export type { DockProps, DockItemProps, DockItemConfig } from './components/Dock
 export { Divider } from './components/Divider';
 export type { DividerProps } from './components/Divider';
 export { Drawer } from './components/Drawer';
-export type { DrawerProps } from './components/Drawer';
+export type { DrawerProps, DrawerPlacement, DrawerSize } from './components/Drawer';
+export { SidebarDrawer } from './components/SidebarDrawer';
+export type { SidebarDrawerProps } from './components/SidebarDrawer';
 export { Fieldset } from './components/Fieldset';
 export type { FieldsetProps, FieldsetLegendProps } from './components/Fieldset';
 export { FileInput } from './components/FileInput';
@@ -71,7 +73,7 @@ export type { ImageProps } from './components/Image';
 export { Indicator } from './components/Indicator';
 export type { IndicatorProps, IndicatorPosition } from './components/Indicator';
 export { Dropdown } from './components/Dropdown';
-export type { DropdownProps, DropdownTriggerProps, DropdownMenuProps, DropdownItemProps, DropdownDividerProps } from './components/Dropdown';
+export type { DropdownProps, DropdownTriggerProps, DropdownMenuProps, DropdownItemProps, DropdownSubMenuProps, DropdownDividerProps, DropdownMenuItem, DropdownMenuDivider, DropdownMenuItemType, DropdownTriggerType, } from './components/Dropdown';
 export { Empty } from './components/Empty';
 export type { EmptyProps } from './components/Empty';
 export { Input } from './components/Input';
@@ -109,7 +111,7 @@ export type { WindowProps } from './components/Window';
 export { Modal } from './components/Modal';
 export type { ModalProps, ModalFuncProps, ModalPosition, ModalAlign, ResponsivePosition } from './components/Modal';
 export { Navbar } from './components/Navbar';
-export type { NavbarProps } from './components/Navbar';
+export type { NavbarProps, NavbarColor, NavbarShadow, NavbarRounded } from './components/Navbar';
 export { notification } from './components/Notification';
 export type { NotificationConfig, NotificationType, NotificationPlacement } from './components/Notification';
 export { OTPInput } from './components/OTPInput';
@@ -155,7 +157,7 @@ export type { StepsProps, StepProps, StepItem, StepsDirection } from './componen
 export { Table } from './components/Table';
 export type { TableProps, ColumnType, PaginationConfig, FilterConfig, RowSelection } from './components/Table';
 export { Tabs } from './components/Tabs';
-export type { TabsProps, TabPanelProps } from './components/Tabs';
+export type { TabsProps, TabPanelProps, TabItem, TabsVariant, TabsSize, TabsPosition } from './components/Tabs';
 export { Textarea } from './components/Textarea';
 export type { TextareaProps } from './components/Textarea';
 export { TextRotate } from './components/TextRotate';