antd

antd

Version 5.16.4
Published 3 days ago
45 MB
48 dependencies
MIT license

Install

npm i antd

yarn add antd

pnpm add antd

Overview

An enterprise-class UI design language and React components implementation

Index

Variables

variable Affix

const Affix: React.ForwardRefExoticComponent<any>;

variable Alert

const Alert: any;

variable Anchor

const Anchor: any;

variable App

const App: any;

variable AutoComplete

const AutoComplete: (<
    ValueType = any,
    OptionType extends unknown = DefaultOptionType
>(
    props: any
) => React.ReactElement) & {
    displayName?: string | undefined;
    Option: any;
    _InternalPanelDoNotUseOrYouWillBeFired: typeof PurePanel;
};

variable Avatar

const Avatar: any;

variable BackTop

const BackTop: React.FC<BackTopProps>;

variable Badge

const Badge: any;

const Breadcrumb: {
    <T extends AnyObject = AnyObject>(props: BreadcrumbProps<T>): React.ReactElement<
        any,
        any
    >;
    Item: React.FC<BreadcrumbItemProps> & { __ANT_BREADCRUMB_ITEM: boolean };
    Separator: React.FC<{ children?: React.ReactNode }> & {
        __ANT_BREADCRUMB_SEPARATOR: boolean;
    };
    displayName: string;
};

variable Button

const Button: any;

variable Calendar

const Calendar: CalendarType;

variable Card

const Card: CardInterface;

variable Carousel

const Carousel: React.ForwardRefExoticComponent<any>;

variable Cascader

const Cascader: (<OptionType extends unknown = DefaultOptionType>(
    props: any
) => React.ReactElement) & {
    displayName: string;
    SHOW_PARENT: typeof SHOW_PARENT;
    SHOW_CHILD: typeof SHOW_CHILD;
    Panel: React.FC<CascaderPanelProps>;
    _InternalPanelDoNotUseOrYouWillBeFired: typeof PurePanel;
};

variable Checkbox

const Checkbox: any;

variable Col

const Col: React.ForwardRefExoticComponent<any>;

variable Collapse

const Collapse: any;

variable ColorPicker

const ColorPicker: any;

variable ConfigProvider

const ConfigProvider: any;

variable DatePicker

const DatePicker: DatePickerType;

variable Descriptions

const Descriptions: any;

variable Divider

const Divider: React.FC<DividerProps>;

variable Drawer

const Drawer: any;

const Dropdown: any;

variable Empty

const Empty: any;

variable Flex

const Flex: React.ForwardRefExoticComponent<any>;

variable FloatButton

const FloatButton: any;

variable Form

const Form: CompoundedComponent;

variable Grid

const Grid: { useBreakpoint: typeof useBreakpoint };

variable Image

const Image: CompositionImage<ImageProps>;

variable Input

const Input: any;

variable InputNumber

const InputNumber: (<T extends ValueType = ValueType>(
    props: any
) => React.ReactElement) & {
    displayName?: string | undefined;
    _InternalPanelDoNotUseOrYouWillBeFired: React.FC<InputNumberProps<ValueType>>;
};

variable Layout

const Layout: any;

variable Mentions

const Mentions: any;

const Menu: GenericComponent;

variable message

const message: MessageMethods & BaseMethods;

const Modal: any;

variable notification

const notification: NoticeMethods & BaseMethods;

const Pagination: React.FC<PaginationProps>;

variable Popconfirm

const Popconfirm: any;

const Popover: any;

variable Progress

const Progress: React.ForwardRefExoticComponent<any>;

variable QRCode

const QRCode: React.FC<QRCodeProps>;

variable Radio

const Radio: any;

variable Rate

const Rate: React.ForwardRefExoticComponent<any>;

variable Result

const Result: ResultType;

variable Row

const Row: React.ForwardRefExoticComponent<any>;

variable Segmented

const Segmented: (<ValueType>(props: any) => ReturnType<typeof InternalSegmented>) &
    Pick<React.FC<{}>, 'displayName'>;

variable Select

const Select: (<ValueType = any, OptionType extends unknown = DefaultOptionType>(
    props: any
) => React.ReactElement) & {
    displayName?: string | undefined;
    SECRET_COMBOBOX_MODE_DO_NOT_USE: string;
    Option: any;
    OptGroup: any;
    _InternalPanelDoNotUseOrYouWillBeFired: typeof PurePanel;
};

variable Skeleton

const Skeleton: any;

variable Slider

const Slider: React.ForwardRefExoticComponent<any>;

variable Space

const Space: any;

variable Spin

const Spin: any;

variable Statistic

const Statistic: any;

variable Steps

const Steps: any;

variable Switch

const Switch: any;

variable Table

const Table: RefTable & {
    displayName?: string | undefined;
    SELECTION_COLUMN: typeof SELECTION_COLUMN;
    EXPAND_COLUMN: any;
    SELECTION_ALL: typeof SELECTION_ALL;
    SELECTION_INVERT: typeof SELECTION_INVERT;
    SELECTION_NONE: typeof SELECTION_NONE;
    Column: typeof Column;
    ColumnGroup: typeof ColumnGroup;
    Summary: any;
};

variable Tabs

const Tabs: any;

variable Tag

const Tag: any;

variable theme

const theme: {
    defaultConfig: {
        token: import('./interface').SeedToken;
        override: { override: import('./interface').SeedToken };
        hashed: boolean;
    };
    defaultSeed: import('./interface').SeedToken;
    useToken: typeof useToken;
    defaultAlgorithm: typeof defaultAlgorithm;
    darkAlgorithm: any;
    compactAlgorithm: any;
    getDesignToken: (
        config?: import('..').ThemeConfig | undefined
    ) => import('./interface').AliasToken;
};

variable Timeline

const Timeline: any;

variable TimePicker

const TimePicker: any;

const Tooltip: any;

variable Tour

const Tour: any;

variable Transfer

const Transfer: {
    <RecordType extends TransferItem = TransferItem>(
        props: TransferProps<RecordType>
    ): React.ReactElement<any, any>;
    displayName: string;
    List: {
        <RecordType_1 extends KeyWiseTransferItem>(
            props: TransferListProps<RecordType_1>
        ): React.JSX.Element;
        displayName: string;
    };
    Search: React.FC<TransferSearchProps>;
    Operation: React.FC<TransferOperationProps>;
};

variable Tree

const Tree: CompoundedComponent;

variable TreeSelect

const TreeSelect: CompoundedComponent;

variable Typography

const Typography: any;

variable Upload

const Upload: any;

variable version

const version: string;

variable Watermark

const Watermark: React.FC<WatermarkProps>;

Functions

function List

List: typeof List;

Interfaces

interface AffixProps

interface AffixProps {}

property children

children: React.ReactNode;

property className

className?: string;

property offsetBottom

offsetBottom?: number;

Triggered when the specified offset is reached from the bottom of the window

property offsetTop

offsetTop?: number;

Triggered when the specified offset is reached from the top of the window

property onChange

onChange?: (affixed?: boolean) => void;

Callback function triggered when fixed state changes

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property style

style?: React.CSSProperties;

property target

target?: () => Window | HTMLElement | null;

Set the element that Affix needs to listen to its scroll event, the value is a function that returns the corresponding DOM element

interface AffixRef

interface AffixRef {}

property updatePosition

updatePosition: ReturnType<typeof throttleByAnimationFrame>;

interface AlertProps

interface AlertProps {}

property action

action?: React.ReactNode;

property afterClose

afterClose?: () => void;

Trigger when animation ending of Alert

banner?: boolean;

property className

className?: string;

property closable

closable?: ClosableType;

Whether Alert can be closed

property closeIcon

closeIcon?: React.ReactNode;

property closeText

closeText?: React.ReactNode;

Deprecated
please use closable.closeIcon instead. Close text to show

property description

description?: React.ReactNode;

Additional content of Alert

property icon

icon?: React.ReactNode;

property message

message?: React.ReactNode;

Content of Alert

property onClick

onClick?: React.MouseEventHandler<HTMLDivElement>;

property onClose

onClose?: React.MouseEventHandler<HTMLButtonElement>;

Callback when close Alert

property onMouseEnter

onMouseEnter?: React.MouseEventHandler<HTMLDivElement>;

property onMouseLeave

onMouseLeave?: React.MouseEventHandler<HTMLDivElement>;

property prefixCls

prefixCls?: string;

property role

role?: string;

https://www.w3.org/TR/2014/REC-html5-20141028/dom.html#aria-role-attribute

property rootClassName

rootClassName?: string;

property showIcon

showIcon?: boolean;

Whether to show icon

property style

style?: React.CSSProperties;

property type

type?: 'success' | 'info' | 'warning' | 'error';

Type of Alert styles, options:success, info, warning, error

interface AnchorLinkProps

interface AnchorLinkProps extends AnchorLinkBaseProps {}

property children

children?: React.ReactNode;

interface AnchorProps

interface AnchorProps {}

property affix

affix?: boolean;

property bounds

bounds?: number;

property children

children?: React.ReactNode;

Deprecated
Please use items instead.

property className

className?: string;

property direction

direction?: AnchorDirection;

property getContainer

getContainer?: () => AnchorContainer;

property getCurrentAnchor

getCurrentAnchor?: (activeLink: string) => string;

Return customize highlight anchor

property items

items?: AnchorLinkItemProps[];

property offsetTop

offsetTop?: number;

property onChange

onChange?: (currentActiveLink: string) => void;

Listening event when scrolling change active link

property onClick

onClick?: (
    e: React.MouseEvent<HTMLElement>,
    link: {
        title: React.ReactNode;
        href: string;
    }
) => void;

property prefixCls

prefixCls?: string;

property replace

replace?: boolean;

property rootClassName

rootClassName?: string;

property showInkInFixed

showInkInFixed?: boolean;

property style

style?: React.CSSProperties;

property targetOffset

targetOffset?: number;

Scroll to target offset value, if none, it's offsetTop prop value or 0.

interface AppProps

interface AppProps<P = AnyObject> extends AppConfig {}

property children

children?: ReactNode;

property className

className?: string;

property component

component?: CustomComponent<P> | false;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property style

style?: React.CSSProperties;

interface AutoCompleteProps

interface AutoCompleteProps<
    ValueType = any,
    OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType
> extends Omit<
        InternalSelectProps<ValueType, OptionType>,
        'loading' | 'mode' | 'optionLabelProp' | 'labelInValue'
    > {}

property dataSource

dataSource?: DataSourceItemType[];

Deprecated
Please use options instead

property dropdownClassName

dropdownClassName?: string;

Deprecated
Please use popupClassName instead

property dropdownMatchSelectWidth

dropdownMatchSelectWidth?: boolean | number;

Deprecated
Please use popupMatchSelectWidth instead

property popupClassName

popupClassName?: string;

property popupMatchSelectWidth

popupMatchSelectWidth?: boolean | number;

property status

status?: InputStatus;

interface AvatarProps

interface AvatarProps {}

property alt

alt?: string;

property children

children?: React.ReactNode;

property className

className?: string;

property crossOrigin

crossOrigin?: '' | 'anonymous' | 'use-credentials';

property draggable

draggable?: boolean | 'true' | 'false';

property gap

gap?: number;

property icon

icon?: React.ReactNode;

Icon to be used in avatar

property onClick

onClick?: (e?: React.MouseEvent<HTMLElement>) => void;

property onError

onError?: () => boolean;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property shape

shape?: 'circle' | 'square';

Shape of avatar, options: circle, square

property size

size?: AvatarSize;

property src

src?: React.ReactNode;

Src of image avatar

property srcSet

srcSet?: string;

Srcset of image avatar

property style

style?: React.CSSProperties;

interface BackTopProps

interface BackTopProps {}

property children

children?: React.ReactNode;

property className

className?: string;

property duration

duration?: number;

property onClick

onClick?: React.MouseEventHandler<HTMLElement>;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property style

style?: React.CSSProperties;

property target

target?: () => HTMLElement | Window | Document;

property visibilityHeight

visibilityHeight?: number;

interface BadgeProps

interface BadgeProps {}

property children

children?: React.ReactNode;

property className

className?: string;

property classNames

classNames?: {
    root?: string;
    indicator?: string;
};

property color

color?: LiteralUnion<PresetColorKey>;

property count

count?: React.ReactNode;

Number to show in badge

property dot

dot?: boolean;

Whether to show red dot without number

property offset

offset?: [number | string, number | string];

property overflowCount

overflowCount?: number;

Max count to show

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property scrollNumberPrefixCls

scrollNumberPrefixCls?: string;

property showZero

showZero?: boolean;

property size

size?: 'default' | 'small';

property status

status?: PresetStatusColorType;

property style

style?: React.CSSProperties;

property styles

styles?: {
    root?: React.CSSProperties;
    indicator?: React.CSSProperties;
};

property text

text?: React.ReactNode;

property title

title?: string;

interface BreadcrumbItemProps

interface BreadcrumbItemProps extends SeparatorType {}

property children

children?: React.ReactNode;

property className

className?: string;

property dropdownProps

dropdownProps?: DropdownProps;

property href

href?: string;

menu?: Omit<MenuType, 'items'> & {
    items?: MenuItem[];
};

property onClick

onClick?: React.MouseEventHandler<HTMLAnchorElement | HTMLSpanElement>;

property overlay

overlay?: DropdownProps['overlay'];

Deprecated
Please use menu instead

property prefixCls

prefixCls?: string;

interface BreadcrumbProps

interface BreadcrumbProps<T extends AnyObject = AnyObject> {}

property children

children?: React.ReactNode;

property className

className?: string;

property itemRender

itemRender?: (
    route: ItemType,
    params: T,
    routes: ItemType[],
    paths: string[]
) => React.ReactNode;

property items

items?: ItemType[];

property params

params?: T;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property routes

routes?: ItemType[];

Deprecated
Please use items instead

property separator

separator?: React.ReactNode;

property style

style?: React.CSSProperties;

interface ButtonProps

interface ButtonProps extends BaseButtonProps, MergedHTMLAttributes {}

property href

href?: string;

property htmlType

htmlType?: ButtonHTMLType;

interface CalendarProps

interface CalendarProps<DateType> {}

property cellRender

cellRender?: (date: DateType, info: CellRenderInfo<DateType>) => React.ReactNode;

property className

className?: string;

property dateCellRender

dateCellRender?: (date: DateType) => React.ReactNode;

Deprecated
Please use cellRender instead.

property dateFullCellRender

dateFullCellRender?: (date: DateType) => React.ReactNode;

Deprecated
Please use fullCellRender instead.

property defaultValue

defaultValue?: DateType;

property disabledDate

disabledDate?: (date: DateType) => boolean;

property fullCellRender

fullCellRender?: (
    date: DateType,
    info: CellRenderInfo<DateType>
) => React.ReactNode;

property fullscreen

fullscreen?: boolean;

property headerRender

headerRender?: HeaderRender<DateType>;

property locale

locale?: typeof enUS;

property mode

mode?: CalendarMode;

property monthCellRender

monthCellRender?: (date: DateType) => React.ReactNode;

Deprecated
Please use cellRender instead.

property monthFullCellRender

monthFullCellRender?: (date: DateType) => React.ReactNode;

Deprecated
Please use fullCellRender instead.

property onChange

onChange?: (date: DateType) => void;

property onPanelChange

onPanelChange?: (date: DateType, mode: CalendarMode) => void;

property onSelect

onSelect?: (date: DateType, selectInfo: SelectInfo) => void;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property style

style?: React.CSSProperties;

property validRange

validRange?: [DateType, DateType];

property value

value?: DateType;

interface CardProps

interface CardProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {}

property actions

actions?: React.ReactNode[];

property activeTabKey

activeTabKey?: string;

property bodyStyle

bodyStyle?: React.CSSProperties;

Deprecated
Please use styles.body instead

property bordered

bordered?: boolean;

property children

children?: React.ReactNode;

property className

className?: string;

property classNames

classNames?: {
    header?: string;
    body?: string;
    extra?: string;
    title?: string;
    actions?: string;
    cover?: string;
};

property cover

cover?: React.ReactNode;

property defaultActiveTabKey

defaultActiveTabKey?: string;

property extra

extra?: React.ReactNode;

property headStyle

headStyle?: React.CSSProperties;

Deprecated
Please use styles.header instead

property hoverable

hoverable?: boolean;

property id

id?: string;

property loading

loading?: boolean;

property onTabChange

onTabChange?: (key: string) => void;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property size

size?: CardSize;

property style

style?: React.CSSProperties;

property styles

styles?: {
    header?: React.CSSProperties;
    body?: React.CSSProperties;
    extra?: React.CSSProperties;
    title?: React.CSSProperties;
    actions?: React.CSSProperties;
    cover?: React.CSSProperties;
};

property tabBarExtraContent

tabBarExtraContent?: React.ReactNode;

property tabList

tabList?: CardTabListType[];

property tabProps

tabProps?: TabsProps;

property title

title?: React.ReactNode;

property type

type?: CardType;

interface CarouselProps

interface CarouselProps extends Omit<Settings, 'dots' | 'dotsClass'> {}

property children

children?: React.ReactNode;

property dotPosition

dotPosition?: DotPosition;

property dots

dots?:
    | boolean
    | {
          className?: string;
      };

property effect

effect?: CarouselEffect;

property id

id?: string;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property slickGoTo

slickGoTo?: number;

property style

style?: React.CSSProperties;

property waitForAnimate

waitForAnimate?: boolean;

interface CheckboxOptionType

interface CheckboxOptionType<T extends CheckboxValueType = CheckboxValueType> {}

property disabled

disabled?: boolean;

property id

id?: string;

property label

label: React.ReactNode;

property onChange

onChange?: (e: CheckboxChangeEvent) => void;

property required

required?: boolean;

property style

style?: React.CSSProperties;

property title

title?: string;

property value

value: T;

interface CheckboxProps

interface CheckboxProps extends AbstractCheckboxProps<CheckboxChangeEvent> {}

property indeterminate

indeterminate?: boolean;

interface CollapsePanelProps

interface CollapsePanelProps {}

property children

children?: React.ReactNode;

property className

className?: string;

property collapsible

collapsible?: CollapsibleType;

property disabled

disabled?: boolean;

Deprecated
Use collapsible="disabled" instead

property extra

extra?: React.ReactNode;

property forceRender

forceRender?: boolean;

header: React.ReactNode;

property id

id?: string;

property key

key: string | number;

property prefixCls

prefixCls?: string;

property showArrow

showArrow?: boolean;

property style

style?: React.CSSProperties;

interface CollapseProps

interface CollapseProps extends Pick<RcCollapseProps, 'items'> {}

property accordion

accordion?: boolean;

手风琴效果

property activeKey

activeKey?: Array<string | number> | string | number;

property bordered

bordered?: boolean;

property children

children?: React.ReactNode;

Deprecated
use items instead

property className

className?: string;

property collapsible

collapsible?: CollapsibleType;

property defaultActiveKey

defaultActiveKey?: Array<string | number> | string | number;

property destroyInactivePanel

destroyInactivePanel?: boolean;

property expandIcon

expandIcon?: (panelProps: PanelProps) => React.ReactNode;

property expandIconPosition

expandIconPosition?: ExpandIconPosition;

property ghost

ghost?: boolean;

property onChange

onChange?: (key: string | string[]) => void;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property size

size?: SizeType;

property style

style?: React.CSSProperties;

interface ColProps

interface ColProps extends React.HTMLAttributes<HTMLDivElement> {}

property flex

flex?: FlexType;

property lg

lg?: ColSpanType | ColSize;

property md

md?: ColSpanType | ColSize;

property offset

offset?: ColSpanType;

property order

order?: ColSpanType;

property prefixCls

prefixCls?: string;

property pull

pull?: ColSpanType;

property push

push?: ColSpanType;

property sm

sm?: ColSpanType | ColSize;

property span

span?: ColSpanType;

property xl

xl?: ColSpanType | ColSize;

property xs

xs?: ColSpanType | ColSize;

property xxl

xxl?: ColSpanType | ColSize;

interface ConfigProviderProps

interface ConfigProviderProps {}

property alert

alert?: AlertConfig;

property anchor

anchor?: ComponentStyleConfig;

property autoInsertSpaceInButton

autoInsertSpaceInButton?: boolean;

property avatar

avatar?: ComponentStyleConfig;

property badge

badge?: BadgeConfig;

breadcrumb?: ComponentStyleConfig;

property button

button?: ButtonConfig;

property calendar

calendar?: ComponentStyleConfig;

property card

card?: CardConfig;

property carousel

carousel?: ComponentStyleConfig;

property cascader

cascader?: ComponentStyleConfig;

property checkbox

checkbox?: ComponentStyleConfig;

property children

children?: React.ReactNode;

property collapse

collapse?: CollapseConfig;

property colorPicker

colorPicker?: ComponentStyleConfig;

property componentDisabled

componentDisabled?: boolean;

property componentSize

componentSize?: SizeType;

property csp

csp?: CSPConfig;

property datePicker

datePicker?: ComponentStyleConfig;

property descriptions

descriptions?: ComponentStyleConfig;

property direction

direction?: DirectionType;

设置布局展示方向。 Set direction of layout. ltr

property divider

divider?: ComponentStyleConfig;

property drawer

drawer?: DrawerConfig;

dropdown?: ComponentStyleConfig;

property dropdownMatchSelectWidth

dropdownMatchSelectWidth?: boolean;

Deprecated
Please use popupMatchSelectWidth instead

property empty

empty?: ComponentStyleConfig;

property flex

flex?: FlexConfig;

property floatButtonGroup

floatButtonGroup?: FloatButtonGroupConfig;

property form

form?: FormConfig;

property getPopupContainer

getPopupContainer?: (triggerNode?: HTMLElement) => HTMLElement;

property getTargetContainer

getTargetContainer?: () => HTMLElement | Window;

property iconPrefixCls

iconPrefixCls?: string;

property image

image?: ImageConfig;

property input

input?: InputConfig;

property layout

layout?: ComponentStyleConfig;

property list

list?: ComponentStyleConfig;

property locale

locale?: Locale;

语言包配置，语言包可到 antd/locale 目录下寻找。 Language package setting, you can find the packages in antd/locale.

property mentions

mentions?: ComponentStyleConfig;

menu?: MenuConfig;

property message

message?: ComponentStyleConfig;

modal?: ModalConfig;

property notification

notification?: NotificationConfig;

property pagination

pagination?: PaginationConfig;

property popupMatchSelectWidth

popupMatchSelectWidth?: boolean;

property popupOverflow

popupOverflow?: PopupOverflow;

property prefixCls

prefixCls?: string;

property progress

progress?: ComponentStyleConfig;

property radio

radio?: ComponentStyleConfig;

property rangePicker

rangePicker?: ComponentStyleConfig;

property rate

rate?: ComponentStyleConfig;

property renderEmpty

renderEmpty?: RenderEmptyHandler;

property result

result?: ComponentStyleConfig;

property segmented

segmented?: ComponentStyleConfig;

property select

select?: SelectConfig;

property skeleton

skeleton?: ComponentStyleConfig;

property slider

slider?: ComponentStyleConfig;

property space

space?: SpaceConfig;

property spin

spin?: ComponentStyleConfig;

property statistic

statistic?: ComponentStyleConfig;

property steps

steps?: ComponentStyleConfig;

property switch

switch?: ComponentStyleConfig;

property table

table?: TableConfig;

property tabs

tabs?: TabsConfig;

property tag

tag?: TagConfig;

property textArea

textArea?: TextAreaConfig;

property theme

theme?: ThemeConfig;

property timeline

timeline?: ComponentStyleConfig;

property timePicker

timePicker?: ComponentStyleConfig;

property tour

tour?: TourConfig;

property transfer

transfer?: TransferConfig;

property tree

tree?: ComponentStyleConfig;

property typography

typography?: ComponentStyleConfig;

property upload

upload?: ComponentStyleConfig;

property virtual

virtual?: boolean;

设置 false 时关闭虚拟滚动。 Close the virtual scrolling when setting false. true

property warning

warning?: WarningContextProps;

property wave

wave?: WaveConfig;

Wave is special component which only patch on the effect of component interaction.

interface CountdownProps

interface CountdownProps extends StatisticProps {}

property format

format?: string;

property onChange

onChange?: (value?: valueType) => void;

property onFinish

onFinish?: () => void;

interface DescriptionsProps

interface DescriptionsProps {}

property bordered

bordered?: boolean;

property children

children?: React.ReactNode;

Deprecated
use items instead

property className

className?: string;

property colon

colon?: boolean;

property column

column?: number | Partial<Record<Breakpoint, number>>;

property contentStyle

contentStyle?: React.CSSProperties;

property extra

extra?: React.ReactNode;

property id

id?: string;

property items

items?: DescriptionsItemType[];

property labelStyle

labelStyle?: React.CSSProperties;

property layout

layout?: 'horizontal' | 'vertical';

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property size

size?: 'middle' | 'small' | 'default';

property style

style?: React.CSSProperties;

property title

title?: React.ReactNode;

interface DividerProps

interface DividerProps {}

property children

children?: React.ReactNode;

property className

className?: string;

property dashed

dashed?: boolean;

property orientation

orientation?: 'left' | 'right' | 'center';

property orientationMargin

orientationMargin?: string | number;

property plain

plain?: boolean;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property style

style?: React.CSSProperties;

property type

type?: 'horizontal' | 'vertical';

interface DrawerProps

interface DrawerProps
    extends Omit<RcDrawerProps, 'maskStyle'>,
        Omit<DrawerPanelProps, 'prefixCls'> {}

property afterOpenChange

afterOpenChange?: (open: boolean) => void;

property afterVisibleChange

afterVisibleChange?: (open: boolean) => void;

Deprecated
Please use afterOpenChange instead

property classNames

classNames?: DrawerClassNames;

property open

open?: boolean;

property size

size?: sizeType;

property styles

styles?: DrawerStyles;

property visible

visible?: boolean;

Deprecated
Please use open instead

interface DropdownProps

interface DropdownProps {}

property align

align?: AlignType;

property arrow

arrow?: boolean | DropdownArrowOptions;

property autoAdjustOverflow

autoAdjustOverflow?: boolean | AdjustOverflow;

property autoFocus

autoFocus?: boolean;

property children

children?: React.ReactNode;

property className

className?: string;

property destroyPopupOnHide

destroyPopupOnHide?: boolean;

property disabled

disabled?: boolean;

property dropdownRender

dropdownRender?: (originNode: React.ReactNode) => React.ReactNode;

property forceRender

forceRender?: boolean;

property getPopupContainer

getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;

menu?: MenuProps;

property mouseEnterDelay

mouseEnterDelay?: number;

property mouseLeaveDelay

mouseLeaveDelay?: number;

property onOpenChange

onOpenChange?: (
    open: boolean,
    info: {
        source: 'trigger' | 'menu';
    }
) => void;

property onVisibleChange

onVisibleChange?: (open: boolean) => void;

Deprecated
Please use onOpenChange instead

property open

open?: boolean;

property openClassName

openClassName?: string;

property overlay

overlay?: React.ReactElement | OverlayFunc;

Deprecated
Please use menu instead

property overlayClassName

overlayClassName?: string;

property overlayStyle

overlayStyle?: React.CSSProperties;

property placement

placement?: Placement;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property transitionName

transitionName?: string;

property trigger

trigger?: ('click' | 'hover' | 'contextMenu')[];

property visible

visible?: boolean;

Deprecated
Please use open instead

interface DropDownProps

interface DropdownProps {}

property align

align?: AlignType;

property arrow

arrow?: boolean | DropdownArrowOptions;

property autoAdjustOverflow

autoAdjustOverflow?: boolean | AdjustOverflow;

property autoFocus

autoFocus?: boolean;

property children

children?: React.ReactNode;

property className

className?: string;

property destroyPopupOnHide

destroyPopupOnHide?: boolean;

property disabled

disabled?: boolean;

property dropdownRender

dropdownRender?: (originNode: React.ReactNode) => React.ReactNode;

property forceRender

forceRender?: boolean;

property getPopupContainer

getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;

menu?: MenuProps;

property mouseEnterDelay

mouseEnterDelay?: number;

property mouseLeaveDelay

mouseLeaveDelay?: number;

property onOpenChange

onOpenChange?: (
    open: boolean,
    info: {
        source: 'trigger' | 'menu';
    }
) => void;

property onVisibleChange

onVisibleChange?: (open: boolean) => void;

Deprecated
Please use onOpenChange instead

property open

open?: boolean;

property openClassName

openClassName?: string;

property overlay

overlay?: React.ReactElement | OverlayFunc;

Deprecated
Please use menu instead

property overlayClassName

overlayClassName?: string;

property overlayStyle

overlayStyle?: React.CSSProperties;

property placement

placement?: Placement;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property transitionName

transitionName?: string;

property trigger

trigger?: ('click' | 'hover' | 'contextMenu')[];

property visible

visible?: boolean;

Deprecated
Please use open instead

interface EmptyProps

interface EmptyProps {}

property children

children?: React.ReactNode;

property className

className?: string;

property description

description?: React.ReactNode;

property image

image?: React.ReactNode;

property imageStyle

imageStyle?: React.CSSProperties;

3.16.0

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property style

style?: React.CSSProperties;

interface FlexProps

interface FlexProps<P = AnyObject> extends React.HTMLAttributes<HTMLElement> {}

property align

align?: React.CSSProperties['alignItems'];

property children

children: React.ReactNode;

property component

component?: CustomComponent<P>;

property flex

flex?: React.CSSProperties['flex'];

property gap

gap?: React.CSSProperties['gap'] | SizeType;

property justify

justify?: React.CSSProperties['justifyContent'];

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property vertical

vertical?: boolean;

property wrap

wrap?: React.CSSProperties['flexWrap'];

interface FloatButtonGroupProps

interface FloatButtonGroupProps extends FloatButtonProps {}

property children

children: React.ReactNode;

property closeIcon

closeIcon?: React.ReactNode;

property onOpenChange

onOpenChange?: (open: boolean) => void;

property open

open?: boolean;

property trigger

trigger?: FloatButtonGroupTrigger;

interface FloatButtonProps

interface FloatButtonProps extends React.DOMAttributes<FloatButtonElement> {}

property ['aria-label']

['aria-label']?: React.HtmlHTMLAttributes<HTMLElement>['aria-label'];

property badge

badge?: FloatButtonBadgeProps;

property className

className?: string;

property description

description?: React.ReactNode;

property href

href?: string;

property icon

icon?: React.ReactNode;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property shape

shape?: FloatButtonShape;

property style

style?: React.CSSProperties;

property target

target?: React.HTMLAttributeAnchorTarget;

property tooltip

tooltip?: TooltipProps['title'];

property type

type?: FloatButtonType;

interface FloatButtonRef

interface FloatButtonRef {}

property nativeElement

nativeElement: FloatButtonElement | null;

interface FormInstance

interface FormInstance<Values = any> extends RcFormInstance<Values> {}

property getFieldInstance

getFieldInstance: (name: NamePath) => any;

property scrollToField

scrollToField: (name: NamePath, options?: ScrollOptions) => void;

interface FormItemProps

interface FormItemProps<Values = any>
    extends Omit<FormItemLabelProps, 'requiredMark'>,
        FormItemInputProps,
        RcFieldProps<Values> {}

property children

children?: ChildrenType<Values>;

property className

className?: string;

property fieldKey

fieldKey?: React.Key | React.Key[];

Deprecated
No need anymore

property hasFeedback

hasFeedback?:
    | boolean
    | {
          icons: FeedbackIcons;
      };

property hidden

hidden?: boolean;

property id

id?: string;

property initialValue

initialValue?: any;

property messageVariables

messageVariables?: Record<string, string>;

property noStyle

noStyle?: boolean;

property prefixCls

prefixCls?: string;

property required

required?: boolean;

property rootClassName

rootClassName?: string;

property style

style?: React.CSSProperties;

property tooltip

tooltip?: LabelTooltipType;

property validateStatus

validateStatus?: ValidateStatus;

interface FormListFieldData

interface FormListFieldData {}

property fieldKey

fieldKey?: number;

Deprecated
No need anymore Use key instead

property key

key: number;

property name

name: number;

interface FormListOperation

interface FormListOperation {}

property add

add: (defaultValue?: StoreValue, insertIndex?: number) => void;

property move

move: (from: number, to: number) => void;

property remove

remove: (index: number | number[]) => void;

interface FormProps

interface FormProps<Values = any> extends Omit<RcFormProps<Values>, 'form'> {}

property colon

colon?: boolean;

property disabled

disabled?: boolean;

property feedbackIcons

feedbackIcons?: FeedbackIcons;

property form

form?: FormInstance<Values>;

property hideRequiredMark

hideRequiredMark?: boolean;

Deprecated
Will warning in future branch. Pls use requiredMark instead.

property labelAlign

labelAlign?: FormLabelAlign;

property labelCol

labelCol?: ColProps;

property labelWrap

labelWrap?: boolean;

property layout

layout?: FormLayout;

property name

name?: string;

property prefixCls

prefixCls?: string;

property requiredMark

requiredMark?: RequiredMark;

property rootClassName

rootClassName?: string;

property scrollToFirstError

scrollToFirstError?: Options | boolean;

property size

size?: SizeType;

property variant

variant?: Variant;

property wrapperCol

wrapperCol?: ColProps;

interface InputNumberProps

interface InputNumberProps<T extends ValueType = ValueType>
    extends Omit<RcInputNumberProps<T>, 'prefix' | 'size' | 'controls'> {}

property addonAfter

addonAfter?: React.ReactNode;

property addonBefore

addonBefore?: React.ReactNode;

property bordered

bordered?: boolean;

Deprecated
Use variant instead.

property controls

controls?:
    | boolean
    | {
          upIcon?: React.ReactNode;
          downIcon?: React.ReactNode;
      };

property disabled

disabled?: boolean;

property prefix

prefix?: React.ReactNode;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property size

size?: SizeType;

property status

status?: InputStatus;

property variant

variant?: Variant;

5.13.0 "outlined"

interface InputProps

interface InputProps
    extends Omit<
        RcInputProps,
        | 'wrapperClassName'
        | 'groupClassName'
        | 'inputClassName'
        | 'affixWrapperClassName'
        | 'classes'
    > {}

property bordered

bordered?: boolean;

Deprecated
Use variant="borderless" instead.

property disabled

disabled?: boolean;

property rootClassName

rootClassName?: string;

property size

size?: SizeType;

property status

status?: InputStatus;

property variant

variant?: Variant;

5.13.0 "outlined"

index signature

[key: `data-${string}`]: string | undefined;

interface LayoutProps

interface BasicProps extends React.HTMLAttributes<HTMLDivElement> {}

property hasSider

hasSider?: boolean;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property suffixCls

suffixCls?: string;

interface ListProps

interface ListProps<T> {}

property bordered

bordered?: boolean;

property children

children?: React.ReactNode;

property className

className?: string;

property dataSource

dataSource?: T[];

property extra

extra?: React.ReactNode;

footer?: React.ReactNode;

property grid

grid?: ListGridType;

header?: React.ReactNode;

property id

id?: string;

property itemLayout

itemLayout?: ListItemLayout;

property loading

loading?: boolean | SpinProps;

property loadMore

loadMore?: React.ReactNode;

property locale

locale?: ListLocale;

property pagination

pagination?: PaginationConfig | false;

property prefixCls

prefixCls?: string;

property renderItem

renderItem?: (item: T, index: number) => React.ReactNode;

property rootClassName

rootClassName?: string;

property rowKey

rowKey?: ((item: T) => React.Key) | keyof T;

property size

size?: ListSize;

property split

split?: boolean;

property style

style?: React.CSSProperties;

interface MentionProps

interface MentionProps extends Omit<RcMentionsProps, 'suffix'> {}

property loading

loading?: boolean;

property options

options?: MentionsOptionProps[];

property popupClassName

popupClassName?: string;

property rootClassName

rootClassName?: string;

property status

status?: InputStatus;

property variant

variant?: Variant;

5.13.0 "outlined"

interface MenuItemProps

interface MenuItemProps extends Omit<RcMenuItemProps, 'title'> {}

property danger

danger?: boolean;

property icon

icon?: React.ReactNode;

property title

title?: React.ReactNode;

interface MenuProps

interface MenuProps extends Omit<RcMenuProps, 'items'> {}

property inlineIndent

inlineIndent?: number;

property items

items?: ItemType[];

property theme

theme?: MenuTheme;

interface MessageArgsProps

interface ArgsProps {}

property className

className?: string;

property content

content: React.ReactNode;

property duration

duration?: number;

property icon

icon?: React.ReactNode;

property key

key?: string | number;

property onClick

onClick?: (e: React.MouseEvent<HTMLDivElement>) => void;

property onClose

onClose?: () => void;

property style

style?: React.CSSProperties;

property type

type?: NoticeType;

interface ModalFuncProps

interface ModalFuncProps extends ModalCommonProps {}

property afterClose

afterClose?: () => void;

property autoFocusButton

autoFocusButton?: null | 'ok' | 'cancel';

property bodyStyle

bodyStyle?: React.CSSProperties;

Deprecated
Please use styles.body instead

property cancelButtonProps

cancelButtonProps?: ButtonProps;

property cancelText

cancelText?: React.ReactNode;

property centered

centered?: boolean;

property className

className?: string;

property closable

closable?: ClosableType;

property closeIcon

closeIcon?: React.ReactNode;

property content

content?: React.ReactNode;

property direction

direction?: DirectionType;

property focusTriggerAfterClose

focusTriggerAfterClose?: boolean;

footer?: ModalProps['footer'];

property getContainer

getContainer?: string | HTMLElement | getContainerFunc | false;

property icon

icon?: React.ReactNode;

property keyboard

keyboard?: boolean;

property mask

mask?: boolean;

property maskClosable

maskClosable?: boolean;

property maskStyle

maskStyle?: React.CSSProperties;

Deprecated
Please use styles.mask instead

property maskTransitionName

maskTransitionName?: string;

property modalRender

modalRender?: (node: React.ReactNode) => React.ReactNode;

property okButtonProps

okButtonProps?: ButtonProps;

property okCancel

okCancel?: boolean;

property okText

okText?: React.ReactNode;

property okType

okType?: LegacyButtonType;

property onCancel

onCancel?: (...args: any[]) => any;

property onOk

onOk?: (...args: any[]) => any;

property open

open?: boolean;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property style

style?: React.CSSProperties;

property title

title?: React.ReactNode;

property transitionName

transitionName?: string;

property type

type?: 'info' | 'success' | 'error' | 'warn' | 'warning' | 'confirm';

property visible

visible?: boolean;

Deprecated
Please use open instead.

property width

width?: string | number;

property wrapClassName

wrapClassName?: string;

property zIndex

zIndex?: number;

interface ModalProps

interface ModalProps extends ModalCommonProps {}

property afterClose

afterClose?: () => void;

property afterOpenChange

afterOpenChange?: (open: boolean) => void;

Callback when the animation ends when Modal is turned on and off

property bodyStyle

bodyStyle?: React.CSSProperties;

Deprecated
Please use styles.body instead

property cancelButtonProps

cancelButtonProps?: ButtonProps;

property cancelText

cancelText?: React.ReactNode;

Text of the Cancel button

property centered

centered?: boolean;

Centered Modal

property children

children?: React.ReactNode;

property className

className?: string;

property classNames

classNames?: NonNullable<DialogProps['classNames']>;

property closable

closable?: ClosableType;

Whether a close (x) button is visible on top right of the modal dialog or not. Recommend to use closeIcon instead.

property closeIcon

closeIcon?: React.ReactNode;

property confirmLoading

confirmLoading?: boolean;

Whether to apply loading visual effect for OK button or not

property destroyOnClose

destroyOnClose?: boolean;

property focusTriggerAfterClose

focusTriggerAfterClose?: boolean;

footer?: ModalFooterRender | React.ReactNode;

Footer content

property forceRender

forceRender?: boolean;

Force render Modal

property getContainer

getContainer?: string | HTMLElement | getContainerFunc | false;

property keyboard

keyboard?: boolean;

property mask

mask?: boolean;

property maskClosable

maskClosable?: boolean;

Whether to close the modal dialog when the mask (area outside the modal) is clicked

property maskStyle

maskStyle?: React.CSSProperties;

Deprecated
Please use styles.mask instead

property maskTransitionName

maskTransitionName?: string;

property modalRender

modalRender?: (node: React.ReactNode) => React.ReactNode;

property mousePosition

mousePosition?: MousePosition;

property okButtonProps

okButtonProps?: ButtonProps;

property okText

okText?: React.ReactNode;

Text of the OK button

property okType

okType?: LegacyButtonType;

Button type of the OK button

property onCancel

onCancel?: (e: React.MouseEvent<HTMLButtonElement>) => void;

Specify a function that will be called when a user clicks mask, close button on top right or Cancel button

property onOk

onOk?: (e: React.MouseEvent<HTMLButtonElement>) => void;

Specify a function that will be called when a user clicks the OK button

property open

open?: boolean;

Whether the modal dialog is visible or not

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property style

style?: React.CSSProperties;

property title

title?: React.ReactNode;

The modal dialog's title

property transitionName

transitionName?: string;

property visible

visible?: boolean;

Deprecated
Please use open instead.

property width

width?: string | number;

Width of the modal dialog

property wrapClassName

wrapClassName?: string;

property wrapProps

wrapProps?: any;

property zIndex

zIndex?: number;

interface NotificationArgsProps

interface ArgsProps {}

property btn

btn?: React.ReactNode;

property className

className?: string;

property closable

closable?: ClosableType;

property closeIcon

closeIcon?: React.ReactNode;

property description

description?: React.ReactNode;

property duration

duration?: number | null;

property icon

icon?: React.ReactNode;

property key

key?: React.Key;

property message

message: React.ReactNode;

property onClick

onClick?: () => void;

property onClose

onClose?: () => void;

property placement

placement?: NotificationPlacement;

property props

props?: DivProps;

property role

role?: 'alert' | 'status';

property style

style?: React.CSSProperties;

property type

readonly type?: IconType;

interface PaginationProps

interface PaginationProps extends RcPaginationProps {}

property responsive

responsive?: boolean;

property role

role?: string;

property rootClassName

rootClassName?: string;

property showQuickJumper

showQuickJumper?:
    | boolean
    | {
          goButton?: React.ReactNode;
      };

property size

size?: 'default' | 'small';

property totalBoundaryShowSizeChanger

totalBoundaryShowSizeChanger?: number;

interface PopconfirmProps

interface PopconfirmProps extends AbstractTooltipProps {}

property cancelButtonProps

cancelButtonProps?: ButtonProps;

property cancelText

cancelText?: React.ReactNode;

property description

description?: React.ReactNode | RenderFunction;

property disabled

disabled?: boolean;

property icon

icon?: React.ReactNode;

property okButtonProps

okButtonProps?: ButtonProps;

property okText

okText?: React.ReactNode;

property okType

okType?: LegacyButtonType;

property onCancel

onCancel?: (e?: React.MouseEvent<HTMLElement>) => void;

property onConfirm

onConfirm?: (e?: React.MouseEvent<HTMLElement>) => void;

property onOpenChange

onOpenChange?: (
    open: boolean,
    e?: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLDivElement>
) => void;

property onPopupClick

onPopupClick?: (e: React.MouseEvent<HTMLElement>) => void;

property showCancel

showCancel?: boolean;

property title

title: React.ReactNode | RenderFunction;

interface PopoverProps

interface PopoverProps extends AbstractTooltipProps {}

property content

content?: React.ReactNode | RenderFunction;

property onOpenChange

onOpenChange?: (
    open: boolean,
    e?: React.MouseEvent<HTMLElement> | React.KeyboardEvent<HTMLDivElement>
) => void;

property title

title?: React.ReactNode | RenderFunction;

interface ProgressProps

interface ProgressProps extends ProgressAriaProps {}

property children

children?: React.ReactNode;

property className

className?: string;

property format

format?: (percent?: number, successPercent?: number) => React.ReactNode;

property gapDegree

gapDegree?: number;

property gapPosition

gapPosition?: 'top' | 'bottom' | 'left' | 'right';

property percent

percent?: number;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property showInfo

showInfo?: boolean;

property size

size?: number | [number | string, number] | ProgressSize;

property status

status?: (typeof ProgressStatuses)[number];

property steps

steps?:
    | number
    | {
          count: number;
          gap: number;
      };

property strokeColor

strokeColor?: string | string[] | ProgressGradient;

property strokeLinecap

strokeLinecap?: 'butt' | 'square' | 'round';

property strokeWidth

strokeWidth?: number;

property style

style?: React.CSSProperties;

property success

success?: SuccessProps;

property successPercent

successPercent?: number;

Deprecated
Use success instead

property trailColor

trailColor?: string;

property type

type?: ProgressType;

property width

width?: number;

Deprecated
Use size instead

interface QRCodeProps

interface QRCodeProps extends QRProps {}

property bordered

bordered?: boolean;

property className

className?: string;

property errorLevel

errorLevel?: 'L' | 'M' | 'Q' | 'H';

property icon

icon?: string;

property iconSize

iconSize?: number;

property onRefresh

onRefresh?: () => void;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property status

status?: 'active' | 'expired' | 'loading' | 'scanned';

interface RadioChangeEvent

interface RadioChangeEvent {}

property nativeEvent

nativeEvent: MouseEvent;

property preventDefault

preventDefault: () => void;

property stopPropagation

stopPropagation: () => void;

property target

target: RadioChangeEventTarget;

interface RadioGroupProps

interface RadioGroupProps extends AbstractCheckboxGroupProps {}

property buttonStyle

buttonStyle?: RadioGroupButtonStyle;

property children

children?: React.ReactNode;

property defaultValue

defaultValue?: any;

property disabled

disabled?: DisabledType;

property id

id?: string;

property name

name?: string;

property onBlur

onBlur?: React.FocusEventHandler<HTMLDivElement>;

property onChange

onChange?: (e: RadioChangeEvent) => void;

property onFocus

onFocus?: React.FocusEventHandler<HTMLDivElement>;

property onMouseEnter

onMouseEnter?: React.MouseEventHandler<HTMLDivElement>;

property onMouseLeave

onMouseLeave?: React.MouseEventHandler<HTMLDivElement>;

property optionType

optionType?: RadioGroupOptionType;

property size

size?: SizeType;

property value

value?: any;

interface RadioProps

interface RadioProps extends AbstractCheckboxProps<RadioChangeEvent> {}

interface RateProps

interface RateProps extends RcRateProps {}

property rootClassName

rootClassName?: string;

property tooltips

tooltips?: Array<string>;

interface ResultProps

interface ResultProps {}

property children

children?: React.ReactNode;

property className

className?: string;

property extra

extra?: React.ReactNode;

property icon

icon?: React.ReactNode;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property status

status?: ResultStatusType;

property style

style?: React.CSSProperties;

property subTitle

subTitle?: React.ReactNode;

property title

title?: React.ReactNode;

interface RowProps

interface RowProps extends React.HTMLAttributes<HTMLDivElement> {}

property align

align?: (typeof RowAligns)[number] | ResponsiveAligns;

property gutter

gutter?: Gutter | [Gutter, Gutter];

property justify

justify?: (typeof RowJustify)[number] | ResponsiveJustify;

property prefixCls

prefixCls?: string;

property wrap

wrap?: boolean;

interface SegmentedProps

interface SegmentedProps<ValueType = RcSegmentedValue>
    extends Omit<RCSegmentedProps<ValueType>, 'size' | 'options'> {}

property block

block?: boolean;

Option to fit width to its parent's width

property options

options: SegmentedOptions<ValueType>;

property rootClassName

rootClassName?: string;

property size

size?: SizeType;

Option to control the display size

interface SelectProps

interface SelectProps<
    ValueType = any,
    OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType
> extends Omit<
        InternalSelectProps<ValueType, OptionType>,
        'mode' | 'getInputElement' | 'getRawInputElement' | 'backfill' | 'placement'
    > {}

property dropdownClassName

dropdownClassName?: string;

Deprecated
Please use popupClassName instead

property dropdownMatchSelectWidth

dropdownMatchSelectWidth?: boolean | number;

Deprecated
Please use popupMatchSelectWidth instead

property mode

mode?: 'multiple' | 'tags';

property placement

placement?: SelectCommonPlacement;

property popupClassName

popupClassName?: string;

property popupMatchSelectWidth

popupMatchSelectWidth?: boolean | number;

property status

status?: InputStatus;

interface SiderProps

interface SiderProps extends React.HTMLAttributes<HTMLDivElement> {}

property breakpoint

breakpoint?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';

property collapsed

collapsed?: boolean;

property collapsedWidth

collapsedWidth?: number | string;

property collapsible

collapsible?: boolean;

property defaultCollapsed

defaultCollapsed?: boolean;

property onBreakpoint

onBreakpoint?: (broken: boolean) => void;

property onCollapse

onCollapse?: (collapsed: boolean, type: CollapseType) => void;

property prefixCls

prefixCls?: string;

property reverseArrow

reverseArrow?: boolean;

property theme

theme?: SiderTheme;

property trigger

trigger?: React.ReactNode;

property width

width?: number | string;

property zeroWidthTriggerStyle

zeroWidthTriggerStyle?: React.CSSProperties;

interface SkeletonProps

interface SkeletonProps {}

property active

active?: boolean;

property avatar

avatar?: SkeletonAvatarProps | boolean;

property children

children?: React.ReactNode;

property className

className?: string;

property loading

loading?: boolean;

property paragraph

paragraph?: SkeletonParagraphProps | boolean;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property round

round?: boolean;

property style

style?: React.CSSProperties;

property title

title?: SkeletonTitleProps | boolean;

interface SliderSingleProps

interface SliderSingleProps extends SliderBaseProps {}

property defaultValue

defaultValue?: number;

property handleStyle

handleStyle?: React.CSSProperties;

Deprecated
Please use styles.handle instead

property onAfterChange

onAfterChange?: (value: number) => void;

Deprecated
Please use onChangeComplete instead

property onChange

onChange?: (value: number) => void;

property onChangeComplete

onChangeComplete?: (value: number) => void;

property railStyle

railStyle?: React.CSSProperties;

Deprecated
Please use styles.rail instead

property range

range?: false;

property trackStyle

trackStyle?: React.CSSProperties;

Deprecated
Please use styles.track instead

property value

value?: number;

interface SpaceProps

interface SpaceProps extends React.HTMLAttributes<HTMLDivElement> {}

property align

align?: 'start' | 'end' | 'center' | 'baseline';

property className

className?: string;

property classNames

classNames?: {
    item: string;
};

property direction

direction?: 'horizontal' | 'vertical';

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property size

size?: SpaceSize | [SpaceSize, SpaceSize];

property split

split?: React.ReactNode;

property style

style?: React.CSSProperties;

property styles

styles?: {
    item: React.CSSProperties;
};

property wrap

wrap?: boolean;

interface SpinProps

interface SpinProps {}

property children

children?: React.ReactNode;

property className

className?: string;

property delay

delay?: number;

property fullscreen

fullscreen?: boolean;

property indicator

indicator?: SpinIndicator;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property size

size?: SpinSize;

property spinning

spinning?: boolean;

property style

style?: React.CSSProperties;

property tip

tip?: React.ReactNode;

property wrapperClassName

wrapperClassName?: string;

interface StepProps

interface StepProps {}

property className

className?: string;

property description

description?: React.ReactNode;

property disabled

disabled?: boolean;

property icon

icon?: React.ReactNode;

property onClick

onClick?: React.MouseEventHandler<HTMLElement>;

property status

status?: 'wait' | 'process' | 'finish' | 'error';

property style

style?: React.CSSProperties;

property subTitle

subTitle?: React.ReactNode;

property title

title?: React.ReactNode;

interface StepsProps

interface StepsProps {}

property children

children?: React.ReactNode;

property className

className?: string;

property current

current?: number;

property direction

direction?: 'horizontal' | 'vertical';

property iconPrefix

iconPrefix?: string;

property initial

initial?: number;

property items

items?: StepProps[];

property labelPlacement

labelPlacement?: 'horizontal' | 'vertical';

property onChange

onChange?: (current: number) => void;

property percent

percent?: number;

property prefixCls

prefixCls?: string;

property progressDot

progressDot?: boolean | ProgressDotRender;

property responsive

responsive?: boolean;

property rootClassName

rootClassName?: string;

property size

size?: 'default' | 'small';

property status

status?: 'wait' | 'process' | 'finish' | 'error';

property style

style?: React.CSSProperties;

property type

type?: 'default' | 'navigation' | 'inline';

interface SubMenuProps

interface SubMenuProps {}

property children

children?: React.ReactNode;

property className

className?: string;

property disabled

disabled?: boolean;

property icon

icon?: React.ReactNode;

property level

level?: number;

property onTitleClick

onTitleClick?: (e: TitleEventEntity) => void;

property onTitleMouseEnter

onTitleMouseEnter?: (e: TitleEventEntity) => void;

property onTitleMouseLeave

onTitleMouseLeave?: (e: TitleEventEntity) => void;

property popupClassName

popupClassName?: string;

property popupOffset

popupOffset?: [number, number];

property style

style?: React.CSSProperties;

property theme

theme?: MenuTheme;

property title

title?: React.ReactNode;

interface SwitchProps

interface SwitchProps {}

property autoFocus

autoFocus?: boolean;

property checked

checked?: boolean;

property checkedChildren

checkedChildren?: React.ReactNode;

property className

className?: string;

property defaultChecked

defaultChecked?: boolean;

property defaultValue

defaultValue?: boolean;

Alias for defaultChecked. 5.12.0

property disabled

disabled?: boolean;

property id

id?: string;

property loading

loading?: boolean;

property onChange

onChange?: SwitchChangeEventHandler;

property onClick

onClick?: SwitchClickEventHandler;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property size

size?: SwitchSize;

property style

style?: React.CSSProperties;

property tabIndex

tabIndex?: number;

property title

title?: string;

property unCheckedChildren

unCheckedChildren?: React.ReactNode;

property value

value?: boolean;

Alias for checked. 5.12.0

interface TableColumnGroupType

interface ColumnGroupType<RecordType>
    extends Omit<ColumnType<RecordType>, 'dataIndex'> {}

property children

children: ColumnsType<RecordType>;

interface TableColumnProps

interface ColumnProps<RecordType> extends ColumnType<RecordType> {}

property children

children?: null;

interface TableColumnType

interface ColumnType<RecordType> extends Omit<RcColumnType<RecordType>, 'title'> {}

property defaultFilteredValue

defaultFilteredValue?: FilterValue | null;

property defaultSortOrder

defaultSortOrder?: SortOrder;

property filterDropdown

filterDropdown?:
    | React.ReactNode
    | ((props: FilterDropdownProps) => React.ReactNode);

property filterDropdownOpen

filterDropdownOpen?: boolean;

property filterDropdownVisible

filterDropdownVisible?: boolean;

Deprecated
Please use filterDropdownOpen instead

property filtered

filtered?: boolean;

property filteredValue

filteredValue?: FilterValue | null;

property filterIcon

filterIcon?: React.ReactNode | ((filtered: boolean) => React.ReactNode);

property filterMode

filterMode?: 'menu' | 'tree';

property filterMultiple

filterMultiple?: boolean;

property filterOnClose

filterOnClose?: boolean;

property filterResetToDefaultFilteredValue

filterResetToDefaultFilteredValue?: boolean;

property filters

filters?: ColumnFilterItem[];

property filterSearch

filterSearch?: FilterSearchType<ColumnFilterItem>;

property onFilter

onFilter?: (value: React.Key | boolean, record: RecordType) => boolean;

property onFilterDropdownOpenChange

onFilterDropdownOpenChange?: (visible: boolean) => void;

property onFilterDropdownVisibleChange

onFilterDropdownVisibleChange?: (visible: boolean) => void;

Deprecated
Please use onFilterDropdownOpenChange instead

property responsive

responsive?: Breakpoint[];

property showSorterTooltip

showSorterTooltip?: boolean | SorterTooltipProps;

property sortDirections

sortDirections?: SortOrder[];

property sorter

sorter?:
    | boolean
    | CompareFn<RecordType>
    | {
          compare?: CompareFn<RecordType>;
          /** Config multiple sorter order priority */
          multiple?: number;
      };

property sortIcon

sortIcon?: (props: { sortOrder: SortOrder }) => React.ReactNode;

property sortOrder

sortOrder?: SortOrder;

property title

title?: ColumnTitle<RecordType>;

interface TablePaginationConfig

interface TablePaginationConfig extends PaginationProps {}

property position

position?: TablePaginationPosition[];

interface TableProps

interface TableProps<RecordType = any>
    extends Omit<
        RcTableProps<RecordType>,
        | 'transformColumns'
        | 'internalHooks'
        | 'internalRefs'
        | 'data'
        | 'columns'
        | 'scroll'
        | 'emptyText'
    > {}

property bordered

bordered?: boolean;

property columns

columns?: ColumnsType<RecordType>;

property dataSource

dataSource?: RcTableProps<RecordType>['data'];

property dropdownPrefixCls

dropdownPrefixCls?: string;

property getPopupContainer

getPopupContainer?: GetPopupContainer;

property loading

loading?: boolean | SpinProps;

property locale

locale?: TableLocale;

property onChange

onChange?: (
    pagination: TablePaginationConfig,
    filters: Record<string, FilterValue | null>,
    sorter: SorterResult<RecordType> | SorterResult<RecordType>[],
    extra: TableCurrentDataSource<RecordType>
) => void;

property pagination

pagination?: false | TablePaginationConfig;

property rootClassName

rootClassName?: string;

property rowSelection

rowSelection?: TableRowSelection<RecordType>;

property scroll

scroll?: RcTableProps<RecordType>['scroll'] & {
    scrollToFirstRowOnChange?: boolean;
};

property showSorterTooltip

showSorterTooltip?: boolean | SorterTooltipProps;

property size

size?: SizeType;

property sortDirections

sortDirections?: SortOrder[];

property virtual

virtual?: boolean;

interface TabsProps

interface TabsProps extends Omit<RcTabsProps, 'editable'> {}

property addIcon

addIcon?: React.ReactNode;

property centered

centered?: boolean;

property children

children?: React.ReactNode;

property hideAdd

hideAdd?: boolean;

property indicatorSize

indicatorSize?: GetIndicatorSize;

Deprecated
Please use indicator={{ size: ... }} instead

property onEdit

onEdit?: (
    e: React.MouseEvent | React.KeyboardEvent | string,
    action: 'add' | 'remove'
) => void;

property removeIcon

removeIcon?: React.ReactNode;

property rootClassName

rootClassName?: string;

property size

size?: SizeType;

property type

type?: TabsType;

interface TagProps

interface TagProps extends React.HTMLAttributes<HTMLSpanElement> {}

property bordered

bordered?: boolean;

property className

className?: string;

property closable

closable?:
    | boolean
    | ({
          closeIcon?: React.ReactNode;
      } & React.AriaAttributes);

property closeIcon

closeIcon?: React.ReactNode;

Advised to use closeIcon instead.

property color

color?: LiteralUnion<PresetColorType | PresetStatusColorType>;

property icon

icon?: React.ReactNode;

property onClose

onClose?: (e: React.MouseEvent<HTMLElement>) => void;

property prefixCls

prefixCls?: string;

property rootClassName

rootClassName?: string;

property style

style?: React.CSSProperties;

property visible

visible?: boolean;

Deprecated
visible will be removed in next major version.

interface ThemeConfig

interface ThemeConfig {}

property algorithm

algorithm?: MappingAlgorithm | MappingAlgorithm[];

用于修改 Seed Token 到 Map Token 的算法。 Modify the algorithms of theme. defaultAlgorithm

property components

components?: ComponentsConfig;

用于修改各个组件的 Component Token 以及覆盖该组件消费的 Alias Token。 Modify Component Token and Alias Token applied to components.

property cssVar

cssVar?:
    | {
          /**
           * @descCN css 变量的前缀
           * @descEN Prefix for css variable.
           * @default ant
           */
          prefix?: string;
          /**
           * @descCN 主题的唯一 key，版本低于 react@18 时需要手动设置。
           * @descEN Unique key for theme, should be set manually < react@18.
           */
          key?: string;
      }
    | boolean;

通过 cssVar 配置来开启 CSS 变量模式，这个配置会被继承。 Enable CSS variable mode through cssVar configuration, This configuration will be inherited. false 5.12.0

property hashed

hashed?: boolean;

是否开启 hashed 属性。如果你的应用中只存在一个版本的 antd，你可以设置为 false 来进一步减小样式体积。 Whether to enable the hashed attribute. If there is only one version of antd in your application, you can set false to reduce the bundle size. true 5.12.0

property inherit

inherit?: boolean;

是否继承外层 ConfigProvider 中配置的主题。 Whether to inherit the theme configured in the outer layer ConfigProvider. true

property token

token?: Partial<AliasToken>;

用于修改 Design Token。 Modify Design Token.

interface TimelineItemProps

interface TimelineItemProps {}

property children

children?: React.ReactNode;

property className

className?: string;

property color

color?: LiteralUnion<Color>;

property dot

dot?: React.ReactNode;

property key

key?: React.Key;

property label

label?: React.ReactNode;

property pending

pending?: boolean;

property position

position?: string;

property prefixCls

prefixCls?: string;

property style

style?: React.CSSProperties;

interface TimelineProps

interface TimelineProps {}

property children

children?: React.ReactNode;

property className

className?: string;

property items

items?: TimelineItemProps[];

property mode

mode?: 'left' | 'alternate' | 'right';

property pending

pending?: React.ReactNode;

指定最后一个幽灵节点是否存在或内容

property pendingDot

pendingDot?: React.ReactNode;

property prefixCls

prefixCls?: string;

property reverse

reverse?: boolean;

property rootClassName

rootClassName?: string;

property style

style?: React.CSSProperties;

interface TimePickerProps

interface TimePickerProps extends Omit<PickerTimeProps<Dayjs>, 'picker'> {}

property addon

addon?: () => React.ReactNode;

property popupClassName

popupClassName?: string;

property rootClassName

rootClassName?: string;

property status

status?: InputStatus;

interface TimeRangePickerProps

interface TimeRangePickerProps extends Omit<RangePickerTimeProps<Dayjs>, 'picker'> {}

property popupClassName

popupClassName?: string;

interface TourProps

interface TourProps extends Omit<RCTourProps, 'renderPanel'> {}

property className

className?: string;

property current

current?: number;

property indicatorsRender

indicatorsRender?: (current: number, total: number) => ReactNode;

property prefixCls

prefixCls?: string;

property steps

steps?: TourStepProps[];

property type

type?: 'default' | 'primary';

interface TourStepProps

interface TourStepProps extends RCTourStepProps {}

property cover

cover?: ReactNode;

property indicatorsRender

indicatorsRender?: (current: number, total: number) => ReactNode;

property nextButtonProps

nextButtonProps?: {
    children?: ReactNode;
    onClick?: () => void;
    className?: string;
    style?: React.CSSProperties;
};

property prevButtonProps

prevButtonProps?: {
    children?: ReactNode;
    onClick?: () => void;
    className?: string;
    style?: React.CSSProperties;
};

property type

type?: 'default' | 'primary';

interface TransferProps

interface TransferProps<RecordType = any> {}

property children

children?: (props: TransferCustomListBodyProps<RecordType>) => React.ReactNode;

property className

className?: string;

property dataSource

dataSource?: RecordType[];

property disabled

disabled?: boolean;

filterOption?: (
    inputValue: string,
    item: RecordType,
    direction: TransferDirection
) => boolean;

footer?: (
    props: TransferListProps<RecordType>,
    info?: {
        direction: TransferDirection;
    }
) => React.ReactNode;

property listStyle

listStyle?: ((style: ListStyle) => CSSProperties) | CSSProperties;

property locale

locale?: Partial<TransferLocale>;

property onChange

onChange?: (
    targetKeys: TransferKey[],
    direction: TransferDirection,
    moveKeys: TransferKey[]
) => void;

property oneWay

oneWay?: boolean;

property onScroll

onScroll?: (
    direction: TransferDirection,
    e: React.SyntheticEvent<HTMLUListElement>
) => void;

property onSearch

onSearch?: (direction: TransferDirection, value: string) => void;

property onSelectChange

onSelectChange?: (
    sourceSelectedKeys: TransferKey[],
    targetSelectedKeys: TransferKey[]
) => void;

property operations

operations?: string[];

property operationStyle

operationStyle?: CSSProperties;

property pagination

pagination?: PaginationType;

property prefixCls

prefixCls?: string;

property render

render?: TransferRender<RecordType>;

property rootClassName

rootClassName?: string;

property rowKey

rowKey?: (record: RecordType) => TransferKey;

property selectAllLabels

selectAllLabels?: SelectAllLabel[];

property selectedKeys

selectedKeys?: TransferKey[];

property selectionsIcon

selectionsIcon?: React.ReactNode;

property showSearch

showSearch?: boolean;

property showSelectAll

showSelectAll?: boolean;

property status

status?: InputStatus;

property style

style?: React.CSSProperties;

property targetKeys

targetKeys?: TransferKey[];

property titles

titles?: React.ReactNode[];

interface TreeNodeProps

interface AntTreeNodeProps {}

property checkable

checkable?: boolean;

property checked

checked?: boolean;

property children

children?: React.ReactNode;

property className

className?: string;

property disableCheckbox

disableCheckbox?: boolean;

property disabled

disabled?: boolean;

property eventKey

eventKey?: string;

property expanded

expanded?: boolean;

property icon

icon?: ((treeNode: AntdTreeNodeAttribute) => React.ReactNode) | React.ReactNode;

property isLeaf

isLeaf?: boolean;

property key

key?: Key;

property loading

loading?: boolean;

property selectable

selectable?: boolean;

property selected

selected?: boolean;

property title

title?: string | React.ReactNode;

index signature

[customProp: string]: any;

interface TreeProps

interface TreeProps<T extends BasicDataNode = DataNode>
    extends Omit<
        RcTreeProps<T>,
        | 'prefixCls'
        | 'showLine'
        | 'direction'
        | 'draggable'
        | 'icon'
        | 'switcherIcon'
    > {}

property autoExpandParent

autoExpandParent?: boolean;

Whether to automatically expand the parent node

property blockNode

blockNode?: boolean;

property checkable

checkable?: boolean;

Whether to support selection

property checkedKeys

checkedKeys?:
    | Key[]
    | {
          checked: Key[];
          halfChecked: Key[];
      };

(Controlled) Tree node with checked checkbox

property checkStrictly

checkStrictly?: boolean;

Node selection in Checkable state is fully controlled (the selected state of parent and child nodes is no longer associated)

property children

children?: React.ReactNode;

property className

className?: string;

property defaultCheckedKeys

defaultCheckedKeys?: Key[];

Tree node with checkbox checked by default

property defaultExpandAll

defaultExpandAll?: boolean;

Expand all tree nodes by default

property defaultExpandedKeys

defaultExpandedKeys?: Key[];

Expand the specified tree node by default

property defaultExpandParent

defaultExpandParent?: boolean;

Expand the corresponding tree node by default

property defaultSelectedKeys

defaultSelectedKeys?: Key[];

Tree node selected by default

property disabled

disabled?: boolean;

whether to disable the tree

property draggable

draggable?: DraggableFn | boolean | DraggableConfig;

Set the node to be draggable (IE>8)

property expandedKeys

expandedKeys?: Key[];

(Controlled) Expand the specified tree node

property filterAntTreeNode

filterAntTreeNode?: (node: AntTreeNode) => boolean;

Click on the tree node to trigger

property icon

icon?:
    | ((nodeProps: AntdTreeNodeAttribute) => React.ReactNode)
    | React.ReactNode
    | RcTreeProps<T>['icon'];

property loadedKeys

loadedKeys?: Key[];

property multiple

multiple?: boolean;

Whether to support multiple selection

property prefixCls

prefixCls?: string;

property selectable

selectable?: boolean;

property selectedKeys

selectedKeys?: Key[];

(Controlled) Set the selected tree node

property showIcon

showIcon?: boolean;

property showLine

showLine?:
    | boolean
    | {
          showLeafIcon: boolean | TreeLeafIcon;
      };

property style

style?: React.CSSProperties;

property switcherIcon

switcherIcon?: SwitcherIcon | RcTreeProps<T>['switcherIcon'];

interface TreeSelectProps

interface TreeSelectProps<
    ValueType = any,
    OptionType extends BaseOptionType | DefaultOptionType = DefaultOptionType
> extends Omit<
        RcTreeSelectProps<ValueType, OptionType>,
        | 'showTreeIcon'
        | 'treeMotion'
        | 'mode'
        | 'getInputElement'
        | 'backfill'
        | 'treeLine'
        | 'switcherIcon'
    > {}

property bordered

bordered?: boolean;

Deprecated
Use variant instead.

property disabled

disabled?: boolean;

property dropdownClassName

dropdownClassName?: string;

Deprecated
Please use popupClassName instead

property dropdownMatchSelectWidth

dropdownMatchSelectWidth?: boolean | number;

Deprecated
Please use popupMatchSelectWidth instead

property placement

placement?: SelectCommonPlacement;

property popupClassName

popupClassName?: string;

property popupMatchSelectWidth

popupMatchSelectWidth?: boolean | number;

property rootClassName

rootClassName?: string;

property showArrow

showArrow?: boolean;

Deprecated
showArrow is deprecated which will be removed in next major version. It will be a default behavior, you can hide it by setting suffixIcon to null.

property size

size?: SizeType;

property status

status?: InputStatus;

property suffixIcon

suffixIcon?: React.ReactNode;

property switcherIcon

switcherIcon?:
    | SwitcherIcon
    | RcTreeSelectProps<ValueType, OptionType>['switcherIcon'];

property treeLine

treeLine?: TreeProps['showLine'];

property variant

variant?: Variant;

5.13.0 "outlined"

index signature

[key: `aria-${string}`]: React.AriaAttributes[keyof React.AriaAttributes];

interface UploadFile

interface UploadFile<T = any> extends ProgressAriaProps {}

property crossOrigin

crossOrigin?: React.ImgHTMLAttributes<HTMLImageElement>['crossOrigin'];

property error

error?: any;

property fileName

fileName?: string;

property lastModified

lastModified?: number;

property lastModifiedDate

lastModifiedDate?: Date;

property linkProps

linkProps?: any;

property name

name: string;

property originFileObj

originFileObj?: RcFile;

property percent

percent?: number;

property preview

preview?: string;

property response

response?: T;

property size

size?: number;

property status

status?: UploadFileStatus;

property thumbUrl

thumbUrl?: string;

property type

type?: string;

property uid

uid: string;

property url

url?: string;

property xhr

xhr?: T;

interface UploadProps

interface UploadProps<T = any>
    extends Pick<RcUploadProps, 'capture' | 'hasControlInside'> {}

property accept

accept?: string;

property action

action?:
    | string
    | ((file: RcFile) => string)
    | ((file: RcFile) => PromiseLike<string>);

property beforeUpload

beforeUpload?: (
    file: RcFile,
    FileList: RcFile[]
) => BeforeUploadValueType | Promise<BeforeUploadValueType>;

property children

children?: React.ReactNode;

property className

className?: string;

property customRequest

customRequest?: (options: RcCustomRequestOptions) => void;

property data

data?:
    | Record<string, unknown>
    | ((
          file: UploadFile<T>
      ) => Record<string, unknown> | Promise<Record<string, unknown>>);

property defaultFileList

defaultFileList?: Array<UploadFile<T>>;

property directory

directory?: boolean;

property disabled

disabled?: boolean;

property fileList

fileList?: Array<UploadFile<T>>;

property headers

headers?: HttpRequestHeader;

property iconRender

iconRender?: (file: UploadFile<T>, listType?: UploadListType) => React.ReactNode;

property id

id?: string;

property isImageUrl

isImageUrl?: (file: UploadFile<T>) => boolean;

property itemRender

itemRender?: ItemRender<T>;

property listType

listType?: UploadListType;

property locale

locale?: UploadLocale;

property maxCount

maxCount?: number;

Config max count of fileList. Will replace current one when maxCount is 1

property method

method?: 'POST' | 'PUT' | 'PATCH' | 'post' | 'put' | 'patch';

property multiple

multiple?: boolean;

property name

name?: string;

property onChange

onChange?: (info: UploadChangeParam<UploadFile<T>>) => void;

property onDownload

onDownload?: (file: UploadFile<T>) => void;

property onDrop

onDrop?: (event: React.DragEvent<HTMLDivElement>) => void;

property onPreview

onPreview?: (file: UploadFile<T>) => void;

property onRemove

onRemove?: (file: UploadFile<T>) => void | boolean | Promise<void | boolean>;

property openFileDialogOnClick

openFileDialogOnClick?: boolean;

property prefixCls

prefixCls?: string;

property previewFile

previewFile?: PreviewFileHandler;

property progress

progress?: UploadListProgressProps;

property rootClassName

rootClassName?: string;

property showUploadList

showUploadList?: boolean | ShowUploadListInterface;

property style

style?: React.CSSProperties;

property supportServerRender

supportServerRender?: boolean;

property transformFile

transformFile?: TransformFileHandler;

Deprecated
Please use beforeUpload directly

property type

type?: UploadType;

property withCredentials

withCredentials?: boolean;

interface WatermarkProps

interface WatermarkProps {}

property children

children?: React.ReactNode;

property className

className?: string;

property content

content?: string | string[];

property font

font?: {
    color?: CanvasFillStrokeStyles['fillStyle'];
    fontSize?: number | string;
    fontWeight?: 'normal' | 'light' | 'weight' | number;
    fontStyle?: 'none' | 'normal' | 'italic' | 'oblique';
    fontFamily?: string;
    textAlign?: CanvasTextAlign;
};

property gap

gap?: [number, number];

property height

height?: number;

property image

image?: string;

property inherit

inherit?: boolean;

property offset

offset?: [number, number];

property rootClassName

rootClassName?: string;

property rotate

rotate?: number;

property style

style?: React.CSSProperties;

property width

width?: number;

property zIndex

zIndex?: number;

Type Aliases

type Breakpoint

type Breakpoint = 'xxl' | 'xl' | 'lg' | 'md' | 'sm' | 'xs';

type CascaderProps

type CascaderProps<DataNodeType extends BaseOptionType = any> =
    UnionCascaderProps<DataNodeType> & {
        multiple?: boolean;
        size?: SizeType;
        /**
         * @deprecated `showArrow` is deprecated which will be removed in next major version. It will be a
         *   default behavior, you can hide it by setting `suffixIcon` to null.
         */
        showArrow?: boolean;
        disabled?: boolean;
        /** @deprecated Use `variant` instead. */
        bordered?: boolean;
        placement?: SelectCommonPlacement;
        suffixIcon?: React.ReactNode;
        options?: DataNodeType[];
        status?: InputStatus;
        autoClearSearchValue?: boolean;
        rootClassName?: string;
        popupClassName?: string;
        /** @deprecated Please use `popupClassName` instead */
        dropdownClassName?: string;
        /**
         * @since 5.13.0
         * @default "outlined"
         */
        variant?: Variant;
    };

type ColorPickerProps

type ColorPickerProps = Omit<
    RcColorPickerProps,
    | 'onChange'
    | 'value'
    | 'defaultValue'
    | 'panelRender'
    | 'disabledAlpha'
    | 'onChangeComplete'
> & {
    value?: ColorValueType;
    defaultValue?: ColorValueType;
    children?: React.ReactNode;
    open?: boolean;
    disabled?: boolean;
    placement?: TriggerPlacement;
    trigger?: TriggerType;
    format?: ColorFormatType;
    defaultFormat?: ColorFormatType;
    allowClear?: boolean;
    presets?: PresetsItem[];
    arrow?:
        | boolean
        | {
              pointAtCenter: boolean;
          };
    panelRender?: (
        panel: React.ReactNode,
        extra: {
            components: {
                Picker: FC;
                Presets: FC;
            };
        }
    ) => React.ReactNode;
    showText?: boolean | ((color: Color) => React.ReactNode);
    size?: SizeType;
    styles?: {
        popup?: CSSProperties;
        popupOverlayInner?: CSSProperties;
    };
    rootClassName?: string;
    disabledAlpha?: boolean;
    [key: `data-${string}`]: string;
    onOpenChange?: (open: boolean) => void;
    onFormatChange?: (format?: ColorFormatType) => void;
    onChange?: (value: Color, hex: string) => void;
    onClear?: () => void;
    onChangeComplete?: (value: Color) => void;
} & Pick<
        PopoverProps,
        'getPopupContainer' | 'autoAdjustOverflow' | 'destroyTooltipOnHide'
    >;

type DatePickerProps

type DatePickerProps<ValueType = Dayjs | Dayjs> = PickerPropsWithMultiple<
    Dayjs,
    PickerProps<Dayjs>,
    ValueType
>;

type GetProp

type GetProp<
    T extends React.ComponentType<any> | object,
    PropName extends keyof GetProps<T>
> = NonNullable<GetProps<T>[PropName]>;

type GetProps

type GetProps<T extends React.ComponentType<any> | object> =
    T extends React.ComponentType<infer P> ? P : T extends object ? T : never;

type GetRef

type GetRef<T extends ReactRefComponent<any> | React.Component<any>> =
    T extends React.Component<any>
        ? T
        : T extends React.ComponentType<infer P>
        ? ExtractRefAttributesRef<P>
        : never;

type GlobalToken

type GlobalToken = AliasToken & ComponentTokenMap;

Final token which contains the components level override

type MappingAlgorithm

type MappingAlgorithm = DerivativeFunc<SeedToken, MapToken>;

type MenuRef

type MenuRef = {
    menu: RcMenuRef | null;
    focus: (options?: FocusOptions) => void;
};

type MenuTheme

type MenuTheme = 'light' | 'dark';

type QRPropsCanvas

type QRPropsCanvas = QRProps & React.CanvasHTMLAttributes<HTMLCanvasElement>;

type QRPropsSvg

type QRPropsSvg = QRProps & React.SVGAttributes<SVGSVGElement>;

type StatisticProps

type StatisticProps = HTMLAriaDataAttributes & StatisticReactProps;

type TableColumnsType

type ColumnsType<RecordType = any> = (
    | ColumnGroupType<RecordType>
    | ColumnType<RecordType>
)[];

type TagType

type TagType = typeof InternalTag & {
    CheckableTag: typeof CheckableTag;
};

type TooltipProps

type TooltipProps = TooltipPropsWithTitle | TooltipPropsWithOverlay;

type TypographyProps

type TypographyProps = typeof OriginTypography & {
    Text: typeof Text;
    Link: typeof Link;
    Title: typeof Title;
    Paragraph: typeof Paragraph;
};

Namespaces

namespace List

namespace List {}

variable displayName

var displayName: string;

variable Item

var Item: any;

Package Files (116)

Dev Dependencies (180)

Peer Dependencies (2)

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/antd.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/antd)

HTML

<a href="https://www.jsdocs.io/package/antd"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 2 days ago.
Package analyzed in 19597 ms.
Missing or incorrect documentation? Open an issue for this package.

antd

Install

Overview

Index

Variables

Functions

Interfaces

Type Aliases

Namespaces

Variables

variable Affix

variable Alert

variable Anchor

variable App

variable AutoComplete

variable Avatar

variable BackTop

variable Badge

variable Breadcrumb

variable Button

variable Calendar

variable Card

variable Carousel

variable Cascader

variable Checkbox

variable Col

variable Collapse

variable ColorPicker

variable ConfigProvider

variable DatePicker

variable Descriptions

variable Divider

variable Drawer

variable Dropdown

variable Empty

variable Flex

variable FloatButton

variable Form

variable Grid

variable Image

variable Input

variable InputNumber

variable Layout

variable Mentions

variable Menu

variable message

variable Modal

variable notification

variable Pagination

variable Popconfirm

variable Popover

variable Progress

variable QRCode

variable Radio

variable Rate

variable Result

variable Row

variable Segmented

variable Select

variable Skeleton

variable Slider

variable Space

variable Spin

variable Statistic

variable Steps

variable Switch

variable Table

variable Tabs

variable Tag

variable theme

variable Timeline

variable TimePicker

variable Tooltip

variable Tour

variable Transfer

variable Tree

variable TreeSelect

variable Typography

variable Upload

variable version