rsuite 5.76.2 → 6.0.0-canary-20250103

package/esm/internals/Menu/useMenu.js

@@ -1,102 +1,109 @@
 'use client';
-import _extends from "@babel/runtime/helpers/esm/extends";
 // Inspired by tailwindlabs/headlessui
 import { useReducer } from 'react';
 import { MenuActionTypes, MoveFocusTo } from "./MenuContext.js";
-export var initialMenuState = {
+export const initialMenuState = {
   role: 'menu',
   open: false,
   items: [],
   activeItemIndex: null
 };
 export function menuReducer(state, action) {
-  var items = state.items,
-    activeItemIndex = state.activeItemIndex;
+  const {
+    items,
+    activeItemIndex
+  } = state;
   switch (action.type) {
     case MenuActionTypes.RegisterItem:
-      return _extends({}, state, {
-        items: [].concat(items, [{
+      return {
+        ...state,
+        items: [...items, {
           element: action.element,
           props: action.props
-        }])
-      });
+        }]
+      };
     case MenuActionTypes.UnregisterItem:
-      return _extends({}, state, {
-        items: items.filter(function (item) {
-          return item.element.id !== action.id;
-        })
-      });
+      return {
+        ...state,
+        items: items.filter(item => item.element.id !== action.id)
+      };
     case MenuActionTypes.OpenMenu:
-      return _extends({}, state, {
+      return {
+        ...state,
         open: true
-      });
+      };
     case MenuActionTypes.CloseMenu:
-      return _extends({}, state, {
+      return {
+        ...state,
         open: false
-      });
+      };
     case MenuActionTypes.MoveFocus:
-      var nextActiveItemIndex = activeItemIndex;
-      switch (action.to) {
-        case MoveFocusTo.Next:
-          for (var i = activeItemIndex === null ? 0 : activeItemIndex + 1; i < items.length; i++) {
-            var _items$i$props;
-            if (!((_items$i$props = items[i].props) !== null && _items$i$props !== void 0 && _items$i$props.disabled)) {
-              nextActiveItemIndex = i;
-              break;
+      {
+        let nextActiveItemIndex = activeItemIndex;
+        switch (action.to) {
+          case MoveFocusTo.Next:
+            for (let i = activeItemIndex === null ? 0 : activeItemIndex + 1; i < items.length; i++) {
+              var _items$i$props;
+              if (!((_items$i$props = items[i].props) !== null && _items$i$props !== void 0 && _items$i$props.disabled)) {
+                nextActiveItemIndex = i;
+                break;
+              }
             }
-          }
-          break;
-        case MoveFocusTo.Prev:
-          for (var _i = activeItemIndex === null ? items.length - 1 : activeItemIndex - 1; _i >= 0; _i--) {
-            var _items$_i$props;
-            if (!((_items$_i$props = items[_i].props) !== null && _items$_i$props !== void 0 && _items$_i$props.disabled)) {
-              nextActiveItemIndex = _i;
-              break;
+            break;
+          case MoveFocusTo.Prev:
+            for (let i = activeItemIndex === null ? items.length - 1 : activeItemIndex - 1; i >= 0; i--) {
+              var _items$i$props2;
+              if (!((_items$i$props2 = items[i].props) !== null && _items$i$props2 !== void 0 && _items$i$props2.disabled)) {
+                nextActiveItemIndex = i;
+                break;
+              }
             }
-          }
-          break;
-        case MoveFocusTo.First:
-          for (var _i2 = 0; _i2 < items.length; _i2++) {
-            var _items$_i2$props;
-            if (!((_items$_i2$props = items[_i2].props) !== null && _items$_i2$props !== void 0 && _items$_i2$props.disabled)) {
-              nextActiveItemIndex = _i2;
-              break;
+            break;
+          case MoveFocusTo.First:
+            for (let i = 0; i < items.length; i++) {
+              var _items$i$props3;
+              if (!((_items$i$props3 = items[i].props) !== null && _items$i$props3 !== void 0 && _items$i$props3.disabled)) {
+                nextActiveItemIndex = i;
+                break;
+              }
             }
-          }
-          break;
-        case MoveFocusTo.Last:
-          for (var _i3 = items.length - 1; _i3 >= 0; _i3--) {
-            var _items$_i3$props;
-            if (!((_items$_i3$props = items[_i3].props) !== null && _items$_i3$props !== void 0 && _items$_i3$props.disabled)) {
-              nextActiveItemIndex = _i3;
-              break;
+            break;
+          case MoveFocusTo.Last:
+            for (let i = items.length - 1; i >= 0; i--) {
+              var _items$i$props4;
+              if (!((_items$i$props4 = items[i].props) !== null && _items$i$props4 !== void 0 && _items$i$props4.disabled)) {
+                nextActiveItemIndex = i;
+                break;
+              }
             }
-          }
-          break;
-        case MoveFocusTo.Specific:
-          for (var _i4 = 0; _i4 < items.length; _i4++) {
-            var _items$_i4$props;
-            if (items[_i4].element.id === action.id && !((_items$_i4$props = items[_i4].props) !== null && _items$_i4$props !== void 0 && _items$_i4$props.disabled)) {
-              nextActiveItemIndex = _i4;
-              break;
+            break;
+          case MoveFocusTo.Specific:
+            for (let i = 0; i < items.length; i++) {
+              var _items$i$props5;
+              if (items[i].element.id === action.id && !((_items$i$props5 = items[i].props) !== null && _items$i$props5 !== void 0 && _items$i$props5.disabled)) {
+                nextActiveItemIndex = i;
+                break;
+              }
             }
-          }
-          break;
-        case MoveFocusTo.None:
-          nextActiveItemIndex = null;
-          break;
+            break;
+          case MoveFocusTo.None:
+            nextActiveItemIndex = null;
+            break;
+        }
+        return {
+          ...state,
+          activeItemIndex: nextActiveItemIndex
+        };
       }
-      return _extends({}, state, {
-        activeItemIndex: nextActiveItemIndex
-      });
     default:
       return state;
   }
 }
 export default function useMenu(initialState) {
   // `menuitem`s
-  var _useReducer = useReducer(menuReducer, _extends({}, initialMenuState, initialState)),
-    state = _useReducer[0],
-    dispatch = _useReducer[1];
+  const [state, dispatch] = useReducer(menuReducer, {
+    ...initialMenuState,
+    ...initialState
+  });
   return [state, dispatch];
 }

package/esm/internals/Overlay/Modal.d.ts

@@ -1,11 +1,10 @@
 import React from 'react';
-import PropTypes from 'prop-types';
-import { WithAsProps, AnimationEventProps, RsRefForwardingComponent } from '../types';
-export interface BaseModalProps extends WithAsProps, AnimationEventProps {
+import { WithAsPropsWithoutChildren, AnimationEventProps } from '../types';
+export interface BaseModalProps extends WithAsPropsWithoutChildren, AnimationEventProps {
     /** Animation-related properties */
     animationProps?: any;
     /** Primary content */
-    children?: React.ReactNode;
+    children?: any;
     /**
      * Add an optional extra class name to .modal-backdrop
      * It could end up looking like class="modal-backdrop foo-modal-backdrop in"
@@ -43,22 +42,9 @@ export interface BaseModalProps extends WithAsProps, AnimationEventProps {
     dialogTransitionTimeout?: number;
     transition?: React.ElementType;
     onEsc?: React.KeyboardEventHandler;
+    onClick?: React.MouseEventHandler;
+    onMouseDown?: React.MouseEventHandler;
     onBackdropClick?: React.MouseEventHandler;
 }
-declare const Modal: RsRefForwardingComponent<'div', BaseModalProps>;
-export declare const modalPropTypes: {
-    as: PropTypes.Requireable<PropTypes.ReactComponentLike>;
-    className: PropTypes.Requireable<string>;
-    backdropClassName: PropTypes.Requireable<string>;
-    style: PropTypes.Requireable<object>;
-    backdropStyle: PropTypes.Requireable<object>;
-    open: PropTypes.Requireable<boolean>;
-    backdrop: PropTypes.Requireable<NonNullable<string | boolean | null | undefined>>;
-    keyboard: PropTypes.Requireable<boolean>;
-    autoFocus: PropTypes.Requireable<boolean>;
-    enforceFocus: PropTypes.Requireable<boolean>;
-    animationProps: PropTypes.Requireable<object>;
-    onOpen: PropTypes.Requireable<(...args: any[]) => any>;
-    onClose: PropTypes.Requireable<(...args: any[]) => any>;
-};
+declare const Modal: React.ForwardRefExoticComponent<BaseModalProps & React.RefAttributes<HTMLDivElement>>;
 export default Modal;

package/esm/internals/Overlay/Modal.js

@@ -1,10 +1,6 @@
 'use client';
 import _extends from "@babel/runtime/helpers/esm/extends";
-import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
-var _excluded = ["as", "children", "transition", "dialogTransitionTimeout", "style", "className", "container", "animationProps", "containerClassName", "keyboard", "enforceFocus", "backdrop", "backdropTransitionTimeout", "backdropStyle", "backdropClassName", "open", "autoFocus", "onEsc", "onExit", "onExiting", "onExited", "onEnter", "onEntering", "onEntered", "onClose", "onOpen"],
-  _excluded2 = ["className"];
 import React, { useRef, useEffect, useState, useCallback, useMemo } from 'react';
-import PropTypes from 'prop-types';
 import classNames from 'classnames';
 import contains from 'dom-lib/contains';
 import on from 'dom-lib/on';
@@ -13,16 +9,15 @@ import { usePortal, useWillUnmount, useEventCallback } from "../hooks/index.js";
 import { mergeRefs, createChainedFunction } from "../utils/index.js";
 import ModalManager from "./ModalManager.js";
 import Fade from "../../Animation/Fade.js";
-import { animationPropTypes } from "../../Animation/utils.js";
 import OverlayContext from "./OverlayContext.js";
-var manager;
+let manager;
 function getManager() {
   if (!manager) manager = new ModalManager();
   return manager;
 }
-var useModalManager = function useModalManager() {
-  var modalManager = getManager();
-  var modal = useRef({
+const useModalManager = () => {
+  const modalManager = getManager();
+  const modal = useRef({
     dialog: null,
     backdrop: null
   });
@@ -31,79 +26,69 @@ var useModalManager = function useModalManager() {
       var _modal$current;
       return (_modal$current = modal.current) === null || _modal$current === void 0 ? void 0 : _modal$current.dialog;
     },
-    add: function add(containerElement, containerClassName) {
-      return modalManager.add(modal.current, containerElement, containerClassName);
-    },
-    remove: function remove() {
-      return modalManager.remove(modal.current);
-    },
-    isTopModal: function isTopModal() {
-      return modalManager.isTopModal(modal.current);
-    },
-    setDialogRef: useCallback(function (ref) {
+    add: (containerElement, containerClassName) => modalManager.add(modal.current, containerElement, containerClassName),
+    remove: () => modalManager.remove(modal.current),
+    isTopModal: () => modalManager.isTopModal(modal.current),
+    setDialogRef: useCallback(ref => {
       modal.current.dialog = ref;
     }, []),
-    setBackdropRef: useCallback(function (ref) {
+    setBackdropRef: useCallback(ref => {
       modal.current.backdrop = ref;
     }, [])
   };
 };
-var Modal = /*#__PURE__*/React.forwardRef(function (props, ref) {
-  var _props$as = props.as,
-    Component = _props$as === void 0 ? 'div' : _props$as,
-    children = props.children,
-    Transition = props.transition,
-    dialogTransitionTimeout = props.dialogTransitionTimeout,
-    style = props.style,
-    className = props.className,
-    container = props.container,
-    animationProps = props.animationProps,
-    containerClassName = props.containerClassName,
-    _props$keyboard = props.keyboard,
-    keyboard = _props$keyboard === void 0 ? true : _props$keyboard,
-    _props$enforceFocus = props.enforceFocus,
-    enforceFocus = _props$enforceFocus === void 0 ? true : _props$enforceFocus,
-    _props$backdrop = props.backdrop,
-    backdrop = _props$backdrop === void 0 ? true : _props$backdrop,
-    backdropTransitionTimeout = props.backdropTransitionTimeout,
-    backdropStyle = props.backdropStyle,
-    backdropClassName = props.backdropClassName,
-    open = props.open,
-    _props$autoFocus = props.autoFocus,
-    autoFocus = _props$autoFocus === void 0 ? true : _props$autoFocus,
-    onEsc = props.onEsc,
-    onExit = props.onExit,
-    onExiting = props.onExiting,
-    onExited = props.onExited,
-    onEnter = props.onEnter,
-    onEntering = props.onEntering,
-    onEntered = props.onEntered,
-    onClose = props.onClose,
-    onOpen = props.onOpen,
-    rest = _objectWithoutPropertiesLoose(props, _excluded);
-  var _useState = useState(!open),
-    exited = _useState[0],
-    setExited = _useState[1];
-  var _usePortal = usePortal({
-      container: container
-    }),
-    Portal = _usePortal.Portal,
-    containerElement = _usePortal.target;
-  var modal = useModalManager();
+const Modal = /*#__PURE__*/React.forwardRef((props, ref) => {
+  const {
+    as: Component = 'div',
+    children,
+    transition: Transition,
+    dialogTransitionTimeout,
+    style,
+    className,
+    container,
+    animationProps,
+    containerClassName,
+    keyboard = true,
+    enforceFocus = true,
+    backdrop = true,
+    backdropTransitionTimeout,
+    backdropStyle,
+    backdropClassName,
+    open,
+    autoFocus = true,
+    onEsc,
+    onExit,
+    onExiting,
+    onExited,
+    onEnter,
+    onEntering,
+    onEntered,
+    onClose,
+    onOpen,
+    ...rest
+  } = props;
+  const [exited, setExited] = useState(!open);
+  const {
+    Portal,
+    target: containerElement
+  } = usePortal({
+    container
+  });
+  const modal = useModalManager();
   if (open) {
     if (exited) setExited(false);
   } else if (!Transition && !exited) {
     setExited(true);
   }
-  var mountModal = open || Transition && !exited;
-  var lastFocus = useRef(null);
-  var handleDocumentKeyDown = useEventCallback(function (event) {
+  const mountModal = open || Transition && !exited;
+  const lastFocus = useRef(null);
+  const handleDocumentKeyDown = useEventCallback(event => {
     if (keyboard && event.key === KEY_VALUES.ESC && modal.isTopModal()) {
       onEsc === null || onEsc === void 0 || onEsc(event);
       onClose === null || onClose === void 0 || onClose(event);
     }
   });
-  var restoreLastFocus = useCallback(function () {
+  const restoreLastFocus = useCallback(() => {
     if (lastFocus.current) {
       var _lastFocus$current$fo, _lastFocus$current;
       (_lastFocus$current$fo = (_lastFocus$current = lastFocus.current).focus) === null || _lastFocus$current$fo === void 0 || _lastFocus$current$fo.call(_lastFocus$current);
@@ -116,23 +101,23 @@ var Modal = /*#__PURE__*/React.forwardRef(function (props, ref) {
    * and if not, returns the focus to the dialog.
    *
    */
-  var handleFocusDialog = useEventCallback(function (onBeforeFocusCallback) {
-    var currentActiveElement = document.activeElement;
-    var dialog = modal.dialog;
+  const handleFocusDialog = useEventCallback(onBeforeFocusCallback => {
+    const currentActiveElement = document.activeElement;
+    const dialog = modal.dialog;
     if (dialog && currentActiveElement && !contains(dialog, currentActiveElement)) {
       onBeforeFocusCallback === null || onBeforeFocusCallback === void 0 || onBeforeFocusCallback();
       dialog.focus();
     }
   });
-  var handleEnforceFocus = useEventCallback(function () {
+  const handleEnforceFocus = useEventCallback(() => {
     if (!enforceFocus || !modal.isTopModal()) {
       return;
     }
     handleFocusDialog();
   });
-  var documentKeyDownListener = useRef();
-  var documentFocusListener = useRef();
-  var handleOpen = useEventCallback(function () {
+  const documentKeyDownListener = useRef();
+  const documentFocusListener = useRef();
+  const handleOpen = useEventCallback(() => {
     if (containerElement) {
       modal.add(containerElement, containerClassName);
     }
@@ -143,13 +128,13 @@ var Modal = /*#__PURE__*/React.forwardRef(function (props, ref) {
       documentFocusListener.current = on(document, 'focus', handleEnforceFocus, true);
     }
     if (autoFocus) {
-      handleFocusDialog(function () {
+      handleFocusDialog(() => {
         lastFocus.current = document.activeElement;
       });
     }
     onOpen === null || onOpen === void 0 || onOpen();
   });
-  var handleClose = useEventCallback(function () {
+  const handleClose = useEventCallback(() => {
     var _documentKeyDownListe, _documentFocusListene;
     modal.remove();
     (_documentKeyDownListe = documentKeyDownListener.current) === null || _documentKeyDownListe === void 0 || _documentKeyDownListe.off();
@@ -158,43 +143,43 @@ var Modal = /*#__PURE__*/React.forwardRef(function (props, ref) {
     documentFocusListener.current = null;
     restoreLastFocus();
   });
-  useEffect(function () {
+  useEffect(() => {
     if (!open) {
       return;
     }
     handleOpen();
   }, [open, handleOpen]);
-  useEffect(function () {
+  useEffect(() => {
     if (!exited) {
       return;
     }
     handleClose();
   }, [exited, handleClose]);
-  useWillUnmount(function () {
+  useWillUnmount(() => {
     handleClose();
   });
-  var handleExited = useCallback(function () {
+  const handleExited = useCallback(() => {
     setExited(true);
   }, []);
-  var contextValue = useMemo(function () {
-    return {
-      overlayContainer: function overlayContainer() {
-        return modal.dialog;
-      }
-    };
-  }, [modal.dialog]);
+  const contextValue = useMemo(() => ({
+    overlayContainer: () => {
+      return modal.dialog;
+    }
+  }), [modal.dialog]);
   if (!mountModal) {
     return null;
   }
-  var renderBackdrop = function renderBackdrop() {
+  const renderBackdrop = () => {
     if (Transition) {
       return /*#__PURE__*/React.createElement(Fade, {
         transitionAppear: true,
         in: open,
         timeout: backdropTransitionTimeout
-      }, function (fadeProps, ref) {
-        var className = fadeProps.className,
-          rest = _objectWithoutPropertiesLoose(fadeProps, _excluded2);
+      }, (fadeProps, ref) => {
+        const {
+          className,
+          ...rest
+        } = fadeProps;
         return /*#__PURE__*/React.createElement("div", _extends({
           "aria-hidden": true,
           "data-testid": "backdrop"
@@ -211,7 +196,7 @@ var Modal = /*#__PURE__*/React.forwardRef(function (props, ref) {
       className: backdropClassName
     });
   };
-  var dialogElement = Transition ? /*#__PURE__*/React.createElement(Transition, _extends({}, animationProps, {
+  const dialogElement = Transition ? /*#__PURE__*/React.createElement(Transition, _extends({}, animationProps, {
     transitionAppear: true,
     unmountOnExit: true,
     in: open,
@@ -232,29 +217,5 @@ var Modal = /*#__PURE__*/React.forwardRef(function (props, ref) {
     tabIndex: -1
   }), dialogElement)));
 });
-export var modalPropTypes = {
-  as: PropTypes.elementType,
-  className: PropTypes.string,
-  backdropClassName: PropTypes.string,
-  style: PropTypes.object,
-  backdropStyle: PropTypes.object,
-  open: PropTypes.bool,
-  backdrop: PropTypes.oneOfType([PropTypes.bool, PropTypes.string]),
-  keyboard: PropTypes.bool,
-  autoFocus: PropTypes.bool,
-  enforceFocus: PropTypes.bool,
-  animationProps: PropTypes.object,
-  onOpen: PropTypes.func,
-  onClose: PropTypes.func
-};
 Modal.displayName = 'OverlayModal';
-Modal.propTypes = _extends({}, animationPropTypes, modalPropTypes, {
-  children: PropTypes.func,
-  container: PropTypes.any,
-  containerClassName: PropTypes.string,
-  dialogTransitionTimeout: PropTypes.number,
-  backdropTransitionTimeout: PropTypes.number,
-  transition: PropTypes.any,
-  onEsc: PropTypes.func
-});
 export default Modal;

package/esm/internals/Overlay/ModalManager.js

@@ -6,8 +6,8 @@ import getStyle from 'dom-lib/getStyle';
 import getScrollbarSize from 'dom-lib/getScrollbarSize';
 import isOverflowing from 'dom-lib/isOverflowing';
 function findIndexOf(arr, cb) {
-  var index = -1;
-  arr.some(function (d, i) {
+  let index = -1;
+  arr.some((d, i) => {
     if (cb(d, i)) {
       index = i;
       return true;
@@ -17,20 +17,17 @@ function findIndexOf(arr, cb) {
   return index;
 }
 function findContainer(data, modal) {
-  return findIndexOf(data, function (d) {
-    return d.modals.indexOf(modal) !== -1;
-  });
+  return findIndexOf(data, d => d.modals.indexOf(modal) !== -1);
 }
-var ModalManager = /*#__PURE__*/function () {
-  function ModalManager() {
+class ModalManager {
+  constructor() {
     this.modals = [];
     this.containers = [];
     this.data = [];
   }
-  var _proto = ModalManager.prototype;
-  _proto.add = function add(modal, container, className) {
-    var modalIndex = this.modals.indexOf(modal);
-    var containerIndex = this.containers.indexOf(container);
+  add(modal, container, className) {
+    let modalIndex = this.modals.indexOf(modal);
+    const containerIndex = this.containers.indexOf(container);
     if (modalIndex !== -1) {
       return modalIndex;
     }
@@ -40,7 +37,7 @@ var ModalManager = /*#__PURE__*/function () {
       this.data[containerIndex].modals.push(modal);
       return modalIndex;
     }
-    var containerState = {
+    const containerState = {
       modals: [modal],
       classes: className ? className.split(/\s+/) : [],
       style: {
@@ -50,8 +47,8 @@ var ModalManager = /*#__PURE__*/function () {
       overflowing: isOverflowing(container)
     };
     if (containerState.overflowing) {
-      var paddingRight = parseInt(getStyle(container, 'paddingRight') || 0, 10);
-      var barSize = getScrollbarSize();
+      const paddingRight = parseInt(getStyle(container, 'paddingRight') || 0, 10);
+      const barSize = getScrollbarSize();
       addStyle(container, {
         paddingRight: (barSize ? paddingRight + barSize : paddingRight) + 'px'
       });
@@ -60,29 +57,26 @@ var ModalManager = /*#__PURE__*/function () {
     this.containers.push(container);
     this.data.push(containerState);
     return modalIndex;
-  };
-  _proto.remove = function remove(modal) {
-    var modalIndex = this.modals.indexOf(modal);
+  }
+  remove(modal) {
+    const modalIndex = this.modals.indexOf(modal);
     if (modalIndex === -1) {
       return;
     }
-    var containerIndex = findContainer(this.data, modal);
-    var containerState = this.data[containerIndex];
-    var container = this.containers[containerIndex];
+    const containerIndex = findContainer(this.data, modal);
+    const containerState = this.data[containerIndex];
+    const container = this.containers[containerIndex];
     containerState.modals.splice(containerState.modals.indexOf(modal), 1);
     this.modals.splice(modalIndex, 1);
     if (containerState.modals.length === 0) {
-      Object.keys(containerState.style).forEach(function (key) {
-        return container.style[key] = containerState.style[key];
-      });
+      Object.keys(containerState.style).forEach(key => container.style[key] = containerState.style[key]);
       containerState.classes.forEach(removeClass.bind(null, container));
       this.containers.splice(containerIndex, 1);
       this.data.splice(containerIndex, 1);
     }
-  };
-  _proto.isTopModal = function isTopModal(modal) {
+  }
+  isTopModal(modal) {
     return !!this.modals.length && this.modals[this.modals.length - 1] === modal;
-  };
-  return ModalManager;
-}();
+  }
+}
 export default ModalManager;

package/esm/internals/Overlay/Overlay.d.ts

@@ -1,14 +1,13 @@
 import React from 'react';
-import PropTypes from 'prop-types';
 import { PositionChildProps } from './Position';
-import { TypeAttributes, AnimationEventProps, CursorPosition } from '../types';
+import { Placement, AnimationEventProps, CursorPosition } from '../types';
 export interface OverlayProps extends AnimationEventProps {
     container?: HTMLElement | (() => HTMLElement | null) | null;
     children: React.ReactElement | ((props: PositionChildProps & React.HTMLAttributes<HTMLElement>, ref: React.RefCallback<HTMLElement>) => React.ReactElement);
     childrenProps?: React.HTMLAttributes<HTMLElement>;
     className?: string;
     containerPadding?: number;
-    placement?: TypeAttributes.Placement;
+    placement?: Placement;
     preventOverflow?: boolean;
     open?: boolean;
     rootClose?: boolean;
@@ -18,26 +17,6 @@ export interface OverlayProps extends AnimationEventProps {
     followCursor?: boolean;
     cursorPosition?: CursorPosition | null;
 }
-export declare const overlayPropTypes: {
-    container: PropTypes.Requireable<any>;
-    children: PropTypes.Requireable<any>;
-    childrenProps: PropTypes.Requireable<object>;
-    className: PropTypes.Requireable<string>;
-    containerPadding: PropTypes.Requireable<number>;
-    placement: PropTypes.Requireable<any>;
-    preventOverflow: PropTypes.Requireable<boolean>;
-    open: PropTypes.Requireable<boolean>;
-    rootClose: PropTypes.Requireable<boolean>;
-    transition: PropTypes.Requireable<any>;
-    triggerTarget: PropTypes.Requireable<any>;
-    onClose: PropTypes.Requireable<(...args: any[]) => any>;
-    onEnter: PropTypes.Requireable<(...args: any[]) => any>;
-    onEntering: PropTypes.Requireable<(...args: any[]) => any>;
-    onEntered: PropTypes.Requireable<(...args: any[]) => any>;
-    onExit: PropTypes.Requireable<(...args: any[]) => any>;
-    onExiting: PropTypes.Requireable<(...args: any[]) => any>;
-    onExited: PropTypes.Requireable<(...args: any[]) => any>;
-};
 /**
  * Overlay is a powerful component that helps you create floating components.
  * @private