antd

  • Version 5.16.1
  • Published
  • 44.9 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

Functions

Interfaces

Type Aliases

Namespaces

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;
                          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;

                                                                              variable Pagination

                                                                              const Pagination: React.FC<PaginationProps>;

                                                                                variable Popconfirm

                                                                                const Popconfirm: any;

                                                                                  variable Popover

                                                                                  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: TagType;

                                                                                                                        variable theme

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

                                                                                                                          variable Timeline

                                                                                                                          const Timeline: any;

                                                                                                                            variable TimePicker

                                                                                                                            const TimePicker: any;

                                                                                                                              variable Tooltip

                                                                                                                              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

                                                                                                                                                                      property banner

                                                                                                                                                                      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 extends SeparatorType {}
                                                                                                                                                                                                                                                                                                                                children?: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                  className?: string;
                                                                                                                                                                                                                                                                                                                                    dropdownProps?: DropdownProps;
                                                                                                                                                                                                                                                                                                                                      href?: string;
                                                                                                                                                                                                                                                                                                                                        menu?: Omit<MenuType, 'items'> & {
                                                                                                                                                                                                                                                                                                                                        items?: MenuItem[];
                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                          onClick?: React.MouseEventHandler<HTMLAnchorElement | HTMLSpanElement>;
                                                                                                                                                                                                                                                                                                                                            overlay?: DropdownProps['overlay'];
                                                                                                                                                                                                                                                                                                                                            • Deprecated

                                                                                                                                                                                                                                                                                                                                              Please use menu instead

                                                                                                                                                                                                                                                                                                                                            prefixCls?: string;
                                                                                                                                                                                                                                                                                                                                              interface BreadcrumbProps<T extends AnyObject = AnyObject> {}
                                                                                                                                                                                                                                                                                                                                                children?: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                  className?: string;
                                                                                                                                                                                                                                                                                                                                                    itemRender?: (
                                                                                                                                                                                                                                                                                                                                                    route: ItemType,
                                                                                                                                                                                                                                                                                                                                                    params: T,
                                                                                                                                                                                                                                                                                                                                                    routes: ItemType[],
                                                                                                                                                                                                                                                                                                                                                    paths: string[]
                                                                                                                                                                                                                                                                                                                                                    ) => React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                      items?: ItemType[];
                                                                                                                                                                                                                                                                                                                                                        params?: T;
                                                                                                                                                                                                                                                                                                                                                          prefixCls?: string;
                                                                                                                                                                                                                                                                                                                                                            rootClassName?: string;
                                                                                                                                                                                                                                                                                                                                                              routes?: ItemType[];
                                                                                                                                                                                                                                                                                                                                                              • Deprecated

                                                                                                                                                                                                                                                                                                                                                                Please use items instead

                                                                                                                                                                                                                                                                                                                                                              separator?: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property header

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property breadcrumb

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property dropdown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property menu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  menu?: MenuConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    message?: ComponentStyleConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property modal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      align?: AlignType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        arrow?: boolean | DropdownArrowOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          autoAdjustOverflow?: boolean | AdjustOverflow;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            autoFocus?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              children?: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                className?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  destroyPopupOnHide?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      dropdownRender?: (originNode: React.ReactNode) => React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        forceRender?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            menu?: MenuProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mouseEnterDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mouseLeaveDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onOpenChange?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  open: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  info: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  source: 'trigger' | 'menu';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onVisibleChange?: (open: boolean) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Please use onOpenChange instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    open?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      openClassName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        overlay?: React.ReactElement | OverlayFunc;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Please use menu instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        overlayClassName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          overlayStyle?: React.CSSProperties;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            placement?: Placement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              prefixCls?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rootClassName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  transitionName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    trigger?: ('click' | 'hover' | 'contextMenu')[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      visible?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Please use open instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface DropdownProps {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        align?: AlignType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arrow?: boolean | DropdownArrowOptions;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            autoAdjustOverflow?: boolean | AdjustOverflow;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              autoFocus?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                children?: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  className?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    destroyPopupOnHide?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        dropdownRender?: (originNode: React.ReactNode) => React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          forceRender?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              menu?: MenuProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mouseEnterDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  mouseLeaveDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onOpenChange?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    open: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    info: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source: 'trigger' | 'menu';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onVisibleChange?: (open: boolean) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Please use onOpenChange instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      open?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        openClassName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          overlay?: React.ReactElement | OverlayFunc;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Please use menu instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          overlayClassName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            overlayStyle?: React.CSSProperties;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              placement?: Placement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                prefixCls?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  rootClassName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    transitionName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      trigger?: ('click' | 'hover' | 'contextMenu')[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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