@unicom-cloud/ui 0.8.45 → 0.8.47

package/types/pc/tabs/Tab.d.ts

@@ -0,0 +1,19 @@
+import React, { ReactElement } from 'react';
+import TabPane, { TabPaneProps, TabPaneType } from './TabPane';
+import type { TabsProps } from './interface';
+export declare const TabsContext: React.Context<TabsProps & {
+    getIdPrefix?: (suffix?: number | string) => {
+        tab: string;
+        tabpane: string;
+    };
+    paneChildren?: ReactElement<TabPaneProps, TabPaneType>[];
+    prefixCls?: string;
+}>;
+declare const ForwardRefTabs: React.ForwardRefExoticComponent<TabsProps & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<unknown>>;
+declare const TabsComponent: typeof ForwardRefTabs & {
+    TabPane: typeof TabPane;
+};
+export default TabsComponent;
+export type { TabsProps };

package/types/pc/tabs/index.d.ts

@@ -0,0 +1,3 @@
+import Tabs from './Tab';
+export default Tabs;
+export type { TabPaneProps, TabsProps } from './interface';

package/types/pc/tabs/util.d.ts

@@ -0,0 +1,12 @@
+export declare const getRectDiff: (node: HTMLElement, parentNode: HTMLElement) => {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+export declare const updateScrollOffset: (parentNode: HTMLElement, direction: "horizontal" | "vertical") => void;
+export declare const getKeyDownEvent: ({ onPressEnter }: {
+    onPressEnter: any;
+}) => {
+    onKeyDown: (e: any) => void;
+};

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

@@ -0,0 +1,4 @@
+import type { TagProps } from './interface';
+declare const TagComponent: import("react").ForwardRefExoticComponent<TagProps & import("react").RefAttributes<unknown>>;
+export default TagComponent;
+export type { TagProps };

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

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

package/types/pc/timeline/Item.d.ts

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

package/types/pc/timeline/Timeline.d.ts

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

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+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/pc/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;
+    renderExtra?: TreeProps["renderExtra"];
+    renderTitle?: TreeProps["renderTitle"];
+    virtualListProps?: AvailableVirtualListProps;
+    onSelect?: (_key: string, e: any) => void;
+    onSelect_?: (node: NodeProps) => void;
+    onCheck?: (checked: boolean, _key: string, e: any) => void;
+    onExpand?: (expanded: boolean, _key: string) => void;
+    onNodeDrop?: (e: DragEvent<HTMLSpanElement>, nodeProps: NodeProps, dragPosition: 0 | 1 | -1) => void;
+    key2nodeProps?: {
+        [key: string]: NodeProps;
+    };
+    actionOnClick?: TreeProps["actionOnClick"];
+    getNodeProps?: <T extends NodeProps | NodeProps[]>(nodes: T, dataSet?: any) => T;
+    getTreeState?: () => TreeState;
+    onExpandEnd?: (key: string) => void;
+    onNodeDragStart?: (e: DragEvent<HTMLSpanElement>, nodeProps: NodeProps) => void;
+    onNodeDragEnd?: (e: DragEvent<HTMLSpanElement>, nodeProps: NodeProps) => void;
+    onNodeDragOver?: (e: DragEvent<HTMLSpanElement>, nodeProps: NodeProps, position: any) => void;
+    onNodeDragLeave?: (e: DragEvent<HTMLSpanElement>, nodeProps: NodeProps) => void;
+    allowDrop?: (nodeProps: NodeProps, dragPosition: 0 | 1 | -1) => boolean;
+    getFieldInfo?: (nodeProps: NodeProps) => TreeDataType;
+}>;

package/types/pc/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 | undefined;
+} & React.RefAttributes<HTMLDivElement>>>;
+export default _default;

package/types/pc/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 | undefined;
+    } & 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/pc/tree/index.d.ts

@@ -0,0 +1,7 @@
+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;
+};

package/types/pc/tree-select/Select.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import Tree from '../tree';
+import { RefTreeSelectType, TreeSelectProps } from './interface';
+declare const ForwardRefTreeSelect: import("react").ForwardRefExoticComponent<TreeSelectProps & {
+    children?: ReactNode | undefined;
+} & import("react").RefAttributes<RefTreeSelectType>>;
+declare const TreeSelectComponent: typeof ForwardRefTreeSelect & {
+    Node: typeof Tree.Node;
+    SHOW_ALL: typeof Tree.SHOW_ALL;
+    SHOW_PARENT: typeof Tree.SHOW_PARENT;
+    SHOW_CHILD: typeof Tree.SHOW_CHILD;
+};
+export default TreeSelectComponent;

package/types/pc/tree-select/hook/useStateValue.d.ts

@@ -0,0 +1,19 @@
+import { MutableRefObject } from 'react';
+import { LabelValue, TreeSelectProps } from '../../tree-select/interface';
+import { NodeProps } from '../../tree/interface';
+import { KeyCacheType } from './useKeyCache';
+type valueType = (string | LabelValue)[];
+export interface TreeSelectState {
+    value: valueType[];
+    popupVisible: boolean;
+    focused: boolean;
+    inputValue: string;
+    searchKeys: string[];
+}
+export declare const parseValue: (v: valueType, key2nodeProps: any, valueMap?: LabelValue[]) => LabelValue[];
+declare const useStateValue: (props: TreeSelectProps, key2nodeProps: KeyCacheType, indeterminateKeys: MutableRefObject<string[]>) => [LabelValue[], (v: LabelValue[], extra: {
+    trigger?: NodeProps;
+    checked?: boolean;
+    selected?: boolean;
+}) => void];
+export default useStateValue;

package/types/pc/tree-select/index.d.ts

@@ -0,0 +1,3 @@
+import TreeSelect from './Select';
+export default TreeSelect;
+export type { RefTreeSelectType, TreeSelectProps } from './interface';

package/types/pc/trigger/getPopupStyle.d.ts

@@ -0,0 +1,20 @@
+import { CSSProperties } from 'react';
+import { MouseLocationType, TriggerProps } from './interface';
+export declare const getBoundingClientRect: (dom: any, options: {
+    boundaryDistance?: TriggerProps["boundaryDistance"];
+    position: TriggerProps["position"];
+}) => {
+    width: any;
+    height: any;
+    left: any;
+    right: any;
+    top: any;
+    bottom: any;
+};
+type ReturnType = {
+    style?: CSSProperties;
+    arrowStyle?: CSSProperties;
+    realPosition?: TriggerProps['position'];
+};
+declare const _default: (props: TriggerProps, content: HTMLElement, child: HTMLElement, mountContainer: Element, mouseLocation: MouseLocationType) => ReturnType;
+export default _default;

package/types/pc/trigger/index.d.ts

@@ -0,0 +1,128 @@
+import React, { CSSProperties, PropsWithChildren, PureComponent, RefObject } from 'react';
+import { ConfigContext } from '../config-provider';
+import type { MouseLocationType, TriggerProps } from './interface';
+export { TriggerProps };
+declare function getDOMPos(dom: HTMLElement, options: {
+    boundaryDistance: TriggerProps['boundaryDistance'];
+    position: TriggerProps['position'];
+}): {
+    width?: undefined;
+    height?: undefined;
+    left?: undefined;
+    right?: undefined;
+} | {
+    width: any;
+    height: any;
+    left: any;
+    right: any;
+};
+export interface TriggerState {
+    popupVisible: boolean;
+    popupStyle: object;
+}
+export declare const EventsByTriggerNeed: string[];
+export type EventsByTriggerNeedType = 'onClick' | 'onMouseEnter' | 'onMouseLeave' | 'onMouseMove' | 'onFocus' | 'onBlur' | 'onContextMenu' | 'onKeyDown';
+declare class Trigger extends PureComponent<TriggerProps, TriggerState> {
+    static displayName: string;
+    static contextType: React.Context<import("../config-provider").ConfigProviderProps>;
+    context: React.ContextType<typeof ConfigContext>;
+    static getDerivedStateFromProps(nextProps: any, state: any): {
+        popupVisible: any;
+    } | null;
+    popupContainer: any;
+    rootElementRef: any;
+    triggerRef: RefObject<HTMLSpanElement | null>;
+    triggerRefDestoried: boolean;
+    delayTimer: any;
+    updatePositionTimer: any;
+    realPosition: string;
+    arrowStyle: CSSProperties;
+    popupOpen: boolean;
+    mousedownToHide: boolean;
+    mouseDownTimeout: any;
+    hasPopupMouseDown: boolean;
+    handleClickOutside: boolean;
+    handleWindowResize: boolean;
+    unmount: boolean;
+    isDidMount: boolean;
+    mouseLocation: MouseLocationType;
+    observerContainer: null;
+    scrollElements: (HTMLElement | Window)[];
+    resizeObserver: ResizeObserver;
+    resizeObserver2: ResizeObserver;
+    onResizeObserver2: () => void;
+    offResizeObserver2: () => void;
+    resizeObserver3: ResizeObserver | null;
+    onResizeObserver3: () => void;
+    offResizeObserver3: () => void;
+    childrenDom: null;
+    childrenDomSize: ReturnType<typeof getDOMPos>;
+    getMergedProps: (basePropsOrKeys?: any) => PropsWithChildren<TriggerProps>;
+    constructor(props: any, context: any);
+    getRootElement: () => HTMLElement;
+    getPopupElement: () => HTMLSpanElement | null;
+    componentDidMount(): void;
+    componentDidUpdate(_prevProps: any): void;
+    componentWillUnmount(): void;
+    offScrollListeners: () => void;
+    offWindowResize: () => void;
+    offContainerResize: () => void;
+    handleScroll: () => void;
+    onContainersScroll: (props: TriggerProps) => void;
+    onContainerResize: () => void;
+    handleUpdatePosition: {
+        (...args: any[]): void;
+        cancel(): void;
+    };
+    isClickTrigger: () => boolean;
+    isFocusTrigger: () => boolean;
+    isHoverTrigger: () => boolean;
+    isContextMenuTrigger: () => boolean;
+    isMouseLeaveToClose: () => boolean | undefined;
+    isPopupHoverHide: () => boolean;
+    isClickToHide: () => boolean | undefined;
+    isBlurToHide: () => boolean | undefined;
+    clearTimer: () => void;
+    offClickOutside: () => void;
+    getTransformOrigin: (position: any) => {
+        transformOrigin?: undefined;
+    } | {
+        transformOrigin: any;
+    };
+    getTransformTranslate: () => "" | "scaleY(0.9) translateY(-4px)" | "scaleY(0.9) translateY(4px)";
+    getPopupStyle: () => any;
+    showPopup: (callback?: () => void) => void;
+    update: {
+        (...args: any[]): void;
+        cancel(): void;
+    };
+    getRootDOMNode: () => HTMLElement;
+    updatePopupPosition: (delay?: number, callback?: () => void) => void;
+    setPopupVisible: (visible: boolean, delay?: number, callback?: () => void) => void;
+    delayToDo: (delay: number, callback: () => void) => void;
+    clearDelayTimer(): void;
+    onClickOutside: (e: any) => void;
+    onKeyDown: (e: any) => void;
+    onPressEsc: (e: any) => void;
+    onMouseEnter: (e: any) => void;
+    onMouseMove: (e: any) => void;
+    onMouseLeave: (e: any) => void;
+    onPopupMouseEnter: () => void;
+    onPopupMouseLeave: (e: any) => void;
+    setMouseLocation: (e: any) => void;
+    onContextMenu: (e: any) => void;
+    clickToHidePopup: (e: any) => void;
+    onClick: (e: any) => void;
+    onFocus: (e: any) => void;
+    onBlur: (e: any) => void;
+    onResize: () => void;
+    onPopupMouseDown: () => void;
+    getChild: () => string | number | true | Iterable<React.ReactNode> | import("react/jsx-dev-runtime").JSX.Element;
+    rafId: number;
+    appendToContainer: (node: HTMLDivElement) => void;
+    getContainer: () => HTMLDivElement;
+    triggerPropsEvent: (eventName: EventsByTriggerNeedType, e: any) => void;
+    triggerOriginEvent: (eventName: EventsByTriggerNeedType) => any;
+    render(): import("react/jsx-dev-runtime").JSX.Element | null;
+}
+export default Trigger;

package/types/pc/trigger/style/index.d.ts

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

package/types/pc/typography/Base.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { TypographyParagraphProps, TypographyTitleProps } from './interface';
+declare const _default: React.ForwardRefExoticComponent<TypographyParagraphProps & TypographyTitleProps & import("./interface").CommonProps & {
+    children?: React.ReactNode | undefined;
+} & {
+    componentType: "Title" | "Paragraph" | "Text";
+} & React.RefAttributes<unknown>>;
+export default _default;

package/types/pc/typography/Ellipsis.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { TypographyEllipsisProps } from './interface';
+declare const Ellipsis: React.ForwardRefExoticComponent<TypographyEllipsisProps & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<unknown>>;
+export default Ellipsis;

package/types/pc/typography/index.d.ts

@@ -0,0 +1,13 @@
+import Ellipsis from './Ellipsis';
+import Paragraph from './Paragraph';
+import Text from './Text';
+import Title from './Title';
+import OriginTypography from './Typography';
+declare const Typography: typeof OriginTypography & {
+    Title: typeof Title;
+    Text: typeof Text;
+    Paragraph: typeof Paragraph;
+    Ellipsis: typeof Ellipsis;
+};
+export default Typography;
+export type { EllipsisConfig, TypographyEllipsisProps, TypographyParagraphProps, TypographyProps, TypographyTextProps, TypographyTitleProps, } from './interface';

package/types/pc/upload/TriggerNode.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { TriggerProps } from './interface';
+declare const _default: React.ForwardRefExoticComponent<TriggerProps & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<HTMLDivElement>>;
+export default _default;

package/types/pc/upload/Upload.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { type UploadInstance, type UploadItem, type UploadProps } from './interface';
+export type UploadState = {
+    uploadState: {
+        [key: string]: UploadItem;
+    };
+};
+declare const UploadRef: React.ForwardRefExoticComponent<UploadProps & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<UploadInstance>>;
+export default UploadRef;
+export { UploadItem, UploadProps };

package/types/pc/upload/index.d.ts

@@ -0,0 +1,3 @@
+import Upload from './Upload';
+export default Upload;
+export type { RequestOptions, UploadInstance, UploadItem, UploadListProps, UploadProps, UploadRequestReturn, UploadStatus, } from './interface';

package/types/pc/upload/list/PictureItem.d.ts

@@ -0,0 +1,8 @@
+import { ConfigProviderProps } from '../../config-provider';
+import { UploadItem } from '../../upload/Upload';
+import { UploadListProps } from '../../upload/interface';
+declare const _default: import("react").ForwardRefExoticComponent<UploadListProps & {
+    file: UploadItem;
+    locale: ConfigProviderProps["locale"];
+} & import("react").RefAttributes<HTMLDivElement>>;
+export default _default;

package/types/pc/upload/list/TextItem.d.ts

@@ -0,0 +1,8 @@
+import { ConfigProviderProps } from '../../config-provider';
+import { UploadItem } from '../../upload/Upload';
+import { UploadListProps } from '../../upload/interface';
+declare const _default: import("react").ForwardRefExoticComponent<UploadListProps & {
+    file: UploadItem;
+    locale: ConfigProviderProps["locale"];
+} & import("react").RefAttributes<HTMLDivElement>>;
+export default _default;

package/types/pc/upload/util.d.ts

@@ -0,0 +1,4 @@
+import { UploadProps } from './interface';
+export declare const isAcceptFile: (file: File, propsAccept?: UploadProps["accept"]) => boolean;
+export declare const getFiles: (fileList: any, accept: any) => never[] | undefined;
+export declare const loopDirectory: (items: DataTransferItemList, accept: any, callback: any) => void;

package/types/pc/utils/copy.d.ts

@@ -0,0 +1,2 @@
+export default copy;
+import copy from '@unicom-cloud/utils/clipboard-copy';

package/types/pc/utils/names.d.ts

@@ -0,0 +1,83 @@
+export namespace COMPONENT_NAMES {
+    let Affix: string;
+    let Alert: string;
+    let Anchor: string;
+    let AutoComplete: string;
+    let Avatar: string;
+    let BackTop: string;
+    let Badge: string;
+    let Breadcrumb: string;
+    let Button: string;
+    let Calendar: string;
+    let Card: string;
+    let Carousel: string;
+    let Cascader: string;
+    let Checkbox: string;
+    let Collapse: string;
+    let Comment: string;
+    let ConfigConsumer: string;
+    let ConfigContext: string;
+    let ConfigProvider: string;
+    let Copy: string;
+    let DatePicker: string;
+    let Descriptions: string;
+    let Divider: string;
+    let Drawer: string;
+    let Dropdown: string;
+    let Empty: string;
+    let Form: string;
+    let Grid: string;
+    let Col: string;
+    let Row: string;
+    let Icon: string;
+    let Image: string;
+    let Input: string;
+    let InputNumber: string;
+    let InputTag: string;
+    let Layout: string;
+    let Link: string;
+    let List: string;
+    let Mentions: string;
+    let Menu: string;
+    let Message: string;
+    let Modal: string;
+    let Notification: string;
+    let PageHeader: string;
+    let Pagination: string;
+    let Popconfirm: string;
+    let Popover: string;
+    let Portal: string;
+    let Progress: string;
+    let Qrcode: string;
+    let ColorPicker: string;
+    let IconHover: string;
+    let Loading: string;
+    let Radio: string;
+    let Rate: string;
+    let ResizeBox: string;
+    let Result: string;
+    let Select: string;
+    let Skeleton: string;
+    let Slider: string;
+    let Space: string;
+    let SpeechSynthesis: string;
+    let Spin: string;
+    let Statistic: string;
+    let Steps: string;
+    let SuspenseFallbackTest: string;
+    let Switch: string;
+    let Table: string;
+    let Tabs: string;
+    let Tag: string;
+    let TimePicker: string;
+    let Timeline: string;
+    let Tooltip: string;
+    let Transfer: string;
+    let Tree: string;
+    let TreeSelect: string;
+    let Trigger: string;
+    let Typography: string;
+    let Upload: string;
+    let VerificationCode: string;
+    let Watermark: string;
+}

package/types/pc/utils/saveAs.d.ts

@@ -0,0 +1,2 @@
+export default saveAs;
+import saveAs from '@unicom-cloud/utils/file/saveAs';

package/types/pc/utils/type.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+export type Tag = string | typeof React.Component;
+export type ValueOrFunc<T> = T | ((any: any) => T);
+declare const _default: {};
+export default _default;

package/types/pc/verification-code/index.d.ts

@@ -0,0 +1,4 @@
+import { VerificationCodeProps } from './interface';
+import VerificationCode from './VerificationCode';
+export type { VerificationCodeProps };
+export default VerificationCode;

package/types/pc/version/index.d.ts

@@ -0,0 +1,2 @@
+export declare const version = "2.63.1";
+export default version;

package/types/pc/virtual-list/index.d.ts

@@ -0,0 +1,3 @@
+import VirtualList from './VirtualList';
+export default VirtualList;
+export type { AvailableVirtualListProps, RenderFunc, VirtualListHandle, } from './VirtualList';

package/types/pc/virtual-list/style/index.d.ts

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

package/types/pc/watermark/index.d.ts

@@ -0,0 +1,4 @@
+import { WatermarkProps } from './interface';
+import Watermark from './Watermark';
+export { type WatermarkProps };
+export default Watermark;

package/types/pc/watermark/style/index.d.ts

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