@unicom-cloud/ui 0.8.41

package/types/Popover/index.d.ts

@@ -0,0 +1,7 @@
+import './style';
+import type { PopoverProps } from './interface';
+declare const PopoverComponent: import("react").ForwardRefExoticComponent<PopoverProps & {
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<unknown>>;
+export default PopoverComponent;
+export type { PopoverProps };

package/types/Popover/interface.d.ts

@@ -0,0 +1,8 @@
+import { CSSProperties, ReactNode } from 'react';
+import type { TooltipProps } from '../tooltip';
+export interface PopoverProps extends Omit<TooltipProps, 'mini'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    title?: ReactNode;
+    disabled?: boolean;
+}

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

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

package/types/affix/index.d.ts

@@ -0,0 +1,9 @@
+import type { AffixProps } from './interface';
+type AffixHandle = {
+    updatePosition: () => void;
+};
+declare const AffixComponent: import("react").ForwardRefExoticComponent<AffixProps & {
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<AffixHandle>>;
+export default AffixComponent;
+export type { AffixProps };

package/types/affix/interface.d.ts

@@ -0,0 +1,12 @@
+import { CSSProperties } from 'react';
+export interface AffixProps {
+    className?: string | string[];
+    style?: CSSProperties;
+    affixClassName?: string | string[];
+    affixStyle?: CSSProperties;
+    offsetTop?: number;
+    offsetBottom?: number;
+    target?: () => HTMLElement | null | Window;
+    targetContainer?: () => HTMLElement | null | Window;
+    onChange?: (affixed: boolean) => void;
+}

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

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

package/types/alert/index.d.ts

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

package/types/alert/interface.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface AlertProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    action?: ReactNode;
+    closable?: boolean;
+    closeable?: boolean;
+    onClose?: (event: any) => void;
+    afterClose?: () => void;
+    type?: 'info' | 'success' | 'warning' | 'error';
+    title?: ReactNode;
+    content?: ReactNode;
+    icon?: ReactNode;
+    closeElement?: ReactNode;
+    showIcon?: boolean;
+    banner?: boolean;
+}

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

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

package/types/anchor/Anchor.d.ts

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

package/types/anchor/Link.d.ts

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

package/types/anchor/context.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { AnchorProps } from './interface';
+interface AnchorContext {
+    currentLink: string;
+    onLinkClick: (e: React.MouseEvent<HTMLAnchorElement, MouseEvent>, href: string) => void;
+    addLink: (href: string, node: HTMLElement) => void;
+    removeLink: (href: string) => void;
+    direction: AnchorProps['direction'];
+}
+declare const _default: React.Context<AnchorContext>;
+export default _default;

package/types/anchor/index.d.ts

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

package/types/anchor/interface.d.ts

@@ -0,0 +1,24 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface AnchorProps {
+    className?: string | string[];
+    style?: CSSProperties;
+    animation?: boolean;
+    direction?: 'vertical' | 'horizontal';
+    scrollContainer?: string | HTMLElement | Window;
+    boundary?: number | 'end' | 'start' | 'center' | 'nearest';
+    hash?: boolean;
+    affix?: boolean;
+    affixStyle?: CSSProperties;
+    offsetTop?: number;
+    offsetBottom?: number;
+    onChange?: (newLink: string, oldLink: string) => void;
+    onSelect?: (newLink: string, oldLink: string) => void;
+    lineless?: boolean;
+    targetOffset?: number;
+}
+export interface AnchorLinkProps {
+    className?: string | string[];
+    style?: CSSProperties;
+    href?: string;
+    title?: string | ReactNode;
+}

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

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

package/types/anchor/util.d.ts

@@ -0,0 +1,4 @@
+export declare function findNode(dom: HTMLElement | Document, selector: string): HTMLElement | null;
+export declare function slide(el: HTMLElement, top: number, cb: Function): void;
+export declare function getContainer(targetContainer?: string | HTMLElement | Window): HTMLElement | Window | null;
+export declare function getContainerElement(scrollContainer: HTMLElement | Window): HTMLElement;

package/types/auto-complete/index.d.ts

@@ -0,0 +1,11 @@
+import './style';
+import React from 'react';
+import { RefInputType } from '../input/interface';
+import Select from '../select/Select';
+import type { AutoCompleteProps } from './interface';
+declare const AutoCompleteComponent: React.ForwardRefExoticComponent<AutoCompleteProps & React.RefAttributes<RefInputType>> & {
+    Option: typeof Select.Option;
+    OptGroup: typeof Select.OptGroup;
+};
+export default AutoCompleteComponent;
+export type { AutoCompleteProps };

package/types/auto-complete/interface.d.ts

@@ -0,0 +1,36 @@
+import { CSSProperties, ReactElement, ReactNode } from 'react';
+import { InputProps } from '../input';
+import { OptionInfo, SelectProps } from '../select/interface';
+import { AvailableVirtualListProps } from '../virtual-list';
+type PartialSelectProps = Pick<SelectProps, 'filterOption' | 'dropdownRender' | 'triggerProps' | 'getPopupContainer' | 'defaultActiveFirstOption'>;
+export interface AutoCompleteProps extends PartialSelectProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    disabled?: boolean;
+    children?: ReactNode;
+    allowClear?: boolean;
+    data?: (string | {
+        value: string;
+        name: string;
+        [key: string]: any;
+    } | ReactNode)[];
+    placeholder?: string;
+    defaultValue?: string;
+    value?: string;
+    error?: boolean;
+    status?: 'error' | 'warning';
+    strict?: boolean;
+    loading?: boolean;
+    triggerElement?: ReactElement | (({ value }: {
+        value: any;
+    }) => ReactElement);
+    onSearch?: (value: string) => void;
+    onSelect?: (value: string, option: OptionInfo) => void;
+    onChange?: (value: string, option?: OptionInfo) => void;
+    onPressEnter?: (e: any, activeOption?: OptionInfo) => void;
+    onFocus?: (e: any) => void;
+    onBlur?: (e: any) => void;
+    virtualListProps?: AvailableVirtualListProps;
+    inputProps?: Partial<InputProps>;
+}
+export {};

package/types/auto-complete/style/index.d.ts

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

package/types/avatar/Avatar.d.ts

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

package/types/avatar/Group.d.ts

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

package/types/avatar/context.d.ts

@@ -0,0 +1,3 @@
+import type { AvatarProps } from './interface';
+declare const _default: import("react").Context<AvatarProps>;
+export default _default;

package/types/avatar/index.d.ts

@@ -0,0 +1,9 @@
+import './style';
+import Avatar from './Avatar';
+import Group from './Group';
+export * from './interface';
+type AvatarComponentType = typeof Avatar & {
+    Group: typeof Group;
+};
+declare const AvatarComponent: AvatarComponentType;
+export default AvatarComponent;

package/types/avatar/interface.d.ts

@@ -0,0 +1,24 @@
+import { CSSProperties, ReactNode } from 'react';
+import { TriggerProps } from '../trigger';
+export interface AvatarProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    shape?: 'circle' | 'square';
+    size?: number;
+    autoFixFontSize?: boolean;
+    triggerIcon?: ReactNode;
+    triggerIconStyle?: CSSProperties;
+    triggerType?: 'mask' | 'button';
+    onClick?: (e: MouseEvent) => void;
+}
+export interface AvatarGroupProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    shape?: 'circle' | 'square';
+    size?: number;
+    autoFixFontSize?: boolean;
+    zIndexAscend?: boolean;
+    maxCount?: number;
+    maxStyle?: CSSProperties;
+    maxPopoverTriggerProps?: TriggerProps;
+}

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

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

package/types/back-top/index.d.ts

@@ -0,0 +1,8 @@
+import './style';
+import React from 'react';
+import type { BackTopProps } from './interface';
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<BackTopProps & {
+    children?: React.ReactNode;
+} & React.RefAttributes<unknown>>>;
+export default _default;
+export type { BackTopProps };

package/types/back-top/interface.d.ts

@@ -0,0 +1,11 @@
+import { CSSProperties } from 'react';
+export interface BackTopProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    visibleHeight?: number;
+    target?: () => HTMLElement | Window;
+    onClick?: () => void;
+    tween?: boolean;
+    easing?: Function | string;
+    duration?: number;
+}

package/types/back-top/style/index.d.ts

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

package/types/badge/Count.d.ts

@@ -0,0 +1,7 @@
+export default function Count({ prefixCls, maxCount, count, className, style, }: {
+    prefixCls: any;
+    maxCount: any;
+    count: any;
+    className: any;
+    style: any;
+}): import("react/jsx-dev-runtime").JSX.Element;

package/types/badge/index.d.ts

@@ -0,0 +1,7 @@
+import './style';
+import type { BadgeProps } from './interface';
+export declare const COLORS: string[];
+export declare const STATUS: string[];
+declare const BadgeComponent: import("react").ForwardRefExoticComponent<BadgeProps & import("react").RefAttributes<unknown>>;
+export default BadgeComponent;
+export type { BadgeProps };

package/types/badge/interface.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties, HTMLAttributes, ReactNode } from 'react';
+import { Omit } from '../utils/type';
+export interface BadgeProps extends Omit<HTMLAttributes<HTMLElement>, 'className'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    count?: number | ReactNode;
+    prefixText?: string;
+    text?: string;
+    dot?: boolean;
+    dotStyle?: CSSProperties;
+    dotClassName?: string | string[];
+    maxCount?: number;
+    offset?: [number, number];
+    color?: 'red' | 'orangered' | 'orange' | 'gold' | 'lime' | 'green' | 'cyan' | 'pqbblue' | 'purple' | 'magenta' | 'gray' | string;
+    status?: 'default' | 'processing' | 'success' | 'warning' | 'error';
+    children?: ReactNode;
+}

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

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

package/types/breadcrumb/Item.d.ts

@@ -0,0 +1,8 @@
+import { PropsWithChildren } from 'react';
+import type { BreadCrumbItemProps } from './interface';
+declare function Item(props: PropsWithChildren<BreadCrumbItemProps>): import("react/jsx-dev-runtime").JSX.Element;
+declare namespace Item {
+    var displayName: string;
+}
+export default Item;
+export type { BreadCrumbItemProps };

package/types/breadcrumb/index.d.ts

@@ -0,0 +1,9 @@
+import './style';
+import React from 'react';
+import type { BreadcrumbProps } from './interface';
+import Item from './Item';
+declare const BreadcrumbComponent: React.ForwardRefExoticComponent<BreadcrumbProps & React.RefAttributes<unknown>> & {
+    Item: typeof Item;
+};
+export default BreadcrumbComponent;
+export type { BreadcrumbProps };

package/types/breadcrumb/interface.d.ts

@@ -0,0 +1,31 @@
+import React, { CSSProperties, HTMLAttributes, ReactNode } from 'react';
+import { DropdownProps } from '../dropdown';
+export interface RouteProps {
+    path: string;
+    breadcrumbName: string;
+    children?: Array<{
+        path: string;
+        breadcrumbName: string;
+    }>;
+}
+export interface BreadcrumbProps {
+    style?: CSSProperties;
+    children?: ReactNode;
+    className?: string | string[];
+    separator?: string | ReactNode;
+    routes?: RouteProps[];
+    maxCount?: number;
+    itemRender?: (route: RouteProps, routes: RouteProps[], paths: string[]) => ReactNode;
+}
+type CustomHTMLElement = Omit<HTMLAttributes<HTMLDivElement>, 'className'>;
+export interface BreadCrumbItemProps extends CustomHTMLElement {
+    style?: CSSProperties;
+    className?: string | string[];
+    prefixCls?: string;
+    droplist?: DropdownProps['droplist'];
+    dropdownProps?: DropdownProps;
+    href?: string;
+    onClick?: (e: any) => void;
+    tagName?: string | React.FC<any> | React.ComponentClass<any>;
+}
+export {};

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

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

package/types/button/Group.d.ts

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

package/types/button/index.d.ts

@@ -0,0 +1,16 @@
+import './style';
+import React from 'react';
+import Group from './Group';
+import type { ButtonProps } from './interface';
+declare const ButtonComponent: React.ForwardRefExoticComponent<Partial<{
+    htmlType?: "button" | "reset" | "submit" | undefined;
+} & import("./interface").BaseButtonProps & Omit<React.ButtonHTMLAttributes<any>, "className" | "onClick" | "type"> & {
+    href: string;
+    target?: string | undefined;
+    anchorProps?: React.HTMLProps<HTMLAnchorElement> | undefined;
+} & Omit<React.AnchorHTMLAttributes<any>, "className" | "onClick" | "type">> & React.RefAttributes<unknown>> & {
+    __PQB_BUTTON: boolean;
+    Group: typeof Group;
+};
+export default ButtonComponent;
+export type { ButtonProps };

package/types/button/interface.d.ts

@@ -0,0 +1,37 @@
+import { AnchorHTMLAttributes, ButtonHTMLAttributes, CSSProperties, HTMLProps, ReactNode } from 'react';
+export interface BaseButtonProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    children?: ReactNode;
+    type?: 'default' | 'primary' | 'secondary' | 'dashed' | 'text' | 'text-only' | 'outline';
+    status?: 'warning' | 'danger' | 'success' | 'processing' | 'default';
+    size?: 'mini' | 'small' | 'default' | 'large';
+    shape?: 'circle' | 'round' | 'square';
+    href?: string;
+    target?: string;
+    anchorProps?: HTMLProps<HTMLAnchorElement>;
+    disabled?: boolean;
+    loading?: boolean;
+    loadingFixedWidth?: boolean;
+    icon?: ReactNode;
+    iconRight?: ReactNode;
+    iconSuffix?: ReactNode;
+    iconOnly?: boolean;
+    long?: boolean;
+    error?: boolean;
+    onClick?: (e: Event) => void;
+}
+export type AnchorButtonProps = {
+    href: string;
+    target?: string;
+    anchorProps?: HTMLProps<HTMLAnchorElement>;
+} & BaseButtonProps & Omit<AnchorHTMLAttributes<any>, 'type' | 'onClick' | 'className'>;
+export type FinalButtonProps = {
+    htmlType?: 'button' | 'submit' | 'reset';
+} & BaseButtonProps & Omit<ButtonHTMLAttributes<any>, 'type' | 'onClick' | 'className'>;
+export type ButtonProps = Partial<FinalButtonProps & AnchorButtonProps>;
+export interface ButtonGroupProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    children?: ReactNode;
+}

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

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

package/types/calendar/Month.d.ts

@@ -0,0 +1,15 @@
+import { Dayjs } from 'dayjs';
+import type { CalendarProps } from './interface';
+export interface MonthProps extends CalendarProps {
+    prefixCls?: string;
+    cell?: boolean;
+    pageData?: any;
+    mergedValue?: Dayjs;
+    selectHandler?: (time: Dayjs, disabled: boolean) => void;
+    innerMode?: 'day' | 'week' | 'month' | 'year';
+    mergedPageShowDate?: Dayjs;
+    CALENDAR_LOCALE?: Record<string, any>;
+}
+export declare function getAllDaysByTime(props: CalendarProps, time: Dayjs): never[][];
+declare function Month(props: MonthProps): import("react/jsx-dev-runtime").JSX.Element;
+export default Month;

package/types/calendar/WeekList.d.ts

@@ -0,0 +1,10 @@
+interface WeekListProps {
+    prefixCls?: string;
+    dayStartOfWeek?: 0 | 1;
+    isWeek?: boolean;
+    CALENDAR_LOCALE?: Record<string, any>;
+    panel?: boolean;
+    innerMode?: 'day' | 'week' | 'month' | 'year';
+}
+declare function WeekList(props: WeekListProps): import("react/jsx-dev-runtime").JSX.Element;
+export default WeekList;

package/types/calendar/Year.d.ts

@@ -0,0 +1,13 @@
+import { Dayjs } from 'dayjs';
+import type { CalendarProps } from './interface';
+interface YearProps extends CalendarProps {
+    prefixCls?: string;
+    pageData?: any;
+    mergedValue?: Dayjs;
+    selectHandler?: (time: Dayjs, disabled: boolean) => void;
+    mergedPageShowDate?: Dayjs;
+    CALENDAR_LOCALE?: Record<string, any>;
+    innerMode?: 'day' | 'week' | 'month' | 'year';
+}
+declare function Year(props: YearProps): import("react/jsx-dev-runtime").JSX.Element;
+export default Year;

package/types/calendar/header/Panel.d.ts

@@ -0,0 +1,2 @@
+declare function PanelHeader(props: any): import("react/jsx-dev-runtime").JSX.Element;
+export default PanelHeader;

package/types/calendar/header/index.d.ts

@@ -0,0 +1,2 @@
+declare function Header(props: any): import("react/jsx-dev-runtime").JSX.Element;
+export default Header;

package/types/calendar/hook/useCellClassName.d.ts

@@ -0,0 +1 @@
+export default function useClassName(props: any): (cellDateObj: any, disabled: any) => string;

package/types/calendar/index.d.ts

@@ -0,0 +1,8 @@
+import './style';
+import type { CalendarProps } from './interface';
+declare function Calendar(baseProps: CalendarProps): import("react/jsx-dev-runtime").JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+export default Calendar;
+export type { CalendarProps };

package/types/calendar/interface.d.ts

@@ -0,0 +1,41 @@
+import { ReactNode, CSSProperties } from 'react';
+import { Dayjs } from 'dayjs';
+export type CalendarValue = Dayjs | Date | string | number;
+export interface CalendarProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    allowSelect?: boolean;
+    panel?: boolean;
+    panelWidth?: number | string;
+    panelTodayBtn?: boolean;
+    panelOperations?: Array<'left' | 'double-left' | 'right' | 'double-right'>;
+    isWeek?: boolean;
+    dayStartOfWeek?: 0 | 1;
+    defaultValue?: CalendarValue;
+    value?: CalendarValue;
+    defaultPageShowDate?: CalendarValue;
+    pageShowDate?: CalendarValue;
+    defaultMode?: 'day' | 'week' | 'month' | 'year';
+    mode?: 'day' | 'week' | 'month' | 'year';
+    modes?: ('day' | 'week' | 'month' | 'year')[];
+    disabledDate?: (current: Dayjs) => boolean;
+    onChange?: (date: Dayjs) => void;
+    onPanelChange?: (date: Dayjs) => void;
+    dateRender?: (currentDate: Dayjs) => ReactNode;
+    monthRender?: (currentDate: Dayjs) => ReactNode;
+    dateInnerContent?: (currentDate: Dayjs) => ReactNode;
+    headerRender?: (props: {
+        value?: Dayjs;
+        pageShowDate?: Dayjs;
+        mode?: string;
+        onChange: any;
+        onChangePageDate: any;
+        onChangeMode: any;
+    }) => ReactNode;
+    locale?: Record<string, any>;
+    headerType?: 'button' | 'select';
+    rangeValues?: Dayjs[];
+    hoverRangeValues?: Dayjs[];
+    onMouseEnterCell?: (time: Dayjs, disabled: boolean) => void;
+    onMouseLeaveCell?: (time: Dayjs, disabled: boolean) => void;
+}

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

@@ -0,0 +1,4 @@
+import '../../button/style';
+import '../../select/style';
+import '../../style/index.less';
+import './index.less';

package/types/card/Grid.d.ts

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

package/types/card/Meta.d.ts

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

package/types/card/index.d.ts

@@ -0,0 +1,11 @@
+import './style';
+import React from 'react';
+import Grid from './Grid';
+import Meta from './Meta';
+import type { CardProps } from './interface';
+declare const CardComponent: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<unknown>> & {
+    Meta: typeof Meta;
+    Grid: typeof Grid;
+};
+export default CardComponent;
+export type { CardProps };

package/types/card/interface.d.ts

@@ -0,0 +1,32 @@
+import { CSSProperties, HTMLAttributes, ReactNode } from 'react';
+import { Omit } from '../utils/type';
+export interface CardProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title' | 'className'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    children?: ReactNode;
+    id?: string;
+    bordered?: boolean;
+    loading?: boolean;
+    hoverable?: boolean;
+    size?: 'default' | 'small';
+    title?: string | ReactNode;
+    extra?: string | ReactNode;
+    cover?: ReactNode;
+    actions?: ReactNode[];
+    headerStyle?: CSSProperties;
+    bodyStyle?: CSSProperties;
+}
+export interface CardMetaProps {
+    style?: CSSProperties;
+    className?: string | string[];
+    actionList?: ReactNode[];
+    avatar?: ReactNode;
+    title?: string | ReactNode;
+    description?: string | ReactNode;
+}
+export interface CardGridProps {
+    children?: ReactNode;
+    style?: CSSProperties;
+    className?: string | string[];
+    hoverable?: boolean;
+}