antd

  • Version 4.16.2
  • Published
  • 50.5 MB
  • 42 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

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable Alert

const Alert: AlertInterface;

    variable AutoComplete

    const AutoComplete: any;

      variable Avatar

      const Avatar: CompoundedComponent;

        variable BackTop

        const BackTop: any;

          variable Badge

          const Badge: CompoundedComponent;
            const Breadcrumb: BreadcrumbInterface;

              variable Button

              const Button: CompoundedComponent;

                variable Card

                const Card: CardInterface;
                  const Carousel: any;

                    variable Checkbox

                    const Checkbox: CompoundedComponent;

                      variable Col

                      const Col: any;

                        variable Collapse

                        const Collapse: CollapseInterface;

                          variable Comment

                          const Comment: any;

                            variable ConfigProvider

                            const ConfigProvider: any;

                              variable DatePicker

                              const DatePicker: any;

                                variable Divider

                                const Divider: any;

                                  variable Drawer

                                  const Drawer: any;
                                    const Dropdown: DropdownInterface;

                                      variable Empty

                                      const Empty: EmptyType;

                                        variable Form

                                        const Form: FormInterface;

                                          variable Grid

                                          const Grid: { useBreakpoint: typeof useBreakpoint };

                                            variable Image

                                            const Image: CompositionImage<any>;

                                              variable InputNumber

                                              const InputNumber: (<T extends ValueType = ValueType>(
                                              props: InputNumberProps<T> & { children?: any } & {
                                              ref?: React.Ref<HTMLInputElement> | undefined;
                                              }
                                              ) => any) & { displayName?: string | undefined };

                                                variable Layout

                                                const Layout: LayoutType;

                                                  variable Mentions

                                                  const Mentions: CompoundedComponent;

                                                    variable message

                                                    const message: MessageApi;
                                                      const Modal: ModalInterface &
                                                      ModalStaticFunctions & {
                                                      destroyAll: () => void;
                                                      config: ({ rootPrefixCls }: { rootPrefixCls: string }) => void;
                                                      };

                                                        variable notification

                                                        const notification: NotificationApi;
                                                          const PageHeader: any;

                                                            variable Pagination

                                                            const Pagination: any;

                                                              variable Popconfirm

                                                              const Popconfirm: any;

                                                                variable Popover

                                                                const Popover: any;

                                                                  variable Radio

                                                                  const Radio: CompoundedComponent;

                                                                    variable Rate

                                                                    const Rate: any;

                                                                      variable Result

                                                                      const Result: ResultType;

                                                                        variable Row

                                                                        const Row: any;

                                                                          variable Select

                                                                          const Select: SelectInterface;

                                                                            variable Skeleton

                                                                            const Skeleton: {
                                                                            (props: SkeletonProps): any;
                                                                            defaultProps: { avatar: boolean; title: boolean; paragraph: boolean };
                                                                            Button: {
                                                                            (props: import('./Button').SkeletonButtonProps): any;
                                                                            defaultProps: { size: string };
                                                                            };
                                                                            Avatar: {
                                                                            (props: AvatarProps): any;
                                                                            defaultProps: { size: string; shape: string };
                                                                            };
                                                                            Input: {
                                                                            (props: import('./Input').SkeletonInputProps): any;
                                                                            defaultProps: { size: string };
                                                                            };
                                                                            Image: (props: import('./Image').SkeletonImageProps) => any;
                                                                            };

                                                                              variable Slider

                                                                              const Slider: any;

                                                                                variable Space

                                                                                const Space: any;

                                                                                  variable Statistic

                                                                                  const Statistic: any;

                                                                                    variable Steps

                                                                                    const Steps: StepsType;

                                                                                      variable Switch

                                                                                      const Switch: CompoundedComponent;

                                                                                        variable Tag

                                                                                        const Tag: TagType;

                                                                                          variable Timeline

                                                                                          const Timeline: TimelineType;

                                                                                            variable TimePicker

                                                                                            const TimePicker: any;

                                                                                              variable Tooltip

                                                                                              const Tooltip: any;

                                                                                                variable Tree

                                                                                                const Tree: CompoundedComponent;

                                                                                                  variable TreeSelect

                                                                                                  const TreeSelect: TreeSelectInterface;

                                                                                                    variable Typography

                                                                                                    const Typography: any;

                                                                                                      variable Upload

                                                                                                      const Upload: CompoundedComponent;

                                                                                                        variable version

                                                                                                        const version: string;

                                                                                                          Functions

                                                                                                          function Calendar

                                                                                                          Calendar: (props: CalendarProps<Moment>) => any;

                                                                                                            function Descriptions

                                                                                                            Descriptions: typeof Descriptions;

                                                                                                              function List

                                                                                                              List: typeof List;

                                                                                                                function Table

                                                                                                                Table: typeof Table;

                                                                                                                  function Tabs

                                                                                                                  Tabs: typeof Tabs;

                                                                                                                    Classes

                                                                                                                    class Affix

                                                                                                                    class Affix extends React.Component<AffixProps, AffixState> {}

                                                                                                                      property context

                                                                                                                      context: ConfigConsumerProps;

                                                                                                                        property contextType

                                                                                                                        static contextType: any;

                                                                                                                          property fixedNode

                                                                                                                          fixedNode: HTMLDivElement;

                                                                                                                            property getOffsetBottom

                                                                                                                            getOffsetBottom: () => number | undefined;

                                                                                                                              property getOffsetTop

                                                                                                                              getOffsetTop: () => number | undefined;

                                                                                                                                property measure

                                                                                                                                measure: () => void;

                                                                                                                                  property placeholderNode

                                                                                                                                  placeholderNode: HTMLDivElement;

                                                                                                                                    property prepareMeasure

                                                                                                                                    prepareMeasure: () => void;

                                                                                                                                      property render

                                                                                                                                      render: () => any;

                                                                                                                                        property saveFixedNode

                                                                                                                                        saveFixedNode: (node: HTMLDivElement) => void;

                                                                                                                                          property savePlaceholderNode

                                                                                                                                          savePlaceholderNode: (node: HTMLDivElement) => void;

                                                                                                                                            property state

                                                                                                                                            state: AffixState;

                                                                                                                                              method componentDidMount

                                                                                                                                              componentDidMount: () => void;

                                                                                                                                                method componentDidUpdate

                                                                                                                                                componentDidUpdate: (prevProps: AffixProps) => void;

                                                                                                                                                  method componentWillUnmount

                                                                                                                                                  componentWillUnmount: () => void;

                                                                                                                                                    method lazyUpdatePosition

                                                                                                                                                    lazyUpdatePosition: () => void;

                                                                                                                                                      method updatePosition

                                                                                                                                                      updatePosition: () => void;

                                                                                                                                                        class Anchor

                                                                                                                                                        class Anchor extends React.Component<
                                                                                                                                                        AnchorProps,
                                                                                                                                                        AnchorState,
                                                                                                                                                        ConfigConsumerProps
                                                                                                                                                        > {}

                                                                                                                                                          property content

                                                                                                                                                          content: ConfigConsumerProps;

                                                                                                                                                            property contextType

                                                                                                                                                            static contextType: any;

                                                                                                                                                              property defaultProps

                                                                                                                                                              static defaultProps: { affix: boolean; showInkInFixed: boolean };

                                                                                                                                                                property getContainer

                                                                                                                                                                getContainer: () => any;

                                                                                                                                                                  property handleScroll

                                                                                                                                                                  handleScroll: () => void;

                                                                                                                                                                    property handleScrollTo

                                                                                                                                                                    handleScrollTo: (link: string) => void;
                                                                                                                                                                      static Link: typeof AnchorLink;
                                                                                                                                                                        registerLink: (link: string) => void;

                                                                                                                                                                          property render

                                                                                                                                                                          render: () => any;

                                                                                                                                                                            property saveInkNode

                                                                                                                                                                            saveInkNode: (node: HTMLSpanElement) => void;
                                                                                                                                                                              setCurrentActiveLink: (link: string) => void;

                                                                                                                                                                                property state

                                                                                                                                                                                state: { activeLink: null };
                                                                                                                                                                                  unregisterLink: (link: string) => void;

                                                                                                                                                                                    property updateInk

                                                                                                                                                                                    updateInk: () => void;

                                                                                                                                                                                      method componentDidMount

                                                                                                                                                                                      componentDidMount: () => void;

                                                                                                                                                                                        method componentDidUpdate

                                                                                                                                                                                        componentDidUpdate: () => void;

                                                                                                                                                                                          method componentWillUnmount

                                                                                                                                                                                          componentWillUnmount: () => void;

                                                                                                                                                                                            method getCurrentAnchor

                                                                                                                                                                                            getCurrentAnchor: (offsetTop?: number, bounds?: number) => string;

                                                                                                                                                                                              class Cascader

                                                                                                                                                                                              class Cascader extends React.Component<CascaderProps, CascaderState> {}

                                                                                                                                                                                                constructor

                                                                                                                                                                                                constructor(props: CascaderProps);

                                                                                                                                                                                                  property cachedOptions

                                                                                                                                                                                                  cachedOptions: CascaderOptionType[];

                                                                                                                                                                                                    property clearSelection

                                                                                                                                                                                                    clearSelection: (e: any) => void;

                                                                                                                                                                                                      property clearSelectionTimeout

                                                                                                                                                                                                      clearSelectionTimeout: any;

                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                        static defaultProps: {
                                                                                                                                                                                                        options: never[];
                                                                                                                                                                                                        disabled: boolean;
                                                                                                                                                                                                        allowClear: boolean;
                                                                                                                                                                                                        bordered: boolean;
                                                                                                                                                                                                        };

                                                                                                                                                                                                          property handleChange

                                                                                                                                                                                                          handleChange: (value: any, selectedOptions: CascaderOptionType[]) => void;

                                                                                                                                                                                                            property handleInputBlur

                                                                                                                                                                                                            handleInputBlur: () => void;

                                                                                                                                                                                                              property handleInputChange

                                                                                                                                                                                                              handleInputChange: (e: any) => void;

                                                                                                                                                                                                                property handleInputClick

                                                                                                                                                                                                                handleInputClick: (e: any) => void;

                                                                                                                                                                                                                  property handleKeyDown

                                                                                                                                                                                                                  handleKeyDown: (e: any) => void;

                                                                                                                                                                                                                    property handlePopupVisibleChange

                                                                                                                                                                                                                    handlePopupVisibleChange: (popupVisible: boolean) => void;

                                                                                                                                                                                                                      property renderCascader

                                                                                                                                                                                                                      renderCascader: (
                                                                                                                                                                                                                      {
                                                                                                                                                                                                                      getPopupContainer: getContextPopupContainer,
                                                                                                                                                                                                                      getPrefixCls,
                                                                                                                                                                                                                      renderEmpty,
                                                                                                                                                                                                                      direction,
                                                                                                                                                                                                                      }: ConfigConsumerProps,
                                                                                                                                                                                                                      locale: CascaderLocale
                                                                                                                                                                                                                      ) => any;

                                                                                                                                                                                                                        property saveInput

                                                                                                                                                                                                                        saveInput: (node: Input) => void;

                                                                                                                                                                                                                          property setValue

                                                                                                                                                                                                                          setValue: (
                                                                                                                                                                                                                          value: CascaderValueType,
                                                                                                                                                                                                                          selectedOptions?: CascaderOptionType[]
                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                            method blur

                                                                                                                                                                                                                            blur: () => void;

                                                                                                                                                                                                                              method componentWillUnmount

                                                                                                                                                                                                                              componentWillUnmount: () => void;

                                                                                                                                                                                                                                method focus

                                                                                                                                                                                                                                focus: () => void;

                                                                                                                                                                                                                                  method generateFilteredOptions

                                                                                                                                                                                                                                  generateFilteredOptions: (
                                                                                                                                                                                                                                  prefixCls: string | undefined,
                                                                                                                                                                                                                                  renderEmpty: RenderEmptyHandler
                                                                                                                                                                                                                                  ) =>
                                                                                                                                                                                                                                  | CascaderOptionType[]
                                                                                                                                                                                                                                  | { [x: string]: {}; disabled: boolean; isEmptyNode: boolean }[];

                                                                                                                                                                                                                                    method getDerivedStateFromProps

                                                                                                                                                                                                                                    static getDerivedStateFromProps: (
                                                                                                                                                                                                                                    nextProps: CascaderProps,
                                                                                                                                                                                                                                    { prevProps }: CascaderState
                                                                                                                                                                                                                                    ) => Partial<CascaderState>;

                                                                                                                                                                                                                                      method getLabel

                                                                                                                                                                                                                                      getLabel: () => any;

                                                                                                                                                                                                                                        method getPopupPlacement

                                                                                                                                                                                                                                        getPopupPlacement: (direction?: DirectionType) => string;

                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                          render: () => any;

                                                                                                                                                                                                                                            class Input

                                                                                                                                                                                                                                            class Input extends React.Component<InputProps, InputState> {}

                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                              constructor(props: InputProps);

                                                                                                                                                                                                                                                property clearableInput

                                                                                                                                                                                                                                                clearableInput: ClearableLabeledInput;

                                                                                                                                                                                                                                                  property clearPasswordValueAttribute

                                                                                                                                                                                                                                                  clearPasswordValueAttribute: () => void;

                                                                                                                                                                                                                                                    property defaultProps

                                                                                                                                                                                                                                                    static defaultProps: { type: string };

                                                                                                                                                                                                                                                      property direction

                                                                                                                                                                                                                                                      direction: DirectionType;

                                                                                                                                                                                                                                                        property focus

                                                                                                                                                                                                                                                        focus: (option?: InputFocusOptions | undefined) => void;

                                                                                                                                                                                                                                                          property Group

                                                                                                                                                                                                                                                          static Group: any;

                                                                                                                                                                                                                                                            property handleChange

                                                                                                                                                                                                                                                            handleChange: (e: any) => void;

                                                                                                                                                                                                                                                              property handleKeyDown

                                                                                                                                                                                                                                                              handleKeyDown: (e: any) => void;

                                                                                                                                                                                                                                                                property handleReset

                                                                                                                                                                                                                                                                handleReset: (e: any) => void;

                                                                                                                                                                                                                                                                  property input

                                                                                                                                                                                                                                                                  input: HTMLInputElement;

                                                                                                                                                                                                                                                                    property onBlur

                                                                                                                                                                                                                                                                    onBlur: any;

                                                                                                                                                                                                                                                                      property onFocus

                                                                                                                                                                                                                                                                      onFocus: any;

                                                                                                                                                                                                                                                                        property Password

                                                                                                                                                                                                                                                                        static Password: any;

                                                                                                                                                                                                                                                                          property removePasswordTimeout

                                                                                                                                                                                                                                                                          removePasswordTimeout: any;

                                                                                                                                                                                                                                                                            property renderComponent

                                                                                                                                                                                                                                                                            renderComponent: ({
                                                                                                                                                                                                                                                                            getPrefixCls,
                                                                                                                                                                                                                                                                            direction,
                                                                                                                                                                                                                                                                            input,
                                                                                                                                                                                                                                                                            }: ConfigConsumerProps) => any;

                                                                                                                                                                                                                                                                              property renderInput

                                                                                                                                                                                                                                                                              renderInput: (
                                                                                                                                                                                                                                                                              prefixCls: string,
                                                                                                                                                                                                                                                                              size: SizeType | undefined,
                                                                                                                                                                                                                                                                              bordered: boolean,
                                                                                                                                                                                                                                                                              input?: ConfigConsumerProps['input']
                                                                                                                                                                                                                                                                              ) => any;

                                                                                                                                                                                                                                                                                property saveClearableInput

                                                                                                                                                                                                                                                                                saveClearableInput: (input: ClearableLabeledInput) => void;

                                                                                                                                                                                                                                                                                  property saveInput

                                                                                                                                                                                                                                                                                  saveInput: (input: HTMLInputElement) => void;

                                                                                                                                                                                                                                                                                    property Search

                                                                                                                                                                                                                                                                                    static Search: any;

                                                                                                                                                                                                                                                                                      property TextArea

                                                                                                                                                                                                                                                                                      static TextArea: any;

                                                                                                                                                                                                                                                                                        method blur

                                                                                                                                                                                                                                                                                        blur: () => void;

                                                                                                                                                                                                                                                                                          method componentDidMount

                                                                                                                                                                                                                                                                                          componentDidMount: () => void;

                                                                                                                                                                                                                                                                                            method componentDidUpdate

                                                                                                                                                                                                                                                                                            componentDidUpdate: () => void;

                                                                                                                                                                                                                                                                                              method componentWillUnmount

                                                                                                                                                                                                                                                                                              componentWillUnmount: () => void;

                                                                                                                                                                                                                                                                                                method getDerivedStateFromProps

                                                                                                                                                                                                                                                                                                static getDerivedStateFromProps: (
                                                                                                                                                                                                                                                                                                nextProps: InputProps,
                                                                                                                                                                                                                                                                                                { prevValue }: InputState
                                                                                                                                                                                                                                                                                                ) => Partial<InputState>;

                                                                                                                                                                                                                                                                                                  method getSnapshotBeforeUpdate

                                                                                                                                                                                                                                                                                                  getSnapshotBeforeUpdate: (prevProps: InputProps) => null;

                                                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                                                    render: () => any;

                                                                                                                                                                                                                                                                                                      method select

                                                                                                                                                                                                                                                                                                      select: () => void;

                                                                                                                                                                                                                                                                                                        method setSelectionRange

                                                                                                                                                                                                                                                                                                        setSelectionRange: (
                                                                                                                                                                                                                                                                                                        start: number,
                                                                                                                                                                                                                                                                                                        end: number,
                                                                                                                                                                                                                                                                                                        direction?: 'forward' | 'backward' | 'none'
                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                          method setValue

                                                                                                                                                                                                                                                                                                          setValue: (value: string, callback?: () => void) => void;
                                                                                                                                                                                                                                                                                                            class Menu extends React.Component<MenuProps, {}> {}
                                                                                                                                                                                                                                                                                                              static Divider: any;
                                                                                                                                                                                                                                                                                                                static Item: typeof Item;
                                                                                                                                                                                                                                                                                                                  static ItemGroup: any;
                                                                                                                                                                                                                                                                                                                    static SubMenu: (props: SubMenuProps) => any;
                                                                                                                                                                                                                                                                                                                      render: () => any;

                                                                                                                                                                                                                                                                                                                        class Progress

                                                                                                                                                                                                                                                                                                                        class Progress extends React.Component<ProgressProps> {}

                                                                                                                                                                                                                                                                                                                          property defaultProps

                                                                                                                                                                                                                                                                                                                          static defaultProps: {
                                                                                                                                                                                                                                                                                                                          type: 'circle' | 'line' | 'dashboard' | undefined;
                                                                                                                                                                                                                                                                                                                          percent: number;
                                                                                                                                                                                                                                                                                                                          showInfo: boolean;
                                                                                                                                                                                                                                                                                                                          trailColor: null;
                                                                                                                                                                                                                                                                                                                          size: ProgressSize | undefined;
                                                                                                                                                                                                                                                                                                                          gapDegree: undefined;
                                                                                                                                                                                                                                                                                                                          strokeLinecap: 'round' | 'butt' | 'square' | undefined;
                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                            property renderProgress

                                                                                                                                                                                                                                                                                                                            renderProgress: ({ getPrefixCls, direction }: ConfigConsumerProps) => any;

                                                                                                                                                                                                                                                                                                                              method getPercentNumber

                                                                                                                                                                                                                                                                                                                              getPercentNumber: () => number;

                                                                                                                                                                                                                                                                                                                                method getProgressStatus

                                                                                                                                                                                                                                                                                                                                getProgressStatus: () => 'success' | 'normal' | 'active' | 'exception';

                                                                                                                                                                                                                                                                                                                                  method render

                                                                                                                                                                                                                                                                                                                                  render: () => any;

                                                                                                                                                                                                                                                                                                                                    method renderProcessInfo

                                                                                                                                                                                                                                                                                                                                    renderProcessInfo: (
                                                                                                                                                                                                                                                                                                                                    prefixCls: string,
                                                                                                                                                                                                                                                                                                                                    progressStatus: typeof ProgressStatuses[number]
                                                                                                                                                                                                                                                                                                                                    ) => JSX.Element | null;

                                                                                                                                                                                                                                                                                                                                      class Spin

                                                                                                                                                                                                                                                                                                                                      class Spin extends React.Component<SpinProps, SpinState> {}

                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                        constructor(props: SpinProps);

                                                                                                                                                                                                                                                                                                                                          property debouncifyUpdateSpinning

                                                                                                                                                                                                                                                                                                                                          debouncifyUpdateSpinning: (props?: SpinProps | undefined) => void;

                                                                                                                                                                                                                                                                                                                                            property defaultProps

                                                                                                                                                                                                                                                                                                                                            static defaultProps: {
                                                                                                                                                                                                                                                                                                                                            spinning: boolean;
                                                                                                                                                                                                                                                                                                                                            size: 'small' | 'large' | 'default';
                                                                                                                                                                                                                                                                                                                                            wrapperClassName: string;
                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                              property originalUpdateSpinning

                                                                                                                                                                                                                                                                                                                                              originalUpdateSpinning: () => void;

                                                                                                                                                                                                                                                                                                                                                property renderSpin

                                                                                                                                                                                                                                                                                                                                                renderSpin: ({ getPrefixCls, direction }: ConfigConsumerProps) => any;

                                                                                                                                                                                                                                                                                                                                                  property updateSpinning

                                                                                                                                                                                                                                                                                                                                                  updateSpinning: () => void;

                                                                                                                                                                                                                                                                                                                                                    method cancelExistingSpin

                                                                                                                                                                                                                                                                                                                                                    cancelExistingSpin: () => void;

                                                                                                                                                                                                                                                                                                                                                      method componentDidMount

                                                                                                                                                                                                                                                                                                                                                      componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                        method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                        componentDidUpdate: () => void;

                                                                                                                                                                                                                                                                                                                                                          method componentWillUnmount

                                                                                                                                                                                                                                                                                                                                                          componentWillUnmount: () => void;

                                                                                                                                                                                                                                                                                                                                                            method isNestedPattern

                                                                                                                                                                                                                                                                                                                                                            isNestedPattern: () => boolean;

                                                                                                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                                                                                                              render: () => any;

                                                                                                                                                                                                                                                                                                                                                                method setDefaultIndicator

                                                                                                                                                                                                                                                                                                                                                                static setDefaultIndicator: (indicator: any) => void;

                                                                                                                                                                                                                                                                                                                                                                  class Transfer

                                                                                                                                                                                                                                                                                                                                                                  class Transfer<
                                                                                                                                                                                                                                                                                                                                                                  RecordType extends TransferItem = TransferItem
                                                                                                                                                                                                                                                                                                                                                                  > extends React.Component<TransferProps<RecordType>, TransferState> {}

                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                    constructor(props: TransferProps<RecordType>);

                                                                                                                                                                                                                                                                                                                                                                      property defaultProps

                                                                                                                                                                                                                                                                                                                                                                      static defaultProps: {
                                                                                                                                                                                                                                                                                                                                                                      dataSource: never[];
                                                                                                                                                                                                                                                                                                                                                                      locale: {};
                                                                                                                                                                                                                                                                                                                                                                      showSearch: boolean;
                                                                                                                                                                                                                                                                                                                                                                      listStyle: () => void;
                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                        property getLocale

                                                                                                                                                                                                                                                                                                                                                                        getLocale: (
                                                                                                                                                                                                                                                                                                                                                                        transferLocale: TransferLocale,
                                                                                                                                                                                                                                                                                                                                                                        renderEmpty: RenderEmptyHandler
                                                                                                                                                                                                                                                                                                                                                                        ) => {
                                                                                                                                                                                                                                                                                                                                                                        titles: React.ReactNode[];
                                                                                                                                                                                                                                                                                                                                                                        notFoundContent:
                                                                                                                                                                                                                                                                                                                                                                        | string
                                                                                                                                                                                                                                                                                                                                                                        | number
                                                                                                                                                                                                                                                                                                                                                                        | boolean
                                                                                                                                                                                                                                                                                                                                                                        | {}
                                                                                                                                                                                                                                                                                                                                                                        | React.ReactElement<any, string | React.JSXElementConstructor<any>>
                                                                                                                                                                                                                                                                                                                                                                        | React.ReactNodeArray
                                                                                                                                                                                                                                                                                                                                                                        | React.ReactPortal
                                                                                                                                                                                                                                                                                                                                                                        | null
                                                                                                                                                                                                                                                                                                                                                                        | undefined;
                                                                                                                                                                                                                                                                                                                                                                        searchPlaceholder: string;
                                                                                                                                                                                                                                                                                                                                                                        itemUnit: string;
                                                                                                                                                                                                                                                                                                                                                                        itemsUnit: string;
                                                                                                                                                                                                                                                                                                                                                                        remove: string;
                                                                                                                                                                                                                                                                                                                                                                        selectAll: string;
                                                                                                                                                                                                                                                                                                                                                                        selectCurrent: string;
                                                                                                                                                                                                                                                                                                                                                                        selectInvert: string;
                                                                                                                                                                                                                                                                                                                                                                        removeAll: string;
                                                                                                                                                                                                                                                                                                                                                                        removeCurrent: string;
                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                          property handleClear

                                                                                                                                                                                                                                                                                                                                                                          handleClear: (direction: TransferDirection) => void;

                                                                                                                                                                                                                                                                                                                                                                            property handleFilter

                                                                                                                                                                                                                                                                                                                                                                            handleFilter: (direction: TransferDirection, e: any) => void;

                                                                                                                                                                                                                                                                                                                                                                              property handleLeftClear

                                                                                                                                                                                                                                                                                                                                                                              handleLeftClear: () => void;

                                                                                                                                                                                                                                                                                                                                                                                property handleLeftFilter

                                                                                                                                                                                                                                                                                                                                                                                handleLeftFilter: (e: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                  property handleLeftScroll

                                                                                                                                                                                                                                                                                                                                                                                  handleLeftScroll: (e: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                    property handleListStyle

                                                                                                                                                                                                                                                                                                                                                                                    handleListStyle: (listStyle: any, direction: TransferDirection) => any;

                                                                                                                                                                                                                                                                                                                                                                                      property handleRightClear

                                                                                                                                                                                                                                                                                                                                                                                      handleRightClear: () => void;

                                                                                                                                                                                                                                                                                                                                                                                        property handleRightFilter

                                                                                                                                                                                                                                                                                                                                                                                        handleRightFilter: (e: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                          property handleRightScroll

                                                                                                                                                                                                                                                                                                                                                                                          handleRightScroll: (e: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                            property handleScroll

                                                                                                                                                                                                                                                                                                                                                                                            handleScroll: (direction: TransferDirection, e: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                              property List

                                                                                                                                                                                                                                                                                                                                                                                              static List: typeof List;

                                                                                                                                                                                                                                                                                                                                                                                                property moveTo

                                                                                                                                                                                                                                                                                                                                                                                                moveTo: (direction: TransferDirection) => void;

                                                                                                                                                                                                                                                                                                                                                                                                  property moveToLeft

                                                                                                                                                                                                                                                                                                                                                                                                  moveToLeft: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                    property moveToRight

                                                                                                                                                                                                                                                                                                                                                                                                    moveToRight: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                      property onItemSelect

                                                                                                                                                                                                                                                                                                                                                                                                      onItemSelect: (
                                                                                                                                                                                                                                                                                                                                                                                                      direction: TransferDirection,
                                                                                                                                                                                                                                                                                                                                                                                                      selectedKey: string,
                                                                                                                                                                                                                                                                                                                                                                                                      checked: boolean
                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                        property onItemSelectAll

                                                                                                                                                                                                                                                                                                                                                                                                        onItemSelectAll: (
                                                                                                                                                                                                                                                                                                                                                                                                        direction: TransferDirection,
                                                                                                                                                                                                                                                                                                                                                                                                        selectedKeys: string[],
                                                                                                                                                                                                                                                                                                                                                                                                        checkAll: boolean
                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                          property onLeftItemSelect

                                                                                                                                                                                                                                                                                                                                                                                                          onLeftItemSelect: (selectedKey: string, checked: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                            property onLeftItemSelectAll

                                                                                                                                                                                                                                                                                                                                                                                                            onLeftItemSelectAll: (selectedKeys: string[], checkAll: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                              property onRightItemRemove

                                                                                                                                                                                                                                                                                                                                                                                                              onRightItemRemove: (selectedKeys: string[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                property onRightItemSelect

                                                                                                                                                                                                                                                                                                                                                                                                                onRightItemSelect: (selectedKey: string, checked: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                  property onRightItemSelectAll

                                                                                                                                                                                                                                                                                                                                                                                                                  onRightItemSelectAll: (selectedKeys: string[], checkAll: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                    property Operation

                                                                                                                                                                                                                                                                                                                                                                                                                    static Operation: ({
                                                                                                                                                                                                                                                                                                                                                                                                                    disabled,
                                                                                                                                                                                                                                                                                                                                                                                                                    moveToLeft,
                                                                                                                                                                                                                                                                                                                                                                                                                    moveToRight,
                                                                                                                                                                                                                                                                                                                                                                                                                    leftArrowText,
                                                                                                                                                                                                                                                                                                                                                                                                                    rightArrowText,
                                                                                                                                                                                                                                                                                                                                                                                                                    leftActive,
                                                                                                                                                                                                                                                                                                                                                                                                                    rightActive,
                                                                                                                                                                                                                                                                                                                                                                                                                    className,
                                                                                                                                                                                                                                                                                                                                                                                                                    style,
                                                                                                                                                                                                                                                                                                                                                                                                                    direction,
                                                                                                                                                                                                                                                                                                                                                                                                                    oneWay,
                                                                                                                                                                                                                                                                                                                                                                                                                    }: import('./operation').TransferOperationProps) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                      property renderTransfer

                                                                                                                                                                                                                                                                                                                                                                                                                      renderTransfer: (transferLocale: TransferLocale) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                        property Search

                                                                                                                                                                                                                                                                                                                                                                                                                        static Search: (props: TransferSearchProps) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                          property separatedDataSource

                                                                                                                                                                                                                                                                                                                                                                                                                          separatedDataSource: {
                                                                                                                                                                                                                                                                                                                                                                                                                          leftDataSource: RecordType[];
                                                                                                                                                                                                                                                                                                                                                                                                                          rightDataSource: RecordType[];
                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                            property setStateKeys

                                                                                                                                                                                                                                                                                                                                                                                                                            setStateKeys: (
                                                                                                                                                                                                                                                                                                                                                                                                                            direction: TransferDirection,
                                                                                                                                                                                                                                                                                                                                                                                                                            keys: string[] | ((prevKeys: string[]) => string[])
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                              method getDerivedStateFromProps

                                                                                                                                                                                                                                                                                                                                                                                                                              static getDerivedStateFromProps: <T>({
                                                                                                                                                                                                                                                                                                                                                                                                                              selectedKeys,
                                                                                                                                                                                                                                                                                                                                                                                                                              targetKeys,
                                                                                                                                                                                                                                                                                                                                                                                                                              pagination,
                                                                                                                                                                                                                                                                                                                                                                                                                              children,
                                                                                                                                                                                                                                                                                                                                                                                                                              }: TransferProps<T>) => {
                                                                                                                                                                                                                                                                                                                                                                                                                              sourceSelectedKeys: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                              targetSelectedKeys: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                              } | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                method getTitles

                                                                                                                                                                                                                                                                                                                                                                                                                                getTitles: (transferLocale: TransferLocale) => React.ReactNode[];

                                                                                                                                                                                                                                                                                                                                                                                                                                  method handleSelectChange

                                                                                                                                                                                                                                                                                                                                                                                                                                  handleSelectChange: (direction: TransferDirection, holder: string[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                                                                                                                                                                                    render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method separateDataSource

                                                                                                                                                                                                                                                                                                                                                                                                                                      separateDataSource: () => {
                                                                                                                                                                                                                                                                                                                                                                                                                                      leftDataSource: KeyWise<RecordType>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                      rightDataSource: KeyWise<RecordType>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                        Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface AffixProps

                                                                                                                                                                                                                                                                                                                                                                                                                                        interface AffixProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                          property children

                                                                                                                                                                                                                                                                                                                                                                                                                                          children: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property className

                                                                                                                                                                                                                                                                                                                                                                                                                                            className?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property offsetBottom

                                                                                                                                                                                                                                                                                                                                                                                                                                              offsetBottom?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                              • 距离窗口底部达到指定偏移量后触发

                                                                                                                                                                                                                                                                                                                                                                                                                                              property offsetTop

                                                                                                                                                                                                                                                                                                                                                                                                                                              offsetTop?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                              • 距离窗口顶部达到指定偏移量后触发

                                                                                                                                                                                                                                                                                                                                                                                                                                              property onChange

                                                                                                                                                                                                                                                                                                                                                                                                                                              onChange?: (affixed?: boolean) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                              • 固定状态改变时触发的回调函数

                                                                                                                                                                                                                                                                                                                                                                                                                                              property prefixCls

                                                                                                                                                                                                                                                                                                                                                                                                                                              prefixCls?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property style

                                                                                                                                                                                                                                                                                                                                                                                                                                                style?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                  target?: () => Window | HTMLElement | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 设置 Affix 需要监听其滚动事件的元素,值为一个返回对应 DOM 元素的函数

                                                                                                                                                                                                                                                                                                                                                                                                                                                  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?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Whether Alert can be closed

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property closeText

                                                                                                                                                                                                                                                                                                                                                                                                                                                          closeText?: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 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 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 {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        children?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          className?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property href

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            href: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property prefixCls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              prefixCls?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property target

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                target?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  title: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface AnchorProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface AnchorProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property affix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      affix?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property bounds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bounds?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          children?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            className?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property getContainer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getContainer?: () => AnchorContainer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property getCurrentAnchor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getCurrentAnchor?: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Return customize highlight anchor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface AutoCompleteProps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          extends Omit<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          InternalSelectProps<string>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'inputIcon' | 'loading' | 'mode' | 'optionLabelProp' | 'labelInValue'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property dataSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            dataSource?: DataSourceItemType[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface AvatarProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface AvatarProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property alt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                alt?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  children?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    className?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property draggable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      draggable?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property gap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        gap?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property icon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          icon?: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Icon to be used in avatar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onError?: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property prefixCls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            prefixCls?: 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 style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              style?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property target

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property visibilityHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  visibilityHeight?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property visible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    visible?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface BadgeProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface BadgeProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        className?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property color

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          color?: LiteralUnion<PresetColorType, string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 scrollNumberPrefixCls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scrollNumberPrefixCls?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property showZero

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  showZero?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    size?: 'default' | 'small';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property status

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      status?: PresetStatusColorType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        style?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          text?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            title?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface BreadcrumbItemProps {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                className?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dropdownProps?: DropDownProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    href?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onClick?: React.MouseEventHandler<HTMLAnchorElement | HTMLSpanElement>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        overlay?: DropDownProps['overlay'];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          prefixCls?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            separator?: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface BreadcrumbProps {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                className?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  itemRender?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  route: Route,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  params: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  routes: Array<Route>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  paths: Array<string>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    params?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      prefixCls?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        routes?: Route[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          separator?: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            style?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CalendarProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CalendarProps<DateType> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                className?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dateCellRender

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property dateFullCellRender

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property defaultValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      defaultValue?: DateType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property disabledDate

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property monthFullCellRender

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property onChange

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property onPanelChange

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onSelect

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property prefixCls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            prefixCls?: 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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property bordered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bordered?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              children?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                className?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cover

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cover?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property defaultActiveTabKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    defaultActiveTabKey?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property extra

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      extra?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property headStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        headStyle?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property hoverable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hoverable?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property loading

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              loading?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onTabChange

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property prefixCls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  prefixCls?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    size?: CardSize;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      style?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tabBarExtraContent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tabBarExtraContent?: React.ReactNode | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 prefixCls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            prefixCls?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property slickGoTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              slickGoTo?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                style?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CascaderProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CascaderProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property allowClear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    allowClear?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 是否支持清除

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property autoComplete

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    autoComplete?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property autoFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      autoFocus?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 自动获取焦点

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property bordered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      bordered?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Whether has border style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property changeOnSelect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      changeOnSelect?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 当此项为 true 时,点选每级菜单选项值都会发生变化

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      children?: React.ReactElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        className?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 自定义类名

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultValue?: CascaderValueType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 默认的选中项

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 禁用

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property displayRender

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        displayRender?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        label: string[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        selectedOptions?: CascaderOptionType[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 选择后展示的渲染函数

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property dropdownRender

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property expandIcon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          expandIcon?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property expandTrigger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            expandTrigger?: CascaderExpandTrigger;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 次级菜单的展开方式,可选 'click' 和 'hover'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fieldNames

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fieldNames?: FieldNamesType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use this after antd@3.7.0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property getPopupContainer

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              id?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 输入框 id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property inputPrefixCls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              inputPrefixCls?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property loadData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                loadData?: (selectedOptions?: CascaderOptionType[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 输入框 name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property notFoundContent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  notFoundContent?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onChange?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: CascaderValueType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    selectedOptions?: CascaderOptionType[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 选择完成后的回调

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onPopupVisibleChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onPopupVisibleChange?: (popupVisible: boolean) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 浮层可见变化时回调

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options: CascaderOptionType[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 可选项数据源

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property placeholder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    placeholder?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 输入框占位文本

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property popupClassName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    popupClassName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 自定义浮层类名

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property popupPlacement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    popupPlacement?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 浮层预设位置:bottomLeft bottomRight topLeft topRight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property popupVisible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    popupVisible?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property prefixCls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      prefixCls?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property showSearch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        showSearch?: boolean | ShowSearchType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          size?: SizeType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 输入框大小,可选 large default small

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          style?: React.CSSProperties;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 自定义样式

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property suffixIcon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          suffixIcon?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property transitionName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            transitionName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value?: CascaderValueType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 指定选中项

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CheckboxOptionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CheckboxOptionType {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property disabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                disabled?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  label: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onChange

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      style?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: CheckboxValueType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CheckboxProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CheckboxProps extends AbstractCheckboxProps<CheckboxChangeEvent> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property indeterminate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            indeterminate?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CollapsePanelProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface CollapsePanelProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property accordion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      accordion?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 手风琴效果

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property activeKey

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property bordered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bordered?: boolean;

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface CommentProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property actions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            actions?: Array<React.ReactNode>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • List of action items rendered below the comment content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property author

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            author?: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The element to display as the comment author.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property avatar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            avatar?: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The element to display as the comment avatar - generally an antd Avatar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            children?: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Nested comments should be provided as children of the Comment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            className?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • ClassName of comment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property content

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            content: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The main content of the comment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property datetime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            datetime?: React.ReactNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A datetime element containing the time to be displayed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property prefixCls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            prefixCls?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Comment prefix defaults to '.ant-comment'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            style?: React.CSSProperties;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Additional style for the comment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DescriptionsProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DescriptionsProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property bordered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bordered?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                children?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 labelStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            labelStyle?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property layout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              layout?: 'horizontal' | 'vertical';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property prefixCls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                prefixCls?: 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 plain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  plain?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property prefixCls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    prefixCls?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      style?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type?: 'horizontal' | 'vertical';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DrawerProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface DrawerProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property afterVisibleChange

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property bodyStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bodyStyle?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                className?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property closable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  closable?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property closeIcon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    closeIcon?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property contentWrapperStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      contentWrapperStyle?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property destroyOnClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        destroyOnClose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property drawerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          drawerStyle?: React.CSSProperties;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Wrapper dom node style of header and body

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property footer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          footer?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property footerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            footerStyle?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property forceRender

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              forceRender?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property getContainer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getContainer?: string | HTMLElement | getContainerFunc | false;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property handler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  handler?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property headerStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    headerStyle?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property height

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      height?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property keyboard

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        keyboard?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property level

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          level?: string | string[] | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property mask

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mask?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property maskClosable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              maskClosable?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property maskStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                maskStyle?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onClose?: (e: EventType) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property placement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    placement?: placementType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property prefixCls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      prefixCls?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property push

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        push?: boolean | PushState;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          style?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            title?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property visible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              visible?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property width

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                width?: number | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property zIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  zIndex?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface DropDownProps {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      align?: Align;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        arrow?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          className?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            disabled?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              forceRender?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getPopupContainer?: (triggerNode: HTMLElement) => HTMLElement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  mouseEnterDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mouseLeaveDelay?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onVisibleChange?: (visible: boolean) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        openClassName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          overlay: React.ReactElement | OverlayFunc;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            overlayClassName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              overlayStyle?: React.CSSProperties;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                placement?: Placement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  prefixCls?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    transitionName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      trigger?: ('click' | 'hover' | 'contextMenu')[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        visible?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      style?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 FormItemLabelProps,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              FormItemInputProps,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RcFieldProps<Values> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                children?: ChildrenType<Values>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  className?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property fieldKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fieldKey?: React.Key | React.Key[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Auto passed by List render props. User should not use this.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property hasFeedback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hasFeedback?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 style

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    style?: React.CSSProperties;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tooltip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tooltip?: LabelTooltipType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property validateStatus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        validateStatus?: ValidateStatus;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface FormProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property colon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            colon?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 layout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    layout?: FormLayout;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property prefixCls

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        prefixCls?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property requiredMark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          requiredMark?: RequiredMark;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property scrollToFirstError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scrollToFirstError?: Options | boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              size?: SizeType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property wrapperCol

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                wrapperCol?: ColProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface InputNumberProps

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property bordered

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    bordered?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property