@douyinfe/semi-ui 2.1.0-beta.3 → 2.1.0-next.3

package/lib/cjs/input/inputGroup.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import BaseComponent from '../_base/baseComponent';
+import { noop } from '@douyinfe/semi-foundation/lib/cjs/utils/function';
+export declare type InputSize = 'small' | 'large' | 'default';
+export interface InputGroupProps {
+    className?: string;
+    children?: React.ReactNode;
+    size?: InputSize;
+    style?: Record<string, any>;
+    onBlur?: (e: React.FocusEvent<HTMLSpanElement>) => void;
+    onFocus?: (e: React.FocusEvent<HTMLSpanElement>) => void;
+    label?: Record<string, any>;
+    labelPosition?: string;
+    disabled?: boolean;
+}
+export interface InputGroupState {
+}
+export default class inputGroup extends BaseComponent<InputGroupProps, InputGroupState> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        size: PropTypes.Requireable<"default" | "small" | "large">;
+        style: PropTypes.Requireable<object>;
+        onBlur: PropTypes.Requireable<(...args: any[]) => any>;
+        onFocus: PropTypes.Requireable<(...args: any[]) => any>;
+        label: PropTypes.Requireable<object>;
+        labelPosition: PropTypes.Requireable<string>;
+    };
+    static defaultProps: {
+        size: string;
+        className: string;
+        onBlur: typeof noop;
+        onFocus: typeof noop;
+    };
+    renderGroupWithLabel(inner: React.ReactNode): JSX.Element;
+    render(): JSX.Element;
+}

package/lib/cjs/input/inputGroup.js

@@ -0,0 +1,163 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = void 0;
+
+var _indexOf = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/index-of"));
+
+var _getOwnPropertySymbols = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols"));
+
+var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+
+var _isArray = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/array/is-array"));
+
+var _isFunction2 = _interopRequireDefault(require("lodash/isFunction"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _constants = require("@douyinfe/semi-foundation/lib/cjs/input/constants");
+
+var _baseComponent = _interopRequireDefault(require("../_base/baseComponent"));
+
+var _label = _interopRequireDefault(require("../form/label"));
+
+var _function = require("@douyinfe/semi-foundation/lib/cjs/utils/function");
+
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && (0, _indexOf.default)(e).call(e, p) < 0) t[p] = s[p];
+
+  if (s != null && typeof _getOwnPropertySymbols.default === "function") for (var i = 0, p = (0, _getOwnPropertySymbols.default)(s); i < p.length; i++) {
+    if ((0, _indexOf.default)(e).call(e, p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+/* eslint-disable max-len */
+
+
+const prefixCls = _constants.cssClasses.PREFIX;
+const sizeSet = _constants.strings.SIZE;
+
+class inputGroup extends _baseComponent.default {
+  renderGroupWithLabel(inner) {
+    var _context;
+
+    // eslint-disable-next-line no-unused-vars
+    const _a = this.props,
+          {
+      size,
+      className,
+      label,
+      labelPosition
+    } = _a,
+          rest = __rest(_a, ["size", "className", "label", "labelPosition"]);
+
+    const groupWrapperCls = (0, _classnames.default)({
+      ["".concat(prefixCls, "-group-wrapper")]: true,
+      ["".concat(prefixCls, "-group-wrapper-with-top-label")]: labelPosition === 'top',
+      ["".concat(prefixCls, "-group-wrapper-with-left-label")]: labelPosition === 'left'
+    });
+    const groupCls = (0, _classnames.default)("".concat(prefixCls, "-group"), className, {
+      [(0, _concat.default)(_context = "".concat(prefixCls, "-")).call(_context, size)]: size !== 'default'
+    }); // const labelCls = cls(label.className, '');
+
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: groupWrapperCls
+    }, label && label.text ? /*#__PURE__*/_react.default.createElement(_label.default, (0, _assign.default)({}, label)) : null, /*#__PURE__*/_react.default.createElement("span", {
+      className: groupCls,
+      style: this.props.style,
+      onFocus: this.props.onFocus,
+      onBlur: this.props.onBlur
+    }, inner));
+  }
+
+  render() {
+    var _context2;
+
+    const _a = this.props,
+          {
+      size,
+      style,
+      className,
+      children,
+      label,
+      onBlur: groupOnBlur,
+      onFocus: groupOnFocus
+    } = _a,
+          rest = __rest(_a, ["size", "style", "className", "children", "label", "onBlur", "onFocus"]);
+
+    const groupCls = (0, _classnames.default)("".concat(prefixCls, "-group"), {
+      [(0, _concat.default)(_context2 = "".concat(prefixCls, "-")).call(_context2, size)]: size !== 'default'
+    }, className);
+    let inner;
+
+    if (children) {
+      var _context3;
+
+      inner = (0, _map.default)(_context3 = (0, _isArray.default)(children) ? children : [children]).call(_context3, (item, index) => {
+        if (item) {
+          const {
+            onBlur: itemOnBlur,
+            onFocus: itemOnFocus
+          } = item.props;
+          const onBlur = (0, _isFunction2.default)(itemOnBlur) ? itemOnBlur : groupOnBlur;
+          const onFocus = (0, _isFunction2.default)(itemOnFocus) ? itemOnFocus : groupOnFocus;
+          return /*#__PURE__*/_react.default.cloneElement(item, (0, _assign.default)({
+            key: index,
+            size,
+            onBlur,
+            onFocus
+          }, rest));
+        }
+
+        return null;
+      });
+    }
+
+    if (label && label.text) {
+      return this.renderGroupWithLabel(inner);
+    }
+
+    return /*#__PURE__*/_react.default.createElement("span", {
+      className: groupCls,
+      style: style,
+      onFocus: this.props.onFocus,
+      onBlur: this.props.onBlur
+    }, inner);
+  }
+
+}
+
+exports.default = inputGroup;
+inputGroup.propTypes = {
+  className: _propTypes.default.string,
+  children: _propTypes.default.node,
+  size: _propTypes.default.oneOf(sizeSet),
+  style: _propTypes.default.object,
+  onBlur: _propTypes.default.func,
+  onFocus: _propTypes.default.func,
+  label: _propTypes.default.object,
+  labelPosition: _propTypes.default.string
+};
+inputGroup.defaultProps = {
+  size: 'default',
+  className: '',
+  onBlur: _function.noop,
+  onFocus: _function.noop
+};

package/lib/cjs/input/textarea.d.ts

@@ -0,0 +1,44 @@
+import React from 'react';
+import { ValidateStatus } from '../_base/baseComponent';
+import '@douyinfe/semi-foundation/lib/cjs/input/textarea.css';
+declare type OmitTextareaAttr = 'onChange' | 'onInput' | 'prefix' | 'size' | 'onFocus' | 'onBlur' | 'onKeyDown' | 'onKeyPress' | 'onKeyUp';
+export interface TextAreaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, OmitTextareaAttr> {
+    autosize?: boolean;
+    placeholder?: string;
+    value?: string;
+    rows?: number;
+    cols?: number;
+    maxCount?: number;
+    validateStatus?: ValidateStatus;
+    defaultValue?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    autofocus?: boolean;
+    showCounter?: boolean;
+    showClear?: boolean;
+    onClear?: (e: React.MouseEvent<HTMLTextAreaElement>) => void;
+    onChange?: (value: string, e: React.MouseEvent<HTMLTextAreaElement>) => void;
+    onBlur?: (e: React.MouseEvent<HTMLTextAreaElement>) => void;
+    onFocus?: (e: React.MouseEvent<HTMLTextAreaElement>) => void;
+    onInput?: (e: React.MouseEvent<HTMLTextAreaElement>) => void;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLTextAreaElement>) => void;
+    onKeyUp?: (e: React.KeyboardEvent<HTMLTextAreaElement>) => void;
+    onKeyPress?: (e: React.KeyboardEvent<HTMLTextAreaElement>) => void;
+    onEnterPress?: (e: React.KeyboardEvent<HTMLTextAreaElement>) => void;
+    onPressEnter?: (e: React.KeyboardEvent<HTMLTextAreaElement>) => void;
+    onResize?: (data: {
+        height: number;
+    }) => void;
+    getValueLength?: (value: string) => number;
+    forwardRef?: ((instance: HTMLTextAreaElement) => void) | React.MutableRefObject<HTMLTextAreaElement> | null;
+}
+export interface TextAreaState {
+    value: string;
+    isFocus: boolean;
+    isHover: boolean;
+    height: number;
+    minLength: number;
+    cachedValue?: string;
+}
+declare const ForwardTextarea: React.ForwardRefExoticComponent<Omit<TextAreaProps, "forwardRef"> & React.RefAttributes<HTMLTextAreaElement>>;
+export default ForwardTextarea;

package/lib/cjs/input/textarea.js

@@ -0,0 +1,341 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = void 0;
+
+var _indexOf = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/index-of"));
+
+var _getOwnPropertySymbols = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols"));
+
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+
+var _isFunction2 = _interopRequireDefault(require("lodash/isFunction"));
+
+var _omit2 = _interopRequireDefault(require("lodash/omit"));
+
+var _noop2 = _interopRequireDefault(require("lodash/noop"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _textareaFoundation = _interopRequireDefault(require("@douyinfe/semi-foundation/lib/cjs/input/textareaFoundation"));
+
+var _constants = require("@douyinfe/semi-foundation/lib/cjs/input/constants");
+
+var _baseComponent = _interopRequireDefault(require("../_base/baseComponent"));
+
+require("@douyinfe/semi-foundation/lib/cjs/input/textarea.css");
+
+var _semiIcons = require("@douyinfe/semi-icons");
+
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && (0, _indexOf.default)(e).call(e, p) < 0) t[p] = s[p];
+
+  if (s != null && typeof _getOwnPropertySymbols.default === "function") for (var i = 0, p = (0, _getOwnPropertySymbols.default)(s); i < p.length; i++) {
+    if ((0, _indexOf.default)(e).call(e, p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+/* eslint-disable no-unused-vars */
+
+
+const prefixCls = _constants.cssClasses.PREFIX;
+
+class TextArea extends _baseComponent.default {
+  constructor(props) {
+    super(props);
+
+    this.handleClear = e => {
+      this.foundation.handleClear(e);
+    };
+
+    this.setRef = node => {
+      this.libRef.current = node;
+      const {
+        forwardRef
+      } = this.props;
+
+      if (typeof forwardRef === 'function') {
+        forwardRef(node);
+      } else if (forwardRef && typeof forwardRef === 'object') {
+        forwardRef.current = node;
+      }
+    };
+
+    this.state = {
+      value: '',
+      isFocus: false,
+      isHover: false,
+      height: 0,
+      minLength: props.minLength
+    };
+    this.focusing = false;
+    this.foundation = new _textareaFoundation.default(this.adapter);
+    this.libRef = /*#__PURE__*/_react.default.createRef();
+    this._resizeLock = false;
+  }
+
+  get adapter() {
+    return (0, _assign.default)((0, _assign.default)({}, super.adapter), {
+      setValue: value => this.setState({
+        value
+      }, () => {
+        if (this.props.autosize) {
+          this.foundation.resizeTextarea();
+        }
+      }),
+      getRef: () => this.libRef,
+      toggleFocusing: focusing => this.setState({
+        isFocus: focusing
+      }),
+      toggleHovering: hovering => this.setState({
+        isHover: hovering
+      }),
+      notifyChange: (val, e) => {
+        this.props.onChange(val, e);
+      },
+      notifyClear: e => this.props.onClear(e),
+      notifyBlur: (val, e) => this.props.onBlur(e),
+      notifyFocus: (val, e) => this.props.onFocus(e),
+      notifyKeyDown: e => {
+        this.props.onKeyDown(e);
+      },
+      notifyHeightUpdate: height => {
+        this.setState({
+          height
+        });
+        this.props.onResize({
+          height
+        });
+      },
+      notifyPressEnter: e => {
+        this.props.onEnterPress && this.props.onEnterPress(e);
+      },
+      setMinLength: minLength => this.setState({
+        minLength
+      })
+    });
+  }
+
+  static getDerivedStateFromProps(props, state) {
+    const willUpdateStates = {};
+
+    if (props.value !== state.cachedValue) {
+      willUpdateStates.value = props.value;
+      willUpdateStates.cachedValue = props.value;
+    }
+
+    return willUpdateStates;
+  }
+
+  componentDidMount() {
+    this.foundation.init();
+    this._resizeListener = null;
+
+    if (this.props.autosize) {
+      // Working around Firefox bug which runs resize listeners even when other JS is running at the same moment
+      // causing competing rerenders (due to setState in the listener) in React.
+      // More can be found here - facebook/react#6324
+      // // Reference to https://github.com/andreypopp/react-textarea-autosize/
+      this._resizeListener = () => {
+        if (this._resizeLock) {
+          return;
+        }
+
+        this._resizeLock = true;
+        this.foundation.resizeTextarea(() => {
+          this._resizeLock = false;
+        });
+      };
+
+      window.addEventListener('resize', this._resizeListener);
+    }
+  }
+
+  componentWillUnmount() {
+    this.foundation.destroy();
+    this._resizeListener && window.removeEventListener('resize', this._resizeListener);
+  }
+
+  componentDidUpdate(prevProps, prevState) {
+    if (this.props.value !== prevProps.value && this.props.autosize) {
+      this.foundation.resizeTextarea();
+    }
+  }
+
+  renderClearBtn() {
+    const {
+      showClear
+    } = this.props;
+    const displayClearBtn = this.foundation.isAllowClear();
+    const clearCls = (0, _classnames.default)("".concat(prefixCls, "-clearbtn"), {
+      ["".concat(prefixCls, "-clearbtn-hidden")]: !displayClearBtn
+    });
+
+    if (showClear) {
+      return /*#__PURE__*/_react.default.createElement("div", {
+        className: clearCls,
+        onClick: this.handleClear
+      }, /*#__PURE__*/_react.default.createElement(_semiIcons.IconClear, null));
+    }
+
+    return null;
+  }
+
+  renderCounter() {
+    let counter, current, total, countCls;
+    const {
+      showCounter,
+      maxCount,
+      getValueLength
+    } = this.props;
+
+    if (showCounter || maxCount) {
+      const {
+        value
+      } = this.state; // eslint-disable-next-line no-nested-ternary
+
+      current = value ? (0, _isFunction2.default)(getValueLength) ? getValueLength(value) : value.length : 0;
+      total = maxCount || null;
+      countCls = (0, _classnames.default)("".concat(prefixCls, "-textarea-counter"), {
+        ["".concat(prefixCls, "-textarea-counter-exceed")]: current > total
+      });
+      counter = /*#__PURE__*/_react.default.createElement("div", {
+        className: countCls
+      }, current, total ? '/' : null, total);
+    } else {
+      counter = null;
+    }
+
+    return counter;
+  }
+
+  render() {
+    var _context;
+
+    const _a = this.props,
+          {
+      autosize,
+      placeholder,
+      onEnterPress,
+      onResize,
+      // resize,
+      disabled,
+      readonly,
+      className,
+      showCounter,
+      validateStatus,
+      maxCount,
+      defaultValue,
+      style,
+      forwardRef,
+      getValueLength,
+      maxLength,
+      minLength,
+      showClear
+    } = _a,
+          rest = __rest(_a, ["autosize", "placeholder", "onEnterPress", "onResize", "disabled", "readonly", "className", "showCounter", "validateStatus", "maxCount", "defaultValue", "style", "forwardRef", "getValueLength", "maxLength", "minLength", "showClear"]);
+
+    const {
+      isFocus,
+      value,
+      minLength: stateMinLength
+    } = this.state;
+    const wrapperCls = (0, _classnames.default)(className, "".concat(prefixCls, "-textarea-wrapper"), {
+      ["".concat(prefixCls, "-textarea-wrapper-disabled")]: disabled || readonly,
+      [(0, _concat.default)(_context = "".concat(prefixCls, "-textarea-wrapper-")).call(_context, validateStatus)]: Boolean(validateStatus),
+      ["".concat(prefixCls, "-textarea-wrapper-focus")]: isFocus // [`${prefixCls}-textarea-wrapper-resize`]: !autosize && resize,
+
+    }); // const ref = this.props.forwardRef || this.textAreaRef;
+
+    const itemCls = (0, _classnames.default)("".concat(prefixCls, "-textarea"), {
+      ["".concat(prefixCls, "-textarea-disabled")]: disabled || readonly,
+      ["".concat(prefixCls, "-textarea-autosize")]: autosize,
+      ["".concat(prefixCls, "-textarea-showClear")]: showClear
+    });
+    const itemProps = (0, _assign.default)((0, _assign.default)({}, (0, _omit2.default)(rest, 'insetLabel', 'getValueLength', 'onClear', 'showClear')), {
+      className: itemCls,
+      disabled,
+      readOnly: readonly,
+      placeholder: !placeholder ? null : placeholder,
+      onChange: e => this.foundation.handleChange(e.target.value, e),
+      onFocus: e => this.foundation.handleFocus(e),
+      onBlur: e => this.foundation.handleBlur(e.nativeEvent),
+      onKeyDown: e => this.foundation.handleKeyDown(e),
+      value: value === null || value === undefined ? '' : value
+    });
+
+    if (!(0, _isFunction2.default)(getValueLength)) {
+      itemProps.maxLength = maxLength;
+    }
+
+    if (stateMinLength) {
+      itemProps.minLength = stateMinLength;
+    }
+
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: wrapperCls,
+      style: style,
+      onMouseEnter: e => this.foundation.handleMouseEnter(e),
+      onMouseLeave: e => this.foundation.handleMouseLeave(e)
+    }, /*#__PURE__*/_react.default.createElement("textarea", (0, _assign.default)({}, itemProps, {
+      ref: this.setRef
+    })), this.renderClearBtn(), this.renderCounter());
+  }
+
+}
+
+TextArea.propTypes = {
+  autosize: _propTypes.default.bool,
+  placeholder: _propTypes.default.string,
+  value: _propTypes.default.string,
+  rows: _propTypes.default.number,
+  cols: _propTypes.default.number,
+  maxCount: _propTypes.default.number,
+  onEnterPress: _propTypes.default.func,
+  validateStatus: _propTypes.default.string,
+  className: _propTypes.default.string,
+  style: _propTypes.default.object,
+  showClear: _propTypes.default.bool,
+  onClear: _propTypes.default.func,
+  onResize: _propTypes.default.func,
+  getValueLength: _propTypes.default.func // TODO
+  // resize: PropTypes.bool,
+
+};
+TextArea.defaultProps = {
+  autosize: false,
+  rows: 4,
+  cols: 20,
+  showCounter: false,
+  showClear: false,
+  onEnterPress: _noop2.default,
+  onChange: _noop2.default,
+  onBlur: _noop2.default,
+  onFocus: _noop2.default,
+  onKeyDown: _noop2.default,
+  onResize: _noop2.default,
+  onClear: _noop2.default // resize: false,
+
+};
+
+const ForwardTextarea = /*#__PURE__*/_react.default.forwardRef((props, ref) => /*#__PURE__*/_react.default.createElement(TextArea, (0, _assign.default)({}, props, {
+  forwardRef: ref
+})));
+
+var _default = ForwardTextarea;
+exports.default = _default;

package/lib/cjs/inputNumber/index.d.ts

@@ -0,0 +1,108 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { InputProps } from '../input';
+import { InputNumberAdapter } from '@douyinfe/semi-foundation/lib/cjs/inputNumber/foundation';
+import BaseComponent from '../_base/baseComponent';
+import { strings } from '@douyinfe/semi-foundation/lib/cjs/inputNumber/constants';
+import '@douyinfe/semi-foundation/lib/cjs/inputNumber/inputNumber.css';
+import { ArrayElement } from '../_base/base';
+export interface InputNumberProps extends InputProps {
+    autofocus?: boolean;
+    className?: string;
+    defaultValue?: number | string;
+    disabled?: boolean;
+    formatter?: (value: number | string) => string;
+    forwardedRef?: React.MutableRefObject<HTMLInputElement> | ((instance: HTMLInputElement) => void);
+    hideButtons?: boolean;
+    innerButtons?: boolean;
+    insetLabel?: React.ReactNode;
+    keepFocus?: boolean;
+    max?: number;
+    min?: number;
+    parser?: (value: string) => string;
+    precision?: number;
+    prefixCls?: string;
+    pressInterval?: number;
+    pressTimeout?: number;
+    shiftStep?: number;
+    showClear?: boolean;
+    size?: ArrayElement<typeof strings.SIZE>;
+    step?: number;
+    style?: React.CSSProperties;
+    suffix?: React.ReactNode;
+    value?: number | string;
+    onBlur?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    onChange?: (value: number | string, e?: React.ChangeEvent) => void;
+    onDownClick?: (value: string, e: React.MouseEvent<HTMLButtonElement>) => void;
+    onFocus?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    onKeyDown?: React.KeyboardEventHandler;
+    onNumberChange?: (value: number, e?: React.ChangeEvent) => void;
+    onUpClick?: (value: string, e: React.MouseEvent<HTMLButtonElement>) => void;
+}
+export interface InputNumberState {
+    value?: number | string;
+    number?: number | null;
+    focusing?: boolean;
+    hovering?: boolean;
+}
+declare class InputNumber extends BaseComponent<InputNumberProps, InputNumberState> {
+    static propTypes: {
+        autofocus: PropTypes.Requireable<boolean>;
+        className: PropTypes.Requireable<string>;
+        defaultValue: PropTypes.Requireable<string | number>;
+        disabled: PropTypes.Requireable<boolean>;
+        formatter: PropTypes.Requireable<(...args: any[]) => any>;
+        forwardedRef: PropTypes.Requireable<any>;
+        hideButtons: PropTypes.Requireable<boolean>;
+        innerButtons: PropTypes.Requireable<boolean>;
+        insetLabel: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        keepFocus: PropTypes.Requireable<boolean>;
+        max: PropTypes.Requireable<number>;
+        min: PropTypes.Requireable<number>;
+        parser: PropTypes.Requireable<(...args: any[]) => any>;
+        precision: PropTypes.Requireable<number>;
+        prefixCls: PropTypes.Requireable<string>;
+        pressInterval: PropTypes.Requireable<number>;
+        pressTimeout: PropTypes.Requireable<number>;
+        shiftStep: PropTypes.Requireable<number>;
+        step: PropTypes.Requireable<number>;
+        style: PropTypes.Requireable<object>;
+        suffix: PropTypes.Requireable<any>;
+        value: PropTypes.Requireable<string | number>;
+        onBlur: PropTypes.Requireable<(...args: any[]) => any>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        onDownClick: PropTypes.Requireable<(...args: any[]) => any>;
+        onKeyDown: PropTypes.Requireable<(...args: any[]) => any>;
+        onNumberChange: PropTypes.Requireable<(...args: any[]) => any>;
+        onUpClick: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    static defaultProps: InputNumberProps;
+    get adapter(): InputNumberAdapter;
+    inputNode: HTMLInputElement;
+    clickUpOrDown: boolean;
+    cursorStart: number;
+    cursorEnd: number;
+    currentValue: number | string;
+    cursorBefore: string;
+    cursorAfter: string;
+    constructor(props: InputNumberProps);
+    componentDidUpdate(prevProps: InputNumberProps): void;
+    setInputRef: (node: HTMLInputElement) => void;
+    handleInputFocus: (e: React.FocusEvent<HTMLInputElement>) => any;
+    handleInputChange: (value: string, event: React.ChangeEvent<HTMLInputElement>) => any;
+    handleInputBlur: (e: React.FocusEvent<HTMLInputElement>) => any;
+    handleInputKeyDown: (e: React.KeyboardEvent) => any;
+    handleInputMouseEnter: (e: React.MouseEvent) => any;
+    handleInputMouseLeave: (e: React.MouseEvent) => any;
+    handleInputMouseMove: (e: React.MouseEvent) => any;
+    handleUpClick: (e: React.KeyboardEvent) => any;
+    handleDownClick: (e: React.KeyboardEvent) => any;
+    handleMouseUp: (e: React.MouseEvent) => any;
+    handleMouseLeave: (e: React.MouseEvent) => any;
+    renderButtons: () => JSX.Element;
+    renderSuffix: () => React.ReactNode;
+    render(): JSX.Element;
+}
+declare const _default: React.ForwardRefExoticComponent<InputNumberProps & React.RefAttributes<HTMLInputElement>>;
+export default _default;
+export { InputNumber };