@unicom-cloud/ui 0.8.46 → 0.8.48

package/types/pc/form/interface.d.ts

@@ -0,0 +1,228 @@
+import { Options as ScrollIntoViewOptions } from '@unicom-cloud/scroll-into-view-if-needed';
+import { ValidateMessagesTemplateType } from '@unicom-cloud/utils/types/validate';
+import React, { CSSProperties, FormHTMLAttributes, HTMLAttributes, ReactElement, ReactNode } from 'react';
+import { JSX } from 'react/jsx-runtime';
+import { ColProps } from '../grid/Col';
+import type { TooltipProps } from '../tooltip/interface';
+import Store from './store';
+export type IndexedObject = {
+    [key: string]: any;
+};
+export type KeyType = string | number | symbol;
+export type ComponentType = keyof JSX.IntrinsicElements | React.ComponentType<any>;
+export type FieldError<FieldValue = any> = {
+    value?: FieldValue;
+    message?: ReactNode;
+    type?: string;
+    requiredError?: boolean;
+};
+export type ValidateFieldsErrors<FieldValue = any, FieldKey extends KeyType = string> = Record<FieldKey, FieldValue> | undefined | null;
+export interface FormProps<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> extends Omit<FormHTMLAttributes<any>, 'className' | 'onChange' | 'onSubmit' | 'onReset'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    prefixCls?: string;
+    form?: FormInstance<FormData, FieldValue, FieldKey>;
+    id?: string;
+    layout?: 'horizontal' | 'vertical' | 'inline';
+    size?: 'mini' | 'small' | 'default' | 'large';
+    labelCol?: ColProps;
+    wrapperCol?: ColProps;
+    requiredSymbol?: boolean | {
+        position: 'start' | 'end';
+    };
+    labelAlign?: 'left' | 'right';
+    initialValues?: Partial<FormData>;
+    validateTrigger?: string | string[];
+    onValuesChange?: (value: Partial<FormData>, values: Partial<FormData>) => void;
+    onChange?: (value: Partial<FormData>, values: Partial<FormData>) => void;
+    wrapper?: ComponentType;
+    wrapperProps?: IndexedObject;
+    disabled?: boolean;
+    colon?: boolean | ReactNode;
+    scrollToFirstError?: boolean | ScrollIntoViewOptions;
+    validateMessages?: Partial<{
+        [key in keyof ValidateMessagesTemplateType]: ValidateMessagesTemplateType[key] extends string ? ValidateMessagesTemplateType[key] | ((data: any, { label }: {
+            label: any;
+        }) => any) : Partial<Record<keyof ValidateMessagesTemplateType[key], string | ((data: any, { label }: {
+            label: any;
+        }) => any)>>;
+    }>;
+    onSubmit?: (values: FormData) => void;
+    onReset?: (values: FormData) => void;
+    onSubmitFailed?: (errors: {
+        [key: string]: FieldError;
+    }) => void;
+}
+export interface RulesProps<FieldValue = any> {
+    validateTrigger?: string | string[];
+    validateLevel?: 'error' | 'warning';
+    required?: boolean;
+    type?: string;
+    length?: number;
+    maxLength?: number;
+    minLength?: number;
+    includes?: boolean;
+    deepEqual?: any;
+    empty?: boolean;
+    min?: number;
+    max?: number;
+    equal?: number;
+    positive?: boolean;
+    negative?: boolean;
+    hasKeys?: string[];
+    match?: RegExp;
+    uppercase?: boolean;
+    lowercase?: boolean;
+    true?: boolean;
+    false?: boolean;
+    validator?: (value: FieldValue | undefined, callback: (error?: ReactNode) => void) => void;
+    message?: ReactNode;
+}
+export type FormItemChildrenFn<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> = (formData: any, form: FormInstance<FormData, FieldValue, FieldKey>) => React.ReactNode;
+export interface FormItemProps<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> extends Omit<HTMLAttributes<any>, 'className' | 'children'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    prefixCls?: string;
+    store?: FormInstance<FormData, FieldValue, FieldKey>;
+    initialValue?: FieldValue;
+    field?: FieldKey;
+    label?: ReactNode;
+    tooltip?: ReactNode | (TooltipProps & {
+        icon?: ReactElement;
+    });
+    labelCol?: ColProps;
+    wrapperCol?: ColProps;
+    colon?: boolean | ReactNode;
+    disabled?: boolean;
+    rules?: RulesProps<FieldValue>[];
+    trigger?: string;
+    triggerPropName?: string;
+    getValueFromEvent?: (...args: any[]) => FieldValue;
+    validateTrigger?: string | string[];
+    noStyle?: boolean | {
+        showErrorTip: boolean;
+    };
+    required?: boolean;
+    hidden?: boolean;
+    extra?: ReactNode;
+    validateStatus?: 'success' | 'warning' | 'error' | 'validating';
+    hasFeedback?: boolean;
+    help?: ReactNode;
+    normalize?: (value: FieldValue | undefined, prevValue: FieldValue | undefined, allValues: Partial<FormData>) => any;
+    formatter?: (value: FieldValue | undefined) => any;
+    dependencies?: string[];
+    shouldUpdate?: boolean | ((prevValues: Partial<FormData>, currentValues: Partial<FormData>, info: {
+        isFormList?: boolean;
+        field?: FieldKey | FieldKey[];
+        isInner?: boolean;
+    }) => boolean);
+    labelAlign?: 'left' | 'right';
+    layout?: 'horizontal' | 'vertical' | 'inline';
+    requiredSymbol?: boolean | {
+        position: 'start' | 'end';
+    };
+    isFormList?: boolean;
+    children?: React.ReactNode | FormItemChildrenFn<FormData, FieldValue, FieldKey>;
+}
+export interface FormControlProps<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> {
+    field?: FieldKey;
+    _key?: FieldKey;
+    initialValue?: FieldValue;
+    dependencies?: FormItemProps['dependencies'];
+    getValueFromEvent?: FormItemProps['getValueFromEvent'];
+    rules?: RulesProps<FieldValue>[];
+    trigger?: string;
+    triggerPropName?: string;
+    validateTrigger?: string | string[];
+    normalize?: (value: FieldValue | undefined, prevValue: FieldValue | undefined, allValues: Partial<FormData>) => any;
+    formatter?: FormItemProps['formatter'];
+    onValuesChange?: (value: Partial<FormData>, values: Partial<FormData>) => void;
+    noStyle?: boolean;
+    shouldUpdate?: FormItemProps['shouldUpdate'];
+    disabled?: boolean;
+    validateStatus?: 'success' | 'warning' | 'error' | 'validating';
+    help?: ReactNode;
+    isFormList?: boolean;
+    hasFeedback?: boolean;
+    children?: ReactNode;
+}
+export interface FormListProps<SubFieldValue = any, SubFieldKey extends KeyType = string, FieldKey extends KeyType = string> {
+    field: FieldKey;
+    initialValue?: SubFieldValue[];
+    noStyle?: FormItemProps['noStyle'];
+    rules?: RulesProps<SubFieldValue[]>[];
+    children?: (fields: {
+        key: number;
+        field: SubFieldKey;
+    }[], operation: {
+        add: (defaultValue?: SubFieldValue, index?: number) => void;
+        remove: (index: number) => void;
+        move: (fromIndex: number, toIndex: number) => void;
+    }) => React.ReactNode;
+}
+export type FormContextProps<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> = Pick<FormProps<FormData, FieldValue, FieldKey>, 'prefixCls' | 'labelCol' | 'wrapperCol' | 'requiredSymbol' | 'labelAlign' | 'disabled' | 'colon' | 'layout' | 'validateTrigger'> & {
+    validateMessages?: FormProps['validateMessages'];
+    getFormElementId?: (field: FieldKey) => string;
+    store?: FormInstance<FormData, FieldValue, FieldKey>;
+};
+export type FormItemContextProps<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> = FormContextProps<FormData, FieldValue, FieldKey> & {
+    validateMessages?: FormProps['validateMessages'];
+    updateFormItem?: (field: string, params: {
+        errors?: FieldError<FieldValue>;
+        warnings?: ReactNode[];
+    }) => void;
+};
+export type FormInstance<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> = Pick<Store<FormData, FieldValue, FieldKey>, 'getFieldsValue' | 'getFieldValue' | 'getFieldError' | 'getFieldsError' | 'getTouchedFields' | 'getFields' | 'getInitialValues' | 'setInitialValues' | 'setInitialValue' | 'setFieldValue' | 'setFieldsValue' | 'setFields' | 'resetFields' | 'clearFields' | 'submit' | 'validate' | 'getFieldsState'> & {
+    scrollToField: (field: FieldKey, options?: ScrollIntoViewOptions) => void;
+    getInnerMethods: (inner?: boolean) => InnerMethodsReturnType<FormData, FieldValue, FieldKey>;
+};
+export type InnerMethodsReturnType<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> = Pick<Store<FormData, FieldValue, FieldKey>, 'registerField' | 'registerStateWatcher' | 'registerFormWatcher' | 'registerWatcher' | 'innerSetInitialValues' | 'innerSetInitialValue' | 'innerSetCallbacks' | 'innerSetFieldValue' | 'innerGetStore' | 'innerGetStoreStatus' | 'innerCollectFormState' | 'innerGetFieldValue'>;
+export interface ValidateOptions {
+    validateOnly?: boolean;
+}
+export interface FormValidateFn<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> {
+    (): Promise<FormData>;
+    (fields: FieldKey[]): Promise<Partial<FormData>>;
+    (options: ValidateOptions): Promise<Partial<FormData>>;
+    (callback: (errors?: ValidateFieldsErrors<FieldValue, FieldKey>, values?: FormData) => void): void;
+    (fields: FieldKey[], callback: (errors?: ValidateFieldsErrors<FieldValue, FieldKey>, values?: Partial<FormData>) => void): void;
+    (fields: FieldKey[], options: ValidateOptions): Promise<Partial<FormData>>;
+    (options: ValidateOptions, callback: (errors?: ValidateFieldsErrors<FieldValue, FieldKey>, values?: Partial<FormData>) => void): void;
+    (fields: FieldKey[], options: ValidateOptions, callback: (errors?: ValidateFieldsErrors<FieldValue, FieldKey>, values?: Partial<FormData>) => void): void;
+}
+export declare const VALIDATE_STATUS: {
+    error: string;
+    success: string;
+    warning: string;
+    validating: string;
+};
+export interface FormProviderProps {
+    onFormValuesChange?: (id: string | undefined, changedValues: any, { forms, }: {
+        forms: {
+            [key: string]: FormInstance;
+        };
+    }) => void;
+    onFormSubmit?: (id: string | undefined, values: any, { forms, }: {
+        forms: {
+            [key: string]: FormInstance;
+        };
+    }) => void;
+    onFormReset?: (id: string | undefined, values: any, { forms, }: {
+        forms: {
+            [key: string]: FormInstance;
+        };
+    }) => void;
+}
+export type FieldState<FieldValue = any> = {
+    errors: FieldError<FieldValue>[];
+    warnings: ReactNode[];
+    validateStatus: FormItemProps['validateStatus'] | undefined;
+    isSubmitting: boolean;
+    isTouched: boolean;
+};
+export declare enum SubmitStatus {
+    init = "init",
+    error = "error",
+    success = "success",
+    submitting = "submitting"
+}

package/types/pc/form/store.d.ts

@@ -0,0 +1,89 @@
+import React from 'react';
+import Control from './Control';
+import type { FieldError, FieldState, FormProps, FormValidateFn, KeyType } from './interface';
+import { SubmitStatus } from './interface';
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type NotifyType = 'setFieldValue' | 'reset' | 'innerSetValue';
+export type innerCallbackType = 'onValuesChange' | 'onSubmit' | 'onReset' | 'onChange' | 'onSubmitFailed';
+export type StoreChangeInfo<T> = {
+    prev: any;
+    field?: T | T[];
+    isFormList?: boolean;
+    ignore?: boolean;
+    changeValues?: {
+        [key in KeyType]: unknown;
+    };
+    data?: {
+        errors?: FieldError;
+        warnings?: React.ReactNode;
+        touched?: boolean;
+    };
+};
+declare class Store<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> {
+    private submitStatus;
+    private registerFields;
+    private registerWatchers;
+    private registerStateWatchers;
+    private registerFormWatchers;
+    private touchedFields;
+    private store;
+    private initialValues;
+    private callbacks;
+    private notifyWatchers;
+    private notifyFormWatcher;
+    private notifyStateWatchers;
+    private triggerValuesChange;
+    private triggerTouchChange;
+    innerCollectFormState: () => void;
+    innerSetCallbacks: (values: Pick<FormProps<FormData, FieldValue, FieldKey>, innerCallbackType> & {
+        onValidateFail?: (errors: { [key in FieldKey]: FieldError<FieldValue>; }) => void;
+    }) => void;
+    registerFormWatcher: (item: any) => () => void;
+    registerStateWatcher: (item: any) => () => void;
+    registerWatcher: (item: any) => () => void;
+    registerField: (item: Control<FormData, FieldValue, FieldKey>) => () => void;
+    private getRegisteredFields;
+    getRegisteredField: (field?: FieldKey) => Control<FormData, FieldValue, FieldKey>;
+    private notify;
+    innerSetInitialValues: (values: Partial<FormData>) => void;
+    innerSetInitialValue: (field: FieldKey, value: FieldValue) => void;
+    private _getIterativelyKeysByField;
+    private _inTouchFields;
+    private _popTouchField;
+    private _pushTouchField;
+    innerSetFieldValue: (field: FieldKey, value: FieldValue, options?: {
+        isFormList?: boolean;
+        ignore?: boolean;
+    }) => void;
+    innerGetStore: () => Partial<FormData>;
+    innerGetStoreStatus: () => {
+        submitStatus: SubmitStatus;
+    };
+    innerGetFieldValue: (field: FieldKey) => any;
+    getTouchedFields: () => FieldKey[];
+    setFieldValue: (field: FieldKey, value: FieldValue) => void;
+    setFieldsValue: (values: DeepPartial<FormData>) => void;
+    setFields: (obj: { [field in FieldKey]?: {
+        value?: FieldValue;
+        error?: FieldError<FieldValue>;
+        touched?: boolean;
+        warning?: React.ReactNode;
+    }; }) => void;
+    getFieldValue: (field: FieldKey) => FieldValue;
+    getFieldError: (field: FieldKey) => FieldError<FieldValue> | null;
+    getFieldsError: (fields?: FieldKey[]) => { [key in FieldKey]?: FieldError<FieldValue> | undefined; };
+    getFields: () => Partial<FormData>;
+    getFieldsValue: (fields?: FieldKey[]) => Partial<FormData>;
+    getInitialValues: () => Partial<FormData>;
+    setInitialValues: (values: Partial<FormData>) => void;
+    setInitialValue: (field: FieldKey, value: FieldValue) => void;
+    resetFields: (fieldKeys?: FieldKey | FieldKey[]) => void;
+    validate: FormValidateFn<FormData, FieldValue, FieldKey>;
+    private toggleSubmitStatus;
+    submit: () => void;
+    getFieldsState: (fields?: FieldKey[]) => { [key in FieldKey]?: FieldState<FieldValue>; };
+    clearFields: (fieldKeys?: FieldKey | FieldKey[]) => void;
+}
+export default Store;

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

@@ -0,0 +1,14 @@
+import type { PropertyPath } from 'lodash';
+import { ReactNode } from 'react';
+import type { RulesProps } from '../form/interface';
+import type { FormProps, IndexedObject } from './interface';
+export declare function cloneDeep(value: any): any;
+export declare const formatValidateMsg: (validateMessages: FormProps["validateMessages"], info: {
+    label: ReactNode;
+}) => any;
+export declare function set<T extends IndexedObject>(target: T, field: PropertyPath, value: any): T;
+export declare function iterativelyGetKeys(_obj: any, _prefix?: string): any;
+export declare function isSyntheticEvent(e: any): boolean;
+export declare function schemaValidate(field: any, value: any, _rules: RulesProps[], validateMessages: any): Promise<unknown>;
+export declare function isFieldMatch(field: any, fields: any): any;
+export declare const ID_SUFFIX = "_input";

package/types/pc/grid/context.d.ts

@@ -0,0 +1,19 @@
+import { GridItemData } from './interface';
+type RowContextType = {
+    gutter?: [number, number];
+    div?: boolean;
+};
+export declare const RowContext: import("react").Context<RowContextType>;
+type GridContextType = {
+    overflow?: boolean;
+    collapsed?: boolean;
+    displayIndexList?: number[];
+    cols?: number;
+    colGap?: number;
+};
+export declare const GridContext: import("react").Context<GridContextType>;
+export declare const GridDataCollectorContext: import("react").Context<Readonly<{
+    collectItemData?: (index: number, itemData: GridItemData) => void;
+    removeItemData?: (index: number) => void;
+}>>;
+export {};

package/types/pc/grid/grid-item.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { GridItemProps } from './interface';
+declare const ForwardRefGridItem: React.ForwardRefExoticComponent<GridItemProps & React.RefAttributes<unknown>>;
+declare const GridItemComponent: typeof ForwardRefGridItem & {
+    __PQB_GRID_ITEM__: boolean;
+};
+export default GridItemComponent;
+export type { GridItemProps };

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

@@ -0,0 +1,12 @@
+import Col from './Col';
+import Row from './Row';
+import OriginGrid from './grid';
+import GridItem from './grid-item';
+declare const Grid: typeof OriginGrid & {
+    Col: typeof Col;
+    Row: typeof Row;
+    GridItem: typeof GridItem;
+};
+export { Col, Row };
+export default Grid;
+export type { ColProps, GridProps, ResponsiveValue, RowProps, } from './interface';

package/types/pc/hooks/factory/createReducerContext.d.ts

@@ -0,0 +1,5 @@
+declare const createReducerContext: <R extends React.Reducer<any, any>>(reducer: R, defaultInitialState: React.ReducerState<R>) => readonly [() => [import("react").ReducerState<R>, import("react").Dispatch<import("react").ReducerAction<R>>], ({ children, initialState, }: {
+    children?: React.ReactNode;
+    initialState?: React.ReducerState<R>;
+}) => import("react").FunctionComponentElement<import("react").ProviderProps<[import("react").ReducerState<R>, import("react").Dispatch<import("react").ReducerAction<R>>] | undefined>>, import("react").Context<[import("react").ReducerState<R>, import("react").Dispatch<import("react").ReducerAction<R>>] | undefined>];
+export default createReducerContext;

package/types/pc/hooks/useAudio.d.ts

@@ -0,0 +1,11 @@
+declare const useAudio: (elOrProps: import("./factory/createHTMLMediaHook").HTMLMediaProps | import("react").ReactElement<import("./factory/createHTMLMediaHook").HTMLMediaProps>) => readonly [import("react").ReactElement<import("./factory/createHTMLMediaHook").HTMLMediaProps & {
+    ref?: import("react").MutableRefObject<HTMLAudioElement | null> | undefined;
+}, string | import("react").JSXElementConstructor<any>>, import("./factory/createHTMLMediaHook").HTMLMediaState, {
+    play: () => Promise<void> | undefined;
+    pause: () => void;
+    seek: (time: number) => void;
+    volume: (volume: number) => void;
+    mute: () => void;
+    unmute: () => void;
+}, import("react").MutableRefObject<HTMLAudioElement | null>];
+export default useAudio;

package/types/pc/hooks/useCopyToClipboard.d.ts

@@ -0,0 +1,7 @@
+export interface CopyToClipboardState {
+    value?: string;
+    noUserInteraction: boolean;
+    error?: Error;
+}
+declare const useCopyToClipboard: () => [CopyToClipboardState, (value: string) => void];
+export default useCopyToClipboard;

package/types/pc/hooks/useKeyboardEvent.d.ts

@@ -0,0 +1,8 @@
+import { KeyboardEventHandler } from 'react';
+type CallBackEventType = 'onPressEnter' | 'onArrowUp' | 'onArrowLeft' | 'onArrowRight' | 'onArrowDown';
+export default function useKeyboardEvent(props?: {
+    onKeyDown?: KeyboardEventHandler;
+}): (callbacks: { [key in CallBackEventType]?: (event: any) => void; }) => {
+    onKeyDown: (event: any) => void;
+};
+export {};

package/types/pc/hooks/useVideo.d.ts

@@ -0,0 +1,11 @@
+declare const useVideo: (elOrProps: import("./factory/createHTMLMediaHook").HTMLMediaProps | import("react").ReactElement<import("./factory/createHTMLMediaHook").HTMLMediaProps>) => readonly [import("react").ReactElement<import("./factory/createHTMLMediaHook").HTMLMediaProps & {
+    ref?: import("react").MutableRefObject<HTMLVideoElement | null> | undefined;
+}, string | import("react").JSXElementConstructor<any>>, import("./factory/createHTMLMediaHook").HTMLMediaState, {
+    play: () => Promise<void> | undefined;
+    pause: () => void;
+    seek: (time: number) => void;
+    volume: (volume: number) => void;
+    mute: () => void;
+    unmute: () => void;
+}, import("react").MutableRefObject<HTMLVideoElement | null>];
+export default useVideo;

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

@@ -0,0 +1,17 @@
+import React, { CSSProperties, SVGAttributes } from 'react';
+export interface IconProps extends Omit<SVGAttributes<SVGElement>, 'className'> {
+    style?: CSSProperties;
+    type?: string;
+    spin?: boolean;
+    className?: string | string[];
+}
+export interface CustomIconComponentProps {
+    style?: CSSProperties;
+    className?: string;
+    width?: string | number;
+    height?: string | number;
+    fill?: string;
+    viewBox?: string;
+}
+declare const Icon: React.ForwardRefExoticComponent<IconProps & React.RefAttributes<unknown>>;
+export default Icon;

package/types/pc/icon-hover/index.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+interface HoverProps extends React.HTMLAttributes<HTMLSpanElement> {
+    size?: 'small' | 'mini' | 'default' | 'large';
+    className?: string;
+    prefix?: string;
+    disabled?: boolean;
+    onClick?: (e: any) => void;
+}
+declare const IconHover: React.ForwardRefExoticComponent<HoverProps & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<unknown>>;
+export default IconHover;

package/types/pc/image/Image.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import ImagePreview from './ImagePreview';
+import ImagePreviewGroup from './ImagePreviewGroup';
+import type { ImageProps } from './interface';
+declare const RefImageComponent: React.ForwardRefExoticComponent<ImageProps & {
+    _index?: number;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const ImageComponent: typeof RefImageComponent & {
+    Preview: typeof ImagePreview;
+    PreviewGroup: typeof ImagePreviewGroup;
+};
+export default ImageComponent;

package/types/pc/image/ImagePreviewArrow.d.ts

@@ -0,0 +1,11 @@
+interface ImagePreviewArrowProps {
+    current: number;
+    previewCount: number;
+    infinite?: boolean;
+    disableLeft?: boolean;
+    disableRight?: boolean;
+    onPrev?: () => void;
+    onNext?: () => void;
+}
+declare function ImagePreviewArrow(props: ImagePreviewArrowProps): import("react/jsx-dev-runtime").JSX.Element;
+export default ImagePreviewArrow;

package/types/pc/image/ImagePreviewGroup.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { ImagePreviewGroupProps } from './interface';
+export type { ImagePreviewGroupProps };
+export interface ImagePreviewGroupHandle {
+    reset: () => void;
+}
+declare const PreviewGroupComponent: React.ForwardRefExoticComponent<ImagePreviewGroupProps & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<ImagePreviewGroupHandle>>;
+export default PreviewGroupComponent;

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

@@ -0,0 +1,3 @@
+import Image from './Image';
+export default Image;
+export type { ImagePreviewActionProps, ImagePreviewGroupProps, ImagePreviewProps, ImageProps, } from './interface';

package/types/pc/index.d.ts

@@ -0,0 +1,84 @@
+export { default as computeScrollIntoView } from "@unicom-cloud/compute-scroll-into-view";
+export { default as scrollIntoViewIfNeeded } from "@unicom-cloud/scroll-into-view-if-needed";
+export * from "./hooks";
+export { default as className } from "./utils/className";
+export { default as Affix } from "./affix";
+export { default as Alert } from "./alert";
+export { default as Anchor } from "./anchor";
+export { default as AutoComplete } from "./auto-complete";
+export { default as Avatar } from "./avatar";
+export { default as BackTop } from "./back-top";
+export { default as Badge } from "./badge";
+export { default as Breadcrumb } from "./breadcrumb";
+export { default as Button } from "./button";
+export { default as Calendar } from "./calendar";
+export { default as Card } from "./card";
+export { default as Carousel } from "./carousel";
+export { default as Cascader } from "./cascader";
+export { default as Checkbox } from "./checkbox";
+export { default as Collapse } from "./collapse";
+export { default as Comment } from "./comment";
+export { default as Copy } from "./copy";
+export { default as DatePicker } from "./date-picker";
+export { default as Descriptions } from "./descriptions";
+export { default as Divider } from "./divider";
+export { default as Drawer } from "./drawer";
+export { default as Dropdown } from "./dropdown";
+export { default as Empty } from "./empty";
+export { default as Form } from "./form";
+export { default as Grid } from "./grid";
+export { default as Col } from "./grid/Col";
+export { default as Row } from "./grid/Row";
+export { default as Icon } from "./icon";
+export { default as Image } from "./image";
+export { default as Input } from "./input";
+export { default as InputNumber } from "./input-number";
+export { default as InputTag } from "./input-tag";
+export { default as Layout } from "./layout";
+export { default as Link } from "./link";
+export { default as List } from "./list";
+export { default as Mentions } from "./mentions";
+export { default as Menu } from "./menu";
+export { default as Message } from "./message";
+export { default as Modal } from "./modal";
+export { default as Notification } from "./notification";
+export { default as PageHeader } from "./page-header";
+export { default as Pagination } from "./pagination";
+export { default as Popconfirm } from "./popconfirm";
+export { default as Popover } from "./popover";
+export { default as Portal } from "./portal";
+export { default as Progress } from "./progress";
+export { default as ColorPicker } from "./color-picker";
+export { default as IconHover } from "./icon-hover";
+export { default as Loading } from "./loading";
+export { default as Radio } from "./radio";
+export { default as Rate } from "./rate";
+export { default as ResizeBox } from "./resize-box";
+export { default as Result } from "./result";
+export { default as Select } from "./select";
+export { default as Skeleton } from "./skeleton";
+export { default as Slider } from "./slider";
+export { default as Space } from "./space";
+export { default as SpeechSynthesis } from "./speech-synthesis";
+export { default as Spin } from "./spin";
+export { default as Statistic } from "./statistic";
+export { default as Steps } from "./steps";
+export { default as SuspenseFallbackTest } from "./suspense-fallback-test";
+export { default as Switch } from "./switch";
+export { default as Table } from "./table";
+export { default as Tabs } from "./tabs";
+export { default as Tag } from "./tag";
+export { default as TimePicker } from "./time-picker";
+export { default as Timeline } from "./timeline";
+export { default as Tooltip } from "./tooltip";
+export { default as Transfer } from "./transfer";
+export { default as Tree } from "./tree";
+export { default as TreeSelect } from "./tree-select";
+export { default as Trigger } from "./trigger";
+export { default as Typography } from "./typography";
+export { default as Upload } from "./upload";
+export { default as VerificationCode } from "./verification-code";
+export { default as Version } from "./version";
+export { default as Watermark } from "./watermark";
+export { CSSTransition, SwitchTransition, Transition, TransitionGroup } from "@unicom-cloud/react-transition-group";
+export { ConfigConsumer, ConfigContext, default as ConfigProvider } from "./config-provider";

package/types/pc/input/Group.d.ts

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

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

@@ -0,0 +1,7 @@
+import Input from './Input';
+import type { InputProps, RefInputType, TextAreaProps } from './interface';
+import { InputPasswordProps } from './Password';
+import { InputSearchProps } from './Search';
+import { RefTextAreaType } from './Textarea';
+export type { InputPasswordProps, InputProps, InputSearchProps, RefInputType, RefTextAreaType, TextAreaProps, };
+export default Input;

package/types/pc/input-number/index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { RefInputType } from '../input/interface';
+import type { InputNumberProps } from './interface';
+declare const InputNumberComponent: React.ForwardRefExoticComponent<InputNumberProps & React.RefAttributes<RefInputType>>;
+export default InputNumberComponent;
+export type { InputNumberProps };

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

@@ -0,0 +1,3 @@
+import InputTag, { InputTagProps } from './InputTag';
+export default InputTag;
+export type { InputTagProps };

package/types/pc/layout/Sider.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { SiderProps } from './interface';
+export declare const SiderContext: React.Context<{
+    siderCollapsed: boolean;
+    collapsedWidth: string | number;
+}>;
+declare const ForwardRefSider: React.ForwardRefExoticComponent<SiderProps & React.RefAttributes<unknown>>;
+declare const SiderComponent: typeof ForwardRefSider & {
+    __PQB_SIGN__: "sider";
+};
+export default SiderComponent;

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

@@ -0,0 +1,18 @@
+import React from 'react';
+import Content from './Content';
+import Footer from './Footer';
+import Header from './Header';
+import Sider, { SiderContext } from './Sider';
+import type { LayoutProps } from './interface';
+export interface LayoutState {
+    siders: string[];
+}
+export type { SiderContext };
+declare const ForwardRefLayout: React.ForwardRefExoticComponent<LayoutProps & React.RefAttributes<unknown>>;
+declare const LayoutComponent: typeof ForwardRefLayout & {
+    Sider: typeof Sider;
+    Header: typeof Header;
+    Footer: typeof Footer;
+    Content: typeof Content;
+};
+export default LayoutComponent;