asterui 0.10.2

package/dist/components/Divider.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+export interface DividerProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+    orientation?: 'horizontal' | 'vertical';
+    position?: 'start' | 'center' | 'end';
+    type?: 'neutral' | 'primary' | 'secondary' | 'accent' | 'success' | 'warning' | 'info' | 'error';
+}
+export declare function Divider({ children, orientation, position, type, className, ...rest }: DividerProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Drawer.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+export interface DrawerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: React.ReactNode;
+    sidebar: React.ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    end?: boolean;
+    sidebarClassName?: string;
+}
+export declare const Drawer: React.FC<DrawerProps>;

package/dist/components/Dropdown.d.ts

@@ -0,0 +1,39 @@
+import { default as React } from 'react';
+export interface DropdownProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    hover?: boolean;
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    align?: 'start' | 'center' | 'end';
+}
+export interface DropdownTriggerProps {
+    children: React.ReactNode;
+    className?: string;
+}
+export interface DropdownMenuProps {
+    children: React.ReactNode;
+    className?: string;
+}
+export interface DropdownItemProps {
+    children: React.ReactNode;
+    onClick?: () => void;
+    active?: boolean;
+    disabled?: boolean;
+    danger?: boolean;
+    className?: string;
+    _index?: number;
+}
+export interface DropdownDividerProps {
+    className?: string;
+}
+declare function DropdownRoot({ children, hover, position, align, className, ...rest }: DropdownProps): import("react/jsx-runtime").JSX.Element;
+declare function DropdownTrigger({ children, className }: DropdownTriggerProps): import("react/jsx-runtime").JSX.Element;
+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 DropdownDivider({ className }: DropdownDividerProps): import("react/jsx-runtime").JSX.Element;
+export declare const Dropdown: typeof DropdownRoot & {
+    Trigger: typeof DropdownTrigger;
+    Menu: typeof DropdownMenu;
+    Item: typeof DropdownItem;
+    Divider: typeof DropdownDivider;
+};
+export {};

package/dist/components/Empty.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+export interface EmptyProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+    description?: React.ReactNode;
+    image?: React.ReactNode;
+    imageStyle?: React.CSSProperties;
+}
+export declare const Empty: React.FC<EmptyProps>;

package/dist/components/Fieldset.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+export interface FieldsetProps extends React.FieldsetHTMLAttributes<HTMLFieldSetElement> {
+    children: React.ReactNode;
+    className?: string;
+}
+export interface FieldsetLegendProps {
+    children: React.ReactNode;
+    className?: string;
+}
+declare function FieldsetRoot({ children, className, ...props }: FieldsetProps): import("react/jsx-runtime").JSX.Element;
+declare function FieldsetLegend({ children, className }: FieldsetLegendProps): import("react/jsx-runtime").JSX.Element;
+export declare const Fieldset: typeof FieldsetRoot & {
+    Legend: typeof FieldsetLegend;
+};
+export {};

package/dist/components/FileInput.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export interface FileInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'type'> {
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    color?: 'neutral' | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error';
+    ghost?: boolean;
+    bordered?: boolean;
+    className?: string;
+}
+export declare const FileInput: React.ForwardRefExoticComponent<FileInputProps & React.RefAttributes<HTMLInputElement>>;

package/dist/components/Flex.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+export interface FlexProps extends React.HTMLAttributes<HTMLDivElement> {
+    direction?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
+    justify?: 'start' | 'end' | 'center' | 'between' | 'around' | 'evenly';
+    align?: 'start' | 'end' | 'center' | 'baseline' | 'stretch';
+    wrap?: boolean | 'wrap' | 'nowrap' | 'wrap-reverse';
+    gap?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number;
+    flex?: '1' | 'auto' | 'initial' | 'none';
+    inline?: boolean;
+    minHeight?: 'screen' | 'full' | 'fit' | 'min' | 'max';
+    minWidth?: 'full' | 'fit' | 'min' | 'max';
+    children?: React.ReactNode;
+}
+export declare const Flex: React.FC<FlexProps>;

package/dist/components/FloatButton.d.ts

@@ -0,0 +1,34 @@
+import { default as React } from 'react';
+export interface FloatButtonProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'type'> {
+    /** Button content (icon or text) */
+    children?: React.ReactNode;
+    /** Button type/color */
+    type?: 'default' | 'primary' | 'secondary' | 'accent';
+    /** Button shape */
+    shape?: 'circle' | 'square';
+    /** Position on screen */
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    /** Distance from edge in pixels */
+    offset?: number;
+    /** Tooltip text */
+    tooltip?: string;
+    /** Tooltip placement */
+    tooltipPlacement?: 'left' | 'right' | 'top' | 'bottom';
+}
+export interface BackTopProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'type' | 'onClick'> {
+    /** Scroll threshold to show button (pixels) */
+    visibilityHeight?: number;
+    /** Scroll target (default: window) */
+    target?: () => HTMLElement | Window;
+    /** Click handler (called before scrolling) */
+    onClick?: () => void;
+    /** Custom content */
+    children?: React.ReactNode;
+    /** Position on screen */
+    position?: 'bottom-right' | 'bottom-left';
+    /** Distance from edge in pixels */
+    offset?: number;
+}
+export declare const FloatButton: React.FC<FloatButtonProps> & {
+    BackTop: React.FC<BackTopProps>;
+};

package/dist/components/Footer.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+export interface FooterProps extends React.HTMLAttributes<HTMLElement> {
+    children: React.ReactNode;
+    center?: boolean;
+    horizontal?: boolean;
+    vertical?: boolean;
+}
+export interface FooterTitleProps extends React.HTMLAttributes<HTMLHeadingElement> {
+    children: React.ReactNode;
+}
+declare function FooterRoot({ children, className, center, horizontal, vertical, ...rest }: FooterProps): import("react/jsx-runtime").JSX.Element;
+declare function FooterTitle({ children, className, ...rest }: FooterTitleProps): import("react/jsx-runtime").JSX.Element;
+export declare const Footer: typeof FooterRoot & {
+    Title: typeof FooterTitle;
+};
+export {};

package/dist/components/Form.d.ts

@@ -0,0 +1,66 @@
+import { default as React } from 'react';
+import { UseFormReturn, FieldValues, SubmitHandler, UseFormProps, FieldArrayPath, FieldArray } from 'react-hook-form';
+export interface FormProps<TFieldValues extends FieldValues = FieldValues> extends Omit<React.FormHTMLAttributes<HTMLFormElement>, 'onSubmit'> {
+    form?: UseFormReturn<TFieldValues>;
+    onFinish?: SubmitHandler<TFieldValues>;
+    initialValues?: UseFormProps<TFieldValues>['defaultValues'];
+    layout?: 'vertical' | 'horizontal' | 'inline';
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    children: React.ReactNode;
+}
+export interface FormRule {
+    required?: boolean | string;
+    type?: 'email' | 'url' | 'number';
+    min?: number | {
+        value: number;
+        message: string;
+    };
+    max?: number | {
+        value: number;
+        message: string;
+    };
+    pattern?: RegExp | {
+        value: RegExp;
+        message: string;
+    };
+    message?: string;
+    validate?: (value: any) => boolean | string | Promise<boolean | string>;
+}
+export interface FormItemProps {
+    name?: string | string[];
+    label?: string;
+    help?: string;
+    required?: boolean;
+    rules?: FormRule | FormRule[];
+    valuePropName?: string;
+    inline?: boolean;
+    className?: string;
+    children: React.ReactElement;
+}
+export interface FormListProps<TFieldValues extends FieldValues = FieldValues> {
+    name: FieldArrayPath<TFieldValues>;
+    children: (fields: FieldArray<TFieldValues>[], operations: {
+        add: (value?: any) => void;
+        remove: (index: number) => void;
+        move: (from: number, to: number) => void;
+    }) => React.ReactNode;
+}
+declare function FormRoot<TFieldValues extends FieldValues = FieldValues>({ form: externalForm, onFinish, initialValues, layout, size, children, className, noValidate, ...props }: FormProps<TFieldValues>): import("react/jsx-runtime").JSX.Element;
+declare function FormItem({ name, label, help, required, rules, valuePropName, inline, className, children, }: 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> & {
+    setFieldValue: import('react-hook-form').UseFormSetValue<TFieldValues>;
+    getFieldValue: (name: any) => any;
+    getFieldsValue: import('react-hook-form').UseFormGetValues<TFieldValues>;
+    setFieldsValue: (values: any) => void;
+    validateFields: import('react-hook-form').UseFormTrigger<TFieldValues>;
+    resetFields: import('react-hook-form').UseFormReset<TFieldValues>;
+    isFieldTouched: (name: string) => boolean;
+    getFieldError: (name: string) => string | undefined;
+};
+export declare const Form: typeof FormRoot & {
+    Item: typeof FormItem;
+    List: typeof FormList;
+    useForm: typeof useFormInstance;
+};
+export type { UseFormReturn as FormInstance };

package/dist/components/Grid.d.ts

@@ -0,0 +1,26 @@
+import { default as React } from 'react';
+export interface RowProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    cols?: 24 | 120;
+    gutter?: number | [number, number];
+    justify?: 'start' | 'end' | 'center' | 'between' | 'around' | 'evenly';
+    align?: 'start' | 'end' | 'center' | 'stretch' | 'baseline';
+}
+export interface ColProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    span?: number;
+    offset?: number;
+    order?: number;
+    xs?: number;
+    sm?: number;
+    md?: number;
+    lg?: number;
+    xl?: number;
+    xxl?: number;
+}
+export declare function Row({ children, cols, gutter, justify, align, className, style: userStyle, ...rest }: RowProps): import("react/jsx-runtime").JSX.Element;
+export declare function Col({ children, span, offset, order, xs, sm, md, lg, xl, xxl, className, ...rest }: ColProps): import("react/jsx-runtime").JSX.Element;
+export declare const Grid: {
+    Row: typeof Row;
+    Col: typeof Col;
+};

package/dist/components/Hero.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export interface HeroProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    overlay?: boolean;
+    overlayClassName?: string;
+    contentClassName?: string;
+    wrapperClassName?: string;
+}
+export declare function Hero({ children, overlay, overlayClassName, contentClassName, wrapperClassName, className, style, ...rest }: HeroProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Image.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+export interface ImageProps extends Omit<React.ImgHTMLAttributes<HTMLImageElement>, 'placeholder'> {
+    src: string;
+    alt?: string;
+    fallback?: string;
+    placeholder?: React.ReactNode;
+    preview?: boolean;
+    width?: string | number;
+    height?: string | number;
+    className?: string;
+    onLoad?: () => void;
+    onError?: () => void;
+}
+export declare const Image: React.FC<ImageProps>;

package/dist/components/Indicator.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+export type IndicatorPosition = 'top-start' | 'top-center' | 'top-end' | 'middle-start' | 'middle-center' | 'middle-end' | 'bottom-start' | 'bottom-center' | 'bottom-end';
+export interface IndicatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    position?: IndicatorPosition;
+    children: React.ReactNode;
+}
+export declare const Indicator: React.FC<IndicatorProps>;

package/dist/components/Input.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+export interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    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';
+    ghost?: boolean;
+    bordered?: boolean;
+    className?: string;
+    /** Input mask pattern. Use # for digits, A for letters, * for alphanumeric */
+    mask?: string;
+    /** Placeholder character shown in mask (default: _) */
+    maskPlaceholder?: string;
+}
+export declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;

package/dist/components/InputNumber.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+export interface InputNumberProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'onChange' | 'value' | 'defaultValue'> {
+    value?: number;
+    defaultValue?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    precision?: number;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    disabled?: boolean;
+    onChange?: (value: number | null) => void;
+    formatter?: (value: number | undefined) => string;
+    parser?: (displayValue: string) => number;
+    className?: string;
+    controls?: boolean;
+    block?: boolean;
+}
+export declare const InputNumber: React.ForwardRefExoticComponent<InputNumberProps & React.RefAttributes<HTMLInputElement>>;
+export default InputNumber;

package/dist/components/Join.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+export interface JoinProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    vertical?: boolean;
+}
+export declare function Join({ children, vertical, className, ...rest }: JoinProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Label.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+export interface LabelProps extends React.HTMLAttributes<HTMLSpanElement> {
+    children: React.ReactNode;
+}
+export interface FloatingLabelProps extends React.LabelHTMLAttributes<HTMLLabelElement> {
+    children: React.ReactNode;
+    label: string;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+}
+declare function LabelRoot({ children, className, ...rest }: LabelProps): import("react/jsx-runtime").JSX.Element;
+declare function FloatingLabel({ children, label, size, className, ...rest }: FloatingLabelProps): import("react/jsx-runtime").JSX.Element;
+export declare const Label: typeof LabelRoot & {
+    Floating: typeof FloatingLabel;
+};
+export {};

package/dist/components/Layout.d.ts

@@ -0,0 +1,59 @@
+import { default as React } from 'react';
+export interface LayoutProps {
+    children: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export interface LayoutHeaderProps {
+    children: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export interface LayoutFooterProps {
+    children: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export interface LayoutContentProps {
+    children: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export interface LayoutSiderProps {
+    children: React.ReactNode;
+    width?: number | string;
+    collapsedWidth?: number | string;
+    collapsed?: boolean;
+    defaultCollapsed?: boolean;
+    collapsible?: boolean;
+    onCollapse?: (collapsed: boolean) => void;
+    trigger?: React.ReactNode | null;
+    breakpoint?: 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+    onBreakpoint?: (broken: boolean) => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+interface SiderContextValue {
+    collapsed: boolean;
+    collapsedWidth: number | string;
+    width: number | string;
+}
+export declare function useSiderContext(): SiderContextValue | null;
+declare function LayoutRoot({ children, className, style }: LayoutProps): import("react/jsx-runtime").JSX.Element;
+declare namespace LayoutRoot {
+    var displayName: string;
+}
+declare function LayoutHeader({ children, className, style }: LayoutHeaderProps): import("react/jsx-runtime").JSX.Element;
+declare function LayoutFooter({ children, className, style }: LayoutFooterProps): import("react/jsx-runtime").JSX.Element;
+declare function LayoutContent({ children, className, style }: LayoutContentProps): import("react/jsx-runtime").JSX.Element;
+declare function LayoutSider({ children, width, collapsedWidth, collapsed: controlledCollapsed, defaultCollapsed, collapsible, onCollapse, trigger, className, style, }: LayoutSiderProps): import("react/jsx-runtime").JSX.Element;
+declare namespace LayoutSider {
+    var displayName: string;
+}
+export declare const Layout: typeof LayoutRoot & {
+    Header: typeof LayoutHeader;
+    Footer: typeof LayoutFooter;
+    Content: typeof LayoutContent;
+    Sider: typeof LayoutSider;
+};
+export {};

package/dist/components/List.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+export interface ListProps extends React.HTMLAttributes<HTMLUListElement> {
+    children: React.ReactNode;
+}
+export interface ListRowProps extends React.LiHTMLAttributes<HTMLLIElement> {
+    children: React.ReactNode;
+}
+declare function ListRoot({ children, className, ...rest }: ListProps): import("react/jsx-runtime").JSX.Element;
+declare function ListRow({ children, className, ...rest }: ListRowProps): import("react/jsx-runtime").JSX.Element;
+export declare const List: typeof ListRoot & {
+    Row: typeof ListRow;
+};
+export {};

package/dist/components/Loading.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export interface LoadingProps extends React.HTMLAttributes<HTMLDivElement> {
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    type?: 'spinner' | 'dots' | 'ring' | 'ball' | 'bars' | 'infinity';
+    spinning?: boolean;
+    children?: React.ReactNode;
+    tip?: string;
+}
+export declare const Loading: React.FC<LoadingProps>;

package/dist/components/Masonry.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+export interface MasonryProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    columns?: number | {
+        xs?: number;
+        sm?: number;
+        md?: number;
+        lg?: number;
+        xl?: number;
+        '2xl'?: number;
+    };
+    gap?: number | string;
+}
+export declare const Masonry: React.FC<MasonryProps>;
+export default Masonry;

package/dist/components/Mention.d.ts

@@ -0,0 +1,30 @@
+import { default as React } from 'react';
+export interface MentionOption {
+    value: string;
+    label?: string;
+    avatar?: string;
+    disabled?: boolean;
+}
+export interface MentionProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'onSelect' | 'defaultValue' | 'prefix'> {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onSelect?: (option: MentionOption, prefix: string) => void;
+    onSearch?: (text: string, prefix: string) => void;
+    options?: MentionOption[];
+    loading?: boolean;
+    prefix?: string | string[];
+    split?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    rows?: number;
+    autoSize?: boolean | {
+        minRows?: number;
+        maxRows?: number;
+    };
+    notFoundContent?: React.ReactNode;
+    filterOption?: boolean | ((input: string, option: MentionOption) => boolean);
+    dropdownClassName?: string;
+}
+export declare const Mention: React.FC<MentionProps>;

package/dist/components/Menu.d.ts

@@ -0,0 +1,45 @@
+import { default as React } from 'react';
+export type MenuMode = 'vertical' | 'horizontal' | 'inline';
+export interface MenuProps extends Omit<React.HTMLAttributes<HTMLUListElement>, 'onSelect'> {
+    children: React.ReactNode;
+    mode?: MenuMode;
+    selectedKeys?: string[];
+    defaultSelectedKeys?: string[];
+    openKeys?: string[];
+    defaultOpenKeys?: string[];
+    onSelect?: (key: string) => void;
+    onOpenChange?: (openKeys: string[]) => void;
+}
+export interface MenuItemProps extends Omit<React.HTMLAttributes<HTMLAnchorElement>, 'onClick'> {
+    children: React.ReactNode;
+    itemKey?: string;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+    onClick?: () => void;
+    /** @deprecated Use itemKey and selectedKeys instead */
+    active?: boolean;
+}
+export interface MenuSubMenuProps extends React.HTMLAttributes<HTMLLIElement> {
+    children: React.ReactNode;
+    itemKey: string;
+    label: React.ReactNode;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+}
+export interface MenuTitleProps extends React.HTMLAttributes<HTMLLIElement> {
+    children: React.ReactNode;
+}
+export interface MenuDividerProps extends React.HTMLAttributes<HTMLLIElement> {
+}
+declare function MenuRoot({ children, mode, selectedKeys: controlledSelectedKeys, defaultSelectedKeys, openKeys: controlledOpenKeys, defaultOpenKeys, onSelect, onOpenChange, className, ...rest }: MenuProps): import("react/jsx-runtime").JSX.Element;
+declare function MenuItem({ children, itemKey, icon, disabled, onClick, active, className, ...rest }: MenuItemProps): import("react/jsx-runtime").JSX.Element;
+declare function MenuSubMenu({ children, itemKey, label, icon, disabled, className, ...rest }: MenuSubMenuProps): import("react/jsx-runtime").JSX.Element;
+declare function MenuTitle({ children, className, ...rest }: MenuTitleProps): import("react/jsx-runtime").JSX.Element;
+declare function MenuDivider({ className, ...rest }: MenuDividerProps): import("react/jsx-runtime").JSX.Element;
+export declare const Menu: typeof MenuRoot & {
+    Item: typeof MenuItem;
+    SubMenu: typeof MenuSubMenu;
+    Title: typeof MenuTitle;
+    Divider: typeof MenuDivider;
+};
+export {};

package/dist/components/Modal.d.ts

@@ -0,0 +1,42 @@
+import { default as React } from 'react';
+export interface ModalProps extends Omit<React.HTMLAttributes<HTMLDialogElement>, 'title'> {
+    children: React.ReactNode;
+    title?: React.ReactNode;
+    footer?: React.ReactNode;
+    open?: boolean;
+    onOk?: () => void | Promise<void>;
+    onCancel?: () => void;
+    okText?: string;
+    cancelText?: string;
+    maskClosable?: boolean;
+    closable?: boolean;
+    position?: 'top' | 'middle' | 'bottom';
+    align?: 'start' | 'end';
+}
+export interface ModalFuncProps {
+    title?: React.ReactNode;
+    content?: React.ReactNode;
+    onOk?: () => void | Promise<void>;
+    onCancel?: () => void;
+    okText?: string;
+    cancelText?: string;
+    type?: 'info' | 'success' | 'warning' | 'error';
+}
+export declare function Modal({ children, title, footer, open, onOk, onCancel, okText, cancelText, maskClosable, closable, position, align, className, ...rest }: ModalProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Modal {
+    var confirm: (config: ModalFuncProps) => {
+        destroy: () => void;
+    };
+    var info: (config: ModalFuncProps) => {
+        destroy: () => void;
+    };
+    var success: (config: ModalFuncProps) => {
+        destroy: () => void;
+    };
+    var warning: (config: ModalFuncProps) => {
+        destroy: () => void;
+    };
+    var error: (config: ModalFuncProps) => {
+        destroy: () => void;
+    };
+}

package/dist/components/Navbar.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+export interface NavbarProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+    start?: React.ReactNode;
+    center?: React.ReactNode;
+    end?: React.ReactNode;
+}
+export declare const Navbar: React.FC<NavbarProps>;

package/dist/components/Notification.d.ts

@@ -0,0 +1,43 @@
+import { default as React } from 'react';
+export type NotificationType = 'success' | 'info' | 'warning' | 'error';
+export type NotificationPlacement = 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight';
+export interface NotificationConfig {
+    message: React.ReactNode;
+    description?: React.ReactNode;
+    type?: NotificationType;
+    duration?: number;
+    placement?: NotificationPlacement;
+    closable?: boolean;
+    onClick?: () => void;
+    onClose?: () => void;
+}
+interface NotificationItem extends NotificationConfig {
+    id: string;
+    createdAt: number;
+}
+type Listener = () => void;
+declare class NotificationManager {
+    private notifications;
+    private listeners;
+    private container;
+    private root;
+    private idCounter;
+    subscribe(listener: Listener): () => void;
+    getNotifications(): NotificationItem[];
+    private emit;
+    private ensureContainer;
+    open(config: NotificationConfig): string;
+    close(id: string): void;
+    success(config: Omit<NotificationConfig, 'type'>): string;
+    error(config: Omit<NotificationConfig, 'type'>): string;
+    info(config: Omit<NotificationConfig, 'type'>): string;
+    warning(config: Omit<NotificationConfig, 'type'>): string;
+    destroy(): void;
+}
+interface NotificationItemProps {
+    notification: NotificationItem;
+    onClose: () => void;
+}
+declare function NotificationItem({ notification, onClose }: NotificationItemProps): import("react/jsx-runtime").JSX.Element;
+export declare const notification: NotificationManager;
+export {};