@rio-cloud/rio-uikit 0.16.3 → 0.16.4-beta.2

package/components/collapse/Collapse.js

@@ -1,217 +1,148 @@
-import _extends from "@babel/runtime/helpers/extends";
-import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
-import _inherits from "@babel/runtime/helpers/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-var _excluded = ["children"];
-var _collapseStyles;
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+import { __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
 import PropTypes from 'prop-types';
 import ReactDOM from 'react-dom';
 import css from 'dom-helpers/css';
 import classNames from 'classnames';
 import Transition, { ENTERED, ENTERING, EXITED, EXITING } from 'react-transition-group/Transition';
-var collapseStyles = (_collapseStyles = {}, _defineProperty(_collapseStyles, EXITED, 'collapse'), _defineProperty(_collapseStyles, EXITING, 'collapsing'), _defineProperty(_collapseStyles, ENTERING, 'collapsing'), _defineProperty(_collapseStyles, ENTERED, 'collapse in'), _collapseStyles);
-var MARGINS = {
-  height: ['marginTop', 'marginBottom']
+const collapseStyles = {
+    [EXITED]: 'collapse',
+    [EXITING]: 'collapsing',
+    [ENTERING]: 'collapsing',
+    [ENTERED]: 'collapse in',
 };
-var INITIAL_HEIGHT = '0';
-var Collapse = /*#__PURE__*/function (_React$Component) {
-  _inherits(Collapse, _React$Component);
-  var _super = _createSuper(Collapse);
-  function Collapse(props) {
-    var _this;
-    _classCallCheck(this, Collapse);
-    _this = _super.call(this, props);
-    _this.state = {};
-    _this.handleEnter = _this.handleEnter.bind(_assertThisInitialized(_this));
-    _this.handleEntering = _this.handleEntering.bind(_assertThisInitialized(_this));
-    _this.handleEntered = _this.handleEntered.bind(_assertThisInitialized(_this));
-    _this.handleExit = _this.handleExit.bind(_assertThisInitialized(_this));
-    _this.handleExiting = _this.handleExiting.bind(_assertThisInitialized(_this));
-    _this.handleExited = _this.handleExited.bind(_assertThisInitialized(_this));
-    return _this;
-  }
-  _createClass(Collapse, [{
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      if (!this.props["in"]) {
-        // When the component is collapsed on mount, set initial height to 0
-        this.setState(function () {
-          return {
-            transitionState: EXITED,
-            height: INITIAL_HEIGHT
-          };
-        });
-      } else {
-        // When the component is expanded on mount, set initial height to 'auto'
-        this.setState(function () {
-          return {
-            transitionState: ENTERED,
-            height: 'auto'
-          };
-        });
-      }
+const MARGINS = {
+    height: ['marginTop', 'marginBottom'],
+};
+const INITIAL_HEIGHT = '0';
+export default class Collapse extends React.Component {
+    constructor(props) {
+        super(props);
+        this.state = {};
+        this.handleEnter = this.handleEnter.bind(this);
+        this.handleEntering = this.handleEntering.bind(this);
+        this.handleEntered = this.handleEntered.bind(this);
+        this.handleExit = this.handleExit.bind(this);
+        this.handleExiting = this.handleExiting.bind(this);
+        this.handleExited = this.handleExited.bind(this);
+    }
+    componentDidMount() {
+        if (!this.props.in) {
+            // When the component is collapsed on mount, set initial height to 0
+            this.setState(() => ({
+                transitionState: EXITED,
+                height: INITIAL_HEIGHT,
+            }));
+        }
+        else {
+            // When the component is expanded on mount, set initial height to 'auto'
+            this.setState(() => ({
+                transitionState: ENTERED,
+                height: 'auto',
+            }));
+        }
     }
-
     // eslint-disable-next-line camelcase
-  }, {
-    key: "UNSAFE_componentWillReceiveProps",
-    value: function UNSAFE_componentWillReceiveProps(nextProps) {
-      // As the height is set to "auto" in the final opening step, we need to
-      // set the height before we start the closing animation as "height: auto" cannot be animated
-      if (this.props["in"] && !nextProps["in"]) {
-        this.setState({
-          height: this.getFullHeight(ReactDOM.findDOMNode(this))
-        });
-      }
+    UNSAFE_componentWillReceiveProps(nextProps) {
+        // As the height is set to "auto" in the final opening step, we need to
+        // set the height before we start the closing animation as "height: auto" cannot be animated
+        if (this.props.in && !nextProps.in) {
+            this.setState({
+                height: this.getFullHeight(ReactDOM.findDOMNode(this)),
+            });
+        }
     }
-  }, {
-    key: "getFullHeight",
-    value: function getFullHeight(element) {
-      var value = element.offsetHeight;
-      var margins = MARGINS['height'];
-      if (!value) {
-        return INITIAL_HEIGHT;
-      }
-      var fullHeight = value + parseInt(css(element, margins[0]), 10) + parseInt(css(element, margins[1]), 10);
-      return fullHeight;
+    getFullHeight(element) {
+        const value = element.offsetHeight;
+        const margins = MARGINS['height'];
+        if (!value) {
+            return INITIAL_HEIGHT;
+        }
+        const fullHeight = value + parseInt(css(element, margins[0]), 10) + parseInt(css(element, margins[1]), 10);
+        return fullHeight;
     }
-
     /* -- Expanding -- */
-  }, {
-    key: "handleEnter",
-    value: function handleEnter() {
-      this.setState(function () {
-        return {
-          transitionState: ENTERED,
-          height: INITIAL_HEIGHT
-        };
-      }, this.props.onEnter());
+    handleEnter() {
+        this.setState(() => ({
+            transitionState: ENTERED,
+            height: INITIAL_HEIGHT,
+        }), this.props.onEnter());
     }
-  }, {
-    key: "handleEntering",
-    value: function handleEntering(element) {
-      this.setState(function () {
-        return {
-          transitionState: ENTERING,
-          height: element.scrollHeight
-        };
-      }, this.props.onEntering());
+    handleEntering(element) {
+        this.setState(() => ({
+            transitionState: ENTERING,
+            height: element.scrollHeight,
+        }), this.props.onEntering());
     }
-  }, {
-    key: "handleEntered",
-    value: function handleEntered() {
-      this.setState(function () {
-        return {
-          transitionState: ENTERED,
-          height: 'auto'
-        };
-      }, this.props.onEntered());
+    handleEntered() {
+        this.setState(() => ({
+            transitionState: ENTERED,
+            height: 'auto',
+        }), this.props.onEntered());
     }
-
     /* -- Collapsing -- */
-  }, {
-    key: "handleExit",
-    value: function handleExit(element) {
-      var _this2 = this;
-      this.setState(function () {
-        return {
-          transitionState: EXITING,
-          height: _this2.getFullHeight(element)
-        };
-      }, this.props.onExit());
+    handleExit(element) {
+        this.setState(() => ({
+            transitionState: EXITING,
+            height: this.getFullHeight(element),
+        }), this.props.onExit());
     }
-  }, {
-    key: "handleExiting",
-    value: function handleExiting() {
-      this.setState(function () {
-        return {
-          transitionState: EXITING,
-          height: INITIAL_HEIGHT
-        };
-      }, this.props.onExiting());
+    handleExiting() {
+        this.setState(() => ({
+            transitionState: EXITING,
+            height: INITIAL_HEIGHT,
+        }), this.props.onExiting());
     }
-  }, {
-    key: "handleExited",
-    value: function handleExited() {
-      this.setState(function () {
-        return {
-          transitionState: EXITED,
-          height: INITIAL_HEIGHT
-        };
-      }, this.props.onExited());
+    handleExited() {
+        this.setState(() => ({
+            transitionState: EXITED,
+            height: INITIAL_HEIGHT,
+        }), this.props.onExited());
     }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this3 = this;
-      var _this$props = this.props,
-        children = _this$props.children,
-        props = _objectWithoutProperties(_this$props, _excluded);
-      return /*#__PURE__*/React.createElement(Transition, _extends({
-        ref: function ref(node) {
-          return _this3.refTransition = node;
-        }
-      }, props, {
-        onEnter: this.handleEnter,
-        onEntering: this.handleEntering,
-        onEntered: this.handleEntered,
-        onExit: this.handleExit,
-        onExiting: this.handleExiting,
-        onExited: this.handleExited
-      }), /*#__PURE__*/React.cloneElement(children, {
-        style: {
-          height: this.state.height
-        },
-        className: classNames(children.props.className, collapseStyles[this.state.transitionState])
-      }));
+    render() {
+        const _a = this.props, { children } = _a, props = __rest(_a, ["children"]);
+        return (_jsx(Transition, Object.assign({ ref: node => (this.refTransition = node) }, props, { onEnter: this.handleEnter, onEntering: this.handleEntering, onEntered: this.handleEntered, onExit: this.handleExit, onExiting: this.handleExiting, onExited: this.handleExited }, { children: React.cloneElement(children, {
+                style: { height: this.state.height },
+                className: classNames(children.props.className, collapseStyles[this.state.transitionState]),
+            }) })));
     }
-  }]);
-  return Collapse;
-}(React.Component);
-export { Collapse as default };
+}
 Collapse.defaultProps = {
-  "in": false,
-  timeout: 300,
-  mountOnEnter: false,
-  unmountOnExit: false,
-  appear: false,
-  onEnter: function onEnter() {},
-  onEntering: function onEntering() {},
-  onEntered: function onEntered() {},
-  onExit: function onExit() {},
-  onExiting: function onExiting() {},
-  onExited: function onExited() {}
+    in: false,
+    timeout: 300,
+    mountOnEnter: false,
+    unmountOnExit: false,
+    appear: false,
+    onEnter: () => { },
+    onEntering: () => { },
+    onEntered: () => { },
+    onExit: () => { },
+    onExiting: () => { },
+    onExited: () => { },
 };
 Collapse.propTypes = {
-  // Show the component; triggers the expand or collapse animation
-  "in": PropTypes.bool.isRequired,
-  // Wait until the first "enter" transition to mount the component (add it to the DOM)
-  mountOnEnter: PropTypes.bool,
-  // Unmount the component (remove it from the DOM) when it is collapsed
-  unmountOnExit: PropTypes.bool,
-  // Run the expand animation when the component mounts, if it is initially shown
-  appear: PropTypes.bool,
-  // Duration of the collapse animation in milliseconds, to ensure that finishing callbacks
-  // are fired even if the original browser transition end events are canceled
-  timeout: PropTypes.number,
-  // Callback fired before the component expands
-  onEnter: PropTypes.func,
-  // Callback fired after the component starts to expand
-  onEntering: PropTypes.func,
-  // Callback fired after the component has expanded
-  onEntered: PropTypes.func,
-  // Callback fired before the component collapses
-  onExit: PropTypes.func,
-  // Callback fired after the component starts to collapse
-  onExiting: PropTypes.func,
-  // Callback fired after the component has collapsed
-  onExited: PropTypes.func
-};
+    // Show the component; triggers the expand or collapse animation
+    in: PropTypes.bool.isRequired,
+    // Wait until the first "enter" transition to mount the component (add it to the DOM)
+    mountOnEnter: PropTypes.bool,
+    // Unmount the component (remove it from the DOM) when it is collapsed
+    unmountOnExit: PropTypes.bool,
+    // Run the expand animation when the component mounts, if it is initially shown
+    appear: PropTypes.bool,
+    // Duration of the collapse animation in milliseconds, to ensure that finishing callbacks
+    // are fired even if the original browser transition end events are canceled
+    timeout: PropTypes.number,
+    // Callback fired before the component expands
+    onEnter: PropTypes.func,
+    // Callback fired after the component starts to expand
+    onEntering: PropTypes.func,
+    // Callback fired after the component has expanded
+    onEntered: PropTypes.func,
+    // Callback fired before the component collapses
+    onExit: PropTypes.func,
+    // Callback fired after the component starts to collapse
+    onExiting: PropTypes.func,
+    // Callback fired after the component has collapsed
+    onExited: PropTypes.func,
+};

package/components/contentLoader/ContentLoader.d.ts

@@ -0,0 +1,33 @@
+export default ContentLoader;
+declare function ContentLoader(props: any): JSX.Element;
+declare namespace ContentLoader {
+    const RECT: string;
+    const CIRCLE: string;
+    namespace defaultProps {
+        const speed: number;
+        const height: number;
+        const width: string;
+        const radius: number;
+        const type: string;
+        const className: string;
+        const title: string;
+    }
+    namespace propTypes {
+        const speed_1: PropTypes.Requireable<number>;
+        export { speed_1 as speed };
+        const height_1: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+        export { height_1 as height };
+        const width_1: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+        export { width_1 as width };
+        const type_1: PropTypes.Requireable<string>;
+        export { type_1 as type };
+        const radius_1: PropTypes.Requireable<number>;
+        export { radius_1 as radius };
+        const title_1: PropTypes.Requireable<string>;
+        export { title_1 as title };
+        const className_1: PropTypes.Requireable<string>;
+        export { className_1 as className };
+        export const children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+    }
+}
+import PropTypes from "prop-types";

package/components/contentLoader/ContentLoader.js

@@ -1,82 +1,47 @@
-import _extends from "@babel/runtime/helpers/extends";
-import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
-var _excluded = ["width", "height", "radius", "className"];
+import { __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
 /* eslint-disable no-use-before-define */
 import React from 'react';
 import PropTypes from 'prop-types';
 import { default as _ContentLoader } from 'react-content-loader';
 import cond from 'lodash/fp/cond';
 import isNil from 'lodash/fp/isNil';
-var hasChildren = function hasChildren(_ref) {
-  var children = _ref.children;
-  return !isNil(children);
-};
-var renderChildren = function renderChildren(_ref2) {
-  var children = _ref2.children;
-  return children;
-};
-var isRect = function isRect(_ref3) {
-  var type = _ref3.type;
-  return type === ContentLoader.RECT;
-};
-var isCircle = function isCircle(_ref4) {
-  var type = _ref4.type;
-  return type === ContentLoader.CIRCLE;
-};
-var renderRect = function renderRect(_ref5) {
-  var _ref5$rx = _ref5.rx,
-    rx = _ref5$rx === void 0 ? 3 : _ref5$rx,
-    _ref5$ry = _ref5.ry,
-    ry = _ref5$ry === void 0 ? 3 : _ref5$ry;
-  return /*#__PURE__*/React.createElement("rect", {
-    width: '100%',
-    height: '100%',
-    rx: rx,
-    ry: ry
-  });
-};
-var renderCircle = function renderCircle(_ref6) {
-  var radius = _ref6.radius;
-  return /*#__PURE__*/React.createElement("circle", {
-    cx: radius,
-    cy: radius,
-    r: radius
-  });
-};
-var ContentLoader = function ContentLoader(props) {
-  var width = props.width,
-    height = props.height,
-    radius = props.radius,
-    className = props.className,
-    remainingProps = _objectWithoutProperties(props, _excluded);
-  var content = cond([[hasChildren, renderChildren], [isRect, renderRect], [isCircle, renderCircle]])(props);
-  var wrapperHeight = isCircle(props) ? radius * 2 : height;
-  var wrapperWidth = isCircle(props) ? radius * 2 : width;
-  return /*#__PURE__*/React.createElement(_ContentLoader, _extends({
-    className: "ContentLoader ".concat(className),
-    height: wrapperHeight,
-    width: wrapperWidth
-  }, remainingProps), content);
+const hasChildren = ({ children }) => !isNil(children);
+const renderChildren = ({ children }) => children;
+const isRect = ({ type }) => type === ContentLoader.RECT;
+const isCircle = ({ type }) => type === ContentLoader.CIRCLE;
+const renderRect = ({ rx = 3, ry = 3 }) => _jsx("rect", { width: '100%', height: '100%', rx: rx, ry: ry });
+const renderCircle = ({ radius }) => _jsx("circle", { cx: radius, cy: radius, r: radius });
+const ContentLoader = props => {
+    const { width, height, radius, className } = props, remainingProps = __rest(props, ["width", "height", "radius", "className"]);
+    const content = cond([
+        [hasChildren, renderChildren],
+        [isRect, renderRect],
+        [isCircle, renderCircle],
+    ])(props);
+    const wrapperHeight = isCircle(props) ? radius * 2 : height;
+    const wrapperWidth = isCircle(props) ? radius * 2 : width;
+    return (_jsx(_ContentLoader, Object.assign({ className: `ContentLoader ${className}`, height: wrapperHeight, width: wrapperWidth }, remainingProps, { children: content })));
 };
 ContentLoader.RECT = 'rect';
 ContentLoader.CIRCLE = 'circle';
 ContentLoader.defaultProps = {
-  speed: 2,
-  height: 14,
-  width: '100%',
-  radius: 16,
-  type: 'rect',
-  className: '',
-  title: ''
+    speed: 2,
+    height: 14,
+    width: '100%',
+    radius: 16,
+    type: 'rect',
+    className: '',
+    title: '',
 };
 ContentLoader.propTypes = {
-  speed: PropTypes.number,
-  height: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
-  width: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
-  type: PropTypes.oneOf(['rect', 'circle', ContentLoader.RECT, ContentLoader.CIRCLE]),
-  radius: PropTypes.number,
-  title: PropTypes.string,
-  className: PropTypes.string,
-  children: PropTypes.node
-};
-export default ContentLoader;
+    speed: PropTypes.number,
+    height: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+    width: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+    type: PropTypes.oneOf(['rect', 'circle', ContentLoader.RECT, ContentLoader.CIRCLE]),
+    radius: PropTypes.number,
+    title: PropTypes.string,
+    className: PropTypes.string,
+    children: PropTypes.node,
+};
+export default ContentLoader;

package/components/dataTabs/DataTab.d.ts

@@ -0,0 +1,20 @@
+export default DataTab;
+declare function DataTab(props: any): any;
+declare namespace DataTab {
+    namespace defaultProps {
+        const active: boolean;
+        const disableTransition: boolean;
+        const className: string;
+    }
+    namespace propTypes {
+        const disableTransition_1: PropTypes.Requireable<boolean>;
+        export { disableTransition_1 as disableTransition };
+        const className_1: PropTypes.Requireable<string>;
+        export { className_1 as className };
+        const active_1: PropTypes.Requireable<boolean>;
+        export { active_1 as active };
+        export const tabKey: PropTypes.Validator<string>;
+        export const children: PropTypes.Requireable<NonNullable<PropTypes.ReactNodeLike>>;
+    }
+}
+import PropTypes from "prop-types";

package/components/dataTabs/DataTab.js

@@ -1,56 +1,30 @@
-import _extends from "@babel/runtime/helpers/extends";
-import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
-var _excluded = ["active", "tabKey", "disableTransition", "children", "title"];
+import { __rest } from "tslib";
+import { createElement as _createElement } from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
 import React from 'react';
 import PropTypes from 'prop-types';
 import { motion } from 'framer-motion';
-var DataTab = function DataTab(props) {
-  var active = props.active,
-    tabKey = props.tabKey,
-    disableTransition = props.disableTransition,
-    children = props.children,
-    title = props.title,
-    remainingProps = _objectWithoutProperties(props, _excluded);
-  if (disableTransition) {
-    return /*#__PURE__*/React.createElement("div", null, active && children);
-  }
-  return active && /*#__PURE__*/React.createElement(motion.div, _extends({}, remainingProps, {
-    key: tabKey,
-    initial: {
-      x: 0,
-      y: 0,
-      opacity: 0
-    },
-    animate: {
-      x: 0,
-      y: 0,
-      opacity: 1
-    },
-    exit: {
-      x: 0,
-      y: 0,
-      opacity: 0
-    },
-    transition: {
-      duration: 0.1
+const DataTab = props => {
+    const { active, tabKey, disableTransition, children, title } = props, remainingProps = __rest(props, ["active", "tabKey", "disableTransition", "children", "title"]);
+    if (disableTransition) {
+        return _jsx("div", { children: active && children });
     }
-    // TODO: added "fade in" for backwards compatibility for service tests
-    // To be removed for next major version
-    ,
-    className: "fade in"
-  }), children);
+    return (active && (_createElement(motion.div, Object.assign({}, remainingProps, { key: tabKey, initial: { x: 0, y: 0, opacity: 0 }, animate: { x: 0, y: 0, opacity: 1 }, exit: { x: 0, y: 0, opacity: 0 }, transition: { duration: 0.1 }, 
+        // TODO: added "fade in" for backwards compatibility for service tests
+        // To be removed for next major version
+        className: 'fade in' }), children)));
 };
 DataTab.defaultProps = {
-  active: false,
-  disableTransition: false,
-  className: ''
+    active: false,
+    disableTransition: false,
+    className: '',
 };
 DataTab.propTypes = {
-  // Props are injected from the wrapping DataTabs component
-  disableTransition: PropTypes.bool,
-  className: PropTypes.string,
-  active: PropTypes.bool,
-  tabKey: PropTypes.string.isRequired,
-  children: PropTypes.oneOfType([PropTypes.node, PropTypes.string])
+    // Props are injected from the wrapping DataTabs component
+    disableTransition: PropTypes.bool,
+    className: PropTypes.string,
+    active: PropTypes.bool,
+    tabKey: PropTypes.string.isRequired,
+    children: PropTypes.oneOfType([PropTypes.node, PropTypes.string]),
 };
-export default DataTab;
+export default DataTab;

package/components/dataTabs/DataTabs.d.ts

@@ -0,0 +1,56 @@
+export default DataTabs;
+declare function DataTabs(props: any): JSX.Element;
+declare namespace DataTabs {
+    namespace defaultProps {
+        const activeKey: string;
+        const bordered: boolean;
+        const children: never[];
+        const className: string;
+        const disableTransition: boolean;
+        const arrowClassName: string;
+        function onSelectTab(): void;
+        const tabActiveClassName: string;
+        const tabClassName: string;
+        const tabContentClassName: string;
+        const tabFirstChildClassName: string;
+        const tabHoverClassName: string;
+        const tabLastChildClassName: string;
+        const tabsWrapperClassName: string;
+        const vertical: boolean;
+    }
+    namespace propTypes {
+        const activeKey_1: PropTypes.Requireable<string>;
+        export { activeKey_1 as activeKey };
+        const bordered_1: PropTypes.Requireable<boolean>;
+        export { bordered_1 as bordered };
+        const children_1: PropTypes.Requireable<NonNullable<PropTypes.ReactNodeLike>>;
+        export { children_1 as children };
+        const className_1: PropTypes.Requireable<string>;
+        export { className_1 as className };
+        export const commonTabContent: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        const disableTransition_1: PropTypes.Requireable<boolean>;
+        export { disableTransition_1 as disableTransition };
+        const arrowClassName_1: PropTypes.Requireable<string>;
+        export { arrowClassName_1 as arrowClassName };
+        const onSelectTab_1: PropTypes.Validator<(...args: any[]) => any>;
+        export { onSelectTab_1 as onSelectTab };
+        const tabActiveClassName_1: PropTypes.Requireable<string>;
+        export { tabActiveClassName_1 as tabActiveClassName };
+        const tabClassName_1: PropTypes.Requireable<string>;
+        export { tabClassName_1 as tabClassName };
+        const tabContentClassName_1: PropTypes.Requireable<string>;
+        export { tabContentClassName_1 as tabContentClassName };
+        const tabFirstChildClassName_1: PropTypes.Requireable<string>;
+        export { tabFirstChildClassName_1 as tabFirstChildClassName };
+        const tabHoverClassName_1: PropTypes.Requireable<string>;
+        export { tabHoverClassName_1 as tabHoverClassName };
+        const tabLastChildClassName_1: PropTypes.Requireable<string>;
+        export { tabLastChildClassName_1 as tabLastChildClassName };
+        const tabsWrapperClassName_1: PropTypes.Requireable<string>;
+        export { tabsWrapperClassName_1 as tabsWrapperClassName };
+        export const variant: PropTypes.Requireable<string>;
+        const vertical_1: PropTypes.Requireable<boolean>;
+        export { vertical_1 as vertical };
+    }
+}
+import PropTypes from "prop-types";