@elliemae/ds-tooltip 1.60.0 → 2.0.0-alpha.12

package/esm/v3/index.js

@@ -1,71 +1,62 @@
-import _extends from '@babel/runtime/helpers/esm/extends';
-import _slicedToArray from '@babel/runtime/helpers/esm/slicedToArray';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import _jsx from '@babel/runtime/helpers/esm/jsx';
 import _objectWithoutProperties from '@babel/runtime/helpers/esm/objectWithoutProperties';
-import React, { useState, useCallback, useEffect } from 'react';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/esnext.async-iterator.filter.js';
+import 'core-js/modules/esnext.iterator.constructor.js';
+import 'core-js/modules/esnext.iterator.filter.js';
+import 'core-js/modules/esnext.async-iterator.for-each.js';
+import 'core-js/modules/esnext.iterator.for-each.js';
+import { useState, useCallback, useEffect } from 'react';
 import { DSPopperJS } from '@elliemae/ds-popperjs';
 import { describe } from 'react-desc';
 import { dsTooltipPropTypes } from './propsTypes.js';
 import { useWithDefaultProps } from './config/useWithDefaultProps.js';
 import { TooltipV3DatatestId } from './TooltipV3DatatestId.js';
 import { StyledTriggerWrapper, StyledTooltipContainer, StyledTooltipText, StyledMouseOverDetectionBox } from './styleds.js';
-import '@elliemae/ds-props-helpers';
-import 'styled-components';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
 
-var _excluded = ["text", "children", "onOpen", "onClose", "id", "textAlign"];
+var _StyledMouseOverDetec;
 
-var useGlobalKeyboardListener = function useGlobalKeyboardListener(func) {
-  useEffect(function () {
-    document.addEventListener('keydown', func);
-    return function () {
-      return document.removeEventListener('keydown', func);
-    };
-  }, [func]);
-};
-
-var DSTooltipV3 = function DSTooltipV3(props) {
-  var _useWithDefaultProps = useWithDefaultProps(props),
-      text = _useWithDefaultProps.text,
-      children = _useWithDefaultProps.children,
-      onOpen = _useWithDefaultProps.onOpen,
-      onClose = _useWithDefaultProps.onClose,
-      id = _useWithDefaultProps.id,
-      textAlign = _useWithDefaultProps.textAlign,
-      extraPopperJsProps = _objectWithoutProperties(_useWithDefaultProps, _excluded);
+const _excluded = ["text", "children", "onOpen", "onClose", "id", "textAlign"];
 
-  var _useState = useState(false),
-      _useState2 = _slicedToArray(_useState, 2),
-      isFocused = _useState2[0],
-      setIsFocused = _useState2[1];
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
-  var _useState3 = useState(false),
-      _useState4 = _slicedToArray(_useState3, 2),
-      isHover = _useState4[0],
-      setIsHover = _useState4[1];
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-  var _useState5 = useState(''),
-      _useState6 = _slicedToArray(_useState5, 2),
-      latestOpenInteraction = _useState6[0],
-      setLatestOpenInteraction = _useState6[1];
-
-  var _useState7 = useState(),
-      _useState8 = _slicedToArray(_useState7, 2),
-      referenceElement = _useState8[0],
-      setReferenceElement = _useState8[1];
+const useGlobalKeyboardListener = func => {
+  useEffect(() => {
+    document.addEventListener('keydown', func);
+    return () => document.removeEventListener('keydown', func);
+  }, [func]);
+};
 
-  var _useState9 = useState(false),
-      _useState10 = _slicedToArray(_useState9, 2),
-      showPopover = _useState10[0],
-      setShowPopover = _useState10[1];
+const DSTooltipV3 = props => {
+  const _useWithDefaultProps = useWithDefaultProps(props),
+        {
+    text,
+    children,
+    onOpen,
+    onClose,
+    id,
+    textAlign
+  } = _useWithDefaultProps,
+        extraPopperJsProps = _objectWithoutProperties(_useWithDefaultProps, _excluded);
 
-  var showTooltip = useCallback(function () {
+  const [isFocused, setIsFocused] = useState(false);
+  const [isHover, setIsHover] = useState(false);
+  const [latestOpenInteraction, setLatestOpenInteraction] = useState('');
+  const [referenceElement, setReferenceElement] = useState();
+  const [showPopover, setShowPopover] = useState(false);
+  const showTooltip = useCallback(() => {
     setShowPopover(true);
     onOpen();
   }, [onOpen]);
-  var hideTooltip = useCallback(function () {
+  const hideTooltip = useCallback(() => {
     setShowPopover(false);
     onClose();
   }, [onClose]);
-  var onFocus = useCallback(function () {
+  const onFocus = useCallback(() => {
     setIsFocused(true);
 
     if (!showPopover) {
@@ -73,11 +64,11 @@ var DSTooltipV3 = function DSTooltipV3(props) {
       setLatestOpenInteraction('onFocus');
     }
   }, [showPopover, showTooltip]);
-  var onBlur = useCallback(function () {
+  const onBlur = useCallback(() => {
     setIsFocused(false);
     if (!isHover || latestOpenInteraction === 'onFocus') hideTooltip();
   }, [hideTooltip, isHover, latestOpenInteraction]);
-  var onMouseEnter = useCallback(function () {
+  const onMouseEnter = useCallback(() => {
     setIsHover(true);
 
     if (!showPopover) {
@@ -85,36 +76,41 @@ var DSTooltipV3 = function DSTooltipV3(props) {
       setLatestOpenInteraction('onMouseEnter');
     }
   }, [showPopover, showTooltip]);
-  var onMouseLeave = useCallback(function () {
+  const onMouseLeave = useCallback(() => {
     setIsHover(false);
     if (!isFocused || latestOpenInteraction === 'onMouseEnter') hideTooltip();
   }, [hideTooltip, isFocused, latestOpenInteraction]);
-  var handleEscKey = useCallback(function (_ref) {
-    var key = _ref.key;
+  const handleEscKey = useCallback(_ref => {
+    let {
+      key
+    } = _ref;
     if (key === 'Escape') hideTooltip();
   }, [hideTooltip]);
   useGlobalKeyboardListener(handleEscKey);
-  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(StyledTriggerWrapper, {
-    onMouseEnter: onMouseEnter,
-    onMouseLeave: onMouseLeave,
-    onFocus: onFocus,
-    onBlur: onBlur,
-    ref: setReferenceElement,
-    "data-testid": "".concat(TooltipV3DatatestId.TRIGGER_WRAPPER).concat(id !== '' ? "_".concat(id) : '')
-  }, /*#__PURE__*/React.createElement(DSPopperJS, _extends({
-    referenceElement: referenceElement,
-    showPopover: showPopover,
-    withoutPortal: true
-  }, extraPopperJsProps), /*#__PURE__*/React.createElement("div", {
-    "data-testid": "".concat(TooltipV3DatatestId.TOOLTIP_TEXT_WRAPPER).concat(id !== '' ? "_".concat(id) : '')
-  }, /*#__PURE__*/React.createElement(StyledTooltipContainer, null, /*#__PURE__*/React.createElement(StyledTooltipText, {
-    textAlign: textAlign
-  }, text), /*#__PURE__*/React.createElement(StyledMouseOverDetectionBox, null)))), children));
+  return /*#__PURE__*/jsx(Fragment, {
+    children: /*#__PURE__*/jsxs(StyledTriggerWrapper, {
+      onMouseEnter: onMouseEnter,
+      onMouseLeave: onMouseLeave,
+      onFocus: onFocus,
+      onBlur: onBlur,
+      ref: setReferenceElement,
+      "data-testid": "".concat(TooltipV3DatatestId.TRIGGER_WRAPPER).concat(id !== '' ? "_".concat(id) : ''),
+      children: [/*#__PURE__*/jsx(DSPopperJS, _objectSpread(_objectSpread({
+        referenceElement: referenceElement,
+        showPopover: showPopover,
+        withoutPortal: true
+      }, extraPopperJsProps), {}, {
+        children: /*#__PURE__*/_jsx("div", {
+          "data-testid": "".concat(TooltipV3DatatestId.TOOLTIP_TEXT_WRAPPER).concat(id !== '' ? "_".concat(id) : '')
+        }, void 0, /*#__PURE__*/_jsx(StyledTooltipContainer, {}, void 0, /*#__PURE__*/_jsx(StyledTooltipText, {
+          textAlign: textAlign
+        }, void 0, text), _StyledMouseOverDetec || (_StyledMouseOverDetec = /*#__PURE__*/_jsx(StyledMouseOverDetectionBox, {}))))
+      })), children]
+    })
+  });
 };
 
-DSTooltipV3.propTypes = dsTooltipPropTypes;
-var DSTooltipV3WithSchema = describe(DSTooltipV3).description('A tooltip component');
+const DSTooltipV3WithSchema = describe(DSTooltipV3).description('A tooltip component');
 DSTooltipV3WithSchema.propTypes = dsTooltipPropTypes;
 
 export { DSTooltipV3, DSTooltipV3WithSchema, DSTooltipV3 as default };
-//# sourceMappingURL=index.js.map

package/esm/v3/propsTypes.js

@@ -1,6 +1,6 @@
 import { PropTypes } from 'react-desc';
 
-var dsTooltipPropTypes = {
+const dsTooltipPropTypes = {
   /**
    * Tooltip text to be displayed on hover/focus
    */
@@ -90,4 +90,3 @@ var dsTooltipPropTypes = {
 };
 
 export { dsTooltipPropTypes };
-//# sourceMappingURL=propsTypes.js.map

package/esm/v3/styleds.js

@@ -1,29 +1,36 @@
 import styled from 'styled-components';
 
-var StyledTooltipContainer = /*#__PURE__*/styled.div.withConfig({
+const StyledTooltipContainer = /*#__PURE__*/styled.div.withConfig({
   componentId: "sc-18a4gem-0"
-})(["text-align:center;min-width:", ";max-width:250px;min-height:30px;display:grid;align-items:center;padding:", ";position:relative;background-color:white;border-radius:2px;font-size:13px;color:", ";"], function (_ref) {
-  var theme = _ref.theme;
+})(["text-align:center;min-width:", ";max-width:250px;min-height:30px;display:grid;align-items:center;padding:", ";position:relative;background-color:white;border-radius:2px;font-size:13px;color:", ";"], _ref => {
+  let {
+    theme
+  } = _ref;
   return theme.space.l;
-}, function (_ref2) {
-  var theme = _ref2.theme;
+}, _ref2 => {
+  let {
+    theme
+  } = _ref2;
   return "".concat(theme.space.xxxs, " ").concat(theme.space.xs);
-}, function (_ref3) {
-  var theme = _ref3.theme;
+}, _ref3 => {
+  let {
+    theme
+  } = _ref3;
   return theme.colors.neutral[600];
 });
-var StyledTooltipText = /*#__PURE__*/styled.div.withConfig({
+const StyledTooltipText = /*#__PURE__*/styled.div.withConfig({
   componentId: "sc-18a4gem-1"
-})(["white-space:normal;word-wrap:break-word;display:inline-block;text-align:", ";"], function (_ref4) {
-  var textAlign = _ref4.textAlign;
+})(["white-space:normal;word-wrap:break-word;display:inline-block;text-align:", ";"], _ref4 => {
+  let {
+    textAlign
+  } = _ref4;
   return textAlign;
 });
-var StyledMouseOverDetectionBox = /*#__PURE__*/styled.div.withConfig({
+const StyledMouseOverDetectionBox = /*#__PURE__*/styled.div.withConfig({
   componentId: "sc-18a4gem-2"
 })(["position:absolute;top:-15px;right:-15px;width:calc(100% + 30px);height:calc(100% + 30px);z-index:-1;"]);
-var StyledTriggerWrapper = /*#__PURE__*/styled.div.withConfig({
+const StyledTriggerWrapper = /*#__PURE__*/styled.div.withConfig({
   componentId: "sc-18a4gem-3"
 })(["display:inline-block;width:100%;"]);
 
 export { StyledMouseOverDetectionBox, StyledTooltipContainer, StyledTooltipText, StyledTriggerWrapper };
-//# sourceMappingURL=styleds.js.map

package/package.json

@@ -1,14 +1,90 @@
 {
   "name": "@elliemae/ds-tooltip",
-  "version": "1.60.0",
+  "version": "2.0.0-alpha.12",
   "license": "MIT",
-  "description": "Ellie Mae - Dim Sum - Tooltip",
-  "module": "esm/index.js",
-  "main": "cjs/index.js",
+  "description": "ICE MT - Dimsum - Tooltip",
+  "module": "./esm/index.js",
+  "main": "./cjs/index.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./cjs/index.js"
+    },
+    "./v3/TooltipV3DatatestId": {
+      "import": "./esm/v3/TooltipV3DatatestId.js",
+      "require": "./cjs/v3/TooltipV3DatatestId.js"
+    },
+    "./v3/styleds": {
+      "import": "./esm/v3/styleds.js",
+      "require": "./cjs/v3/styleds.js"
+    },
+    "./v3/propsTypes": {
+      "import": "./esm/v3/propsTypes.js",
+      "require": "./cjs/v3/propsTypes.js"
+    },
+    "./v3": {
+      "import": "./esm/v3/index.js",
+      "require": "./cjs/v3/index.js"
+    },
+    "./v3/config/useWithDefaultProps": {
+      "import": "./esm/v3/config/useWithDefaultProps.js",
+      "require": "./cjs/v3/config/useWithDefaultProps.js"
+    },
+    "./v2/utils/tooltipPositions": {
+      "import": "./esm/v2/utils/tooltipPositions.js",
+      "require": "./cjs/v2/utils/tooltipPositions.js"
+    },
+    "./v2/utils/setMultipleRefs": {
+      "import": "./esm/v2/utils/setMultipleRefs.js",
+      "require": "./cjs/v2/utils/setMultipleRefs.js"
+    },
+    "./v2/TooltipType": {
+      "import": "./esm/v2/TooltipType.js",
+      "require": "./cjs/v2/TooltipType.js"
+    },
+    "./v2/styles": {
+      "import": "./esm/v2/styles.js",
+      "require": "./cjs/v2/styles.js"
+    },
+    "./v2/propTypes": {
+      "import": "./esm/v2/propTypes.js",
+      "require": "./cjs/v2/propTypes.js"
+    },
+    "./v2": {
+      "import": "./esm/v2/index.d.js",
+      "require": "./cjs/v2/index.d.js"
+    },
+    "./v2/DSTooltipArrow": {
+      "import": "./esm/v2/DSTooltipArrow.js",
+      "require": "./cjs/v2/DSTooltipArrow.js"
+    },
+    "./v2/DSTooltip": {
+      "import": "./esm/v2/DSTooltip.js",
+      "require": "./cjs/v2/DSTooltip.js"
+    },
+    "./v1/TooltipType": {
+      "import": "./esm/v1/TooltipType.js",
+      "require": "./cjs/v1/TooltipType.js"
+    },
+    "./v1/DSTooltip": {
+      "import": "./esm/v1/DSTooltip.js",
+      "require": "./cjs/v1/DSTooltip.js"
+    }
+  },
   "sideEffects": [
     "*.css",
     "*.scss"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://git.elliemae.io/platform-ui/dimsum.git"
+  },
+  "engines": {
+    "npm": ">=7",
+    "node": ">=14"
+  },
+  "author": "ICE MT",
   "scripts": {
     "dev": "cross-env NODE_ENV=development && node ../../scripts/build/build.js -w",
     "prebuild": "exit 0",
@@ -16,28 +92,35 @@
     "build": "node ../../scripts/build/build.js"
   },
   "dependencies": {
-    "@elliemae/ds-basic": "1.60.0",
-    "@elliemae/ds-classnames": "1.60.0",
-    "@elliemae/ds-popper": "1.60.0",
-    "@elliemae/ds-popperjs": "1.60.0",
-    "@elliemae/ds-portal": "1.60.0",
-    "@elliemae/ds-shared": "1.60.0",
-    "@elliemae/ds-system": "1.60.0",
-    "@elliemae/ds-utilities": "1.60.0",
-    "@popperjs/core": "2.9.2",
-    "react-desc": "^4.1.2",
-    "react-popper": "2.2.5"
+    "@elliemae/ds-button": "2.0.0-alpha.12",
+    "@elliemae/ds-classnames": "2.0.0-alpha.12",
+    "@elliemae/ds-popper": "2.0.0-alpha.12",
+    "@elliemae/ds-popperjs": "2.0.0-alpha.12",
+    "@elliemae/ds-portal": "2.0.0-alpha.12",
+    "@elliemae/ds-props-helpers": "2.0.0-alpha.12",
+    "@elliemae/ds-shared": "2.0.0-alpha.12",
+    "@elliemae/ds-system": "2.0.0-alpha.12",
+    "@elliemae/ds-utilities": "2.0.0-alpha.12",
+    "@popperjs/core": "~2.9.2",
+    "react-desc": "~4.1.3",
+    "react-popper": "~2.2.5"
   },
   "devDependencies": {
-    "styled-components": "~5.3.0"
+    "@testing-library/jest-dom": "~5.15.0",
+    "@testing-library/react": "~12.1.2",
+    "@testing-library/user-event": "~13.5.0",
+    "react": "^17.0.2",
+    "react-dom": "^17.0.2",
+    "styled-components": "~5.3.3"
   },
   "peerDependencies": {
-    "react": "^17.0.1",
-    "react-dom": "^17.0.1",
-    "styled-components": "^5.3.0"
+    "react": "^17.0.2",
+    "react-dom": "^17.0.2",
+    "styled-components": "^5.3.3"
   },
   "publishConfig": {
     "access": "public",
-    "directory": "dist"
+    "directory": "dist",
+    "generateSubmodules": true
   }
 }

package/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './v1/DSTooltip';
+export { default } from './v1/DSTooltip';
+export * from './v2/DSTooltip';
+export { tooltipPositions } from './v2/utils/tooltipPositions';
+export * from './v2/TooltipType';
+export * from './v3';

package/types/v1/DSTooltip.d.ts

@@ -0,0 +1,106 @@
+/// <reference path="../../../../../shared/typings/react-desc.d.ts" />
+import React from 'react';
+declare const TooltipContainer: React.ForwardRefExoticComponent<React.RefAttributes<unknown>>;
+declare const TooltipText: React.ForwardRefExoticComponent<React.RefAttributes<unknown>>;
+declare const DSTooltip: {
+    ({ containerProps, innerRef, placement, title, delayClose, delayOpen, interactionType, triggerComponent, className, isOpen, onOpen, springAnimationComponent, tooltipType, showArrow, zIndex, ...otherTooltipProps }: {
+        [x: string]: any;
+        containerProps?: {} | undefined;
+        innerRef: any;
+        placement?: string | undefined;
+        title?: string | undefined;
+        delayClose?: any;
+        delayOpen?: any;
+        interactionType?: string | undefined;
+        triggerComponent?: null | undefined;
+        className?: string | undefined;
+        isOpen?: undefined;
+        onOpen?: (() => null) | undefined;
+        springAnimationComponent?: undefined;
+        tooltipType?: string | undefined;
+        showArrow?: boolean | undefined;
+        zIndex: any;
+    }): JSX.Element;
+    propTypes: {
+        containerProps: {
+            defaultValue<T = unknown>(arg: T): {
+                deprecated: import("react-desc").PropTypesDescValidator;
+            };
+            isRequired: import("react-desc").PropTypesDescValidator;
+        };
+        placement: {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        title: import("react-desc").PropTypesDescValidator;
+        delayClose: {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        delayOpen: {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        interactionType: {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        triggerComponent: import("react-desc").PropTypesDescValidator;
+        isOpen: {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        onOpen: {
+            defaultValue<T = unknown>(arg: T): {
+                deprecated: import("react-desc").PropTypesDescValidator;
+            };
+            isRequired: import("react-desc").PropTypesDescValidator;
+        };
+        springAnimationComponent: {
+            defaultValue<T = unknown>(arg: T): {
+                deprecated: import("react-desc").PropTypesDescValidator;
+            };
+            isRequired: import("react-desc").PropTypesDescValidator;
+        };
+        showArrow: {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        className: {
+            defaultValue<T = unknown>(arg: T): {
+                deprecated: import("react-desc").PropTypesDescValidator;
+            };
+            isRequired: import("react-desc").PropTypesDescValidator;
+        };
+        tooltipType: {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        zIndex: {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        innerRef: {
+            defaultValue<T = unknown>(arg: T): {
+                deprecated: import("react-desc").PropTypesDescValidator;
+            };
+            isRequired: import("react-desc").PropTypesDescValidator;
+        };
+    };
+};
+declare const TooltipWithSchema: {
+    (props?: {
+        [x: string]: any;
+        containerProps?: {} | undefined;
+        innerRef: any;
+        placement?: string | undefined;
+        title?: string | undefined;
+        delayClose?: any;
+        delayOpen?: any;
+        interactionType?: string | undefined;
+        triggerComponent?: null | undefined;
+        className?: string | undefined;
+        isOpen?: undefined;
+        onOpen?: (() => null) | undefined;
+        springAnimationComponent?: undefined;
+        tooltipType?: string | undefined;
+        showArrow?: boolean | undefined;
+        zIndex: any;
+    } | undefined): JSX.Element;
+    propTypes: unknown;
+    toTypescript: () => import("react-desc").TypescriptSchema;
+};
+export { DSTooltip, TooltipContainer, TooltipText, TooltipWithSchema };
+export default DSTooltip;

package/types/v1/TooltipType.d.ts

@@ -0,0 +1,4 @@
+export declare const TooltipType: {
+    TOOLTIP: string;
+    TOOLBAR: string;
+};

package/types/v2/DSTooltip.d.ts

@@ -0,0 +1,70 @@
+/// <reference path="../../../../../shared/typings/react-desc.d.ts" />
+import React from 'react';
+import { DSTooltipT } from '.';
+declare const DSTooltipV2: {
+    ({ containerProps, innerRef, placement, title, delayClose, delayOpen, triggerComponent, className, getIsOpen, onOpen, tooltipType, showArrow, offset, zIndex, extraModifiers, }: DSTooltipT): React.ReactElement;
+    propTypes: {
+        containerProps: {
+            defaultValue<T = unknown>(arg: T): {
+                deprecated: import("react-desc").PropTypesDescValidator;
+            };
+            isRequired: import("react-desc").PropTypesDescValidator;
+        };
+        placement: {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        title: import("react-desc").PropTypesDescValidator;
+        delayClose: {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        delayOpen: {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        triggerComponent: import("react-desc").PropTypesDescValidator;
+        getIsOpen: {
+            defaultValue<T = unknown>(arg: T): {
+                deprecated: import("react-desc").PropTypesDescValidator;
+            };
+            isRequired: import("react-desc").PropTypesDescValidator;
+        };
+        onOpen: {
+            defaultValue<T = unknown>(arg: T): {
+                deprecated: import("react-desc").PropTypesDescValidator;
+            };
+            isRequired: import("react-desc").PropTypesDescValidator;
+        };
+        showArrow: {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        className: {
+            defaultValue<T = unknown>(arg: T): {
+                deprecated: import("react-desc").PropTypesDescValidator;
+            };
+            isRequired: import("react-desc").PropTypesDescValidator;
+        };
+        tooltipType: {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        zIndex: {
+            deprecated: import("react-desc").PropTypesDescValidator;
+        };
+        innerRef: {
+            defaultValue<T = unknown>(arg: T): {
+                deprecated: import("react-desc").PropTypesDescValidator;
+            };
+            isRequired: import("react-desc").PropTypesDescValidator;
+        };
+        offset: {
+            defaultValue<T = unknown>(arg: T): {
+                deprecated: import("react-desc").PropTypesDescValidator;
+            };
+            isRequired: import("react-desc").PropTypesDescValidator;
+        };
+    };
+};
+declare const TooltipV2WithSchema: {
+    (props?: DSTooltipT | undefined): JSX.Element;
+    propTypes: unknown;
+    toTypescript: () => import("react-desc").TypescriptSchema;
+};
+export { DSTooltipV2, TooltipV2WithSchema };

package/types/v2/DSTooltipArrow.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { DSTooltipArrowT } from './index.d';
+declare const DSTooltipArrow: ({ placement, style, arrowElementRef }: DSTooltipArrowT) => React.ReactElement;
+export { DSTooltipArrow };

package/types/v2/TooltipType.d.ts

@@ -0,0 +1,5 @@
+declare const TooltipType: {
+    TOOLTIP: "tooltip";
+    TOOLBAR: "toolbar";
+};
+export { TooltipType };