antd-mobile

  • Version 2.3.4
  • Published
  • 5.6 MB
  • 23 dependencies
  • MIT license

Install

npm i antd-mobile
yarn add antd-mobile
pnpm add antd-mobile

Overview

基于 React 的移动设计规范实现

Index

Variables

Classes

Variables

variable ActionSheet

const ActionSheet: {
showActionSheetWithOptions(
config: ActionSheetWithOptions,
callback?: ActionCallBack
): void;
showShareActionSheetWithOptions(
config: ShareActionSheetWithOptions,
callback?: ActionCallBack
): void;
close(): void;
};

    variable Toast

    const Toast: {
    SHORT: number;
    LONG: number;
    show(
    content: any,
    duration?: number | undefined,
    mask?: boolean | undefined
    ): void;
    info(
    content: any,
    duration?: number | undefined,
    onClose?: (() => void) | undefined,
    mask?: boolean | undefined
    ): void;
    success(
    content: any,
    duration?: number | undefined,
    onClose?: (() => void) | undefined,
    mask?: boolean | undefined
    ): void;
    fail(
    content: any,
    duration?: number | undefined,
    onClose?: (() => void) | undefined,
    mask?: boolean | undefined
    ): void;
    offline(
    content: any,
    duration?: number | undefined,
    onClose?: (() => void) | undefined,
    mask?: boolean | undefined
    ): void;
    loading(
    content: any,
    duration?: number | undefined,
    onClose?: (() => void) | undefined,
    mask?: boolean | undefined
    ): void;
    hide(): void;
    config(conf?: Partial<IToastConfig>): void;
    };

      Classes

      class Accordion

      class Accordion extends React.Component<AccordionProps, any> {}

        property defaultProps

        static defaultProps: { prefixCls: string };

          property Panel

          static Panel: any;

            method render

            render: () => any;

              class ActivityIndicator

              class ActivityIndicator extends React.Component<ActivityIndicatorProps, any> {}

                property defaultProps

                static defaultProps: {
                prefixCls: string;
                animating: boolean;
                size: string;
                panelColor: string;
                toast: boolean;
                };

                  method render

                  render: () => JSX.Element | null;

                    class Badge

                    class Badge extends React.Component<BadgeProps, any> {}

                      property defaultProps

                      static defaultProps: {
                      prefixCls: string;
                      size: string;
                      overflowCount: number;
                      dot: boolean;
                      corner: boolean;
                      };

                        method render

                        render: () => any;

                          class Button

                          class Button extends React.Component<ButtonProps, any> {}

                            property defaultProps

                            static defaultProps: {
                            prefixCls: string;
                            size: string;
                            inline: boolean;
                            disabled: boolean;
                            loading: boolean;
                            activeStyle: {};
                            };

                              method render

                              render: () => any;

                                class Calendar

                                class Calendar extends React.Component<CalendarProps, any> {}

                                  property contextTypes

                                  static contextTypes: { antLocale: any };

                                    property defaultProps

                                    static defaultProps: {
                                    prefixCls: string;
                                    timePickerPrefixCls: string;
                                    timePickerPickerPrefixCls: string;
                                    };

                                      method render

                                      render: () => any;

                                        class Card

                                        class Card extends React.Component<CardProps, any> {}

                                          property Body

                                          static Body: typeof CardBody;

                                            property defaultProps

                                            static defaultProps: { prefixCls: string; full: boolean };

                                              property Footer

                                              static Footer: typeof CardFooter;

                                                property Header

                                                static Header: typeof CardHeader;

                                                  method render

                                                  render: () => any;
                                                    class Carousel extends React.Component<CarouselProps, CarouselState> {}

                                                      constructor

                                                      constructor(props: CarouselProps);

                                                        property defaultProps

                                                        static defaultProps: {
                                                        prefixCls: string;
                                                        dots: boolean;
                                                        arrows: boolean;
                                                        autoplay: boolean;
                                                        infinite: boolean;
                                                        cellAlign: string;
                                                        selectedIndex: number;
                                                        dotStyle: {};
                                                        dotActiveStyle: {};
                                                        };

                                                          property onChange

                                                          onChange: (index: number) => void;

                                                            method render

                                                            render: () => any;

                                                              class Checkbox

                                                              class Checkbox extends React.Component<CheckboxProps, any> {}

                                                                property AgreeItem

                                                                static AgreeItem: any;

                                                                  property CheckboxItem

                                                                  static CheckboxItem: any;

                                                                    property defaultProps

                                                                    static defaultProps: { prefixCls: string; wrapLabel: boolean };

                                                                      method render

                                                                      render: () => any;

                                                                        class DatePicker

                                                                        class DatePicker extends React.Component<PropsType, any> {}

                                                                          property contextTypes

                                                                          static contextTypes: { antLocale: any };

                                                                            property defaultProps

                                                                            static defaultProps: {
                                                                            mode: string;
                                                                            prefixCls: string;
                                                                            pickerPrefixCls: string;
                                                                            popupPrefixCls: string;
                                                                            minuteStep: number;
                                                                            use12Hours: boolean;
                                                                            };

                                                                              property fixOnOk

                                                                              fixOnOk: (picker: any) => void;

                                                                                property onOk

                                                                                onOk: (v: any) => void;

                                                                                  property onVisibleChange

                                                                                  onVisibleChange: (visible: boolean) => void;

                                                                                    property setScrollValue

                                                                                    setScrollValue: (v: any) => void;

                                                                                      method render

                                                                                      render: () => any;

                                                                                        class DatePickerView

                                                                                        class DatePickerView extends React.Component<DatePickerProps, any> {}

                                                                                          property contextTypes

                                                                                          static contextTypes: { antLocale: any };

                                                                                            property defaultProps

                                                                                            static defaultProps: {
                                                                                            mode: string;
                                                                                            extra: string;
                                                                                            prefixCls: string;
                                                                                            pickerPrefixCls: string;
                                                                                            minuteStep: number;
                                                                                            use12Hours: boolean;
                                                                                            };

                                                                                              method render

                                                                                              render: () => any;

                                                                                                class Drawer

                                                                                                class Drawer extends React.Component<DrawerWebProps, any> {}

                                                                                                  property defaultProps

                                                                                                  static defaultProps: { prefixCls: string; enableDragHandle: boolean };

                                                                                                    method render

                                                                                                    render: () => any;

                                                                                                      class Flex

                                                                                                      class Flex extends React.Component<FlexProps, any> {}

                                                                                                        property defaultProps

                                                                                                        static defaultProps: { prefixCls: string; align: string };

                                                                                                          property Item

                                                                                                          static Item: any;

                                                                                                            method render

                                                                                                            render: () => any;

                                                                                                              class Grid

                                                                                                              class Grid extends React.Component<GridProps, any> {}

                                                                                                                property defaultProps

                                                                                                                static defaultProps: {
                                                                                                                data: never[];
                                                                                                                hasLine: boolean;
                                                                                                                isCarousel: boolean;
                                                                                                                columnNum: number;
                                                                                                                carouselMaxRow: number;
                                                                                                                prefixCls: string;
                                                                                                                square: boolean;
                                                                                                                itemStyle: {};
                                                                                                                };

                                                                                                                  property getRows

                                                                                                                  getRows: (rowCount: number, dataLength: number) => any[];

                                                                                                                    property renderCarousel

                                                                                                                    renderCarousel: (rowsArr: any[], pageCount: number, rowCount: number) => any[];

                                                                                                                      property renderItem

                                                                                                                      renderItem: (
                                                                                                                      dataItem: any,
                                                                                                                      index: number,
                                                                                                                      columnNum: number,
                                                                                                                      renderItem: any
                                                                                                                      ) => any;

                                                                                                                        property state

                                                                                                                        state: { initialSlideWidth: number };

                                                                                                                          method componentDidMount

                                                                                                                          componentDidMount: () => void;

                                                                                                                            method render

                                                                                                                            render: () => JSX.Element | null;

                                                                                                                              class Icon

                                                                                                                              class Icon extends React.Component<IconProps, any> {}

                                                                                                                                property defaultProps

                                                                                                                                static defaultProps: { size: string };

                                                                                                                                  method componentDidMount

                                                                                                                                  componentDidMount: () => void;

                                                                                                                                    method render

                                                                                                                                    render: () => any;

                                                                                                                                      class ImagePicker

                                                                                                                                      class ImagePicker extends React.Component<ImagePickerPropTypes, any> {}

                                                                                                                                        property addImage

                                                                                                                                        addImage: (imgItem: any) => void;

                                                                                                                                          property defaultProps

                                                                                                                                          static defaultProps: {
                                                                                                                                          prefixCls: string;
                                                                                                                                          files: never[];
                                                                                                                                          onChange: typeof noop;
                                                                                                                                          onImageClick: typeof noop;
                                                                                                                                          onAddImageClick: typeof noop;
                                                                                                                                          onFail: typeof noop;
                                                                                                                                          selectable: boolean;
                                                                                                                                          multiple: boolean;
                                                                                                                                          accept: string;
                                                                                                                                          length: number;
                                                                                                                                          disableDelete: boolean;
                                                                                                                                          };

                                                                                                                                            property fileSelectorInput

                                                                                                                                            fileSelectorInput: HTMLInputElement;

                                                                                                                                              property getOrientation

                                                                                                                                              getOrientation: (file: any, callback: (_: number) => void) => void;

                                                                                                                                                property getRotation

                                                                                                                                                getRotation: (orientation?: number) => number;

                                                                                                                                                  property onFileChange

                                                                                                                                                  onFileChange: () => void;

                                                                                                                                                    property onImageClick

                                                                                                                                                    onImageClick: (index: number) => void;

                                                                                                                                                      property parseFile

                                                                                                                                                      parseFile: (file: any, index: number) => Promise<{}>;

                                                                                                                                                        property removeImage

                                                                                                                                                        removeImage: (index: number) => void;

                                                                                                                                                          method render

                                                                                                                                                          render: () => any;

                                                                                                                                                            class InputItem

                                                                                                                                                            class InputItem extends React.Component<InputItemProps, any> {}

                                                                                                                                                              constructor

                                                                                                                                                              constructor(props: InputItemProps);

                                                                                                                                                                property calcPos

                                                                                                                                                                calcPos: (
                                                                                                                                                                prePos: number,
                                                                                                                                                                preCtrlVal: string,
                                                                                                                                                                rawVal: string,
                                                                                                                                                                ctrlVal: string,
                                                                                                                                                                placeholderChars: string[],
                                                                                                                                                                maskReg: RegExp
                                                                                                                                                                ) => number;

                                                                                                                                                                  property clearInput

                                                                                                                                                                  clearInput: () => void;

                                                                                                                                                                    property contextTypes

                                                                                                                                                                    static contextTypes: { antLocale: any };

                                                                                                                                                                      property defaultProps

                                                                                                                                                                      static defaultProps: {
                                                                                                                                                                      prefixCls: string;
                                                                                                                                                                      prefixListCls: string;
                                                                                                                                                                      type: string;
                                                                                                                                                                      editable: boolean;
                                                                                                                                                                      disabled: boolean;
                                                                                                                                                                      placeholder: string;
                                                                                                                                                                      clear: boolean;
                                                                                                                                                                      onChange: typeof noop;
                                                                                                                                                                      onBlur: typeof noop;
                                                                                                                                                                      onFocus: typeof noop;
                                                                                                                                                                      extra: string;
                                                                                                                                                                      onExtraClick: typeof noop;
                                                                                                                                                                      error: boolean;
                                                                                                                                                                      onErrorClick: typeof noop;
                                                                                                                                                                      onVirtualKeyboardConfirm: typeof noop;
                                                                                                                                                                      labelNumber: number;
                                                                                                                                                                      updatePlaceholder: boolean;
                                                                                                                                                                      moneyKeyboardAlign: string;
                                                                                                                                                                      moneyKeyboardWrapProps: {};
                                                                                                                                                                      moneyKeyboardHeader: null;
                                                                                                                                                                      disabledKeys: null;
                                                                                                                                                                      };

                                                                                                                                                                        property focus

                                                                                                                                                                        focus: () => void;

                                                                                                                                                                          property handleOnChange

                                                                                                                                                                          handleOnChange: (
                                                                                                                                                                          value: string,
                                                                                                                                                                          isMutated?: boolean,
                                                                                                                                                                          adjustPos?: Function
                                                                                                                                                                          ) => void;

                                                                                                                                                                            property inputRef

                                                                                                                                                                            inputRef: Input | CustomInput;

                                                                                                                                                                              property onInputBlur

                                                                                                                                                                              onInputBlur: (value: string) => void;

                                                                                                                                                                                property onInputChange

                                                                                                                                                                                onInputChange: (e: any) => void;

                                                                                                                                                                                  property onInputFocus

                                                                                                                                                                                  onInputFocus: (value: string) => void;

                                                                                                                                                                                    method componentWillReceiveProps

                                                                                                                                                                                    componentWillReceiveProps: (nextProps: InputItemProps) => void;

                                                                                                                                                                                      method componentWillUnmount

                                                                                                                                                                                      componentWillUnmount: () => void;

                                                                                                                                                                                        method render

                                                                                                                                                                                        render: () => any;

                                                                                                                                                                                          class List

                                                                                                                                                                                          class List extends React.Component<ListProps, any> {}

                                                                                                                                                                                            property defaultProps

                                                                                                                                                                                            static defaultProps: Partial<ListProps>;

                                                                                                                                                                                              property Item

                                                                                                                                                                                              static Item: typeof Item;

                                                                                                                                                                                                method render

                                                                                                                                                                                                render: () => any;

                                                                                                                                                                                                  class ListView

                                                                                                                                                                                                  class ListView extends React.Component<ListViewProps, any> {}

                                                                                                                                                                                                    property DataSource

                                                                                                                                                                                                    static DataSource: any;

                                                                                                                                                                                                      property defaultProps

                                                                                                                                                                                                      static defaultProps: { prefixCls: string; listPrefixCls: string };

                                                                                                                                                                                                        property getInnerViewNode

                                                                                                                                                                                                        getInnerViewNode: () => any;

                                                                                                                                                                                                          property IndexedList

                                                                                                                                                                                                          static IndexedList: typeof IndexedList;

                                                                                                                                                                                                            property listviewRef

                                                                                                                                                                                                            listviewRef: any;

                                                                                                                                                                                                              property scrollTo

                                                                                                                                                                                                              scrollTo: (...args: any[]) => any;

                                                                                                                                                                                                                method render

                                                                                                                                                                                                                render: () => any;

                                                                                                                                                                                                                  class LocaleProvider

                                                                                                                                                                                                                  class LocaleProvider extends React.Component<LocaleProviderProps, any> {}

                                                                                                                                                                                                                    property childContextTypes

                                                                                                                                                                                                                    static childContextTypes: { antLocale: any };

                                                                                                                                                                                                                      property propTypes

                                                                                                                                                                                                                      static propTypes: { locale: any };

                                                                                                                                                                                                                        method getChildContext

                                                                                                                                                                                                                        getChildContext: () => {
                                                                                                                                                                                                                        antLocale: {
                                                                                                                                                                                                                        exist: boolean;
                                                                                                                                                                                                                        Pagination?: object | undefined;
                                                                                                                                                                                                                        DatePicker?: object | undefined;
                                                                                                                                                                                                                        DatePickerView?: object | undefined;
                                                                                                                                                                                                                        InputItem?: object | undefined;
                                                                                                                                                                                                                        };
                                                                                                                                                                                                                        };

                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                          render: () => any;
                                                                                                                                                                                                                            class Menu extends React.Component<MenuProps, StateType> {}
                                                                                                                                                                                                                              constructor(props: MenuProps);
                                                                                                                                                                                                                                static contextTypes: { antLocale: any };
                                                                                                                                                                                                                                  static defaultProps: {
                                                                                                                                                                                                                                  prefixCls: string;
                                                                                                                                                                                                                                  subMenuPrefixCls: string;
                                                                                                                                                                                                                                  radioPrefixCls: string;
                                                                                                                                                                                                                                  multiSelectMenuBtnsCls: string;
                                                                                                                                                                                                                                  MenuSelectContanerPrefixCls: string;
                                                                                                                                                                                                                                  data: never[];
                                                                                                                                                                                                                                  level: number;
                                                                                                                                                                                                                                  onChange: () => void;
                                                                                                                                                                                                                                  onOk: () => void;
                                                                                                                                                                                                                                  onCancel: () => void;
                                                                                                                                                                                                                                  multiSelect: boolean;
                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                    getSelectValue: (dataItem: DataItem) => any[];
                                                                                                                                                                                                                                      onClickFirstLevelItem: (dataItem: DataItem) => void;
                                                                                                                                                                                                                                        onClickSubMenuItem: (dataItem: DataItem) => void;
                                                                                                                                                                                                                                          onMenuCancel: () => void;
                                                                                                                                                                                                                                            onMenuOk: () => void;
                                                                                                                                                                                                                                              componentDidMount: () => void;
                                                                                                                                                                                                                                                componentWillReceiveProps: (nextProps: MenuProps) => void;
                                                                                                                                                                                                                                                  getNewFsv: (props: MenuProps) => string;
                                                                                                                                                                                                                                                    render: () => any;
                                                                                                                                                                                                                                                      class Modal extends ModalComponent<ModalProps, any> {}

                                                                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                                                                        static defaultProps: {
                                                                                                                                                                                                                                                        prefixCls: string;
                                                                                                                                                                                                                                                        transparent: boolean;
                                                                                                                                                                                                                                                        popup: boolean;
                                                                                                                                                                                                                                                        animationType: string;
                                                                                                                                                                                                                                                        animated: boolean;
                                                                                                                                                                                                                                                        style: {};
                                                                                                                                                                                                                                                        onShow(): void;
                                                                                                                                                                                                                                                        footer: never[];
                                                                                                                                                                                                                                                        closable: boolean;
                                                                                                                                                                                                                                                        operation: boolean;
                                                                                                                                                                                                                                                        platform: string;
                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                          render: () => any;

                                                                                                                                                                                                                                                            method renderFooterButton

                                                                                                                                                                                                                                                            renderFooterButton: (
                                                                                                                                                                                                                                                            button: Action<React.CSSProperties>,
                                                                                                                                                                                                                                                            prefixCls: string | undefined,
                                                                                                                                                                                                                                                            i: number
                                                                                                                                                                                                                                                            ) => any;
                                                                                                                                                                                                                                                              class NavBar extends React.Component<NavBarProps, any> {}
                                                                                                                                                                                                                                                                static defaultProps: {
                                                                                                                                                                                                                                                                prefixCls: string;
                                                                                                                                                                                                                                                                mode: string;
                                                                                                                                                                                                                                                                onLeftClick: () => void;
                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                  render: () => any;

                                                                                                                                                                                                                                                                    class NoticeBar

                                                                                                                                                                                                                                                                    class NoticeBar extends React.Component<NoticeWebProps, any> {}

                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                      constructor(props: NoticeWebProps);

                                                                                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                                                                                        static defaultProps: {
                                                                                                                                                                                                                                                                        prefixCls: string;
                                                                                                                                                                                                                                                                        mode: string;
                                                                                                                                                                                                                                                                        icon: any;
                                                                                                                                                                                                                                                                        onClick(): void;
                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                          property onClick

                                                                                                                                                                                                                                                                          onClick: () => void;

                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                            render: () => JSX.Element | null;

                                                                                                                                                                                                                                                                              class Pagination

                                                                                                                                                                                                                                                                              class Pagination extends React.Component<PaginationProps, PaginationState> {}

                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                constructor(props: PaginationProps);

                                                                                                                                                                                                                                                                                  property contextTypes

                                                                                                                                                                                                                                                                                  static contextTypes: { antLocale: any };

                                                                                                                                                                                                                                                                                    property defaultProps

                                                                                                                                                                                                                                                                                    static defaultProps: {
                                                                                                                                                                                                                                                                                    prefixCls: string;
                                                                                                                                                                                                                                                                                    mode: string;
                                                                                                                                                                                                                                                                                    current: number;
                                                                                                                                                                                                                                                                                    total: number;
                                                                                                                                                                                                                                                                                    simple: boolean;
                                                                                                                                                                                                                                                                                    onChange: () => void;
                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                      method componentWillReceiveProps

                                                                                                                                                                                                                                                                                      componentWillReceiveProps: (nextProps: PaginationProps) => void;

                                                                                                                                                                                                                                                                                        method onChange

                                                                                                                                                                                                                                                                                        onChange: (p: number) => void;

                                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                                          render: () => any;

                                                                                                                                                                                                                                                                                            class Picker

                                                                                                                                                                                                                                                                                            class Picker extends AbstractPicker {}

                                                                                                                                                                                                                                                                                              property contextTypes

                                                                                                                                                                                                                                                                                              static contextTypes: { antLocale: any };

                                                                                                                                                                                                                                                                                                property defaultProps

                                                                                                                                                                                                                                                                                                static defaultProps: {
                                                                                                                                                                                                                                                                                                triggerType: string;
                                                                                                                                                                                                                                                                                                prefixCls: string;
                                                                                                                                                                                                                                                                                                pickerPrefixCls: string;
                                                                                                                                                                                                                                                                                                popupPrefixCls: string;
                                                                                                                                                                                                                                                                                                format: (values: React.ReactNode[]) => string | React.ReactNode[];
                                                                                                                                                                                                                                                                                                cols: number;
                                                                                                                                                                                                                                                                                                cascade: boolean;
                                                                                                                                                                                                                                                                                                title: string;
                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                  property popupProps

                                                                                                                                                                                                                                                                                                  protected popupProps: {
                                                                                                                                                                                                                                                                                                  WrapComponent: string;
                                                                                                                                                                                                                                                                                                  transitionName: string;
                                                                                                                                                                                                                                                                                                  maskTransitionName: string;
                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                    class PickerView

                                                                                                                                                                                                                                                                                                    class PickerView extends React.Component<IPickerView, any> {}

                                                                                                                                                                                                                                                                                                      property defaultProps

                                                                                                                                                                                                                                                                                                      static defaultProps: {
                                                                                                                                                                                                                                                                                                      prefixCls: string;
                                                                                                                                                                                                                                                                                                      pickerPrefixCls: string;
                                                                                                                                                                                                                                                                                                      cols: number;
                                                                                                                                                                                                                                                                                                      cascade: boolean;
                                                                                                                                                                                                                                                                                                      value: never[];
                                                                                                                                                                                                                                                                                                      onChange(): void;
                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                        property getCol

                                                                                                                                                                                                                                                                                                        getCol: () => JSX.Element[];

                                                                                                                                                                                                                                                                                                          property isMultiPicker

                                                                                                                                                                                                                                                                                                          isMultiPicker: () => boolean;

                                                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                                                            render: () => any;

                                                                                                                                                                                                                                                                                                              class Popover

                                                                                                                                                                                                                                                                                                              class Popover extends React.Component<PopOverPropsType, any> {}

                                                                                                                                                                                                                                                                                                                property defaultProps

                                                                                                                                                                                                                                                                                                                static defaultProps: {
                                                                                                                                                                                                                                                                                                                prefixCls: string;
                                                                                                                                                                                                                                                                                                                placement: string;
                                                                                                                                                                                                                                                                                                                align: { overflow: { adjustY: number; adjustX: number } };
                                                                                                                                                                                                                                                                                                                trigger: string[];
                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                  property Item

                                                                                                                                                                                                                                                                                                                  static Item: typeof Item;

                                                                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                                                                    render: () => any;

                                                                                                                                                                                                                                                                                                                      class Progress

                                                                                                                                                                                                                                                                                                                      class Progress extends React.Component<ProgressProps, any> {}

                                                                                                                                                                                                                                                                                                                        property barRef

                                                                                                                                                                                                                                                                                                                        barRef: HTMLDivElement;

                                                                                                                                                                                                                                                                                                                          property defaultProps

                                                                                                                                                                                                                                                                                                                          static defaultProps: {
                                                                                                                                                                                                                                                                                                                          prefixCls: string;
                                                                                                                                                                                                                                                                                                                          percent: number;
                                                                                                                                                                                                                                                                                                                          position: string;
                                                                                                                                                                                                                                                                                                                          unfilled: boolean;
                                                                                                                                                                                                                                                                                                                          appearTransition: boolean;
                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                            method componentDidMount

                                                                                                                                                                                                                                                                                                                            componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                              method componentWillReceiveProps

                                                                                                                                                                                                                                                                                                                              componentWillReceiveProps: () => void;

                                                                                                                                                                                                                                                                                                                                method render

                                                                                                                                                                                                                                                                                                                                render: () => any;

                                                                                                                                                                                                                                                                                                                                  class PullToRefresh

                                                                                                                                                                                                                                                                                                                                  class PullToRefresh extends React.Component<PropsType, any> {}

                                                                                                                                                                                                                                                                                                                                    property contextTypes

                                                                                                                                                                                                                                                                                                                                    static contextTypes: { antLocale: any };

                                                                                                                                                                                                                                                                                                                                      property defaultProps

                                                                                                                                                                                                                                                                                                                                      static defaultProps: { prefixCls: string };

                                                                                                                                                                                                                                                                                                                                        method render

                                                                                                                                                                                                                                                                                                                                        render: () => any;

                                                                                                                                                                                                                                                                                                                                          class Radio

                                                                                                                                                                                                                                                                                                                                          class Radio extends React.Component<RadioProps, any> {}

                                                                                                                                                                                                                                                                                                                                            property defaultProps

                                                                                                                                                                                                                                                                                                                                            static defaultProps: { prefixCls: string; wrapLabel: boolean };

                                                                                                                                                                                                                                                                                                                                              property RadioItem

                                                                                                                                                                                                                                                                                                                                              static RadioItem: any;

                                                                                                                                                                                                                                                                                                                                                method render

                                                                                                                                                                                                                                                                                                                                                render: () => any;

                                                                                                                                                                                                                                                                                                                                                  class Range

                                                                                                                                                                                                                                                                                                                                                  class Range extends React.Component<RangeProps, any> {}

                                                                                                                                                                                                                                                                                                                                                    property defaultProps

                                                                                                                                                                                                                                                                                                                                                    static defaultProps: { prefixCls: string };

                                                                                                                                                                                                                                                                                                                                                      method render

                                                                                                                                                                                                                                                                                                                                                      render: () => any;

                                                                                                                                                                                                                                                                                                                                                        class Result

                                                                                                                                                                                                                                                                                                                                                        class Result extends React.Component<ResultProps, any> {}

                                                                                                                                                                                                                                                                                                                                                          property defaultProps

                                                                                                                                                                                                                                                                                                                                                          static defaultProps: {
                                                                                                                                                                                                                                                                                                                                                          prefixCls: string;
                                                                                                                                                                                                                                                                                                                                                          buttonType: string;
                                                                                                                                                                                                                                                                                                                                                          onButtonClick: () => void;
                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                                                                                                            render: () => any;
                                                                                                                                                                                                                                                                                                                                                              class SearchBar extends React.Component<SearchBarProps, SearchBarState> {}

                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                constructor(props: SearchBarProps);

                                                                                                                                                                                                                                                                                                                                                                  property blurFromOnClear

                                                                                                                                                                                                                                                                                                                                                                  blurFromOnClear: boolean;

                                                                                                                                                                                                                                                                                                                                                                    property contextTypes

                                                                                                                                                                                                                                                                                                                                                                    static contextTypes: { antLocale: any };

                                                                                                                                                                                                                                                                                                                                                                      property defaultProps

                                                                                                                                                                                                                                                                                                                                                                      static defaultProps: {
                                                                                                                                                                                                                                                                                                                                                                      prefixCls: string;
                                                                                                                                                                                                                                                                                                                                                                      placeholder: string;
                                                                                                                                                                                                                                                                                                                                                                      onSubmit: () => void;
                                                                                                                                                                                                                                                                                                                                                                      onChange: () => void;
                                                                                                                                                                                                                                                                                                                                                                      onFocus: () => void;
                                                                                                                                                                                                                                                                                                                                                                      onBlur: () => void;
                                                                                                                                                                                                                                                                                                                                                                      onClear: () => void;
                                                                                                                                                                                                                                                                                                                                                                      showCancelButton: boolean;
                                                                                                                                                                                                                                                                                                                                                                      disabled: boolean;
                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                        property doClear

                                                                                                                                                                                                                                                                                                                                                                        doClear: (blurFromOnClear?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                          property firstFocus

                                                                                                                                                                                                                                                                                                                                                                          firstFocus: boolean;

                                                                                                                                                                                                                                                                                                                                                                            property focus

                                                                                                                                                                                                                                                                                                                                                                            focus: () => void;

                                                                                                                                                                                                                                                                                                                                                                              property inputRef

                                                                                                                                                                                                                                                                                                                                                                              inputRef: HTMLInputElement;

                                                                                                                                                                                                                                                                                                                                                                                property onBlur

                                                                                                                                                                                                                                                                                                                                                                                onBlur: () => void;

                                                                                                                                                                                                                                                                                                                                                                                  property onBlurTimeout

                                                                                                                                                                                                                                                                                                                                                                                  onBlurTimeout: number;

                                                                                                                                                                                                                                                                                                                                                                                    property onCancel

                                                                                                                                                                                                                                                                                                                                                                                    onCancel: () => void;

                                                                                                                                                                                                                                                                                                                                                                                      property onChange

                                                                                                                                                                                                                                                                                                                                                                                      onChange: (e: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                        property onClear

                                                                                                                                                                                                                                                                                                                                                                                        onClear: () => void;

                                                                                                                                                                                                                                                                                                                                                                                          property onFocus

                                                                                                                                                                                                                                                                                                                                                                                          onFocus: () => void;

                                                                                                                                                                                                                                                                                                                                                                                            property onSubmit

                                                                                                                                                                                                                                                                                                                                                                                            onSubmit: (e: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                              property rightBtnInitMarginleft

                                                                                                                                                                                                                                                                                                                                                                                              rightBtnInitMarginleft: string;

                                                                                                                                                                                                                                                                                                                                                                                                method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                  method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                  componentDidUpdate: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                    method componentWillReceiveProps

                                                                                                                                                                                                                                                                                                                                                                                                    componentWillReceiveProps: (nextProps: SearchBarProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                      method componentWillUnmount

                                                                                                                                                                                                                                                                                                                                                                                                      componentWillUnmount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                        method render

                                                                                                                                                                                                                                                                                                                                                                                                        render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                          class SegmentedControl

                                                                                                                                                                                                                                                                                                                                                                                                          class SegmentedControl extends React.Component<SegmentedControlProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                            constructor(props: SegmentedControlProps);

                                                                                                                                                                                                                                                                                                                                                                                                              property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                              static defaultProps: {
                                                                                                                                                                                                                                                                                                                                                                                                              prefixCls: string;
                                                                                                                                                                                                                                                                                                                                                                                                              selectedIndex: number;
                                                                                                                                                                                                                                                                                                                                                                                                              disabled: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                              values: never[];
                                                                                                                                                                                                                                                                                                                                                                                                              onChange(): void;
                                                                                                                                                                                                                                                                                                                                                                                                              onValueChange(): void;
                                                                                                                                                                                                                                                                                                                                                                                                              style: {};
                                                                                                                                                                                                                                                                                                                                                                                                              tintColor: string;
                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                method componentWillReceiveProps

                                                                                                                                                                                                                                                                                                                                                                                                                componentWillReceiveProps: (nextProps: SegmentedControlProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                  method onClick

                                                                                                                                                                                                                                                                                                                                                                                                                  onClick: (e: any, index: any, value: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                                                                                                                                                                    render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                      method renderSegmentItem

                                                                                                                                                                                                                                                                                                                                                                                                                      renderSegmentItem: (idx: number, value: string, selected: boolean) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                        class Slider

                                                                                                                                                                                                                                                                                                                                                                                                                        class Slider extends React.Component<SliderProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                          property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                          static defaultProps: { prefixCls: string };

                                                                                                                                                                                                                                                                                                                                                                                                                            method render

                                                                                                                                                                                                                                                                                                                                                                                                                            render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                              class Stepper

                                                                                                                                                                                                                                                                                                                                                                                                                              class Stepper extends React.Component<StepProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                static defaultProps: {
                                                                                                                                                                                                                                                                                                                                                                                                                                prefixCls: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                step: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                readOnly: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                showNumber: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                focusOnUpDown: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                  property stepperRef

                                                                                                                                                                                                                                                                                                                                                                                                                                  stepperRef: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                                                                                                                                                                                    render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                      class Steps

                                                                                                                                                                                                                                                                                                                                                                                                                                      class Steps extends React.Component<StepsProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                        static defaultProps: {
                                                                                                                                                                                                                                                                                                                                                                                                                                        prefixCls: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        iconPrefix: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        labelPlacement: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        direction: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                        current: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                          property Step

                                                                                                                                                                                                                                                                                                                                                                                                                                          static Step: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property stepRefs

                                                                                                                                                                                                                                                                                                                                                                                                                                            stepRefs: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                              property stepsRef

                                                                                                                                                                                                                                                                                                                                                                                                                                              stepsRef: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                  componentDidUpdate: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                    render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      class SwipeAction

                                                                                                                                                                                                                                                                                                                                                                                                                                                      class SwipeAction extends React.Component<SwipeActionProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                        static defaultProps: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        prefixCls: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        autoClose: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        disabled: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        left: never[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                        right: never[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                        onOpen(): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        onClose(): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                          render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Switch

                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Switch extends React.Component<SwitchProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                              static defaultProps: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                              prefixCls: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              checked: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              disabled: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              onChange(): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              platform: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              onClick(): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                onChange: (e: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onClick: (e: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class TabBar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class AntTabBar extends React.Component<AntTabbarProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static defaultProps: AntTabbarProps;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property getTabs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getTabs: () => TabBarItemProps[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Item

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static Item: typeof Item;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property renderTabBar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              renderTabBar: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Tabs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Tabs extends React.PureComponent<TabsProps, {}> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static defaultProps: { prefixCls: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property DefaultTabBar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static DefaultTabBar: typeof DefaultTabBar;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property renderTabBar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        renderTabBar: (props: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Tag extends React.Component<TagProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(props: TagProps);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static defaultProps: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                prefixCls: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                disabled: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                selected: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                closable: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                small: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onChange(): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onClose(): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                afterClose(): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onClick: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onTagClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onTagClose: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method componentWillReceiveProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      componentWillReceiveProps: (nextProps: TagProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        render: () => JSX.Element | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Text extends React.Component<ViewProps<HTMLSpanElement>, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static defaultProps: { Component: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class TextareaItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class TextareaItem extends React.Component<TextareaItemProps, TextareaItemState> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(props: TextareaItemProps);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property clearInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    clearInput: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static defaultProps: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      prefixCls: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      prefixListCls: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      autoHeight: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      editable: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      disabled: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      placeholder: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      clear: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      rows: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onChange: typeof noop;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onBlur: typeof noop;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onFocus: typeof noop;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      onErrorClick: typeof noop;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      error: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      labelNumber: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property focus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        focus: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property onBlur

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          onBlur: (e: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property onChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            onChange: (e: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property onErrorClick

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onErrorClick: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property onFocus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onFocus: (e: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property reAlignHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  reAlignHeight: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property textareaRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    textareaRef: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method componentDidMount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      componentDidMount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method componentDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        componentDidUpdate: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method componentWillReceiveProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          componentWillReceiveProps: (nextProps: TextareaItemProps) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method componentWillUnmount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            componentWillUnmount: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class View

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class View extends React.Component<ViewProps<HTMLDivElement>, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static defaultProps: { Component: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class WhiteSpace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class WhiteSpace extends React.Component<WhiteSpaceProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        static defaultProps: { prefixCls: string; size: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class WingBlank

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class WingBlank extends React.Component<WingBlankProps, any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property defaultProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static defaultProps: { prefixCls: string; size: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method render

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                render: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Package Files (50)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dependencies (23)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dev Dependencies (55)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Badge

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/antd-mobile)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <a href="https://www.jsdocs.io/package/antd-mobile"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>