@unicom-cloud/ui 0.8.41

package/types/typography/interface.d.ts

@@ -0,0 +1,97 @@
+import React, { CSSProperties, ReactNode } from 'react';
+import { TooltipProps } from '../tooltip';
+export interface TypographyProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    children?: ReactNode;
+}
+export interface OperationsProps extends Omit<React.HTMLAttributes<HTMLElement>, 'className'> {
+    copyable?: boolean | {
+        text?: string;
+        onCopy?: (text: string, e: any) => void;
+        icon?: ReactNode;
+        tooltips?: [ReactNode, ReactNode];
+        tooltipProps?: TooltipProps;
+    };
+    editable?: boolean | {
+        editing?: boolean;
+        tooltipProps?: TooltipProps;
+        onStart?: (text: any, e: any) => void;
+        onChange?: (text: any) => void;
+        onEnd?: (text: any) => void;
+    };
+    ellipsis?: boolean | EllipsisConfig;
+    isEllipsis?: boolean;
+    expanding?: boolean;
+    onClickExpand?: (e: any) => void;
+    setEditing?: (editing: boolean) => void;
+    forceShowExpand?: boolean;
+    currentContext: Record<string, any>;
+}
+export interface CommonProps extends Omit<OperationsProps, 'currentContext'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    children?: ReactNode;
+    type?: 'primary' | 'secondary' | 'success' | 'error' | 'warning';
+    bold?: boolean;
+    disabled?: boolean;
+    mark?: boolean | {
+        color: string;
+    };
+    underline?: boolean;
+    delete?: boolean;
+    code?: boolean;
+}
+export interface TypographyTitleProps extends CommonProps {
+    heading?: 1 | 2 | 3 | 4 | 5 | 6;
+}
+export interface TypographyParagraphProps extends CommonProps {
+    blockquote?: boolean;
+    spacing?: 'default' | 'close';
+}
+export interface EditContentProps {
+    prefixCls?: string;
+    style?: CSSProperties;
+    className?: string | string[];
+    children?: ReactNode;
+    setEditing?: (editing: boolean) => void;
+    editableConfig?: {
+        editing?: boolean;
+        onStart?: (text: any, e: any) => void;
+        onChange?: (text: any) => void;
+        onEnd?: (text: any) => void;
+    };
+}
+export type TypographyTextProps = CommonProps;
+export type EllipsisConfig = {
+    cssEllipsis?: boolean;
+    rows?: number;
+    expandable?: boolean;
+    ellipsisStr?: string;
+    suffix?: string;
+    expandNodes?: ReactNode[];
+    onEllipsis?: (isEllipsis: boolean) => void;
+    onExpand?: (isExpand: boolean, e: any) => void;
+    showTooltip?: boolean | {
+        type?: 'tooltip' | 'popover';
+        props?: Record<string, any>;
+    };
+    expanded?: boolean;
+    defaultExpanded?: boolean;
+    wrapper?: string | React.FC<any> | React.ComponentClass<any>;
+};
+export interface TypographyEllipsisProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    rows?: number;
+    disabled?: boolean;
+    showTooltip?: boolean | TooltipProps;
+    expandable?: boolean | {
+        single?: boolean;
+    };
+    expandRender?: (expanded: boolean) => ReactNode;
+    defaultExpanded?: boolean;
+    expanded?: boolean;
+    onExpand?: (isExpand: boolean, ev: Event) => void;
+    onEllipsis?: (isEllipsis: boolean) => void;
+}

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

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

package/types/typography/useCssEllipsis.d.ts

@@ -0,0 +1,6 @@
+import type { EllipsisConfig } from './interface';
+declare function useCssEllipsis(props: EllipsisConfig): {
+    simpleEllipsis: boolean;
+    ellipsisStyle: {};
+};
+export default useCssEllipsis;

package/types/typography/useEllipsis.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import type { EllipsisConfig } from './interface';
+interface IEllipsis extends EllipsisConfig {
+    width: number;
+    renderMeasureContent: (slicedNode: any, isEllipsis: boolean) => React.ReactNode;
+    expanding?: boolean;
+    simpleEllipsis?: boolean;
+}
+export declare enum MEASURE_STATUS {
+    INIT = 0,
+    BEFORE_MEASURE = 1,
+    MEASURING = 2,
+    MEASURE_END = 3,
+    NO_NEED_ELLIPSIS = 4
+}
+declare function useEllipsis(props: React.PropsWithChildren<IEllipsis>): {
+    ellipsisNode: any;
+    isEllipsis: boolean;
+    measureStatus: MEASURE_STATUS;
+};
+export default useEllipsis;

package/types/upload/TriggerNode.d.ts

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

package/types/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;
+} & React.RefAttributes<UploadInstance>>;
+export default UploadRef;
+export { UploadItem, UploadProps };

package/types/upload/Uploader.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { UploadItem, UploadRequestReturn, UploaderProps } from './interface';
+export type UploaderType = {
+    upload: (file: UploadItem) => void;
+    abort: (file: UploadItem) => void;
+    delete: (uid: UploadItem['uid']) => void;
+    reupload: (file: UploadItem) => void;
+};
+type UploaderState = {
+    uploadRequests: {
+        [key: string]: UploadRequestReturn;
+    };
+};
+declare const _default: React.ForwardRefExoticComponent<(UploaderProps | UploaderState) & React.RefAttributes<unknown>>;
+export default _default;

package/types/upload/index.d.ts

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

package/types/upload/interface.d.ts

@@ -0,0 +1,126 @@
+import React, { CSSProperties, ReactNode } from 'react';
+import { ProgressProps } from '../progress';
+export declare const STATUS: {
+    [key: string]: UploadStatus;
+};
+export type UploadStatus = 'init' | 'uploading' | 'done' | 'error';
+export type ListType = 'text' | 'picture-list' | 'picture-card';
+export type CustomIconType = {
+    previewIcon?: ReactNode;
+    removeIcon?: ReactNode;
+    fileIcon?: ReactNode;
+    reuploadIcon?: ReactNode;
+    cancelIcon?: ReactNode;
+    startIcon?: ReactNode;
+    errorIcon?: ReactNode;
+    successIcon?: ReactNode;
+    fileName?: (file: UploadItem) => ReactNode;
+    progressRender?: (file: UploadItem, originDom: ReactNode) => React.ReactElement;
+    imageRender?: (file: UploadItem) => React.ReactNode;
+};
+export type RequestOptions = Pick<UploadProps, 'headers' | 'name' | 'data' | 'withCredentials' | 'action' | 'method'> & {
+    onProgress: (percent: number, event?: ProgressEvent) => void;
+    onSuccess: (response?: object) => void;
+    onError: (response?: object) => void;
+    file: File;
+};
+export interface UploadRequestReturn {
+    abort?: () => void;
+    [key: string]: any;
+}
+export type UploadRequest = (options: RequestOptions) => UploadRequestReturn | void;
+export interface UploadProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    defaultFileList?: UploadItem[];
+    fileList?: UploadItem[];
+    directory?: boolean;
+    accept?: string | {
+        type: string;
+        strict?: boolean;
+    };
+    customRequest?: (options: RequestOptions) => UploadRequestReturn | void;
+    listType?: 'text' | 'picture-list' | 'picture-card';
+    imagePreview?: boolean;
+    showUploadList?: boolean | CustomIconType;
+    autoUpload?: boolean;
+    action?: string;
+    method?: string;
+    limit?: number | {
+        maxCount: number;
+        hideOnExceedLimit?: boolean;
+    };
+    disabled?: boolean;
+    drag?: boolean;
+    multiple?: boolean;
+    tip?: string | React.ReactNode;
+    headers?: object;
+    data?: object | ((any: any) => object);
+    name?: string | ((any: any) => string);
+    withCredentials?: boolean;
+    progressProps?: Partial<ProgressProps>;
+    renderUploadItem?: (originNode: ReactNode, file: UploadItem, fileList: UploadItem[]) => ReactNode;
+    renderUploadList?: (fileList: UploadItem[], uploadListProps: UploadListProps) => ReactNode;
+    onChange?: (fileList: UploadItem[], file: UploadItem) => void;
+    onPreview?: (file: UploadItem) => void;
+    onRemove?: (file: UploadItem, fileList: UploadItem[]) => void | boolean | Promise<void | boolean>;
+    onProgress?: (file: UploadItem, e?: ProgressEvent) => void;
+    onReupload?: (file: UploadItem) => void;
+    onExceedLimit?: (files: File[], fileList: UploadItem[]) => void;
+    beforeUpload?: (file: File, filesList: File[]) => boolean | Promise<any>;
+    onDrop?: (e: React.DragEvent) => void;
+    onDragOver?: (e: React.DragEvent) => void;
+    onDragLeave?: (e: React.DragEvent) => void;
+}
+export interface UploadListProps {
+    imagePreview?: boolean;
+    listType?: string;
+    fileList?: UploadItem[];
+    showUploadList?: boolean | CustomIconType;
+    progressProps?: Partial<ProgressProps>;
+    onUpload?: (file: UploadItem) => void;
+    onAbort?: (file: UploadItem) => void;
+    onRemove?: (file: UploadItem) => void | boolean | Promise<void | boolean>;
+    onReupload?: (file: UploadItem) => void;
+    onPreview?: (file: UploadItem) => void;
+    disabled?: boolean;
+    renderUploadItem?: (originNode: ReactNode, file: UploadItem, fileList: UploadItem[]) => ReactNode;
+    renderUploadList?: (fileList: UploadItem[], uploadListProps: Omit<UploadListProps, 'renderUploadList'>) => ReactNode;
+    prefixCls?: string;
+}
+export type UploadItem = {
+    uid: string;
+    status?: UploadStatus;
+    originFile?: File;
+    percent?: number;
+    response?: object;
+    url?: string;
+    name?: string;
+    children?: ReactNode;
+};
+export interface UploaderProps extends UploadProps {
+    prefixCls?: string;
+    limit?: number;
+    hide?: boolean;
+    onFileStatusChange?: (fileList: UploadItem[], file: UploadItem) => void;
+}
+export type TriggerProps = {
+    tip?: string | React.ReactNode;
+    multiple?: boolean;
+    accept?: UploadProps['accept'];
+    disabled?: boolean;
+    directory?: boolean;
+    drag?: boolean;
+    listType?: 'text' | 'picture-list' | 'picture-card';
+    onClick: () => void;
+    onDrop?: (e: React.DragEvent) => void;
+    onDragLeave?: (e: React.DragEvent) => void;
+    onDragOver?: (e: React.DragEvent) => void;
+    onDragFiles: (files: File[]) => void;
+    prefixCls?: string;
+};
+export type UploadInstance = {
+    submit: (file?: UploadItem) => void;
+    abort: (file: UploadItem) => void;
+    reupload: (file: UploadItem) => void;
+};

package/types/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 PictureItem: (props: UploadListProps & {
+    file: UploadItem;
+    locale: ConfigProviderProps['locale'];
+}) => import("react/jsx-dev-runtime").JSX.Element;
+export default PictureItem;

package/types/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 TextItem: (props: UploadListProps & {
+    file: UploadItem;
+    locale: ConfigProviderProps['locale'];
+}) => import("react/jsx-dev-runtime").JSX.Element;
+export default TextItem;

package/types/upload/list/UploadProgress.d.ts

@@ -0,0 +1,14 @@
+import { FC } from 'react';
+import { ProgressProps } from '../../progress';
+import { UploadItem } from '../../upload/Upload';
+import { CustomIconType, UploadListProps } from '../../upload/interface';
+declare const UploadProgress: FC<{
+    listType?: UploadListProps['listType'];
+    file: UploadItem;
+    prefixCls: string | undefined;
+    progressProps?: Partial<ProgressProps>;
+    onReupload?: UploadListProps['onReupload'];
+    onUpload?: UploadListProps['onUpload'];
+    onAbort?: UploadListProps['onAbort'];
+} & CustomIconType>;
+export default UploadProgress;

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

@@ -0,0 +1,6 @@
+import { UploadListProps } from '../../upload/interface';
+export declare const FileList: {
+    (props: UploadListProps): import("react/jsx-dev-runtime").JSX.Element;
+    displayName: string;
+};
+export default FileList;

package/types/upload/request.d.ts

@@ -0,0 +1,3 @@
+import { UploadRequest } from './interface';
+declare const uploadRequest: UploadRequest;
+export default uploadRequest;

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

@@ -0,0 +1,6 @@
+import '../../button/style';
+import '../../image/style';
+import '../../progress/style';
+import '../../style/index.less';
+import '../../tooltip/style';
+import './index.less';

package/types/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/utils/className.d.ts

@@ -0,0 +1,2 @@
+import className from '@unicom-cloud/utils/class-name';
+export default className;

package/types/utils/constant.d.ts

@@ -0,0 +1,3 @@
+export declare const NOOP: () => void;
+export declare function newArray(length: number): unknown[];
+export declare function pickTriggerPropsFromRest(rest: any): Pick<any, "tabIndex" | "onFocus" | "onBlur" | "onClick" | "onContextMenu" | "onMouseEnter" | "onMouseLeave" | "onMouseMove">;

package/types/utils/contextHolder.d.ts

@@ -0,0 +1,9 @@
+import React, { ReactElement } from 'react';
+import { ConfigProviderProps } from '../config-provider';
+export type HolderRef = {
+    addInstance?: (ins: ReactElement) => void;
+    removeInstance?: (ins: ReactElement) => void;
+    getContextConfig?: () => ConfigProviderProps;
+};
+declare const ContextHolderElement: React.ForwardRefExoticComponent<HolderRef & React.RefAttributes<unknown>>;
+export default ContextHolderElement;

package/types/utils/dayjs.d.ts

@@ -0,0 +1,21 @@
+import originDayjs, { Dayjs, OpUnitType, UnitType } from 'dayjs';
+export declare const dayjs: typeof originDayjs;
+export declare const methods: {
+    add(time: any, value: number, unit: UnitType): any;
+    subtract(time: any, value: number, unit: UnitType): any;
+    startOf(time: any, unit?: OpUnitType): any;
+    endOf(time: any, unit?: OpUnitType): any;
+    set(time: any, unit: UnitType, value: number): any;
+    isSameWeek(date1: any, date2: any, weekStart: number, localeName: any): any;
+};
+export declare function timezoneToOffset(inputTs: number, timezone: string): any;
+export declare function getNow(utcOffset?: number, timezone?: string): originDayjs.Dayjs;
+export declare function toTimezone(time: Dayjs, utcOffset?: number, timezone?: string, local?: boolean): Dayjs;
+export declare function toLocal(time: Dayjs, utcOffset?: number, timezone?: string): Dayjs;
+export declare function getTimeFormat(format: any): string;
+export declare function getDayjsValue(time: any, format: string | string[], utcOffset?: number, timezone?: string): originDayjs.Dayjs | (originDayjs.Dayjs | undefined)[] | undefined;
+export declare function getValueWithTime(date: Dayjs, time?: Dayjs): Dayjs;
+export declare function getSortedDayjsArray(values?: Dayjs[]): originDayjs.Dayjs[] | undefined;
+export declare function isDayjsChange(prevValue: Dayjs | undefined, currentValue: Dayjs | undefined): boolean | originDayjs.Dayjs;
+export declare function isDayjsArrayChange(prevValue: Dayjs[] | undefined, currentValue: Dayjs[] | undefined): boolean | originDayjs.Dayjs[];
+export declare function isValidTimeString(str: string, format: string | string[], index?: number): boolean;

package/types/utils/dom.d.ts

@@ -0,0 +1,6 @@
+export declare const isServerRendering: boolean;
+export declare const on: (element: EventTarget | null, event: string, handler: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void;
+export declare const off: (element: EventTarget | null, event: string, handler: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions) => void;
+export declare const contains: (root: HTMLElement, ele: any) => boolean;
+export declare const isScrollElement: (element: HTMLElement) => boolean;
+export declare const getScrollElements: (container: HTMLElement, top?: HTMLElement) => HTMLElement[];

package/types/utils/fillNBSP.d.ts

@@ -0,0 +1 @@
+export default function (str: any): any;

package/types/utils/getHighlightText.d.ts

@@ -0,0 +1,5 @@
+export default function getHighlightText<T>({ nodeList, pattern, highlightClassName, }: {
+    nodeList: T;
+    pattern: string;
+    highlightClassName: string;
+}): T;

package/types/utils/getHotkeyHandler.d.ts

@@ -0,0 +1,8 @@
+export interface Key {
+    code: number | string;
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+}
+export default function getHotkeyHandler(hotkeyMap: Map<Key | number | string, Function>): (e: KeyboardEvent) => void;

package/types/utils/getStringLength.d.ts

@@ -0,0 +1 @@
+export default function getStringLength(str: string): number;

package/types/utils/include.d.ts

@@ -0,0 +1 @@
+export default function include<T extends object, K extends keyof T>(obj: T, keys: Array<K | string>): Partial<T>;

package/types/utils/is.d.ts

@@ -0,0 +1,23 @@
+import { Dayjs } from 'dayjs';
+export declare function isArray(obj: any): obj is any[];
+export declare function isObject(obj: any): obj is {
+    [key: string]: any;
+};
+export declare function isString(obj: any): obj is string;
+export declare function isNumber(obj: any): obj is number;
+export declare function isRegExp(obj: any): boolean;
+export declare function isFile(obj: any): obj is File;
+export declare function isBlob(obj: any): obj is Blob;
+export declare function isColor(color: any): boolean;
+export declare function isValidColor2(color: any): boolean;
+export declare function isValidColor(color: any): boolean;
+export declare function isUndefined(obj: any): obj is undefined;
+export declare function isNull(obj: any): obj is null;
+export declare function isNullOrUndefined(obj: any): boolean;
+export declare function isFunction(obj: any): obj is (...args: any[]) => any;
+export declare function isEmptyObject(obj: any): boolean;
+export declare function isEmptyReactNode(content: any, trim?: boolean): boolean;
+export declare function isExist(obj: any): boolean;
+export declare function isWindow(el: any): el is Window;
+export declare function isDayjs(time: any): time is Dayjs;
+export declare function isBoolean(value: any): value is Boolean;

package/types/utils/keyCode.d.ts

@@ -0,0 +1,45 @@
+export declare const Enter: {
+    key: string;
+    code: string;
+    keyCode: number;
+};
+export declare const Esc: {
+    key: string;
+    code: string;
+    keyCode: number;
+};
+export declare const Backspace: {
+    key: string;
+    code: string;
+    keyCode: number;
+};
+export declare const Tab: {
+    key: string;
+    code: string;
+    keyCode: number;
+};
+export declare const Space: {
+    key: string;
+    code: string;
+    keyCode: number;
+};
+export declare const ArrowUp: {
+    key: string;
+    code: string;
+    keyCode: number;
+};
+export declare const ArrowDown: {
+    key: string;
+    code: string;
+    keyCode: number;
+};
+export declare const ArrowLeft: {
+    key: string;
+    code: string;
+    keyCode: number;
+};
+export declare const ArrowRight: {
+    key: string;
+    code: string;
+    keyCode: number;
+};

package/types/utils/mergeProp.d.ts

@@ -0,0 +1 @@
+export default function mergeProps<PropsType>(_componentProps: PropsType, _defaultProps: Partial<PropsType>, _globalComponentConfig: PropsType, propsNameList?: string[]): Partial<PropsType>;

package/types/utils/mergedToString.d.ts

@@ -0,0 +1 @@
+export default function mergedToString(children: any): string;

package/types/utils/omit.d.ts

@@ -0,0 +1 @@
+export default function omit<T extends object, K extends keyof T>(obj: T, keys: Array<K | string>): Omit<T, K>;

package/types/utils/pad.d.ts

@@ -0,0 +1,2 @@
+export declare function padStart(string: any, length: number, char?: string): any;
+export declare function padEnd(string: any, length: number, char?: string): any;

package/types/utils/pick.d.ts

@@ -0,0 +1,4 @@
+export default function pick<T extends object, K extends keyof T>(o: T, keys: Array<K | string>): Pick<T, K>;
+export declare function pickDataAttributes<T extends object, K extends keyof T>(o: T | undefined): {
+    [key in K]: any;
+};

package/types/utils/raf.d.ts

@@ -0,0 +1,3 @@
+declare let raf: any;
+declare let caf: any;
+export { raf, caf };

package/types/utils/reactDOM.d.ts

@@ -0,0 +1,5 @@
+import { ReactElement } from 'react';
+export declare const render: (app: ReactElement, container: Element | DocumentFragment) => {
+    render: (container: ReactElement) => void;
+    _unmount: () => void;
+};

package/types/utils/responsiveObserve.d.ts

@@ -0,0 +1,15 @@
+export type Breakpoint = 'xxxl' | 'xxl' | 'xl' | 'lg' | 'md' | 'sm' | 'xs';
+export type BreakpointMap = Partial<Record<Breakpoint, string>>;
+export type ScreenMap = Partial<Record<Breakpoint, boolean>>;
+export declare const responsiveArray: Breakpoint[];
+export declare const responsiveMap: BreakpointMap;
+type SubscribeFunc = (screens: ScreenMap, breakpointChecked: Breakpoint) => void;
+declare const responsiveObserve: {
+    matchHandlers: {};
+    dispatch(pointMap: ScreenMap, breakpointChecked: Breakpoint): boolean;
+    subscribe(func: SubscribeFunc): string;
+    unsubscribe(token: string): void;
+    unregister(): void;
+    register(): void;
+};
+export default responsiveObserve;

package/types/utils/scrollIntoView.d.ts

@@ -0,0 +1,2 @@
+import { Options } from '@unicom-cloud/scroll-into-view-if-needed';
+export default function scrollIntoView(node: HTMLElement, options?: Options): void;

package/types/utils/style.d.ts

@@ -0,0 +1,3 @@
+export declare function fixedWidth(width: number | string): object;
+export declare function setTransformStyle(value: string): object;
+export declare function getStyle(element: HTMLElement | null, prop: string | null): any;

package/types/utils/throttleByRaf.d.ts

@@ -0,0 +1,4 @@
+export default function throttleByRaf(cb: (...args: any[]) => void): {
+    (...args: any[]): void;
+    cancel(): void;
+};

package/types/utils/throttleByRafV2.d.ts

@@ -0,0 +1,4 @@
+export default function (cb: (...args: any[]) => void): {
+    (...args: any[]): void;
+    cancel(): void;
+};

package/types/utils/type.d.ts

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

package/types/utils/warning.d.ts

@@ -0,0 +1 @@
+export default function warning(condition: any, message: string): void;

package/types/verification-code/VerificationCode.d.ts

@@ -0,0 +1,7 @@
+import { VerificationCodeProps } from './interface';
+export declare function VerificationCodeComponent(baseProps: VerificationCodeProps, _: any): import("react/jsx-dev-runtime").JSX.Element;
+export declare namespace VerificationCodeComponent {
+    var displayName: string;
+}
+declare const VerificationCode: import("react").ForwardRefExoticComponent<VerificationCodeProps & import("react").RefAttributes<unknown>>;
+export default VerificationCode;

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

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

package/types/verification-code/interface.d.ts

@@ -0,0 +1,25 @@
+import { CSSProperties, ReactNode } from 'react';
+import { InputProps } from '../input';
+export interface VerificationCodeProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    defaultValue?: string;
+    value?: string;
+    length?: number;
+    size?: InputProps['size'];
+    masked?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    status?: 'error';
+    validate?: (data: {
+        inputValue: string;
+        value: string;
+        index: number;
+    }) => boolean | string;
+    separator?: (data: {
+        index: number;
+        character: string;
+    }) => ReactNode;
+    onChange?: (value: string) => void;
+    onFinish?: (value: string) => void;
+}

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

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

package/types/version/index.d.ts

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