asterui 0.10.2

package/dist/components/OTPInput.d.ts

@@ -0,0 +1,32 @@
+import { default as React } from 'react';
+export interface OTPInputProps {
+    /** Number of input fields */
+    length?: number;
+    /** Current value */
+    value?: string;
+    /** Callback when value changes */
+    onChange?: (value: string) => void;
+    /** Callback when all fields are filled */
+    onComplete?: (value: string) => void;
+    /** Input size */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Input type - number only or alphanumeric */
+    type?: 'number' | 'text';
+    /** Mask input (show dots instead of characters) */
+    mask?: boolean;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Error state */
+    error?: boolean;
+    /** Auto focus first input on mount */
+    autoFocus?: boolean;
+    /** Placeholder character */
+    placeholder?: string;
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface OTPInputRef {
+    focus: () => void;
+    clear: () => void;
+}
+export declare const OTPInput: React.ForwardRefExoticComponent<OTPInputProps & React.RefAttributes<OTPInputRef>>;

package/dist/components/PageLayout.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export interface PageLayoutProps {
+    children: React.ReactNode;
+    background?: 'base-100' | 'base-200' | 'base-300' | 'neutral';
+    padding?: 'none' | 'sm' | 'md' | 'lg';
+    minHeight?: 'screen' | 'full' | 'auto';
+    className?: string;
+}
+export declare const PageLayout: React.FC<PageLayoutProps>;

package/dist/components/Pagination.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+export interface PaginationProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    current?: number;
+    defaultCurrent?: number;
+    total: number;
+    pageSize?: number;
+    defaultPageSize?: number;
+    pageSizeOptions?: number[];
+    onChange?: (page: number, pageSize: number) => void;
+    onShowSizeChange?: (current: number, size: number) => void;
+    showSizeChanger?: boolean;
+    showQuickJumper?: boolean;
+    showTotal?: boolean | ((total: number, range: [number, number]) => React.ReactNode);
+    simple?: boolean;
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    disabled?: boolean;
+}
+export declare const Pagination: React.FC<PaginationProps>;

package/dist/components/Phone.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+export interface PhoneProps {
+    children: React.ReactNode;
+    color?: string;
+    className?: string;
+    displayClassName?: string;
+}
+export declare const Phone: React.FC<PhoneProps>;

package/dist/components/Popconfirm.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+export interface PopconfirmProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    children: React.ReactElement;
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    onConfirm?: () => void | Promise<void>;
+    onCancel?: () => void;
+    okText?: string;
+    cancelText?: string;
+    okType?: 'primary' | 'secondary' | 'accent' | 'success' | 'warning' | 'error' | 'info';
+    cancelType?: 'primary' | 'secondary' | 'accent' | 'success' | 'warning' | 'error' | 'info' | 'ghost';
+    placement?: 'top' | 'bottom' | 'left' | 'right';
+    disabled?: boolean;
+    icon?: React.ReactNode;
+    showCancel?: boolean;
+}
+export declare const Popconfirm: React.FC<PopconfirmProps>;

package/dist/components/Popover.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+export type PopoverPlacement = 'top' | 'topLeft' | 'topRight' | 'bottom' | 'bottomLeft' | 'bottomRight' | 'left' | 'leftTop' | 'leftBottom' | 'right' | 'rightTop' | 'rightBottom';
+export type PopoverTrigger = 'hover' | 'click' | 'focus';
+export interface PopoverProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'content' | 'title'> {
+    children: React.ReactNode;
+    content: React.ReactNode;
+    title?: React.ReactNode;
+    trigger?: PopoverTrigger;
+    placement?: PopoverPlacement;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    overlayClassName?: string;
+}
+export declare const Popover: React.FC<PopoverProps>;
+export default Popover;

package/dist/components/Progress.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export interface ProgressProps extends React.ProgressHTMLAttributes<HTMLProgressElement> {
+    type?: 'neutral' | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error';
+}
+export declare function Progress({ value, max, type, className, ...rest }: ProgressProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/QRCode.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+export type QRCodeErrorLevel = 'L' | 'M' | 'Q' | 'H';
+export type QRCodeType = 'canvas' | 'svg';
+export type QRCodeStatus = 'active' | 'loading' | 'expired';
+export interface QRCodeProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'color'> {
+    value: string;
+    size?: number;
+    errorLevel?: QRCodeErrorLevel;
+    icon?: string;
+    iconSize?: number;
+    type?: QRCodeType;
+    color?: string;
+    bgColor?: string;
+    bordered?: boolean;
+    status?: QRCodeStatus;
+    onRefresh?: () => void;
+}
+export declare const QRCode: React.FC<QRCodeProps>;
+export default QRCode;

package/dist/components/RadialProgress.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+export interface RadialProgressProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'color'> {
+    value: number;
+    size?: string | number;
+    thickness?: string | number;
+    color?: 'primary' | 'secondary' | 'accent' | 'success' | 'warning' | 'error' | 'info' | 'neutral';
+    showValue?: boolean;
+    children?: React.ReactNode;
+}
+export declare const RadialProgress: React.FC<RadialProgressProps>;

package/dist/components/Radio.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+export interface RadioProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'type'> {
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    color?: 'neutral' | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error';
+    className?: string;
+    children?: React.ReactNode;
+}
+export interface RadioGroupProps {
+    children: React.ReactNode;
+    value?: string | number;
+    defaultValue?: string | number;
+    onChange?: (value: string | number) => void;
+    name?: string;
+    className?: string;
+}
+declare function RadioGroup({ children, value, defaultValue, onChange, name, className }: RadioGroupProps): import("react/jsx-runtime").JSX.Element;
+export declare const Radio: React.ForwardRefExoticComponent<RadioProps & React.RefAttributes<HTMLInputElement>> & {
+    Group: typeof RadioGroup;
+};
+export {};

package/dist/components/Range.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+export interface RangeProps {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    color?: 'primary' | 'secondary' | 'accent' | 'success' | 'warning' | 'info' | 'error';
+    disabled?: boolean;
+    showValue?: boolean;
+    showSteps?: boolean;
+    className?: string;
+}
+export declare const Range: React.FC<RangeProps>;

package/dist/components/Rating.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+export interface RatingProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    children: React.ReactNode;
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    readOnly?: boolean;
+}
+export interface RatingItemProps {
+    value: number;
+    mask?: 'star' | 'star-2' | 'heart';
+    color?: string;
+    hidden?: boolean;
+    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;
+export declare const Rating: typeof RatingRoot & {
+    Item: typeof RatingItem;
+};
+export {};

package/dist/components/Responsive.d.ts

@@ -0,0 +1,18 @@
+import { default as React, ReactNode } from 'react';
+import { Breakpoint } from '../hooks/useBreakpoint';
+export interface ShowProps {
+    children: ReactNode;
+    above?: Breakpoint;
+    below?: Breakpoint;
+    at?: Breakpoint | Breakpoint[];
+    between?: [Breakpoint, Breakpoint];
+}
+export declare function Show({ children, above, below, at, between }: ShowProps): React.ReactElement | null;
+export interface HideProps {
+    children: ReactNode;
+    above?: Breakpoint;
+    below?: Breakpoint;
+    at?: Breakpoint | Breakpoint[];
+    between?: [Breakpoint, Breakpoint];
+}
+export declare function Hide({ children, above, below, at, between }: HideProps): React.ReactElement | null;

package/dist/components/Result.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+export type ResultStatus = 'success' | 'error' | 'info' | 'warning' | '404' | '403' | '500';
+export interface ResultProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    status?: ResultStatus;
+    title?: React.ReactNode;
+    subTitle?: React.ReactNode;
+    icon?: React.ReactNode;
+    extra?: React.ReactNode;
+    children?: React.ReactNode;
+}
+export declare const Result: React.FC<ResultProps>;
+export default Result;

package/dist/components/Select.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+export interface SelectProps extends Omit<React.SelectHTMLAttributes<HTMLSelectElement>, 'size'> {
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    color?: 'neutral' | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error';
+    ghost?: boolean;
+    bordered?: boolean;
+    className?: string;
+    children?: React.ReactNode;
+}
+export declare const Select: React.ForwardRefExoticComponent<SelectProps & React.RefAttributes<HTMLSelectElement>>;

package/dist/components/Skeleton.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
+    width?: string | number;
+    height?: string | number;
+    circle?: boolean;
+    variant?: 'default' | 'text';
+    children?: React.ReactNode;
+}
+export declare const Skeleton: React.FC<SkeletonProps>;

package/dist/components/Space.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+export interface SpaceProps extends React.HTMLAttributes<HTMLDivElement> {
+    direction?: 'horizontal' | 'vertical';
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | number;
+    align?: 'start' | 'end' | 'center' | 'baseline' | 'stretch';
+    justify?: 'start' | 'end' | 'center' | 'between' | 'around' | 'evenly';
+    wrap?: boolean;
+    children: React.ReactNode;
+}
+export declare const Space: React.FC<SpaceProps>;

package/dist/components/Splitter.d.ts

@@ -0,0 +1,27 @@
+import { default as React } from 'react';
+export interface SplitterPanelProps {
+    children: React.ReactNode;
+    defaultSize?: number;
+    size?: number;
+    minSize?: number;
+    maxSize?: number;
+    collapsible?: boolean;
+    collapsed?: boolean;
+    onCollapse?: (collapsed: boolean) => void;
+    className?: string;
+}
+export interface SplitterProps {
+    children: React.ReactNode;
+    direction?: 'horizontal' | 'vertical';
+    sizes?: number[];
+    defaultSizes?: number[];
+    onSizesChange?: (sizes: number[]) => void;
+    gutterSize?: number;
+    minSize?: number;
+    className?: string;
+}
+declare const Panel: React.FC<SplitterPanelProps>;
+export declare const Splitter: React.FC<SplitterProps> & {
+    Panel: typeof Panel;
+};
+export {};

package/dist/components/Stack.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+export interface StackProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    direction?: 'vertical' | 'horizontal';
+    spacing?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12 | 16 | 20 | 24;
+    align?: 'start' | 'center' | 'end' | 'stretch';
+    justify?: 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
+    wrap?: boolean;
+}
+export declare const Stack: React.FC<StackProps>;

package/dist/components/Stat.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+export interface StatsProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    vertical?: boolean;
+}
+export interface StatProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
+    title?: React.ReactNode;
+    value?: React.ReactNode;
+    desc?: React.ReactNode;
+    figure?: React.ReactNode;
+    actions?: React.ReactNode;
+}
+declare function StatsRoot({ children, className, vertical, ...rest }: StatsProps): import("react/jsx-runtime").JSX.Element;
+declare function StatItem({ title, value, desc, figure, actions, className, ...rest }: StatProps): import("react/jsx-runtime").JSX.Element;
+export declare const Stats: typeof StatsRoot & {
+    Stat: typeof StatItem;
+};
+export {};

package/dist/components/Steps.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+export interface StepsProps extends React.HTMLAttributes<HTMLUListElement> {
+    children: React.ReactNode;
+    vertical?: boolean;
+}
+export interface StepProps extends Omit<React.LiHTMLAttributes<HTMLLIElement>, 'color'> {
+    children: React.ReactNode;
+    color?: 'neutral' | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error';
+    dataContent?: string;
+}
+declare function StepsRoot({ children, vertical, className, ...rest }: StepsProps): import("react/jsx-runtime").JSX.Element;
+declare function Step({ children, color, dataContent, className, ...rest }: StepProps): import("react/jsx-runtime").JSX.Element;
+export declare const Steps: typeof StepsRoot & {
+    Step: typeof Step;
+};
+export {};

package/dist/components/Table.d.ts

@@ -0,0 +1,51 @@
+import { default as React } from 'react';
+export interface FilterConfig {
+    text: string;
+    value: string | number | boolean;
+}
+export interface ColumnType<T = any> {
+    key: string;
+    title: string;
+    dataIndex?: string;
+    render?: (value: any, record: T, index: number) => React.ReactNode;
+    width?: string | number;
+    align?: 'left' | 'center' | 'right';
+    fixed?: 'left' | 'right';
+    sorter?: boolean | ((a: T, b: T) => number);
+    filters?: FilterConfig[];
+    onFilter?: (value: string | number | boolean, record: T) => boolean;
+    defaultSortOrder?: 'ascend' | 'descend';
+    defaultFilteredValue?: (string | number | boolean)[];
+}
+export interface RowSelection<T = any> {
+    type?: 'checkbox' | 'radio';
+    selectedRowKeys?: React.Key[];
+    onChange?: (selectedRowKeys: React.Key[], selectedRows: T[]) => void;
+    getCheckboxProps?: (record: T) => {
+        disabled?: boolean;
+        [key: string]: any;
+    };
+}
+export interface PaginationConfig {
+    current?: number;
+    pageSize?: number;
+    total?: number;
+    onChange?: (page: number, pageSize: number) => void;
+}
+export interface TableProps<T = any> {
+    columns: ColumnType<T>[];
+    dataSource: T[];
+    rowKey?: string | ((record: T) => string);
+    loading?: boolean;
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    bordered?: boolean;
+    hoverable?: boolean;
+    striped?: boolean;
+    pinRows?: boolean;
+    pinCols?: boolean;
+    pagination?: false | PaginationConfig;
+    rowSelection?: RowSelection<T>;
+    className?: string;
+    onRow?: (record: T, index: number) => React.HTMLAttributes<HTMLTableRowElement>;
+}
+export declare function Table<T extends Record<string, any>>({ columns, dataSource, rowKey, loading, size, bordered, hoverable, striped, pinRows, pinCols, pagination, rowSelection, className, onRow, }: TableProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/components/Tabs.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+export interface TabsProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    children: React.ReactNode;
+    activeKey?: string;
+    defaultActiveKey?: string;
+    onChange?: (key: string) => void;
+    variant?: 'box' | 'border' | 'lift';
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+}
+export interface TabPanelProps {
+    tab: React.ReactNode;
+    tabKey: string;
+    disabled?: boolean;
+    children?: React.ReactNode;
+}
+declare function TabsRoot({ children, activeKey, defaultActiveKey, onChange, variant, size, 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;
+};
+export {};

package/dist/components/Tag.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+export interface TagProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'color'> {
+    closable?: boolean;
+    closeIcon?: React.ReactNode;
+    onClose?: () => void;
+    color?: string;
+    icon?: React.ReactNode;
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    children?: React.ReactNode;
+}
+export interface CheckableTagProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'onChange'> {
+    checked?: boolean;
+    onChange?: (checked: boolean) => void;
+    icon?: React.ReactNode;
+    children?: React.ReactNode;
+}
+export declare const Tag: React.FC<TagProps>;
+export declare const CheckableTag: React.FC<CheckableTagProps>;

package/dist/components/Textarea.d.ts

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

package/dist/components/ThemeController.d.ts

@@ -0,0 +1,20 @@
+export interface ThemeControllerSwapProps {
+    lightTheme?: string;
+    darkTheme?: string;
+    initialTheme?: string;
+    onChange?: (theme: string) => void;
+    className?: string;
+}
+export interface ThemeControllerDropdownProps {
+    themes: string[];
+    initialTheme?: string;
+    onChange?: (theme: string) => void;
+    className?: string;
+}
+declare function ThemeControllerSwap({ lightTheme, darkTheme, initialTheme, onChange, className, }: ThemeControllerSwapProps): import("react/jsx-runtime").JSX.Element;
+declare function ThemeControllerDropdown({ themes, initialTheme, onChange, className, }: ThemeControllerDropdownProps): import("react/jsx-runtime").JSX.Element;
+export declare const ThemeController: {
+    Swap: typeof ThemeControllerSwap;
+    Dropdown: typeof ThemeControllerDropdown;
+};
+export {};

package/dist/components/TimePicker.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+export interface TimePickerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onChange?: (date: Date | null) => void;
+    format?: '12' | '24';
+    placeholder?: string;
+    disabled?: boolean;
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+    showSeconds?: boolean;
+}
+export declare const TimePicker: React.FC<TimePickerProps>;

package/dist/components/Timeline.d.ts

@@ -0,0 +1,24 @@
+import { default as React } from 'react';
+export interface TimelineProps extends React.HTMLAttributes<HTMLUListElement> {
+    children: React.ReactNode;
+    vertical?: boolean;
+    horizontal?: boolean;
+    compact?: boolean;
+    snapIcon?: boolean;
+}
+export interface TimelineItemProps extends React.LiHTMLAttributes<HTMLLIElement> {
+    start?: React.ReactNode;
+    end?: React.ReactNode;
+    icon?: React.ReactNode;
+    startBox?: boolean;
+    endBox?: boolean;
+    _index?: number;
+    _compact?: boolean;
+    _vertical?: boolean;
+}
+declare function TimelineRoot({ children, className, vertical, horizontal, compact, snapIcon, ...rest }: TimelineProps): import("react/jsx-runtime").JSX.Element;
+declare function TimelineItem({ start, end, icon, startBox, endBox, className, _index, _compact, _vertical, ...rest }: TimelineItemProps): import("react/jsx-runtime").JSX.Element;
+export declare const Timeline: typeof TimelineRoot & {
+    Item: typeof TimelineItem;
+};
+export {};

package/dist/components/Toggle.d.ts

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

package/dist/components/Tooltip.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export interface TooltipProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    tip: string;
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    color?: 'neutral' | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error';
+    open?: boolean;
+}
+export declare const Tooltip: React.FC<TooltipProps>;

package/dist/components/Transfer.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+export interface TransferItem {
+    key: string;
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    disabled?: boolean;
+}
+export interface TransferProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    dataSource: TransferItem[];
+    targetKeys?: string[];
+    defaultTargetKeys?: string[];
+    onChange?: (targetKeys: string[], direction: 'left' | 'right', moveKeys: string[]) => void;
+    onSelectChange?: (sourceSelectedKeys: string[], targetSelectedKeys: string[]) => void;
+    titles?: [React.ReactNode, React.ReactNode];
+    render?: (item: TransferItem) => React.ReactNode;
+    showSearch?: boolean;
+    filterOption?: (inputValue: string, item: TransferItem) => boolean;
+    showSelectAll?: boolean;
+    disabled?: boolean;
+    listStyle?: React.CSSProperties;
+}
+export declare function Transfer({ dataSource, targetKeys: controlledTargetKeys, defaultTargetKeys, onChange, onSelectChange, titles, render, showSearch, filterOption, showSelectAll, disabled, listStyle, className, ...rest }: TransferProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Tree.d.ts

@@ -0,0 +1,40 @@
+import { default as React } from 'react';
+export interface TreeDataNode {
+    key: string;
+    title: React.ReactNode;
+    children?: TreeDataNode[];
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    selectable?: boolean;
+    checkable?: boolean;
+    icon?: React.ReactNode;
+    isLeaf?: boolean;
+}
+export interface TreeProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect'> {
+    treeData: TreeDataNode[];
+    checkable?: boolean;
+    selectable?: boolean;
+    multiple?: boolean;
+    defaultExpandAll?: boolean;
+    defaultExpandedKeys?: string[];
+    expandedKeys?: string[];
+    defaultSelectedKeys?: string[];
+    selectedKeys?: string[];
+    defaultCheckedKeys?: string[];
+    checkedKeys?: string[];
+    onExpand?: (expandedKeys: string[], info: {
+        node: TreeDataNode;
+        expanded: boolean;
+    }) => void;
+    onSelect?: (selectedKeys: string[], info: {
+        node: TreeDataNode;
+        selected: boolean;
+    }) => void;
+    onCheck?: (checkedKeys: string[], info: {
+        node: TreeDataNode;
+        checked: boolean;
+    }) => void;
+    showLine?: boolean;
+    showIcon?: boolean;
+}
+export declare function Tree({ treeData, checkable, selectable, multiple, defaultExpandAll, defaultExpandedKeys, expandedKeys: controlledExpandedKeys, defaultSelectedKeys, selectedKeys: controlledSelectedKeys, defaultCheckedKeys, checkedKeys: controlledCheckedKeys, onExpand, onSelect, onCheck, showLine, showIcon, className, ...rest }: TreeProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/TreeSelect.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+import { TreeDataNode } from './Tree';
+export interface TreeSelectProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    treeData: TreeDataNode[];
+    value?: string | string[];
+    defaultValue?: string | string[];
+    onChange?: (value: string | string[], labels: React.ReactNode[]) => void;
+    multiple?: boolean;
+    treeCheckable?: boolean;
+    showSearch?: boolean;
+    placeholder?: string;
+    allowClear?: boolean;
+    disabled?: boolean;
+    treeDefaultExpandAll?: boolean;
+    treeDefaultExpandedKeys?: string[];
+    treeExpandedKeys?: string[];
+    onTreeExpand?: (expandedKeys: string[]) => void;
+    size?: 'xs' | 'sm' | 'md' | 'lg';
+}
+export declare function TreeSelect({ treeData, value: controlledValue, defaultValue, onChange, multiple, treeCheckable, showSearch, placeholder, allowClear, disabled, treeDefaultExpandAll, treeDefaultExpandedKeys, treeExpandedKeys: controlledExpandedKeys, onTreeExpand, size, className, ...rest }: TreeSelectProps): import("react/jsx-runtime").JSX.Element;