@unicom-cloud/ui 0.8.41

package/types/tag/interface.d.ts

@@ -0,0 +1,19 @@
+import { CSSProperties, HTMLAttributes, ReactNode } from 'react';
+export interface TagProps extends Omit<HTMLAttributes<HTMLDivElement>, 'className' | 'ref'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    color?: string;
+    bordered?: Boolean;
+    size?: 'small' | 'default' | 'medium' | 'large';
+    visible?: boolean;
+    closable?: boolean;
+    checkable?: boolean;
+    defaultChecked?: boolean;
+    checked?: boolean;
+    icon?: ReactNode;
+    closeIcon?: ReactNode;
+    onClose?: (e: any) => Promise<any> | void;
+    onCheck?: (checked: boolean) => void;
+    fill?: boolean;
+    __closeIconProps?: HTMLAttributes<any>;
+}

package/types/tag/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style/index.less';
+import './index.less';

package/types/time-picker/Picker.d.ts

@@ -0,0 +1,15 @@
+import { Dayjs } from 'dayjs';
+import { ReactElement } from 'react';
+import type { CalendarValue, PickerProps } from './interface';
+interface InnerPickerProps extends PickerProps {
+    defaultValue?: CalendarValue | CalendarValue[];
+    value?: CalendarValue | CalendarValue[];
+    onSelect?: (value: string | string[], dayjsValue: Dayjs | Dayjs[]) => void;
+    onChange?: (value: string | string[], dayjsValue: Dayjs | Dayjs[]) => void;
+    isRangePicker?: boolean;
+    picker?: ReactElement;
+    hideFooter?: boolean;
+    order?: boolean;
+}
+declare const Picker: (baseProps: InnerPickerProps) => import("react/jsx-dev-runtime").JSX.Element;
+export default Picker;

package/types/time-picker/RangePicker.d.ts

@@ -0,0 +1,12 @@
+import { Dayjs } from 'dayjs';
+import type { RangePickerProps } from './interface';
+interface InnerRangePickerProps extends RangePickerProps {
+    focusedInputIndex?: number;
+    changeFocusedInputIndex?: (index: number) => void;
+    popupVisible?: boolean;
+    onConfirmValue?: (value: Dayjs[]) => void;
+    valueShow?: Dayjs[];
+    setValueShow?: (valueShow: Dayjs[]) => void;
+}
+declare function RangePicker(props: InnerRangePickerProps): import("react/jsx-dev-runtime").JSX.Element;
+export default RangePicker;

package/types/time-picker/TimeColumn.d.ts

@@ -0,0 +1,17 @@
+type ListItem = {
+    label?: string;
+    value?: number | string;
+    disabled?: boolean;
+    selected?: boolean;
+};
+export interface TimeColumnProps {
+    prefixCls?: string;
+    list?: ListItem[];
+    value?: number | string;
+    onHandleSelect?: (value?: number | string, unit?: string) => void;
+    unit?: 'hour' | 'minute' | 'second' | 'ampm';
+    popupVisible?: boolean;
+    scrollSticky?: boolean;
+}
+export default function TimeColumn(props: TimeColumnProps): import("react/jsx-dev-runtime").JSX.Element;
+export {};

package/types/time-picker/TimePicker.d.ts

@@ -0,0 +1,24 @@
+import { Dayjs } from 'dayjs';
+import { ReactNode } from 'react';
+import type { CalendarValue, TimePickerProps } from './interface';
+interface InnerTimePickerProps extends TimePickerProps {
+    confirmBtnDisabled?: boolean;
+    popupVisible?: boolean;
+    step?: {
+        hour?: number;
+        minute?: number;
+        second?: number;
+    };
+    disabledHours?: () => number[];
+    disabledMinutes?: (selectedHour: any) => number[];
+    disabledSeconds?: (selectedHour: any, selectedMinute: any) => number[];
+    hideDisabledOptions?: boolean;
+    onConfirmValue?: (value: Dayjs) => void;
+    isRangePicker?: boolean;
+    extra?: ReactNode;
+    valueShow?: CalendarValue;
+    setValueShow?: (valueShow: Dayjs) => void;
+    hideFooter?: boolean;
+}
+declare function TimePicker(props: InnerTimePickerProps): import("react/jsx-dev-runtime").JSX.Element;
+export default TimePicker;

package/types/time-picker/context.d.ts

@@ -0,0 +1,6 @@
+type TimezoneContext = {
+    utcOffset?: number;
+    timezone?: string;
+};
+declare const _default: import("react").Context<TimezoneContext>;
+export default _default;

package/types/time-picker/index.d.ts

@@ -0,0 +1,5 @@
+import './style';
+import type { RangePickerProps, TimePickerDecorator, TimePickerProps } from './interface';
+declare const _default: TimePickerDecorator;
+export default _default;
+export type { TimePickerProps, RangePickerProps as TimeRangePickerProps };

package/types/time-picker/interface.d.ts

@@ -0,0 +1,62 @@
+import { Dayjs } from 'dayjs';
+import { CSSProperties, ReactNode } from 'react';
+import { TriggerProps } from '../trigger';
+export type CalendarValue = Dayjs | Date | string | number;
+export interface PickerProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    disabled?: boolean;
+    error?: boolean;
+    status?: 'error' | 'warning';
+    prefix?: ReactNode;
+    allowClear?: boolean;
+    disableConfirm?: boolean;
+    position?: 'top' | 'tl' | 'tr' | 'bottom' | 'bl' | 'br';
+    getPopupContainer?: (node: HTMLElement) => Element;
+    placeholder?: string | string[];
+    format?: string;
+    use12Hours?: boolean;
+    onClear?: () => void;
+    popupVisible?: boolean;
+    triggerElement?: ReactNode;
+    triggerProps?: Partial<TriggerProps>;
+    step?: {
+        hour?: number;
+        minute?: number;
+        second?: number;
+    };
+    disabledHours?: () => number[];
+    disabledMinutes?: (selectedHour: any) => number[];
+    disabledSeconds?: (selectedHour: any, selectedMinute: any) => number[];
+    hideDisabledOptions?: boolean;
+    size?: 'mini' | 'small' | 'default' | 'large';
+    scrollSticky?: boolean;
+    editable?: boolean;
+    icons?: {
+        inputSuffix?: ReactNode;
+    };
+    extra?: ReactNode;
+    unmountOnExit?: boolean;
+    utcOffset?: number;
+    timezone?: string;
+}
+export type BaseTimePickerProps = {
+    onSelect?: (valueString: string, value: Dayjs) => void;
+    onChange?: (valueString: string, value: Dayjs) => void;
+    defaultValue?: CalendarValue;
+    value?: CalendarValue;
+    showNowBtn?: boolean;
+};
+export type TimePickerProps = BaseTimePickerProps & PickerProps;
+export type BaseRangePickerProps = {
+    onChange?: (valueString: string[], value: Dayjs[]) => void;
+    onSelect?: (valueString: string[], value: Dayjs[]) => void;
+    defaultValue?: CalendarValue[];
+    value?: CalendarValue[];
+    placeholder?: string[];
+    order?: boolean;
+};
+export type RangePickerProps = BaseRangePickerProps & PickerProps;
+export interface TimePickerDecorator extends TimePickerProps {
+    RangePicker?: RangePickerProps;
+}

package/types/time-picker/style/index.d.ts

@@ -0,0 +1,5 @@
+import '../../input/style';
+import '../../picker/style/index.less';
+import '../../style/index.less';
+import '../../trigger/style';
+import './index.less';

package/types/time-picker/util.d.ts

@@ -0,0 +1,7 @@
+import { Dayjs } from 'dayjs';
+export declare function getColumnsFromFormat(format: any): {
+    list: string[];
+    use12Hours: boolean;
+};
+export declare function scrollTo(element: HTMLElement, to: number, duration: number): void;
+export declare function getFormatTime(time: Dayjs): Dayjs;

package/types/timeline/Item.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { TimelineItemProps } from './interface';
+declare const TimelineItem: React.ForwardRefExoticComponent<TimelineItemProps & React.RefAttributes<HTMLDivElement>> & {
+    isTimelineItem?: boolean | undefined;
+};
+export default TimelineItem;
+export type { TimelineItemProps };

package/types/timeline/Timeline.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import Item from './Item';
+import type { TimelineProps } from './interface';
+declare const TimelineComponent: React.ForwardRefExoticComponent<TimelineProps & {
+    children?: React.ReactNode;
+} & React.RefAttributes<unknown>> & {
+    Item: typeof Item;
+};
+export default TimelineComponent;
+export type { TimelineProps };

package/types/timeline/index.d.ts

@@ -0,0 +1,4 @@
+import './style';
+import Timeline from './Timeline';
+export default Timeline;
+export type { TimelineItemProps, TimelineProps } from './interface';

package/types/timeline/interface.d.ts

@@ -0,0 +1,26 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface TimelineProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    reverse?: boolean;
+    direction?: 'horizontal' | 'vertical';
+    mode?: 'left' | 'right' | 'top' | 'bottom' | 'alternate';
+    pending?: boolean | ReactNode;
+    pendingDot?: ReactNode;
+    labelPosition?: 'relative' | 'same';
+}
+export interface TimelineItemProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    dotColor?: string;
+    dotType?: 'hollow' | 'solid';
+    dot?: string | ReactNode;
+    lineType?: 'solid' | 'dashed' | 'dotted';
+    lineColor?: string;
+    label?: string | ReactNode;
+    labelPosition?: 'relative' | 'same';
+    autoFixDotSize?: boolean;
+    position?: 'left' | 'right';
+    direction?: 'horizontal' | 'vertical';
+    children?: ReactNode;
+}

package/types/timeline/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style/index.less';
+import './index.less';

package/types/tooltip/index.d.ts

@@ -0,0 +1,10 @@
+import './style';
+import type { TooltipProps } from './interface';
+export type TooltipHandle = {
+    updatePopupPosition: () => void;
+};
+declare const TooltipComponent: import("react").ForwardRefExoticComponent<TooltipProps & {
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<TooltipHandle>>;
+export default TooltipComponent;
+export type { TooltipProps };

package/types/tooltip/interface.d.ts

@@ -0,0 +1,23 @@
+import { CSSProperties, ReactNode } from 'react';
+import { TriggerProps } from '../trigger';
+export interface TooltipProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    trigger?: TriggerProps['trigger'];
+    escToClose?: TriggerProps['escToClose'];
+    content?: ReactNode;
+    color?: string;
+    getPopupContainer?: (node: HTMLElement) => Element;
+    position?: 'top' | 'tl' | 'tr' | 'bottom' | 'bl' | 'br' | 'left' | 'lt' | 'lb' | 'right' | 'rt' | 'rb';
+    mini?: boolean;
+    prefixCls?: string;
+    unmountOnExit?: boolean;
+    defaultPopupVisible?: boolean;
+    popupVisible?: boolean;
+    onVisibleChange?: (visible: boolean) => void;
+    popupHoverStay?: boolean;
+    blurToHide?: boolean;
+    disabled?: boolean;
+    triggerProps?: Partial<TriggerProps>;
+    childrenPrefix?: string;
+}

package/types/tooltip/style/index.d.ts

@@ -0,0 +1,3 @@
+import '../../style/index.less';
+import '../../trigger/style';
+import './index.less';

package/types/transfer/Item.d.ts

@@ -0,0 +1,3 @@
+import type { TransferItemProps } from './interface';
+declare function TransferItem(props: TransferItemProps): import("react/jsx-dev-runtime").JSX.Element;
+export default TransferItem;

package/types/transfer/List.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { TransferListProps } from './interface';
+export declare const TransferList: (props: TransferListProps, ref: any) => import("react/jsx-dev-runtime").JSX.Element;
+declare const TransferListComponent: React.ForwardRefExoticComponent<TransferListProps & React.RefAttributes<unknown>>;
+export default TransferListComponent;

package/types/transfer/index.d.ts

@@ -0,0 +1,6 @@
+import './style';
+import React from 'react';
+import type { TransferProps } from './interface';
+declare const TransferComponent: React.ForwardRefExoticComponent<TransferProps & React.RefAttributes<unknown>>;
+export default TransferComponent;
+export type { TransferProps };

package/types/transfer/interface.d.ts

@@ -0,0 +1,91 @@
+import { CSSProperties, DragEvent, ReactNode } from 'react';
+import { InputProps } from '../input';
+import { PaginationProps } from '../pagination';
+import { AvailableVirtualListProps } from '../virtual-list';
+export type TransferItem = {
+    key: string;
+    value: string;
+    disabled?: boolean;
+};
+export type TransferListType = 'source' | 'target';
+type TransferListTitle = string | ((params: {
+    countTotal: number;
+    countSelected: number;
+    clear: () => void;
+    checkbox: ReactNode;
+    searchInput: ReactNode;
+}) => ReactNode);
+interface TransferPropsWithArrayType {
+    searchPlaceholder?: string | string[];
+    showSearch?: boolean | InputProps | Array<boolean | InputProps>;
+    showFooter?: boolean | ReactNode | Array<boolean | ReactNode>;
+    pagination?: boolean | PaginationProps | Array<boolean | PaginationProps>;
+    listStyle?: CSSProperties | CSSProperties[];
+}
+export interface TransferProps extends TransferPropsWithArrayType {
+    prefixCls?: string;
+    style?: CSSProperties;
+    className?: string | string[];
+    children?: (props: TransferCustomListProps) => ReactNode;
+    dataSource?: TransferItem[];
+    defaultTargetKeys?: string[];
+    defaultSelectedKeys?: string[];
+    targetKeys?: string[];
+    selectedKeys?: string[];
+    titleTexts?: Array<TransferListTitle>;
+    operationTexts?: string[] | ReactNode[];
+    disabled?: boolean;
+    oneWay?: boolean;
+    simple?: boolean | {
+        retainSelectedItems?: boolean;
+    };
+    draggable?: boolean;
+    operationStyle?: CSSProperties;
+    virtualListProps?: AvailableVirtualListProps;
+    render?: (item: TransferItem) => any;
+    filterOption?: (inputValue: string, item: TransferItem) => boolean;
+    onChange?: (newTargetKeys: string[], direction: 'source' | 'target', moveKeys: string[]) => void;
+    onSelectChange?: (leftSelectedKeys: string[], rightSelectedKeys: string[]) => void;
+    onSearch?: (value: string, type?: 'source' | 'target') => void;
+    onResetData?: () => void;
+    onDragStart?: (e: DragEvent<HTMLSpanElement>, item: TransferItem) => void;
+    onDragEnd?: (e: DragEvent<HTMLSpanElement>, item: TransferItem) => void;
+    onDragLeave?: (e: DragEvent<HTMLSpanElement>, item: TransferItem) => void;
+    onDragOver?: (e: DragEvent<HTMLSpanElement>, item: TransferItem) => void;
+    onDrop?: (info: {
+        e: DragEvent<HTMLSpanElement>;
+        dragItem: TransferItem;
+        dropItem: TransferItem;
+        dropPosition: number;
+    }) => void;
+}
+export interface TransferListProps extends Pick<TransferProps, 'prefixCls' | 'style' | 'className' | 'dataSource' | 'disabled' | 'draggable' | 'render' | 'filterOption' | 'virtualListProps' | 'onSearch' | 'onResetData' | 'onDragStart' | 'onDragEnd' | 'onDragLeave' | 'onDragOver' | 'onDrop'> {
+    searchPlaceholder?: string;
+    showSearch?: boolean | InputProps;
+    showFooter?: boolean | ReactNode;
+    pagination?: boolean | PaginationProps;
+    title: TransferListTitle;
+    allowClear: boolean;
+    selectedKeys: string[];
+    validKeys: string[];
+    selectedDisabledKeys: string[];
+    listType: TransferListType;
+    handleSelect: (newSelectKeys: string[]) => void;
+    handleRemove: (removeKeys: string[]) => void;
+    renderList: (props: TransferCustomListProps) => ReactNode;
+    renderHeaderUnit: (countSelected: any, countAll: any) => ReactNode;
+}
+export interface TransferCustomListProps extends Pick<TransferListProps, 'disabled' | 'listType' | 'selectedKeys' | 'validKeys' | 'selectedDisabledKeys'> {
+    filteredItems: TransferItem[];
+    onItemSelect: (key: string, selected: boolean) => void;
+    onItemRemove: (key: string) => void;
+    onItemSelectAll: (keys: string[], selected: boolean) => void;
+}
+export interface TransferItemProps extends Pick<TransferListProps, 'prefixCls' | 'className' | 'render' | 'disabled' | 'draggable' | 'allowClear' | 'selectedKeys' | 'onDragStart' | 'onDragEnd' | 'onDragLeave' | 'onDragOver'> {
+    item: TransferItem;
+    droppable: boolean;
+    onItemSelect: (key: string, selected: boolean) => void;
+    onItemRemove: (key: string) => void;
+    onDrop?: (e: DragEvent<HTMLSpanElement>, item: TransferItem, dropPosition: number) => void;
+}
+export {};

package/types/transfer/style/index.d.ts

@@ -0,0 +1,6 @@
+import '../../button/style';
+import '../../checkbox/style';
+import '../../input/style';
+import '../../list/style';
+import '../../style/index.less';
+import './index.less';

package/types/tree/Animation.d.ts

@@ -0,0 +1,4 @@
+import { PropsWithChildren } from 'react';
+import type { NodeProps } from './interface';
+declare const TreeAnimation: (props: PropsWithChildren<NodeProps>) => import("react/jsx-dev-runtime").JSX.Element;
+export default TreeAnimation;

package/types/tree/Context.d.ts

@@ -0,0 +1,28 @@
+import { DragEvent } from 'react';
+import { AvailableVirtualListProps } from '../virtual-list';
+import { NodeProps, TreeDataType, TreeProps, TreeState } from './interface';
+export declare const TreeContext: import("react").Context<{
+    icons?: NodeProps['icons'];
+    loadMore?: ((node: NodeProps) => void) | undefined;
+    renderExtra?: TreeProps['renderExtra'];
+    renderTitle?: TreeProps['renderTitle'];
+    virtualListProps?: AvailableVirtualListProps | undefined;
+    onSelect?: ((_key: string, e: any) => void) | undefined;
+    onSelect_?: ((node: NodeProps) => void) | undefined;
+    onCheck?: ((checked: boolean, _key: string, e: any) => void) | undefined;
+    onExpand?: ((expanded: boolean, _key: string) => void) | undefined;
+    onNodeDrop?: ((e: DragEvent<HTMLSpanElement>, nodeProps: NodeProps, dragPosition: 0 | 1 | -1) => void) | undefined;
+    key2nodeProps?: {
+        [key: string]: NodeProps;
+    } | undefined;
+    actionOnClick?: TreeProps['actionOnClick'];
+    getNodeProps?: (<T extends NodeProps | NodeProps[]>(nodes: T, dataSet?: any) => T) | undefined;
+    getTreeState?: (() => TreeState) | undefined;
+    onExpandEnd?: ((key: string) => void) | undefined;
+    onNodeDragStart?: ((e: DragEvent<HTMLSpanElement>, nodeProps: NodeProps) => void) | undefined;
+    onNodeDragEnd?: ((e: DragEvent<HTMLSpanElement>, nodeProps: NodeProps) => void) | undefined;
+    onNodeDragOver?: ((e: DragEvent<HTMLSpanElement>, nodeProps: NodeProps, position: any) => void) | undefined;
+    onNodeDragLeave?: ((e: DragEvent<HTMLSpanElement>, nodeProps: NodeProps) => void) | undefined;
+    allowDrop?: ((nodeProps: NodeProps, dragPosition: 0 | 1 | -1) => boolean) | undefined;
+    getFieldInfo?: ((nodeProps: NodeProps) => TreeDataType) | undefined;
+}>;

package/types/tree/Node.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { NodeProps } from './interface';
+export interface NodeState {
+    isDragOver?: boolean;
+    dragPosition: 0 | -1 | 1;
+    isDragging?: boolean;
+    isAllowDrop?: boolean;
+}
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<NodeProps & {
+    children?: React.ReactNode;
+} & React.RefAttributes<HTMLDivElement>>>;
+export default _default;

package/types/tree/NodeList.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("react").ForwardRefExoticComponent<Omit<any, "ref"> & import("react").RefAttributes<unknown>>;
+export default _default;

package/types/tree/Tree.d.ts

@@ -0,0 +1,73 @@
+import React, { Component, DragEvent } from 'react';
+import { ConfigContext } from '../config-provider';
+import type { NodeInstance, NodeProps, TreeDataType, TreeProps, TreeState } from './interface';
+export type key2nodePropsType = {
+    [key: string]: TreeDataType;
+};
+declare const needMergeKeys: readonly ["style", "className", "height", "size", "blockNode", "autoExpandParent", "checkedStrategy", "fieldNames", "icons", "virtualListProps", "showLine", "selectable", "allowDrop", "actionOnClick"];
+type MergedPropsType = {
+    [key in (typeof needMergeKeys)[number]]?: TreeProps[key];
+};
+declare class Tree extends Component<TreeProps, TreeState> {
+    static displayName: string;
+    static SHOW_PARENT: "parent";
+    static SHOW_ALL: "all";
+    static SHOW_CHILD: "child";
+    static Node: React.MemoExoticComponent<React.ForwardRefExoticComponent<NodeProps & {
+        children?: React.ReactNode;
+    } & React.RefAttributes<HTMLDivElement>>>;
+    static contextType: React.Context<import("../config-provider").ConfigProviderProps>;
+    context: React.ContextType<typeof ConfigContext>;
+    static getDerivedStateFromProps(nextProps: TreeProps, state: TreeState): TreeState | null;
+    key2nodeProps: key2nodePropsType;
+    dragNode: null | NodeInstance;
+    nodeListRef: any;
+    dropPosition: 0 | -1 | 1;
+    getMergedProps: (baseProps?: any) => MergedPropsType;
+    constructor(props: any, context: any);
+    scrollIntoView: (_index: number | string, nodeProps?: NodeProps) => void;
+    componentDidUpdate(prevProps: any): void;
+    getTreeData: () => any;
+    needUpdateTreeData: (prevProps: any, props: any) => boolean;
+    getFieldInfo: (data: any) => {
+        children: any;
+        selectable: any;
+        checkable: any;
+        title: any;
+        disabled: any;
+        disableCheckbox: any;
+        isLeaf: any;
+        key: any;
+    };
+    getNodeList: (treedata: any, prefix?: any) => never[];
+    getInitExpandedKeys: (keys: any) => any;
+    getInitCheckedKeys: (keys: any) => {
+        checkedKeys: any;
+        halfCheckedKeys: string[];
+    };
+    handleSelect: (key: string, e: any) => void;
+    handleCheck: (checked: boolean, key: string, e: any) => void;
+    handleLoadMore: (node: NodeProps) => void;
+    handleNodeDragStart: (e: DragEvent<HTMLSpanElement>, node: NodeProps) => void;
+    handleNodeDragEnd: (e: DragEvent<HTMLSpanElement>, node: NodeProps) => void;
+    handleNodeDragOver: (e: DragEvent<HTMLSpanElement>, node: NodeProps, dropPosition: any) => void;
+    handleNodeDragLeave: (e: DragEvent<HTMLSpanElement>, node: NodeProps) => void;
+    isChildOfNode: (node: NodeProps, target: any) => true | undefined;
+    isSameNode: (node1: NodeInstance, node2: NodeInstance) => boolean;
+    handleNodeDrop: (e: DragEvent<HTMLSpanElement>, node: NodeProps, dropPosition: number) => void;
+    handleAllowDrop: (node: NodeProps, dropPosition: number) => boolean;
+    handleExpand: (expanded: boolean, key: string) => void;
+    getCacheNode: (key: string[]) => NodeInstance[];
+    getDataSet: (dataSet?: any) => {
+        expandedKeysSet: any;
+        checkedKeysSet: any;
+        selectedKeysSet: any;
+        halfCheckedKeysSet: any;
+    };
+    getNodeProps: <T extends NodeProps | NodeProps[]>(nodes: T, dataSet?: any) => T;
+    handleExpandEnd: (key: any) => void;
+    getTreeState: () => Readonly<TreeState>;
+    render(): import("react/jsx-dev-runtime").JSX.Element;
+}
+export default Tree;
+export type { NodeProps as TreeNodeProps, TreeProps };

package/types/tree/index.d.ts

@@ -0,0 +1,8 @@
+import './style';
+import Tree from './Tree';
+export default Tree;
+import type { TreeDataType } from './interface';
+export type { TreeDataType, NodeProps as TreeNodeProps, TreeProps, } from './interface';
+export type key2nodePropsType = {
+    [key: string]: TreeDataType;
+};