/**
 * Bundle of @devexpress/dx-react-grid-bootstrap3
 * Generated: 2024-09-11
 * Version: 4.0.9
 * License: https://js.devexpress.com/Licensing
 */

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('prop-types'), require('@devexpress/dx-react-grid'), require('clsx'), require('@devexpress/dx-react-core'), require('react-bootstrap'), require('@devexpress/dx-grid-core')) :
  typeof define === 'function' && define.amd ? define(['exports', 'react', 'prop-types', '@devexpress/dx-react-grid', 'clsx', '@devexpress/dx-react-core', 'react-bootstrap', '@devexpress/dx-grid-core'], factory) :
  (global = global || self, factory((global.DevExpress = global.DevExpress || {}, global.DevExpress.DXReactGridBootstrap3 = {}), global.React, global.PropTypes, global.dxReactGrid, global.classNames, global.dxReactCore, global.ReactBootstrap, global.dxGridCore));
}(this, (function (exports, React, PropTypes, dxReactGrid, classNames, dxReactCore, reactBootstrap, dxGridCore) { 'use strict';

  if (typeof process === "undefined") { var process = { env: {} }; }

  var React__default = 'default' in React ? React['default'] : React;
  PropTypes = PropTypes && Object.prototype.hasOwnProperty.call(PropTypes, 'default') ? PropTypes['default'] : PropTypes;
  classNames = classNames && Object.prototype.hasOwnProperty.call(classNames, 'default') ? classNames['default'] : classNames;

  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;
  }

  function _objectSpread2(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;
  }

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  function _defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    return Constructor;
  }

  function _defineProperty(obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }

    return obj;
  }

  function _extends() {
    _extends = Object.assign || function (target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];

        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }

      return target;
    };

    return _extends.apply(this, arguments);
  }

  function _inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function");
    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        writable: true,
        configurable: true
      }
    });
    if (superClass) _setPrototypeOf(subClass, superClass);
  }

  function _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
      return o.__proto__ || Object.getPrototypeOf(o);
    };
    return _getPrototypeOf(o);
  }

  function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };

    return _setPrototypeOf(o, p);
  }

  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;
    }
  }

  function _objectWithoutPropertiesLoose(source, excluded) {
    if (source == null) return {};
    var target = {};
    var sourceKeys = Object.keys(source);
    var key, i;

    for (i = 0; i < sourceKeys.length; i++) {
      key = sourceKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      target[key] = source[key];
    }

    return target;
  }

  function _objectWithoutProperties(source, excluded) {
    if (source == null) return {};

    var target = _objectWithoutPropertiesLoose(source, excluded);

    var key, i;

    if (Object.getOwnPropertySymbols) {
      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);

      for (i = 0; i < sourceSymbolKeys.length; i++) {
        key = sourceSymbolKeys[i];
        if (excluded.indexOf(key) >= 0) continue;
        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
        target[key] = source[key];
      }
    }

    return target;
  }

  function _assertThisInitialized(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return self;
  }

  function _possibleConstructorReturn(self, call) {
    if (call && (typeof call === "object" || typeof call === "function")) {
      return call;
    }

    return _assertThisInitialized(self);
  }

  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 _slicedToArray(arr, i) {
    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
  }

  function _arrayWithHoles(arr) {
    if (Array.isArray(arr)) return arr;
  }

  function _iterableToArrayLimit(arr, i) {
    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];

    if (_i == null) return;
    var _arr = [];
    var _n = true;
    var _d = false;

    var _s, _e;

    try {
      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
        _arr.push(_s.value);

        if (i && _arr.length === i) break;
      }
    } catch (err) {
      _d = true;
      _e = err;
    } finally {
      try {
        if (!_n && _i["return"] != null) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  function _unsupportedIterableToArray(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
  }

  function _arrayLikeToArray(arr, len) {
    if (len == null || len > arr.length) len = arr.length;

    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];

    return arr2;
  }

  function _nonIterableRest() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

  /* globals document:true */
  var cache = {};
  var sandboxElement = null;

  var getBrowserStyles = function getBrowserStyles() {
    sandboxElement = sandboxElement || document.createElement('test');
    return sandboxElement.style;
  };

  var findOutValidPropertyValue = function findOutValidPropertyValue(property, value) {
    var prop = "".concat(property, ":");
    var style = getBrowserStyles();
    style.cssText = "".concat(prop + ['-webkit-', '-moz-', '-ms-', '-o-', ''].join("".concat(value, ";").concat(prop)) + value, ";");
    return style[property];
  };

  var getValidPropertyValue = function getValidPropertyValue(property, value) {
    var isServerRender = typeof document === 'undefined';

    if (isServerRender) {
      return undefined;
    }

    if (!(value in cache)) {
      cache[value] = findOutValidPropertyValue(property, value);
    }

    return cache[value];
  };

  var getStickyPosition = function getStickyPosition() {
    return getValidPropertyValue('position', 'sticky');
  };
  var getStickyStyles = function getStickyStyles(_ref) {
    var stickyPosition = _ref.stickyPosition,
        backgroundColor = _ref.backgroundColor;
    return {
      position: stickyPosition,
      backgroundColor: backgroundColor,
      zIndex: 500
    };
  };

  var _excluded = ["children", "className", "style", "rootRef"];
  var StyleContext = /*#__PURE__*/React.createContext();
  var Root = /*#__PURE__*/function (_React$PureComponent) {
    _inherits(Root, _React$PureComponent);

    var _super = _createSuper(Root);

    function Root(props) {
      var _this;

      _classCallCheck(this, Root);

      _this = _super.call(this, props);
      _this.state = {
        backgroundColor: undefined,
        borderColor: undefined,
        stickyPosition: undefined
      };
      return _this;
    }

    _createClass(Root, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        var rootRef = this.props.rootRef;

        var _window$getComputedSt = window.getComputedStyle(rootRef.current),
            backgroundColor = _window$getComputedSt.backgroundColor,
            borderColor = _window$getComputedSt.borderBottomColor;

        var stickyPosition = getStickyPosition();
        this.setState({
          backgroundColor: backgroundColor,
          borderColor: borderColor,
          stickyPosition: stickyPosition
        });
      }
    }, {
      key: "render",
      value: function render() {
        var _this$props = this.props,
            children = _this$props.children,
            className = _this$props.className,
            style = _this$props.style,
            rootRef = _this$props.rootRef,
            restProps = _objectWithoutProperties(_this$props, _excluded);

        var _this$state = this.state,
            backgroundColor = _this$state.backgroundColor,
            borderColor = _this$state.borderColor,
            stickyPosition = _this$state.stickyPosition;
        return /*#__PURE__*/React.createElement(StyleContext.Provider, {
          value: {
            backgroundColor: backgroundColor,
            borderColor: borderColor,
            stickyPosition: stickyPosition
          }
        }, /*#__PURE__*/React.createElement("div", _extends({
          ref: rootRef,
          className: classNames('panel panel-default', className),
          style: _objectSpread2({
            display: 'flex',
            flexDirection: 'column'
          }, style)
        }, restProps), children));
      }
    }]);

    return Root;
  }(React.PureComponent);
  process.env.NODE_ENV !== "production" ? Root.propTypes = {
    children: PropTypes.node,
    className: PropTypes.string,
    style: PropTypes.object,
    rootRef: PropTypes.object
  } : void 0;
  Root.defaultProps = {
    children: undefined,
    className: undefined,
    style: null,
    rootRef: undefined
  };

  var _excluded$1 = ["children"];
  var Grid = function Grid(_ref) {
    var children = _ref.children,
        props = _objectWithoutProperties(_ref, _excluded$1);

    return /*#__PURE__*/React.createElement(dxReactGrid.Grid, _extends({
      rootComponent: Root
    }, props), children);
  };
  Grid.Root = Root;
  process.env.NODE_ENV !== "production" ? Grid.propTypes = {
    children: PropTypes.node.isRequired
  } : void 0;

  var Popover = function Popover(_ref) {
    var children = _ref.children,
        style = _ref.style;
    return /*#__PURE__*/React.createElement("div", {
      className: "dropdown-menu",
      style: _objectSpread2({
        padding: 0,
        display: 'block',
        border: 'none'
      }, style)
    }, children);
  };
  process.env.NODE_ENV !== "production" ? Popover.propTypes = {
    children: PropTypes.node.isRequired,
    style: PropTypes.object
  } : void 0;
  Popover.defaultProps = {
    style: null
  };

  var _excluded$2 = ["visible", "target", "children", "onHide"];
  var Overlay = function Overlay(_ref) {
    var visible = _ref.visible,
        target = _ref.target,
        children = _ref.children,
        onHide = _ref.onHide,
        restProps = _objectWithoutProperties(_ref, _excluded$2);

    return /*#__PURE__*/React.createElement(reactBootstrap.Overlay, _extends({
      show: visible,
      target: target,
      container: target ? target.parentElement : undefined,
      onHide: onHide,
      placement: "bottom",
      rootClose: true,
      animation: false
    }, restProps), /*#__PURE__*/React.createElement(Popover, null, children));
  };
  process.env.NODE_ENV !== "production" ? Overlay.propTypes = {
    children: PropTypes.node.isRequired,
    onHide: PropTypes.func.isRequired,
    visible: PropTypes.bool,
    target: PropTypes.oneOfType([PropTypes.object, PropTypes.func])
  } : void 0;
  Overlay.defaultProps = {
    visible: false,
    target: null
  };

  var _excluded$3 = ["children", "className", "style"];
  var Container = function Container(_ref) {
    var children = _ref.children,
        className = _ref.className,
        style = _ref.style,
        restProps = _objectWithoutProperties(_ref, _excluded$3);

    return /*#__PURE__*/React.createElement("div", _extends({
      className: classNames('list-group', className),
      style: _objectSpread2({
        marginBottom: 0
      }, style)
    }, restProps), children);
  };
  process.env.NODE_ENV !== "production" ? Container.propTypes = {
    children: PropTypes.node.isRequired,
    className: PropTypes.string,
    style: PropTypes.object
  } : void 0;
  Container.defaultProps = {
    className: undefined,
    style: undefined
  };

  var _excluded$4 = ["item", "onToggle", "className", "style", "disabled"];
  var Item = function Item(_ref) {
    var _ref$item = _ref.item,
        column = _ref$item.column,
        hidden = _ref$item.hidden,
        onToggle = _ref.onToggle,
        className = _ref.className,
        style = _ref.style,
        disabled = _ref.disabled,
        restProps = _objectWithoutProperties(_ref, _excluded$4);

    return /*#__PURE__*/React.createElement("button", _extends({
      className: classNames('list-group-item', className),
      style: _objectSpread2({
        outline: 'none'
      }, style),
      type: "button",
      disabled: disabled,
      onClick: onToggle
    }, restProps), /*#__PURE__*/React.createElement("input", {
      type: "checkbox",
      style: {
        cursor: disabled ? 'default' : 'pointer'
      },
      tabIndex: -1,
      checked: !hidden,
      disabled: disabled,
      onChange: onToggle,
      onClick: function onClick(e) {
        return e.stopPropagation();
      }
    }), "\xA0", column.title || column.name);
  };
  process.env.NODE_ENV !== "production" ? Item.propTypes = {
    item: PropTypes.shape({
      column: PropTypes.shape({
        name: PropTypes.string,
        title: PropTypes.string
      }),
      hidden: PropTypes.bool
    }).isRequired,
    disabled: PropTypes.bool,
    onToggle: PropTypes.func,
    className: PropTypes.string,
    style: PropTypes.object
  } : void 0;
  Item.defaultProps = {
    onToggle: function onToggle() {},
    disabled: false,
    className: undefined,
    style: null
  };

  var _excluded$5 = ["onToggle", "className", "getMessage", "buttonRef", "active"];
  var ToggleButton = function ToggleButton(_ref) {
    var onToggle = _ref.onToggle,
        className = _ref.className,
        getMessage = _ref.getMessage,
        buttonRef = _ref.buttonRef,
        active = _ref.active,
        restProps = _objectWithoutProperties(_ref, _excluded$5);

    return /*#__PURE__*/React.createElement("button", _extends({
      type: "button",
      className: classNames('btn btn-link', className),
      onClick: onToggle,
      ref: buttonRef
    }, restProps), /*#__PURE__*/React.createElement("i", {
      className: "glyphicon glyphicon-eye-close"
    }));
  };
  process.env.NODE_ENV !== "production" ? ToggleButton.propTypes = {
    onToggle: PropTypes.func.isRequired,
    getMessage: PropTypes.func.isRequired,
    buttonRef: PropTypes.func.isRequired,
    className: PropTypes.string,
    active: PropTypes.bool
  } : void 0;
  ToggleButton.defaultProps = {
    className: undefined,
    active: false
  };

  var ColumnChooser = dxReactCore.withComponents({
    Container: Container,
    Item: Item,
    Overlay: Overlay,
    ToggleButton: ToggleButton
  })(dxReactGrid.ColumnChooser);

  var _excluded$6 = ["clientOffset", "style", "className", "children"],
      _excluded2 = ["column", "className"];
  var Container$1 = function Container(_ref) {
    var clientOffset = _ref.clientOffset,
        style = _ref.style,
        className = _ref.className,
        children = _ref.children,
        restProps = _objectWithoutProperties(_ref, _excluded$6);

    return /*#__PURE__*/React.createElement("ul", _extends({
      className: classNames('list-group', className),
      style: _objectSpread2({
        cursor: 'move',
        position: 'fixed',
        zIndex: 1000,
        left: 0,
        top: 0,
        display: 'inline-block',
        transform: "translate(calc(".concat(clientOffset.x, "px - 50%), calc(").concat(clientOffset.y, "px - 50%))"),
        msTransform: "translateX(".concat(clientOffset.x, "px) translateX(-50%) translateY(").concat(clientOffset.y, "px) translateY(-50%)")
      }, style)
    }, restProps), children);
  };
  process.env.NODE_ENV !== "production" ? Container$1.propTypes = {
    clientOffset: PropTypes.shape({
      x: PropTypes.number.isRequired,
      y: PropTypes.number.isRequired
    }).isRequired,
    style: PropTypes.object,
    className: PropTypes.string,
    children: PropTypes.node
  } : void 0;
  Container$1.defaultProps = {
    style: null,
    className: undefined,
    children: undefined
  };
  var Column = /*#__PURE__*/React.memo(function (_ref2) {
    var column = _ref2.column,
        className = _ref2.className,
        restProps = _objectWithoutProperties(_ref2, _excluded2);

    return /*#__PURE__*/React.createElement("li", _extends({
      className: classNames('list-group-item', className)
    }, restProps), column.title);
  });
  Column.propTypes = {
    column: PropTypes.object.isRequired,
    className: PropTypes.string
  };
  Column.defaultProps = {
    className: undefined
  };

  var DragDropProvider = dxReactCore.withComponents({
    Container: Container$1,
    Column: Column
  })(dxReactGrid.DragDropProvider);

  var PageSizeSelector = function PageSizeSelector(_ref) {
    var pageSize = _ref.pageSize,
        onPageSizeChange = _ref.onPageSizeChange,
        pageSizes = _ref.pageSizes,
        getMessage = _ref.getMessage;
    var showAll = getMessage('showAll');
    return /*#__PURE__*/React.createElement("div", {
      style: {
        display: 'inline-block'
      }
    }, /*#__PURE__*/React.createElement("select", {
      className: "form-control visible-xs-inline-block",
      style: {
        width: 'auto'
      },
      value: pageSize,
      onChange: function onChange(e) {
        return onPageSizeChange(parseInt(e.target.value, 10));
      }
    }, pageSizes.map(function (val) {
      return /*#__PURE__*/React.createElement("option", {
        key: val,
        value: val
      }, val || showAll);
    })), /*#__PURE__*/React.createElement("ul", {
      className: "pagination hidden-xs",
      style: {
        margin: 0,
        verticalAlign: 'bottom'
      }
    }, pageSizes.map(function (item) {
      return /*#__PURE__*/React.createElement("li", {
        key: item,
        className: item === pageSize ? 'active' : ''
      }, /*#__PURE__*/React.createElement("a", {
        href: "#",
        onClick: function onClick(e) {
          e.preventDefault();
          onPageSizeChange(item);
        }
      }, item || showAll));
    })));
  };
  process.env.NODE_ENV !== "production" ? PageSizeSelector.propTypes = {
    pageSize: PropTypes.number.isRequired,
    onPageSizeChange: PropTypes.func.isRequired,
    pageSizes: PropTypes.arrayOf(PropTypes.number).isRequired,
    getMessage: PropTypes.func.isRequired
  } : void 0;

  var renderPageButtons = function renderPageButtons(currentPage, totalPageCount, onCurrentPageChange) {
    var pageButtons = [];
    var maxButtonCount = 3;
    var startPage = 1;
    var endPage = totalPageCount || 1; // NOTE: take into account last button and ellipsis (T1004797)

    if (maxButtonCount < totalPageCount - 2) {
      startPage = dxGridCore.calculateStartPage(currentPage + 1, maxButtonCount, totalPageCount);
      endPage = startPage + maxButtonCount - 1;
    }

    if (startPage > 1) {
      pageButtons.push( /*#__PURE__*/React.createElement(reactBootstrap.Pagination.Item, {
        key: 1,
        onClick: function onClick() {
          return onCurrentPageChange(0);
        }
      }, 1));

      if (startPage > 2) {
        pageButtons.push( /*#__PURE__*/React.createElement(reactBootstrap.Pagination.Ellipsis, {
          key: "ellipsisStart",
          disabled: true
        }));
      }
    }

    var _loop = function _loop(page) {
      pageButtons.push( /*#__PURE__*/React.createElement(reactBootstrap.Pagination.Item, {
        key: page,
        onClick: function onClick() {
          return onCurrentPageChange(page - 1);
        },
        active: page === currentPage + 1,
        disabled: startPage === endPage
      }, page));
    };

    for (var page = startPage; page <= endPage; page += 1) {
      _loop(page);
    }

    if (endPage < totalPageCount) {
      if (endPage < totalPageCount - 1) {
        pageButtons.push( /*#__PURE__*/React.createElement(reactBootstrap.Pagination.Ellipsis, {
          key: "ellipsisEnd",
          disabled: true
        }));
      }

      pageButtons.push( /*#__PURE__*/React.createElement(reactBootstrap.Pagination.Item, {
        key: totalPageCount,
        onClick: function onClick() {
          return onCurrentPageChange(totalPageCount - 1);
        }
      }, totalPageCount));
    }

    return pageButtons;
  };

  var Pagination = function Pagination(_ref) {
    var totalPages = _ref.totalPages,
        currentPage = _ref.currentPage,
        onCurrentPageChange = _ref.onCurrentPageChange,
        totalCount = _ref.totalCount,
        pageSize = _ref.pageSize,
        getMessage = _ref.getMessage;
    var from = dxGridCore.firstRowOnPage(currentPage, pageSize, totalCount);
    var to = dxGridCore.lastRowOnPage(currentPage, pageSize, totalCount);
    return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(reactBootstrap.Pagination, {
      style: {
        margin: 0,
        verticalAlign: 'bottom'
      },
      className: "pull-right hidden-xs"
    }, /*#__PURE__*/React.createElement(reactBootstrap.Pagination.Item, {
      disabled: currentPage === 0,
      onClick: function onClick() {
        return onCurrentPageChange(currentPage - 1);
      },
      "aria-label": "Previous"
    }, "\xAB"), renderPageButtons(currentPage, totalPages, onCurrentPageChange), /*#__PURE__*/React.createElement(reactBootstrap.Pagination.Item, {
      disabled: currentPage === totalPages - 1 || totalCount === 0,
      onClick: function onClick() {
        return onCurrentPageChange(currentPage + 1);
      },
      "aria-label": "Next"
    }, "\xBB")), /*#__PURE__*/React.createElement(reactBootstrap.Pager, {
      className: "pull-right visible-xs",
      style: {
        margin: 0
      }
    }, /*#__PURE__*/React.createElement(reactBootstrap.Pager.Item, {
      disabled: currentPage === 0,
      onClick: function onClick() {
        return onCurrentPageChange(currentPage - 1);
      },
      "aria-label": "Previous"
    }, "\xAB"), "\xA0", /*#__PURE__*/React.createElement(reactBootstrap.Pager.Item, {
      disabled: currentPage === totalPages - 1 || totalCount === 0,
      onClick: function onClick() {
        return onCurrentPageChange(currentPage + 1);
      },
      "aria-label": "Next"
    }, "\xBB")), /*#__PURE__*/React.createElement("span", {
      className: "pull-right visible-xs",
      style: {
        marginRight: '20px'
      }
    }, /*#__PURE__*/React.createElement("span", {
      style: {
        display: 'inline-block',
        verticalAlign: 'middle',
        lineHeight: '32px'
      }
    }, getMessage('info', {
      from: from,
      to: to,
      count: totalCount
    }))));
  };
  process.env.NODE_ENV !== "production" ? Pagination.propTypes = {
    totalPages: PropTypes.number.isRequired,
    currentPage: PropTypes.number.isRequired,
    onCurrentPageChange: PropTypes.func.isRequired,
    totalCount: PropTypes.number.isRequired,
    pageSize: PropTypes.number.isRequired,
    getMessage: PropTypes.func.isRequired
  } : void 0;

  var _excluded$7 = ["currentPage", "onCurrentPageChange", "totalPages", "pageSize", "onPageSizeChange", "pageSizes", "totalCount", "getMessage", "className", "style", "forwardedRef"];

  var PagerBase = function PagerBase(_ref) {
    var currentPage = _ref.currentPage,
        _onCurrentPageChange = _ref.onCurrentPageChange,
        totalPages = _ref.totalPages,
        pageSize = _ref.pageSize,
        onPageSizeChange = _ref.onPageSizeChange,
        pageSizes = _ref.pageSizes,
        totalCount = _ref.totalCount,
        getMessage = _ref.getMessage,
        className = _ref.className,
        style = _ref.style,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$7);

    return /*#__PURE__*/React.createElement("div", _extends({
      className: classNames('clearfix panel-footer', className),
      ref: forwardedRef,
      style: _objectSpread2({
        flex: 'none'
      }, style)
    }, restProps), !!pageSizes.length && /*#__PURE__*/React.createElement(PageSizeSelector, {
      pageSize: pageSize,
      onPageSizeChange: onPageSizeChange,
      pageSizes: pageSizes,
      getMessage: getMessage
    }), /*#__PURE__*/React.createElement(Pagination, {
      totalPages: totalPages,
      totalCount: totalCount,
      currentPage: currentPage,
      onCurrentPageChange: function onCurrentPageChange(page) {
        return _onCurrentPageChange(page);
      },
      pageSize: pageSize,
      getMessage: getMessage
    }));
  };

  process.env.NODE_ENV !== "production" ? PagerBase.propTypes = {
    currentPage: PropTypes.number.isRequired,
    onCurrentPageChange: PropTypes.func.isRequired,
    totalPages: PropTypes.number.isRequired,
    pageSize: PropTypes.number.isRequired,
    onPageSizeChange: PropTypes.func.isRequired,
    pageSizes: PropTypes.arrayOf(PropTypes.number).isRequired,
    totalCount: PropTypes.number.isRequired,
    getMessage: PropTypes.func.isRequired,
    className: PropTypes.string,
    style: PropTypes.object,
    forwardedRef: PropTypes.func
  } : void 0;
  PagerBase.defaultProps = {
    className: undefined,
    style: null,
    forwardedRef: undefined
  };
  var Pager = dxReactGrid.withKeyboardNavigation('paging', 'none')(PagerBase);

  var PagingPanel = dxReactCore.withComponents({
    Container: Pager
  })(dxReactGrid.PagingPanel);

  var _excluded$8 = ["children", "style", "forwardedRef"];
  var GroupPanelContainer = function GroupPanelContainer(_ref) {
    var children = _ref.children,
        style = _ref.style,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$8);

    return /*#__PURE__*/React.createElement("div", _extends({
      ref: forwardedRef,
      style: _objectSpread2({
        width: '100%',
        marginTop: '5px'
      }, style)
    }, restProps), children);
  };
  process.env.NODE_ENV !== "production" ? GroupPanelContainer.propTypes = {
    children: PropTypes.node,
    style: PropTypes.object,
    forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
  } : void 0;
  GroupPanelContainer.defaultProps = {
    children: undefined,
    style: null,
    forwardedRef: undefined
  };

  var SortingIndicator = /*#__PURE__*/React.memo(function (_ref) {
    var direction = _ref.direction,
        style = _ref.style;
    return /*#__PURE__*/React.createElement("i", {
      className: "glyphicon glyphicon-arrow-".concat(direction === 'desc' ? 'down' : 'up'),
      style: _objectSpread2({
        top: '0',
        fontSize: '9px'
      }, style)
    });
  });
  SortingIndicator.propTypes = {
    direction: PropTypes.oneOf(['asc', 'desc']),
    style: PropTypes.object
  };
  SortingIndicator.defaultProps = {
    direction: null,
    style: null
  };

  var _excluded$9 = ["item", "onGroup", "showGroupingControls", "groupingEnabled", "showSortingControls", "sortingDirection", "onSort", "sortingEnabled", "className", "style", "forwardedRef"];
  var ENTER_KEY_CODE = 13;
  var SPACE_KEY_CODE = 32;

  var isActionKey = function isActionKey(keyCode) {
    return keyCode === ENTER_KEY_CODE || keyCode === SPACE_KEY_CODE;
  };

  var GroupPanelItem = function GroupPanelItem(_ref) {
    var _ref$item = _ref.item,
        column = _ref$item.column,
        draft = _ref$item.draft,
        onGroup = _ref.onGroup,
        showGroupingControls = _ref.showGroupingControls,
        groupingEnabled = _ref.groupingEnabled,
        showSortingControls = _ref.showSortingControls,
        sortingDirection = _ref.sortingDirection,
        onSort = _ref.onSort,
        sortingEnabled = _ref.sortingEnabled,
        className = _ref.className,
        style = _ref.style,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$9);

    var handleSortingChange = function handleSortingChange(e) {
      var isActionKeyDown = isActionKey(e.keyCode);
      var isMouseClick = e.keyCode === undefined;
      if (!showSortingControls || !sortingEnabled || !(isActionKeyDown || isMouseClick)) return;
      var cancelSortingRelatedKey = e.metaKey || e.ctrlKey;
      var direction = (isMouseClick || isActionKeyDown) && cancelSortingRelatedKey ? null : undefined;
      e.preventDefault();
      onSort({
        direction: direction,
        keepOther: cancelSortingRelatedKey
      });
    };

    var handleUngroup = function handleUngroup(e) {
      if (!groupingEnabled) return;
      var isActionKeyDown = isActionKey(e.keyCode);
      var isMouseClick = e.keyCode === undefined;
      if (!isActionKeyDown && !isMouseClick) return;
      onGroup();
    };

    var getButtonClasses = function getButtonClasses(isDisabled) {
      return classNames({
        btn: true,
        'btn-default': true,
        disabled: isDisabled
      });
    };

    return /*#__PURE__*/React.createElement("div", _extends({
      ref: forwardedRef,
      className: classNames('btn-group', className),
      style: _objectSpread2(_objectSpread2({
        marginRight: '5px',
        marginBottom: '5px'
      }, draft ? {
        opacity: 0.3
      } : null), style)
    }, restProps), /*#__PURE__*/React.createElement("span", _extends({
      className: getButtonClasses(!sortingEnabled && (showSortingControls || !groupingEnabled)),
      onClick: handleSortingChange,
      onKeyDown: handleSortingChange
    }, sortingEnabled ? {
      tabIndex: 0
    } : null), column.title || column.name, showSortingControls && sortingDirection && /*#__PURE__*/React.createElement("span", null, "\xA0", /*#__PURE__*/React.createElement(SortingIndicator, {
      direction: sortingDirection
    }))), showGroupingControls && /*#__PURE__*/React.createElement("span", {
      className: getButtonClasses(!groupingEnabled),
      onClick: handleUngroup
    }, "\xA0", /*#__PURE__*/React.createElement("i", {
      className: "glyphicon glyphicon-remove",
      style: {
        top: 0,
        fontSize: '9px',
        marginLeft: '-5px'
      }
    })));
  };
  process.env.NODE_ENV !== "production" ? GroupPanelItem.propTypes = {
    item: PropTypes.shape({
      column: PropTypes.shape({
        title: PropTypes.string,
        name: PropTypes.string
      }).isRequired,
      draft: PropTypes.bool
    }).isRequired,
    showSortingControls: PropTypes.bool,
    sortingDirection: PropTypes.oneOf(['asc', 'desc', null]),
    className: PropTypes.string,
    onSort: PropTypes.func,
    onGroup: PropTypes.func,
    groupingEnabled: PropTypes.bool,
    showGroupingControls: PropTypes.bool,
    sortingEnabled: PropTypes.bool,
    style: PropTypes.object,
    forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
  } : void 0;
  GroupPanelItem.defaultProps = {
    showSortingControls: false,
    sortingDirection: undefined,
    className: undefined,
    onSort: undefined,
    onGroup: undefined,
    showGroupingControls: false,
    sortingEnabled: false,
    groupingEnabled: false,
    style: null,
    forwardedRef: undefined
  };

  var _excluded$a = ["getMessage", "style", "forwardedRef"];
  var GroupPanelEmptyMessage = function GroupPanelEmptyMessage(_ref) {
    var getMessage = _ref.getMessage,
        style = _ref.style,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$a);

    return /*#__PURE__*/React.createElement("div", _extends({
      ref: forwardedRef,
      style: _objectSpread2({
        padding: '7px 0'
      }, style)
    }, restProps), getMessage('groupByColumn'));
  };
  process.env.NODE_ENV !== "production" ? GroupPanelEmptyMessage.propTypes = {
    getMessage: PropTypes.func.isRequired,
    style: PropTypes.object,
    forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
  } : void 0;
  GroupPanelEmptyMessage.defaultProps = {
    style: null,
    forwardedRef: undefined
  };

  var GroupingPanel = dxReactCore.withComponents({
    Container: GroupPanelContainer,
    Item: GroupPanelItem,
    EmptyMessage: GroupPanelEmptyMessage
  })(dxReactGrid.GroupingPanel);

  var _excluded$b = ["visible", "expanded", "onToggle", "className", "style"];
  var ENTER_KEY_CODE$1 = 13;
  var SPACE_KEY_CODE$1 = 32;

  var handleMouseDown = function handleMouseDown(e) {
    e.target.style.outline = 'none';
  };

  var handleBlur = function handleBlur(e) {
    e.target.style.outline = '';
  };

  var ExpandButton = function ExpandButton(_ref) {
    var visible = _ref.visible,
        expanded = _ref.expanded,
        onToggle = _ref.onToggle,
        className = _ref.className,
        style = _ref.style,
        restProps = _objectWithoutProperties(_ref, _excluded$b);

    var fireToggle = function fireToggle() {
      if (!visible) return;
      onToggle(!expanded);
    };

    var handleClick = function handleClick(e) {
      e.stopPropagation();
      fireToggle();
    };

    var handleKeyDown = function handleKeyDown(e) {
      if (e.keyCode === ENTER_KEY_CODE$1 || e.keyCode === SPACE_KEY_CODE$1) {
        e.preventDefault();
        fireToggle();
      }
    };

    return /*#__PURE__*/React.createElement("i", _extends({
      className: classNames({
        glyphicon: true,
        'glyphicon-triangle-bottom': expanded,
        'glyphicon-triangle-right': !expanded
      }, className),
      style: _objectSpread2({
        cursor: visible ? 'pointer' : 'default',
        display: 'inline-block',
        fontSize: '9px',
        top: '0',
        padding: '8px',
        marginTop: '-8px',
        marginBottom: '-8px',
        opacity: visible ? 1 : 0
      }, style),
      tabIndex: visible ? 0 : undefined // eslint-disable-line jsx-a11y/no-noninteractive-tabindex
      ,
      onKeyDown: handleKeyDown,
      onMouseDown: handleMouseDown,
      onBlur: handleBlur,
      onClick: handleClick
    }, restProps));
  };
  process.env.NODE_ENV !== "production" ? ExpandButton.propTypes = {
    visible: PropTypes.bool,
    expanded: PropTypes.bool,
    onToggle: PropTypes.func,
    className: PropTypes.string,
    style: PropTypes.object
  } : void 0;
  ExpandButton.defaultProps = {
    visible: true,
    expanded: false,
    onToggle: function onToggle() {},
    className: undefined,
    style: null
  };

  var _excluded$c = ["expanded", "onToggle", "tableColumn", "tableRow", "row", "style", "forwardedRef"];
  var TableDetailToggleCell = function TableDetailToggleCell(_ref) {
    var expanded = _ref.expanded,
        onToggle = _ref.onToggle,
        tableColumn = _ref.tableColumn,
        tableRow = _ref.tableRow,
        row = _ref.row,
        style = _ref.style,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$c);

    return /*#__PURE__*/React.createElement("td", _extends({
      style: _objectSpread2({
        cursor: 'pointer',
        verticalAlign: 'middle',
        textAlign: 'center'
      }, style),
      ref: forwardedRef
    }, restProps), /*#__PURE__*/React.createElement(ExpandButton, {
      expanded: expanded,
      onToggle: onToggle
    }));
  };
  process.env.NODE_ENV !== "production" ? TableDetailToggleCell.propTypes = {
    style: PropTypes.object,
    expanded: PropTypes.bool,
    onToggle: PropTypes.func,
    tableColumn: PropTypes.object,
    tableRow: PropTypes.object,
    row: PropTypes.any,
    forwardedRef: PropTypes.func
  } : void 0;
  TableDetailToggleCell.defaultProps = {
    style: null,
    expanded: false,
    onToggle: function onToggle() {},
    tableColumn: undefined,
    tableRow: undefined,
    row: undefined,
    forwardedRef: undefined
  };

  var _excluded$d = ["colSpan", "children", "className", "tableColumn", "tableRow", "row", "forwardedRef"];
  var TableDetailCell = function TableDetailCell(_ref) {
    var colSpan = _ref.colSpan,
        children = _ref.children,
        className = _ref.className,
        tableColumn = _ref.tableColumn,
        tableRow = _ref.tableRow,
        row = _ref.row,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$d);

    return /*#__PURE__*/React.createElement("td", _extends({
      colSpan: colSpan,
      ref: forwardedRef,
      className: classNames('active', className)
    }, restProps), children);
  };
  process.env.NODE_ENV !== "production" ? TableDetailCell.propTypes = {
    colSpan: PropTypes.number,
    children: PropTypes.node,
    className: PropTypes.string,
    tableColumn: PropTypes.object,
    tableRow: PropTypes.object,
    row: PropTypes.any,
    forwardedRef: PropTypes.func
  } : void 0;
  TableDetailCell.defaultProps = {
    colSpan: 1,
    className: undefined,
    tableColumn: undefined,
    tableRow: undefined,
    row: undefined,
    children: undefined,
    forwardedRef: undefined
  };

  var _excluded$e = ["children", "row", "tableRow", "forwardedRef"];
  var TableRow = function TableRow(_ref) {
    var children = _ref.children,
        row = _ref.row,
        tableRow = _ref.tableRow,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$e);

    return /*#__PURE__*/React.createElement("tr", _extends({
      ref: forwardedRef
    }, restProps), children);
  };
  process.env.NODE_ENV !== "production" ? TableRow.propTypes = {
    children: PropTypes.node,
    row: PropTypes.any,
    tableRow: PropTypes.object,
    forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
  } : void 0;
  TableRow.defaultProps = {
    children: undefined,
    row: undefined,
    tableRow: undefined,
    forwardedRef: undefined
  };

  var TableRowDetailWithWidth = function TableRowDetailWithWidth(props) {
    return /*#__PURE__*/React.createElement(dxReactGrid.TableRowDetail, _extends({
      toggleColumnWidth: 33
    }, props));
  };

  TableRowDetailWithWidth.components = dxReactGrid.TableRowDetail.components;
  var TableRowDetail = dxReactCore.withComponents({
    Row: TableRow,
    Cell: TableDetailCell,
    ToggleCell: TableDetailToggleCell
  })(TableRowDetailWithWidth);
  TableRowDetail.COLUMN_TYPE = dxReactGrid.TableRowDetail.COLUMN_TYPE;
  TableRowDetail.ROW_TYPE = dxReactGrid.TableRowDetail.ROW_TYPE;

  var _excluded$f = ["row", "column", "tableRow", "tableColumn", "onToggle", "children", "style", "forwardedRef"];
  var Cell = function Cell(_ref) {
    var row = _ref.row,
        column = _ref.column,
        tableRow = _ref.tableRow,
        tableColumn = _ref.tableColumn,
        onToggle = _ref.onToggle,
        children = _ref.children,
        style = _ref.style,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$f);

    var handleClick = function handleClick() {
      return onToggle();
    };

    return /*#__PURE__*/React.createElement("td", _extends({
      style: _objectSpread2({
        cursor: 'pointer',
        // TOOD: extract to constant
        whiteSpace: tableColumn && tableColumn.wordWrapEnabled ? 'normal' : 'nowrap'
      }, style),
      ref: forwardedRef,
      onClick: handleClick
    }, restProps), children);
  };
  process.env.NODE_ENV !== "production" ? Cell.propTypes = {
    row: PropTypes.any,
    column: PropTypes.object,
    colSpan: PropTypes.number,
    onToggle: PropTypes.func,
    children: PropTypes.oneOfType([PropTypes.node, PropTypes.arrayOf(PropTypes.node)]),
    tableRow: PropTypes.object,
    tableColumn: PropTypes.object,
    style: PropTypes.object,
    forwardedRef: PropTypes.func
  } : void 0;
  Cell.defaultProps = {
    row: {},
    column: {},
    colSpan: 1,
    onToggle: function onToggle() {},
    children: undefined,
    tableRow: undefined,
    tableColumn: undefined,
    style: null,
    forwardedRef: undefined
  };

  var _excluded$g = ["row", "column", "expanded", "onToggle", "children", "tableRow", "tableColumn", "iconComponent", "contentComponent", "inlineSummaryComponent", "inlineSummaryItemComponent", "inlineSummaries", "getMessage", "containerComponent", "side", "position"];
  var CaptionCell = function CaptionCell(_ref) {
    var row = _ref.row,
        column = _ref.column,
        expanded = _ref.expanded,
        onToggle = _ref.onToggle,
        children = _ref.children,
        tableRow = _ref.tableRow,
        tableColumn = _ref.tableColumn,
        Icon = _ref.iconComponent,
        Content = _ref.contentComponent,
        InlineSummary = _ref.inlineSummaryComponent,
        InlineSummaryItem = _ref.inlineSummaryItemComponent,
        inlineSummaries = _ref.inlineSummaries,
        getMessage = _ref.getMessage,
        Container = _ref.containerComponent,
        side = _ref.side,
        position = _ref.position,
        restProps = _objectWithoutProperties(_ref, _excluded$g);

    return /*#__PURE__*/React.createElement(Cell, _extends({
      onToggle: onToggle
    }, restProps), /*#__PURE__*/React.createElement(Container, {
      side: side,
      position: position
    }, /*#__PURE__*/React.createElement(Icon, {
      expanded: expanded,
      onToggle: onToggle,
      style: {
        marginRight: '8px'
      }
    }), /*#__PURE__*/React.createElement(Content, {
      column: column,
      row: row
    }, children), inlineSummaries.length ? /*#__PURE__*/React.createElement(InlineSummary, {
      inlineSummaries: inlineSummaries,
      getMessage: getMessage,
      inlineSummaryItemComponent: InlineSummaryItem
    }) : null));
  };
  process.env.NODE_ENV !== "production" ? CaptionCell.propTypes = {
    containerComponent: PropTypes.func.isRequired,
    contentComponent: PropTypes.func.isRequired,
    iconComponent: PropTypes.func.isRequired,
    inlineSummaryComponent: PropTypes.func.isRequired,
    inlineSummaryItemComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).isRequired,
    colSpan: PropTypes.number,
    row: PropTypes.any,
    column: PropTypes.object,
    expanded: PropTypes.bool,
    onToggle: PropTypes.func,
    getMessage: PropTypes.func.isRequired,
    children: PropTypes.oneOfType([PropTypes.node, PropTypes.arrayOf(PropTypes.node)]),
    tableRow: PropTypes.object,
    tableColumn: PropTypes.object,
    inlineSummaries: PropTypes.array,
    side: PropTypes.string,
    position: PropTypes.string
  } : void 0;
  CaptionCell.defaultProps = {
    colSpan: 1,
    row: {},
    column: {},
    expanded: false,
    inlineSummaries: [],
    onToggle: function onToggle() {},
    children: undefined,
    tableRow: undefined,
    tableColumn: undefined,
    side: 'left',
    position: ''
  };

  var _excluded$h = ["column", "row", "children"];
  var Content = function Content(_ref) {
    var column = _ref.column,
        row = _ref.row,
        children = _ref.children,
        restProps = _objectWithoutProperties(_ref, _excluded$h);

    return /*#__PURE__*/React.createElement("span", restProps, /*#__PURE__*/React.createElement("strong", null, column.title || column.name, ":", ' '), children || String(row.value));
  };
  process.env.NODE_ENV !== "production" ? Content.propTypes = {
    row: PropTypes.any,
    column: PropTypes.object,
    children: PropTypes.node
  } : void 0;
  Content.defaultProps = {
    row: {},
    column: {},
    children: undefined
  };

  var _excluded$i = ["children", "side", "position", "style"];
  var Container$2 = function Container(_ref) {
    var _objectSpread2$1;

    var children = _ref.children,
        side = _ref.side,
        position = _ref.position,
        style = _ref.style,
        restProps = _objectWithoutProperties(_ref, _excluded$i);

    var _useContext = React.useContext(StyleContext),
        backgroundColor = _useContext.backgroundColor,
        stickyPosition = _useContext.stickyPosition;

    return /*#__PURE__*/React__default.createElement("div", _extends({
      style: _objectSpread2((_objectSpread2$1 = {
        position: stickyPosition
      }, _defineProperty(_objectSpread2$1, side, position), _defineProperty(_objectSpread2$1, "backgroundColor", backgroundColor), _defineProperty(_objectSpread2$1, "backgroundClip", 'padding-box'), _defineProperty(_objectSpread2$1, "zIndex", 300), _defineProperty(_objectSpread2$1, "display", 'inline-block'), _defineProperty(_objectSpread2$1, "overflow", 'hidden'), _defineProperty(_objectSpread2$1, "textOverflow", 'ellipsis'), _defineProperty(_objectSpread2$1, "maxWidth", '100%'), _objectSpread2$1), style)
    }, restProps), children);
  };
  process.env.NODE_ENV !== "production" ? Container$2.propTypes = {
    children: PropTypes.node,
    side: PropTypes.string,
    position: PropTypes.string,
    style: PropTypes.object
  } : void 0;
  Container$2.defaultProps = {
    children: undefined,
    style: null,
    side: 'left',
    position: ''
  };

  var _excluded$j = ["tableRow", "tableColumn", "row", "column", "style", "position", "side", "forwardedRef"];
  var IndentCell = function IndentCell(_ref) {
    var _objectSpread2$1;

    var tableRow = _ref.tableRow,
        tableColumn = _ref.tableColumn,
        row = _ref.row,
        column = _ref.column,
        style = _ref.style,
        position = _ref.position,
        side = _ref.side,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$j);

    var _useContext = React.useContext(StyleContext),
        backgroundColor = _useContext.backgroundColor,
        stickyPosition = _useContext.stickyPosition;

    return /*#__PURE__*/React__default.createElement("td", _extends({
      ref: forwardedRef,
      style: _objectSpread2((_objectSpread2$1 = {}, _defineProperty(_objectSpread2$1, side, position), _defineProperty(_objectSpread2$1, "backgroundColor", backgroundColor), _defineProperty(_objectSpread2$1, "backgroundClip", 'padding-box'), _defineProperty(_objectSpread2$1, "position", stickyPosition), _defineProperty(_objectSpread2$1, "zIndex", 300), _objectSpread2$1), style)
    }, restProps));
  };
  process.env.NODE_ENV !== "production" ? IndentCell.propTypes = {
    tableRow: PropTypes.object,
    tableColumn: PropTypes.object,
    row: PropTypes.any,
    column: PropTypes.object,
    style: PropTypes.object,
    side: PropTypes.string,
    position: PropTypes.number,
    forwardedRef: PropTypes.func
  } : void 0;
  IndentCell.defaultProps = {
    tableRow: undefined,
    tableColumn: undefined,
    row: {},
    column: {},
    style: null,
    side: 'left',
    position: undefined,
    forwardedRef: undefined
  };

  var _excluded$k = ["style"];
  var Row = function Row(_ref) {
    var style = _ref.style,
        props = _objectWithoutProperties(_ref, _excluded$k);

    return /*#__PURE__*/React.createElement(TableRow, _extends({}, props, {
      style: _objectSpread2({
        cursor: 'pointer'
      }, style)
    }));
  };
  process.env.NODE_ENV !== "production" ? Row.propTypes = {
    style: PropTypes.object
  } : void 0;
  Row.defaultProps = {
    style: null
  };

  var _excluded$l = ["inlineSummaries", "getMessage", "inlineSummaryItemComponent", "style"];
  var InlineSummary = function InlineSummary(_ref) {
    var inlineSummaries = _ref.inlineSummaries,
        getMessage = _ref.getMessage,
        InlineSummaryItem = _ref.inlineSummaryItemComponent,
        style = _ref.style,
        restProps = _objectWithoutProperties(_ref, _excluded$l);

    return /*#__PURE__*/React.createElement("span", _extends({
      style: _objectSpread2({
        marginLeft: '6px'
      }, style)
    }, restProps), '(', inlineSummaries.map(function (s) {
      return /*#__PURE__*/React.createElement(InlineSummaryItem, {
        key: s.type,
        summary: s,
        getMessage: getMessage
      });
    }).reduce(function (acc, summary) {
      return acc.concat(summary, ', ');
    }, []).slice(0, -1), ')');
  };
  process.env.NODE_ENV !== "production" ? InlineSummary.propTypes = {
    getMessage: PropTypes.func.isRequired,
    inlineSummaries: PropTypes.array,
    inlineSummaryItemComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).isRequired,
    style: PropTypes.object
  } : void 0;
  InlineSummary.defaultProps = {
    inlineSummaries: [],
    style: null
  };

  var _excluded$m = ["style", "column", "value", "children", "tableRow", "tableColumn", "row", "forwardedRef"];
  var TableCell = function TableCell(_ref) {
    var style = _ref.style,
        column = _ref.column,
        value = _ref.value,
        children = _ref.children,
        tableRow = _ref.tableRow,
        tableColumn = _ref.tableColumn,
        row = _ref.row,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$m);

    return /*#__PURE__*/React.createElement("td", _extends({
      ref: forwardedRef,
      style: _objectSpread2({
        whiteSpace: tableColumn && tableColumn.wordWrapEnabled ? 'normal' : 'nowrap',
        overflow: 'hidden',
        textOverflow: 'ellipsis',
        textAlign: tableColumn && tableColumn.align || 'left'
      }, style)
    }, restProps), children || value);
  };
  process.env.NODE_ENV !== "production" ? TableCell.propTypes = {
    style: PropTypes.object,
    value: PropTypes.any,
    column: PropTypes.object,
    row: PropTypes.any,
    children: PropTypes.node,
    tableRow: PropTypes.object,
    tableColumn: PropTypes.object,
    forwardedRef: PropTypes.func
  } : void 0;
  TableCell.defaultProps = {
    style: null,
    value: undefined,
    column: undefined,
    row: undefined,
    children: undefined,
    tableRow: undefined,
    tableColumn: undefined,
    forwardedRef: undefined
  };

  var _excluded$n = ["onToggle"];
  var SummaryCell = function SummaryCell(_ref) {
    var onToggle = _ref.onToggle,
        restProps = _objectWithoutProperties(_ref, _excluded$n);

    return /*#__PURE__*/React.createElement(TableCell, _extends({}, restProps, {
      onClick: onToggle
    }));
  };
  process.env.NODE_ENV !== "production" ? SummaryCell.propTypes = {
    onToggle: PropTypes.func
  } : void 0;
  SummaryCell.defaultProps = {
    onToggle: function onToggle() {}
  };

  var _excluded$o = ["children", "type", "value", "getMessage", "style"];
  var TableSummaryItem = function TableSummaryItem(_ref) {
    var children = _ref.children,
        type = _ref.type,
        value = _ref.value,
        getMessage = _ref.getMessage,
        style = _ref.style,
        restProps = _objectWithoutProperties(_ref, _excluded$o);

    return /*#__PURE__*/React.createElement("div", _extends({
      style: _objectSpread2({
        fontWeight: 'bold'
      }, style)
    }, restProps), /*#__PURE__*/React.createElement(React.Fragment, null, getMessage(type), ":\xA0\xA0", children));
  };
  process.env.NODE_ENV !== "production" ? TableSummaryItem.propTypes = {
    value: PropTypes.number,
    type: PropTypes.string.isRequired,
    getMessage: PropTypes.func.isRequired,
    children: PropTypes.node,
    style: PropTypes.object
  } : void 0;
  TableSummaryItem.defaultProps = {
    value: null,
    children: undefined,
    style: null
  };

  var TableGroupRowWithIndent = function TableGroupRowWithIndent(props) {
    return /*#__PURE__*/React.createElement(dxReactGrid.TableGroupRow, _extends({
      indentColumnWidth: 33,
      contentCellPadding: "8px"
    }, props));
  };

  TableGroupRowWithIndent.components = dxReactGrid.TableGroupRow.components;
  var StubCell = SummaryCell;
  var TableGroupRow = dxReactCore.withComponents({
    Row: Row,
    Cell: CaptionCell,
    IndentCell: IndentCell,
    Container: Container$2,
    Content: Content,
    Icon: ExpandButton,
    InlineSummary: InlineSummary,
    InlineSummaryItem: dxReactGrid.InlineSummaryItem,
    SummaryCell: SummaryCell,
    SummaryItem: TableSummaryItem,
    StubCell: StubCell
  })(TableGroupRowWithIndent);
  TableGroupRow.COLUMN_TYPE = dxReactGrid.TableGroupRow.COLUMN_TYPE;
  TableGroupRow.ROW_TYPE = dxReactGrid.TableGroupRow.ROW_TYPE;

  var _excluded$p = ["disabled", "checked", "indeterminate", "onChange", "style"];
  var SelectionControl = function SelectionControl(_ref) {
    var disabled = _ref.disabled,
        checked = _ref.checked,
        indeterminate = _ref.indeterminate,
        _onChange = _ref.onChange,
        style = _ref.style,
        restProps = _objectWithoutProperties(_ref, _excluded$p);

    return /*#__PURE__*/React.createElement("input", _extends({
      style: _objectSpread2({
        display: 'inline-block',
        cursor: !disabled && 'pointer',
        margin: 0
      }, style),
      type: "checkbox",
      disabled: disabled,
      checked: checked,
      ref: function ref(_ref2) {
        if (_ref2) {
          _ref2.indeterminate = indeterminate; // eslint-disable-line no-param-reassign
        }
      },
      onChange: function onChange() {
        if (!disabled) {
          _onChange();
        }
      },
      onClick: function onClick(e) {
        return e.stopPropagation();
      }
    }, restProps));
  };
  process.env.NODE_ENV !== "production" ? SelectionControl.propTypes = {
    disabled: PropTypes.bool,
    checked: PropTypes.bool,
    indeterminate: PropTypes.bool,
    onChange: PropTypes.func,
    style: PropTypes.object
  } : void 0;
  SelectionControl.defaultProps = {
    disabled: false,
    checked: false,
    indeterminate: false,
    onChange: function onChange() {},
    style: null
  };

  var _excluded$q = ["style", "allSelected", "someSelected", "disabled", "onToggle", "tableColumn", "tableRow", "rowSpan", "forwardedRef"];
  var TableSelectAllCell = function TableSelectAllCell(_ref) {
    var style = _ref.style,
        allSelected = _ref.allSelected,
        someSelected = _ref.someSelected,
        disabled = _ref.disabled,
        onToggle = _ref.onToggle,
        tableColumn = _ref.tableColumn,
        tableRow = _ref.tableRow,
        rowSpan = _ref.rowSpan,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$q);

    return /*#__PURE__*/React.createElement("th", _extends({
      style: _objectSpread2(_objectSpread2({
        verticalAlign: 'middle',
        textAlign: 'center'
      }, rowSpan ? {
        verticalAlign: 'bottom'
      } : {
        verticalAlign: 'middle'
      }), style),
      ref: forwardedRef,
      rowSpan: rowSpan
    }, restProps), /*#__PURE__*/React.createElement(SelectionControl, {
      disabled: disabled,
      checked: allSelected,
      indeterminate: someSelected,
      onChange: onToggle
    }));
  };
  process.env.NODE_ENV !== "production" ? TableSelectAllCell.propTypes = {
    style: PropTypes.object,
    allSelected: PropTypes.bool,
    someSelected: PropTypes.bool,
    disabled: PropTypes.bool,
    onToggle: PropTypes.func,
    tableRow: PropTypes.object,
    tableColumn: PropTypes.object,
    rowSpan: PropTypes.number,
    forwardedRef: PropTypes.func
  } : void 0;
  TableSelectAllCell.defaultProps = {
    style: null,
    allSelected: false,
    someSelected: false,
    disabled: false,
    onToggle: function onToggle() {},
    tableRow: undefined,
    tableColumn: undefined,
    rowSpan: undefined,
    forwardedRef: undefined
  };

  var _excluded$r = ["style", "selected", "onToggle", "row", "tableRow", "tableColumn", "forwardedRef"];
  var TableSelectCell = function TableSelectCell(_ref) {
    var style = _ref.style,
        selected = _ref.selected,
        onToggle = _ref.onToggle,
        row = _ref.row,
        tableRow = _ref.tableRow,
        tableColumn = _ref.tableColumn,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$r);

    return /*#__PURE__*/React.createElement("td", _extends({
      style: _objectSpread2({
        verticalAlign: 'middle',
        textAlign: 'center'
      }, style),
      ref: forwardedRef
    }, restProps), /*#__PURE__*/React.createElement(SelectionControl, {
      checked: selected,
      onChange: onToggle
    }));
  };
  process.env.NODE_ENV !== "production" ? TableSelectCell.propTypes = {
    style: PropTypes.object,
    selected: PropTypes.bool,
    onToggle: PropTypes.func,
    row: PropTypes.any,
    tableRow: PropTypes.object,
    tableColumn: PropTypes.object,
    forwardedRef: PropTypes.func
  } : void 0;
  TableSelectCell.defaultProps = {
    style: null,
    selected: false,
    onToggle: function onToggle() {},
    row: undefined,
    tableRow: undefined,
    tableColumn: undefined,
    forwardedRef: undefined
  };

  var _excluded$s = ["highlighted", "selectByRowClick", "onToggle", "children", "className", "row", "tableRow", "tableColumn", "forwardedRef"];
  var TableSelectRow = function TableSelectRow(_ref) {
    var highlighted = _ref.highlighted,
        selectByRowClick = _ref.selectByRowClick,
        onToggle = _ref.onToggle,
        children = _ref.children,
        className = _ref.className,
        row = _ref.row,
        tableRow = _ref.tableRow,
        tableColumn = _ref.tableColumn,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$s);

    return /*#__PURE__*/React.createElement("tr", _extends({
      ref: forwardedRef,
      className: classNames(highlighted ? 'active' : '', className),
      onClick: function onClick(e) {
        if (!selectByRowClick) return;
        e.stopPropagation();
        onToggle();
      }
    }, restProps), children);
  };
  process.env.NODE_ENV !== "production" ? TableSelectRow.propTypes = {
    highlighted: PropTypes.bool,
    children: PropTypes.node,
    onToggle: PropTypes.func,
    selectByRowClick: PropTypes.bool,
    className: PropTypes.string,
    row: PropTypes.any,
    tableColumn: PropTypes.object,
    tableRow: PropTypes.object,
    forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
  } : void 0;
  TableSelectRow.defaultProps = {
    children: undefined,
    onToggle: function onToggle() {},
    highlighted: false,
    selectByRowClick: false,
    className: undefined,
    row: undefined,
    tableColumn: undefined,
    tableRow: undefined,
    forwardedRef: undefined
  };

  var TableSelectionWithWidth = function TableSelectionWithWidth(props) {
    return /*#__PURE__*/React.createElement(dxReactGrid.TableSelection, _extends({
      selectionColumnWidth: 33
    }, props));
  };

  TableSelectionWithWidth.components = dxReactGrid.TableSelection.components;
  var TableSelection = dxReactCore.withComponents({
    Row: TableSelectRow,
    Cell: TableSelectCell,
    HeaderCell: TableSelectAllCell
  })(TableSelectionWithWidth);
  TableSelection.COLUMN_TYPE = dxReactGrid.TableSelection.COLUMN_TYPE;

  var _excluded$t = ["isFixed", "style"],
      _excluded2$1 = ["isFixed"],
      _excluded3 = ["isFixed"];
  var TableHead = function TableHead(_ref) {
    var isFixed = _ref.isFixed,
        style = _ref.style,
        restProps = _objectWithoutProperties(_ref, _excluded$t);

    return /*#__PURE__*/React.createElement("thead", _extends({}, restProps, {
      style: _objectSpread2(_objectSpread2({}, style), isFixed && _objectSpread2(_objectSpread2({}, getStickyStyles(React.useContext(StyleContext))), {}, {
        top: 0
      }))
    }));
  };
  process.env.NODE_ENV !== "production" ? TableHead.propTypes = {
    style: PropTypes.object,
    isFixed: PropTypes.bool
  } : void 0;
  TableHead.defaultProps = {
    isFixed: undefined,
    style: undefined
  };
  var TableBody = function TableBody(_ref2) {
    var isFixed = _ref2.isFixed,
        restProps = _objectWithoutProperties(_ref2, _excluded2$1);

    return /*#__PURE__*/React.createElement("tbody", restProps);
  };
  process.env.NODE_ENV !== "production" ? TableBody.propTypes = {
    isFixed: PropTypes.bool
  } : void 0;
  TableBody.defaultProps = {
    isFixed: undefined
  };
  var TableFooter = function TableFooter(_ref3) {
    var isFixed = _ref3.isFixed,
        restProps = _objectWithoutProperties(_ref3, _excluded3);

    return /*#__PURE__*/React.createElement("tfoot", _extends({}, restProps, {
      style: _objectSpread2({}, isFixed && _objectSpread2(_objectSpread2({}, getStickyStyles(React.useContext(StyleContext))), {}, {
        bottom: 0
      }))
    }));
  };
  process.env.NODE_ENV !== "production" ? TableFooter.propTypes = {
    isFixed: PropTypes.bool
  } : void 0;
  TableFooter.defaultProps = {
    isFixed: undefined
  };

  var MINIMAL_COLUMN_WIDTH = 120;
  var TableLayout = function TableLayout(props) {
    return /*#__PURE__*/React.createElement(dxReactGrid.TableLayout, _extends({
      layoutComponent: dxReactGrid.StaticTableLayout,
      minColumnWidth: MINIMAL_COLUMN_WIDTH
    }, props));
  };

  var _excluded$u = ["style", "tableRow", "tableColumn", "forwardedRef"];
  var TableStubCell = function TableStubCell(_ref) {
    var style = _ref.style,
        tableRow = _ref.tableRow,
        tableColumn = _ref.tableColumn,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$u);

    return /*#__PURE__*/React.createElement("td", _extends({
      ref: forwardedRef,
      style: _objectSpread2({
        padding: 0
      }, style)
    }, restProps));
  };
  process.env.NODE_ENV !== "production" ? TableStubCell.propTypes = {
    style: PropTypes.object,
    tableRow: PropTypes.object,
    tableColumn: PropTypes.object,
    forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
  } : void 0;
  TableStubCell.defaultProps = {
    style: null,
    tableRow: undefined,
    tableColumn: undefined,
    forwardedRef: undefined
  };

  var _excluded$v = ["style", "tableRow", "tableColumn", "forwardedRef"];
  var TableStubHeaderCell = function TableStubHeaderCell(_ref) {
    var style = _ref.style,
        tableRow = _ref.tableRow,
        tableColumn = _ref.tableColumn,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$v);

    return /*#__PURE__*/React.createElement("th", _extends({
      ref: forwardedRef,
      style: _objectSpread2({
        padding: 0
      }, style)
    }, restProps));
  };
  process.env.NODE_ENV !== "production" ? TableStubHeaderCell.propTypes = {
    style: PropTypes.object,
    tableRow: PropTypes.object,
    tableColumn: PropTypes.object,
    forwardedRef: PropTypes.func
  } : void 0;
  TableStubHeaderCell.defaultProps = {
    style: null,
    tableRow: undefined,
    tableColumn: undefined,
    forwardedRef: undefined
  };

  var _excluded$w = ["style", "colSpan", "getMessage", "tableRow", "tableColumn"];
  var TableNoDataCell = /*#__PURE__*/function (_React$PureComponent) {
    _inherits(TableNoDataCell, _React$PureComponent);

    var _super = _createSuper(TableNoDataCell);

    function TableNoDataCell(props) {
      var _this;

      _classCallCheck(this, TableNoDataCell);

      _this = _super.call(this, props);
      _this.state = {
        stickyPosition: getStickyPosition()
      };
      return _this;
    }

    _createClass(TableNoDataCell, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.setState({
          stickyPosition: getStickyPosition()
        });
      }
    }, {
      key: "render",
      value: function render() {
        var _this$props = this.props,
            style = _this$props.style,
            colSpan = _this$props.colSpan,
            getMessage = _this$props.getMessage,
            tableRow = _this$props.tableRow,
            tableColumn = _this$props.tableColumn,
            restProps = _objectWithoutProperties(_this$props, _excluded$w);

        var stickyPosition = this.state.stickyPosition;
        return /*#__PURE__*/React.createElement("td", _extends({
          style: _objectSpread2(_objectSpread2({
            padding: '50px 0'
          }, style), {}, {
            position: 'static !important'
          }),
          colSpan: colSpan
        }, restProps), /*#__PURE__*/React.createElement("div", {
          style: {
            display: 'inline-block',
            position: stickyPosition,
            left: '50%'
          }
        }, /*#__PURE__*/React.createElement("big", {
          className: "text-muted",
          style: {
            display: 'inline-block',
            transform: 'translateX(-50%)',
            msTransform: 'translateX(-50%)'
          }
        }, getMessage('noData'))));
      }
    }]);

    return TableNoDataCell;
  }(React.PureComponent);
  process.env.NODE_ENV !== "production" ? TableNoDataCell.propTypes = {
    style: PropTypes.object,
    colSpan: PropTypes.number,
    getMessage: PropTypes.func.isRequired,
    tableRow: PropTypes.object,
    tableColumn: PropTypes.object
  } : void 0;
  TableNoDataCell.defaultProps = {
    style: null,
    colSpan: 1,
    tableRow: undefined,
    tableColumn: undefined
  };

  var _excluded$x = ["children", "use", "style", "className", "forwardedRef"];
  var Table = function Table(_ref) {
    var children = _ref.children,
        use = _ref.use,
        style = _ref.style,
        className = _ref.className,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$x);

    var _React$useState = React.useState(getStickyPosition()),
        _React$useState2 = _slicedToArray(_React$useState, 2),
        stickyPosition = _React$useState2[0],
        setStickyPosition = _React$useState2[1];

    var _React$useContext = React.useContext(StyleContext),
        backgroundColor = _React$useContext.backgroundColor;

    React.useEffect(function () {
      var realStickyPosition = getStickyPosition();

      if (stickyPosition !== realStickyPosition) {
        setStickyPosition(realStickyPosition);
      }
    }, []);
    return /*#__PURE__*/React.createElement("table", _extends({
      ref: forwardedRef,
      className: classNames('table', className),
      style: _objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({
        tableLayout: 'fixed',
        borderCollapse: 'separate',
        marginBottom: 0
      }, use ? _objectSpread2({}, getStickyStyles({
        stickyPosition: stickyPosition,
        backgroundColor: backgroundColor
      })) : null), use === 'head' ? {
        top: 0
      } : null), use === 'foot' ? {
        bottom: 0
      } : null), style)
    }, restProps), children);
  };
  process.env.NODE_ENV !== "production" ? Table.propTypes = {
    use: PropTypes.oneOf(['head', 'foot']),
    children: PropTypes.node.isRequired,
    style: PropTypes.object,
    className: PropTypes.string,
    forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
  } : void 0;
  Table.defaultProps = {
    use: undefined,
    style: null,
    className: undefined,
    forwardedRef: undefined
  };

  var _excluded$y = ["children", "style", "className", "forwardedRef"];
  var TableContainer = function TableContainer(_ref) {
    var children = _ref.children,
        style = _ref.style,
        className = _ref.className,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$y);

    return /*#__PURE__*/React.createElement("div", _extends({
      ref: forwardedRef,
      className: classNames('table-responsive', className),
      style: _objectSpread2({
        flexGrow: 1,
        overflow: 'auto',
        WebkitOverflowScrolling: 'touch',
        border: 0,
        margin: 0,
        // NOTE: fix sticky positioning in Safari
        width: '100%',
        flexDirection: 'column'
      }, style)
    }, restProps), /*#__PURE__*/React.createElement("div", null, children));
  };
  process.env.NODE_ENV !== "production" ? TableContainer.propTypes = {
    children: PropTypes.node.isRequired,
    style: PropTypes.object,
    className: PropTypes.string,
    forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
  } : void 0;
  TableContainer.defaultProps = {
    className: undefined,
    style: null,
    forwardedRef: undefined
  };

  var _excluded$z = ["children", "tableRow", "forwardedRef"];
  var TableStubRow = function TableStubRow(_ref) {
    var children = _ref.children,
        tableRow = _ref.tableRow,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$z);

    return /*#__PURE__*/React.createElement("tr", _extends({
      ref: forwardedRef
    }, restProps), children);
  };
  process.env.NODE_ENV !== "production" ? TableStubRow.propTypes = {
    children: PropTypes.node,
    tableRow: PropTypes.object,
    forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
  } : void 0;
  TableStubRow.defaultProps = {
    children: undefined,
    tableRow: undefined,
    forwardedRef: undefined
  };

  var Table$1 = dxReactCore.withComponents({
    Table: Table,
    TableHead: TableHead,
    TableBody: TableBody,
    TableFooter: TableFooter,
    Container: TableContainer,
    Layout: TableLayout,
    Row: TableRow,
    Cell: TableCell,
    NoDataRow: TableRow,
    NoDataCell: TableNoDataCell,
    StubRow: TableStubRow,
    StubCell: TableStubCell,
    StubHeaderCell: TableStubHeaderCell
  })(dxReactGrid.Table);
  Table$1.COLUMN_TYPE = dxReactGrid.Table.COLUMN_TYPE;
  Table$1.ROW_TYPE = dxReactGrid.Table.ROW_TYPE;
  Table$1.NODATA_ROW_TYPE = dxReactGrid.Table.NODATA_ROW_TYPE;

  var MINIMAL_COLUMN_WIDTH$1 = 120;
  var VirtualTableLayout = function VirtualTableLayout(props) {
    return /*#__PURE__*/React.createElement(dxReactGrid.TableLayout, _extends({
      layoutComponent: dxReactGrid.VirtualTableLayout,
      minColumnWidth: MINIMAL_COLUMN_WIDTH$1
    }, props));
  };

  var _excluded$A = ["style", "tableRow", "tableColumn"];
  var TableSkeletonCell = function TableSkeletonCell(_ref) {
    var style = _ref.style,
        tableRow = _ref.tableRow,
        tableColumn = _ref.tableColumn,
        restProps = _objectWithoutProperties(_ref, _excluded$A);

    return /*#__PURE__*/React.createElement("td", _extends({
      style: _objectSpread2({
        padding: 7,
        backgroundImage: 'url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAACqCAYAAABbAOqQAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAA39pVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuNi1jMTQyIDc5LjE2MDkyNCwgMjAxNy8wNy8xMy0wMTowNjozOSAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iIHhtcE1NOk9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRpZDpjYWQ2ODE5MS00ZDMxLWRjNGYtOTU0NC1jNjJkMTIxMjY2M2IiIHhtcE1NOkRvY3VtZW50SUQ9InhtcC5kaWQ6MjY1RUVFQzAzRDYzMTFFODlFNThCOUJBQjU4Q0EzRDgiIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5paWQ6MjY1RUVFQkYzRDYzMTFFODlFNThCOUJBQjU4Q0EzRDgiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENDIChXaW5kb3dzKSI+IDx4bXBNTTpEZXJpdmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOjVlMjM1Y2U0LTc5ZWUtNGI0NC05ZjlkLTk2NTZmZGFjNjhhNCIgc3RSZWY6ZG9jdW1lbnRJRD0iYWRvYmU6ZG9jaWQ6cGhvdG9zaG9wOjk1OTQ2MjBiLTUyMTQtYTM0Yy04Nzc5LTEwMmEyMTY4MTlhOSIvPiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gPD94cGFja2V0IGVuZD0iciI/PvLbJKYAAADrSURBVHja7N3BDYBACABBsQn7L48q0BoMD5SZxAZuc74gF1V1MMfpCARBEEEQRBAEEQRBdovnuxxDq3RD/LIQRBAEQRBBEEQQBBEEQQQBAAAAAAAAABhi8gZVbgxi6kQQBBEEQQRBEEEQRBAEQRBBAAAAAAAAAAAabX2Daux2lqkTQRBEEAQRBEEEQRBBEARBBAEAAAAAAAAAaLR1g2osUyeCIIggCCIIggiCIIIgCIIIAgAAAAAAAADQ6KsbVPnXIKZOBEEQQRBEEAQRBEEEQRAEEYRXoqqcghuCIIIgiCAIIgiCCMIUtwADALYCCr92l++TAAAAAElFTkSuQmCC)',
        backgroundRepeat: 'no-repeat repeat',
        backgroundOrigin: 'content-box'
      }, style)
    }, restProps));
  };
  process.env.NODE_ENV !== "production" ? TableSkeletonCell.propTypes = {
    style: PropTypes.object,
    tableRow: PropTypes.object,
    tableColumn: PropTypes.object
  } : void 0;
  TableSkeletonCell.defaultProps = {
    style: null,
    tableRow: undefined,
    tableColumn: undefined
  };

  var FixedHeader = /*#__PURE__*/React.forwardRef(function (props, ref) {
    return /*#__PURE__*/React.createElement(Table, _extends({
      use: "head",
      ref: ref
    }, props));
  });
  var FixedFooter = /*#__PURE__*/React.forwardRef(function (props, ref) {
    return /*#__PURE__*/React.createElement(Table, _extends({
      use: "foot",
      ref: ref
    }, props));
  });
  var VirtualTable = dxReactGrid.makeVirtualTable(Table$1, {
    VirtualLayout: VirtualTableLayout,
    FixedHeader: FixedHeader,
    FixedFooter: FixedFooter,
    SkeletonCell: TableSkeletonCell,
    defaultEstimatedRowHeight: 37,
    defaultHeight: 530
  });
  VirtualTable.COLUMN_TYPE = Table$1.COLUMN_TYPE;
  VirtualTable.ROW_TYPE = Table$1.ROW_TYPE;
  VirtualTable.NODATA_ROW_TYPE = Table$1.NODATA_ROW_TYPE;

  var _excluded$B = ["style", "filter", "onFilter", "children", "column", "tableRow", "tableColumn", "getMessage", "filteringEnabled", "forwardedRef"];
  var TableFilterCell = function TableFilterCell(_ref) {
    var style = _ref.style,
        filter = _ref.filter,
        onFilter = _ref.onFilter,
        children = _ref.children,
        column = _ref.column,
        tableRow = _ref.tableRow,
        tableColumn = _ref.tableColumn,
        getMessage = _ref.getMessage,
        filteringEnabled = _ref.filteringEnabled,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$B);

    return /*#__PURE__*/React.createElement("th", _extends({
      ref: forwardedRef,
      style: _objectSpread2({
        fontWeight: 'normal'
      }, style)
    }, restProps), /*#__PURE__*/React.createElement("div", {
      className: "input-group",
      style: {
        width: '100%'
      }
    }, children));
  };
  process.env.NODE_ENV !== "production" ? TableFilterCell.propTypes = {
    style: PropTypes.object,
    filter: PropTypes.object,
    onFilter: PropTypes.func,
    children: PropTypes.node,
    column: PropTypes.object,
    tableRow: PropTypes.object,
    tableColumn: PropTypes.object,
    getMessage: PropTypes.func,
    filteringEnabled: PropTypes.bool,
    forwardedRef: PropTypes.func
  } : void 0;
  TableFilterCell.defaultProps = {
    style: null,
    filter: null,
    onFilter: function onFilter() {},
    children: undefined,
    column: undefined,
    tableRow: undefined,
    tableColumn: undefined,
    getMessage: undefined,
    filteringEnabled: true,
    forwardedRef: undefined
  };

  var _excluded$C = ["value", "disabled", "getMessage", "onChange", "className"];
  var Editor = function Editor(_ref) {
    var value = _ref.value,
        disabled = _ref.disabled,
        getMessage = _ref.getMessage,
        _onChange = _ref.onChange,
        className = _ref.className,
        restProps = _objectWithoutProperties(_ref, _excluded$C);

    return /*#__PURE__*/React.createElement("input", _extends({
      type: "text",
      className: classNames('form-control', className),
      value: value,
      onChange: function onChange(event) {
        return _onChange(event.target.value);
      },
      readOnly: disabled,
      placeholder: getMessage('filterPlaceholder')
    }, restProps));
  };
  process.env.NODE_ENV !== "production" ? Editor.propTypes = {
    value: PropTypes.any,
    disabled: PropTypes.bool,
    onChange: PropTypes.func,
    getMessage: PropTypes.func.isRequired,
    className: PropTypes.string
  } : void 0;
  Editor.defaultProps = {
    value: '',
    disabled: false,
    onChange: function onChange() {},
    className: undefined
  };

  var _excluded$D = ["value", "availableValues", "disabled", "getMessage", "iconComponent", "toggleButtonComponent", "className"];
  var FilterSelector = /*#__PURE__*/function (_React$PureComponent) {
    _inherits(FilterSelector, _React$PureComponent);

    var _super = _createSuper(FilterSelector);

    function FilterSelector(props) {
      var _this;

      _classCallCheck(this, FilterSelector);

      _this = _super.call(this, props);
      _this.state = {
        opened: false
      };

      _this.handleButtonClick = function () {
        _this.setState(function (prevState) {
          return {
            opened: !prevState.opened
          };
        });
      };

      _this.handleOverlayHide = function () {
        _this.setState({
          opened: false
        });
      };

      _this.handleMenuItemClick = function (nextValue) {
        _this.setState({
          opened: false
        });

        var onChange = _this.props.onChange;
        onChange(nextValue);
      };

      return _this;
    }

    _createClass(FilterSelector, [{
      key: "render",
      value: function render() {
        var _this2 = this;

        var _this$props = this.props,
            value = _this$props.value,
            availableValues = _this$props.availableValues,
            disabled = _this$props.disabled,
            getMessage = _this$props.getMessage,
            Icon = _this$props.iconComponent,
            ToggleButton = _this$props.toggleButtonComponent,
            className = _this$props.className,
            restProps = _objectWithoutProperties(_this$props, _excluded$D);

        var opened = this.state.opened;
        return availableValues.length ? /*#__PURE__*/React.createElement("span", _extends({
          className: classNames('input-group-btn', className)
        }, restProps), /*#__PURE__*/React.createElement(ToggleButton, {
          disabled: disabled || availableValues.length === 1,
          onToggle: this.handleButtonClick,
          buttonRef: function buttonRef(ref) {
            _this2.targetElement = ref;
          }
        }, /*#__PURE__*/React.createElement(Icon, {
          type: value
        })), /*#__PURE__*/React.createElement(Overlay, {
          visible: opened,
          target: this.targetElement,
          onHide: this.handleOverlayHide,
          container: undefined
        }, /*#__PURE__*/React.createElement(reactBootstrap.ListGroup, {
          style: {
            marginBottom: 0
          }
        }, availableValues.map(function (valueItem) {
          return /*#__PURE__*/React.createElement(reactBootstrap.ListGroupItem, {
            key: valueItem,
            active: valueItem === value,
            style: {
              outline: 'none',
              whiteSpace: 'nowrap',
              display: 'flex',
              alignItems: 'center'
            },
            onClick: function onClick() {
              return _this2.handleMenuItemClick(valueItem);
            }
          }, /*#__PURE__*/React.createElement(Icon, {
            type: valueItem
          }), /*#__PURE__*/React.createElement("span", {
            style: {
              marginLeft: 10
            }
          }, getMessage(valueItem)));
        })))) : null;
      }
    }]);

    return FilterSelector;
  }(React.PureComponent);
  process.env.NODE_ENV !== "production" ? FilterSelector.propTypes = {
    value: PropTypes.string,
    availableValues: PropTypes.arrayOf(PropTypes.string),
    onChange: PropTypes.func,
    disabled: PropTypes.bool,
    // oneOfType is a workaround because React.memo returns react object
    iconComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).isRequired,
    toggleButtonComponent: PropTypes.func.isRequired,
    getMessage: PropTypes.func.isRequired,
    className: PropTypes.string
  } : void 0;
  FilterSelector.defaultProps = {
    value: undefined,
    availableValues: [],
    onChange: function onChange() {},
    disabled: false,
    className: undefined
  };

  var _excluded$E = ["buttonRef", "onToggle", "disabled", "children", "className"];
  var ToggleButton$1 = function ToggleButton(_ref) {
    var buttonRef = _ref.buttonRef,
        onToggle = _ref.onToggle,
        disabled = _ref.disabled,
        children = _ref.children,
        className = _ref.className,
        restProps = _objectWithoutProperties(_ref, _excluded$E);

    return /*#__PURE__*/React.createElement("button", _extends({
      type: "button",
      className: classNames('btn btn-default', className),
      disabled: disabled,
      onClick: onToggle,
      ref: buttonRef
    }, restProps), children);
  };
  process.env.NODE_ENV !== "production" ? ToggleButton$1.propTypes = {
    buttonRef: PropTypes.func.isRequired,
    onToggle: PropTypes.func.isRequired,
    children: PropTypes.node,
    disabled: PropTypes.bool,
    className: PropTypes.string
  } : void 0;
  ToggleButton$1.defaultProps = {
    children: undefined,
    disabled: false,
    className: undefined
  };

  var _excluded$F = ["type", "style"];
  var AVAILABLE_PATHS = {
    contains: 'M6.094 19.563l-2.031 0.281c-0.646 0.094-1.13 0.266-1.453 0.516-0.302 0.24-0.453 0.646-0.453 1.219 0 0.438 0.138 0.799 0.414 1.086s0.664 0.419 1.164 0.398c0.708 0 1.281-0.24 1.719-0.719 0.427-0.49 0.641-1.125 0.641-1.906v-0.875zM8.234 24.641h-2.172v-1.641c-0.677 1.24-1.661 1.859-2.953 1.859-0.927 0-1.682-0.276-2.266-0.828-0.552-0.552-0.828-1.292-0.828-2.219 0-1.927 1.068-3.052 3.203-3.375l2.875-0.438c0-1.469-0.656-2.203-1.969-2.203-1.177 0-2.224 0.427-3.141 1.281v-2.078c1.010-0.656 2.198-0.984 3.563-0.984 2.458 0 3.687 1.302 3.687 3.906v6.719zM14.734 16.797c0.521-0.583 1.167-0.875 1.938-0.875 0.74 0 1.323 0.281 1.75 0.844 0.448 0.583 0.672 1.38 0.672 2.391 0 1.188-0.24 2.13-0.719 2.828-0.49 0.677-1.13 1.016-1.922 1.016-0.719 0-1.302-0.271-1.75-0.813-0.427-0.51-0.641-1.141-0.641-1.891v-1.266c-0.021-0.906 0.203-1.651 0.672-2.234zM16.969 24.859c1.375 0 2.443-0.521 3.203-1.562 0.781-1.042 1.172-2.427 1.172-4.156 0-1.542-0.354-2.771-1.063-3.688-0.688-0.958-1.651-1.438-2.891-1.438-1.427 0-2.531 0.693-3.313 2.078v-6.781h-2.156v15.328h2.172v-1.5c0.677 1.146 1.635 1.719 2.875 1.719zM22.266 6.125c0.135 0 0.245 0.063 0.328 0.188 0.104 0.073 0.156 0.182 0.156 0.328v22.953c0 0.125-0.052 0.24-0.156 0.344-0.083 0.115-0.193 0.172-0.328 0.172h-12.281c-0.146 0-0.266-0.057-0.359-0.172-0.115-0.115-0.172-0.229-0.172-0.344v-22.953c0-0.135 0.057-0.245 0.172-0.328 0.094-0.125 0.214-0.188 0.359-0.188h12.281zM31.531 24.141c-0.76 0.479-1.693 0.719-2.797 0.719-1.427 0-2.589-0.479-3.484-1.438-0.865-0.958-1.286-2.198-1.266-3.719 0-1.688 0.448-3.052 1.344-4.094 0.917-1.042 2.208-1.573 3.875-1.594 0.854 0 1.63 0.177 2.328 0.531v2.156c-0.677-0.531-1.391-0.792-2.141-0.781-0.938 0-1.714 0.339-2.328 1.016-0.594 0.677-0.891 1.552-0.891 2.625 0 1.042 0.297 1.88 0.891 2.516 0.521 0.615 1.25 0.922 2.188 0.922 0.813 0 1.573-0.297 2.281-0.891v2.031z',
    notContains: 'M5.828 20.469v0.328c0 0.385-0.057 0.667-0.172 0.844-0.052 0.083-0.117 0.177-0.195 0.281s-0.174 0.224-0.289 0.359c-0.458 0.521-1.031 0.771-1.719 0.75-0.521 0-0.927-0.141-1.219-0.422-0.292-0.292-0.438-0.661-0.438-1.109 0-0.156 0.010-0.273 0.031-0.352s0.052-0.141 0.094-0.188 0.094-0.086 0.156-0.117 0.141-0.078 0.234-0.141c0.031-0.031 0.078-0.070 0.141-0.117s0.146-0.086 0.25-0.117h3.125zM14.016 18.328c0.010-0.406 0.070-0.729 0.18-0.969s0.289-0.49 0.539-0.75c0.479-0.604 1.13-0.906 1.953-0.906 0.75 0 1.344 0.292 1.781 0.875 0.198 0.25 0.349 0.495 0.453 0.734s0.172 0.578 0.203 1.016h-5.109zM19.078 20.469c-0.063 0.427-0.146 0.708-0.25 0.844-0.052 0.073-0.109 0.159-0.172 0.258l-0.219 0.352c-0.469 0.688-1.135 1.031-2 1.031-0.708 0-1.297-0.271-1.766-0.813l-0.305-0.359c-0.089-0.104-0.159-0.198-0.211-0.281-0.104-0.167-0.156-0.448-0.156-0.844v-0.188h5.078zM33.344 18.328l-6.875 0c0.031-0.198 0.070-0.372 0.117-0.523s0.107-0.284 0.18-0.398 0.154-0.224 0.242-0.328l0.305-0.344c0.604-0.688 1.391-1.031 2.359-1.031 0.771 0 1.51 0.266 2.219 0.797v-2.234c-0.75-0.333-1.552-0.5-2.406-0.5-1.667 0-2.974 0.531-3.922 1.594-0.396 0.427-0.708 0.859-0.938 1.297s-0.385 0.995-0.469 1.672h-2.719c-0.021-0.719-0.117-1.31-0.289-1.773s-0.424-0.914-0.758-1.352c-0.729-0.938-1.719-1.417-2.969-1.438-1.479 0-2.615 0.708-3.406 2.125v-6.953h-2.266v9.391h-3.75v-0.594c0-2.646-1.25-3.969-3.75-3.969-1.365 0-2.583 0.328-3.656 0.984v2.125c0.99-0.865 2.063-1.297 3.219-1.297 1.344 0 2.016 0.75 2.016 2.25l-2.953 0.125c-0.25 0.021-0.487 0.070-0.711 0.148l-0.633 0.227h-3.328v2.141h1.828l-0.281 0.594c-0.073 0.135-0.109 0.37-0.109 0.703 0 0.938 0.276 1.682 0.828 2.234 0.542 0.573 1.313 0.859 2.313 0.859 1.281 0 2.297-0.635 3.047-1.906v1.656h2.172v-4.141h3.75v4.141h2.297v-1.516c0.677 1.188 1.661 1.776 2.953 1.766 1.385 0 2.464-0.531 3.234-1.594 0.302-0.385 0.557-0.792 0.766-1.219 0.198-0.385 0.339-0.911 0.422-1.578h2.703c0.021 0.708 0.141 1.25 0.359 1.625 0.115 0.198 0.253 0.401 0.414 0.609s0.346 0.427 0.555 0.656c0.906 1 2.099 1.5 3.578 1.5 1.104 0 2.057-0.245 2.859-0.734v-2.109c-0.75 0.604-1.526 0.917-2.328 0.938-0.979 0-1.74-0.318-2.281-0.953l-0.328-0.328c-0.094-0.094-0.177-0.195-0.25-0.305s-0.13-0.234-0.172-0.375-0.073-0.315-0.094-0.523h6.906v-2.141zM33.297 5.688c0.146 0 0.266 0.047 0.359 0.141 0.104 0.104 0.156 0.229 0.156 0.375v23.484c0 0.135-0.052 0.255-0.156 0.359-0.094 0.115-0.214 0.172-0.359 0.172h-35.078c-0.135 0-0.26-0.057-0.375-0.172-0.094-0.115-0.135-0.234-0.125-0.359v-23.484c0-0.104 0.042-0.229 0.125-0.375 0.104-0.094 0.229-0.141 0.375-0.141h35.078z',
    startsWith: 'M6.109 20.688c0 0.813-0.219 1.474-0.656 1.984-0.448 0.531-1.010 0.786-1.688 0.766-0.51 0-0.896-0.141-1.156-0.422-0.302-0.292-0.443-0.667-0.422-1.125 0-0.615 0.151-1.042 0.453-1.281 0.177-0.135 0.378-0.245 0.602-0.328s0.497-0.146 0.82-0.188l2.047-0.313v0.906zM8.203 18.063c0-2.688-1.219-4.031-3.656-4.031-1.333 0-2.51 0.339-3.531 1.016v2.141c0.917-0.885 1.948-1.328 3.094-1.328 1.333 0 2 0.766 2 2.297l-2.891 0.453c-2.115 0.333-3.161 1.516-3.141 3.547 0 0.958 0.266 1.724 0.797 2.297 0.542 0.573 1.292 0.859 2.25 0.859 1.292 0 2.26-0.641 2.906-1.922v1.688h2.172v-7.016zM14.703 16.906c0.479-0.604 1.109-0.906 1.891-0.906 0.76 0 1.344 0.297 1.75 0.891 0.438 0.615 0.656 1.443 0.656 2.484 0 1.219-0.229 2.198-0.688 2.938-0.469 0.719-1.109 1.078-1.922 1.078-0.719 0-1.286-0.281-1.703-0.844-0.448-0.542-0.672-1.208-0.672-2v-1.313c-0.010-0.938 0.219-1.714 0.688-2.328zM16.906 25.313c1.365 0 2.422-0.542 3.172-1.625 0.771-1.115 1.156-2.563 1.156-4.344 0-1.604-0.339-2.885-1.016-3.844-0.698-0.979-1.661-1.469-2.891-1.469-1.438 0-2.531 0.719-3.281 2.156v-7.078h-2.188v15.969h2.172v-1.563c0.667 1.198 1.625 1.797 2.875 1.797zM31.375 24.563c-0.75 0.5-1.672 0.75-2.766 0.75-1.427 0-2.583-0.505-3.469-1.516-0.885-0.969-1.318-2.26-1.297-3.875 0-1.74 0.464-3.161 1.391-4.266 0.927-1.063 2.198-1.604 3.813-1.625 0.844 0 1.62 0.172 2.328 0.516v2.25c-0.688-0.563-1.406-0.828-2.156-0.797-0.927 0-1.688 0.349-2.281 1.047-0.583 0.698-0.875 1.609-0.875 2.734 0 1.094 0.281 1.969 0.844 2.625 0.542 0.656 1.286 0.984 2.234 0.984 0.781 0 1.526-0.323 2.234-0.969v2.141zM22.172 5.844c0.115 0 0.224 0.052 0.328 0.156 0.094 0.125 0.141 0.25 0.141 0.375v23.844c0 0.156-0.047 0.286-0.141 0.391-0.115 0.094-0.224 0.141-0.328 0.141h-23.469c-0.125 0-0.24-0.047-0.344-0.141-0.094-0.104-0.141-0.234-0.141-0.391v-23.844c0-0.125 0.047-0.25 0.141-0.375 0.104-0.104 0.219-0.156 0.344-0.156h23.469z',
    endsWith: 'M6.234 19.344l-2.047 0.313c-0.625 0.083-1.104 0.26-1.438 0.531-0.302 0.24-0.453 0.651-0.453 1.234 0 0.469 0.141 0.852 0.422 1.148s0.672 0.435 1.172 0.414c0.677 0 1.234-0.25 1.672-0.75 0.448-0.51 0.672-1.167 0.672-1.969v-0.922zM8.359 24.578h-2.141v-1.656c-0.667 1.26-1.656 1.891-2.969 1.891-0.938 0-1.698-0.276-2.281-0.828-0.542-0.573-0.813-1.328-0.813-2.266 0-2.021 1.063-3.188 3.188-3.5l2.891-0.484c0-1.51-0.661-2.266-1.984-2.266-1.167 0-2.214 0.443-3.141 1.328v-2.125c1.042-0.677 2.224-1.016 3.547-1.016 2.469 0 3.703 1.333 3.703 4v6.922zM14.906 16.516c0.49-0.615 1.13-0.922 1.922-0.922 0.76 0 1.339 0.297 1.734 0.891 0.438 0.615 0.656 1.438 0.656 2.469 0 1.208-0.229 2.182-0.688 2.922-0.469 0.698-1.115 1.047-1.938 1.047-0.708 0-1.276-0.276-1.703-0.828-0.458-0.552-0.688-1.214-0.688-1.984v-1.281c-0.010-0.948 0.224-1.719 0.703-2.313zM17.125 24.813c1.354 0 2.417-0.531 3.188-1.594 0.781-1.073 1.172-2.505 1.172-4.297 0-1.604-0.349-2.87-1.047-3.797-0.698-0.979-1.661-1.469-2.891-1.469-1.438 0-2.542 0.714-3.313 2.141v-7h-2.203v15.781h2.188v-1.531c0.677 1.177 1.646 1.766 2.906 1.766zM31.688 21.969c-0.698 0.635-1.453 0.953-2.266 0.953-0.958 0-1.703-0.323-2.234-0.969-0.563-0.667-0.849-1.536-0.859-2.609 0-1.115 0.297-2.016 0.891-2.703 0.594-0.698 1.359-1.047 2.297-1.047 0.76 0 1.484 0.266 2.172 0.797v-2.219c-0.708-0.344-1.49-0.516-2.344-0.516-1.625 0-2.906 0.536-3.844 1.609-0.938 1.083-1.406 2.495-1.406 4.234 0 1.594 0.438 2.875 1.313 3.844 0.885 0.979 2.052 1.469 3.5 1.469 1.083 0 2.010-0.245 2.781-0.734v-2.109zM33.188 5.563c0.104 0 0.219 0.047 0.344 0.141 0.094 0.146 0.141 0.276 0.141 0.391v23.578c0 0.146-0.047 0.281-0.141 0.406-0.125 0.094-0.24 0.141-0.344 0.141h-23.625c-0.125 0-0.24-0.047-0.344-0.141-0.094-0.135-0.135-0.271-0.125-0.406v-23.578c0-0.115 0.042-0.245 0.125-0.391 0.094-0.094 0.208-0.141 0.344-0.141h23.625z',
    equal: 'M29.438 11.797v2.75h-26.922v-2.75h26.922zM29.438 17.406v2.75h-26.922v-2.75h26.922z',
    notEqual: 'M16.906 11.797l3.016-6.547 2.094 1-2.547 5.547h9.969v2.75h-11.234l-1.328 2.859h12.563v2.75h-13.828l-2.875 6.281-2.094-0.984 2.438-5.297h-10.563v-2.75h11.828l1.297-2.859h-13.125v-2.75h14.391z',
    greaterThan: 'M24.125 16.047l-14.906 8.625-1.375-2.375 10.781-6.25-10.781-6.234 1.375-2.375z',
    greaterThanOrEqual: 'M23.031 14.328l-14.906 8.625-1.375-2.375 10.797-6.25-10.797-6.234 1.375-2.375zM23.828 15.641l1.375 2.391-14.938 8.609-1.375-2.375z',
    lessThan: 'M22.75 7.438l1.375 2.375-10.781 6.234 10.781 6.25-1.375 2.375-14.906-8.609z',
    lessThanOrEqual: 'M23.828 5.719l1.375 2.375-10.813 6.234 10.813 6.25-1.375 2.375-14.922-8.609zM23.047 24.266l-1.375 2.375-14.922-8.609 1.375-2.391z'
  };
  var Icon = /*#__PURE__*/React.memo(function (_ref) {
    var type = _ref.type,
        style = _ref.style,
        restProps = _objectWithoutProperties(_ref, _excluded$F);

    var path = AVAILABLE_PATHS[type];
    return path ? /*#__PURE__*/React.createElement("svg", _extends({
      style: _objectSpread2({
        width: 14,
        height: 14,
        position: 'relative',
        top: 1,
        fill: 'currentColor'
      }, style),
      viewBox: "0 0 32 32"
    }, restProps), /*#__PURE__*/React.createElement("path", {
      d: path
    })) : /*#__PURE__*/React.createElement("i", _extends({
      className: "glyphicon glyphicon-search",
      style: style
    }, restProps));
  });
  process.env.NODE_ENV !== "production" ? Icon.propTypes = {
    type: PropTypes.string,
    style: PropTypes.object
  } : void 0;
  Icon.defaultProps = {
    type: undefined,
    style: {}
  };

  var TableFilterRow = dxReactCore.withComponents({
    Row: TableRow,
    Cell: TableFilterCell,
    Editor: Editor,
    FilterSelector: FilterSelector,
    Icon: Icon,
    ToggleButton: ToggleButton$1
  })(dxReactGrid.TableFilterRow);
  TableFilterRow.ROW_TYPE = dxReactGrid.TableFilterRow.ROW_TYPE;

  var ResizingControlLine = function ResizingControlLine(_ref) {
    var resizing = _ref.resizing,
        style = _ref.style;
    var resizingControlLineBody = resizing && /*#__PURE__*/React.createElement("div", {
      className: "bg-primary",
      style: {
        position: 'absolute',
        top: 0,
        left: 0,
        height: '100%',
        width: '100%'
      }
    });
    return /*#__PURE__*/React.createElement("div", {
      style: _objectSpread2({
        position: 'absolute',
        backgroundColor: '#ddd',
        height: '50%',
        width: '1px',
        top: '25%'
      }, style)
    }, resizingControlLineBody);
  };

  process.env.NODE_ENV !== "production" ? ResizingControlLine.propTypes = {
    resizing: PropTypes.bool.isRequired,
    style: PropTypes.object.isRequired
  } : void 0;
  var ResizingControl = /*#__PURE__*/function (_React$PureComponent) {
    _inherits(ResizingControl, _React$PureComponent);

    var _super = _createSuper(ResizingControl);

    function ResizingControl(props) {
      var _this;

      _classCallCheck(this, ResizingControl);

      _this = _super.call(this, props);
      _this.state = {
        resizing: false
      };

      _this.onResizeStart = function (_ref2) {
        var x = _ref2.x;
        _this.resizeStartingX = x;

        _this.setState({
          resizing: true
        });
      };

      _this.onResizeUpdate = function (_ref3) {
        var x = _ref3.x;
        var onWidthDraft = _this.props.onWidthDraft;

        if (x >= 0) {
          onWidthDraft({
            shift: x - _this.resizeStartingX
          });
        }
      };

      _this.onResizeEnd = function (_ref4) {
        var x = _ref4.x;
        var _this$props = _this.props,
            onWidthChange = _this$props.onWidthChange,
            onWidthDraftCancel = _this$props.onWidthDraftCancel;
        onWidthDraftCancel();
        onWidthChange({
          shift: x - _this.resizeStartingX
        });

        _this.setState({
          resizing: false
        });
      };

      return _this;
    }

    _createClass(ResizingControl, [{
      key: "render",
      value: function render() {
        var resizing = this.state.resizing;
        return /*#__PURE__*/React.createElement(dxReactCore.Draggable, {
          onStart: this.onResizeStart,
          onUpdate: this.onResizeUpdate,
          onEnd: this.onResizeEnd
        }, /*#__PURE__*/React.createElement("div", {
          style: {
            position: 'absolute',
            userSelect: 'none',
            MozUserSelect: 'none',
            WebkitUserSelect: 'none',
            top: 0,
            right: '-8px',
            width: '16px',
            height: '100%',
            cursor: 'col-resize',
            zIndex: 100
          }
        }, /*#__PURE__*/React.createElement(ResizingControlLine, {
          resizing: resizing,
          style: {
            left: '6px'
          }
        }), /*#__PURE__*/React.createElement(ResizingControlLine, {
          resizing: resizing,
          style: {
            left: '8px'
          }
        })));
      }
    }]);

    return ResizingControl;
  }(React.PureComponent);
  process.env.NODE_ENV !== "production" ? ResizingControl.propTypes = {
    onWidthChange: PropTypes.func.isRequired,
    onWidthDraft: PropTypes.func.isRequired,
    onWidthDraftCancel: PropTypes.func.isRequired
  } : void 0;

  var _excluded$G = ["style", "column", "tableColumn", "draggingEnabled", "resizingEnabled", "dragging", "onWidthChange", "onWidthDraft", "onWidthDraftCancel", "getCellWidth", "tableRow", "className", "children", "forwardedRef"];
  var CellLayout = function CellLayout(_ref) {
    var style = _ref.style,
        column = _ref.column,
        tableColumn = _ref.tableColumn,
        draggingEnabled = _ref.draggingEnabled,
        resizingEnabled = _ref.resizingEnabled,
        dragging = _ref.dragging,
        onWidthChange = _ref.onWidthChange,
        onWidthDraft = _ref.onWidthDraft,
        onWidthDraftCancel = _ref.onWidthDraftCancel,
        getCellWidth = _ref.getCellWidth,
        tableRow = _ref.tableRow,
        className = _ref.className,
        children = _ref.children,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$G);

    var cellRef = React.useRef();
    var getWidthGetter = React.useCallback(function () {
      var node = cellRef.current;
      return node && getCellWidth(function () {
        var _node$getBoundingClie = node.getBoundingClientRect(),
            width = _node$getBoundingClie.width;

        return width;
      });
    });
    React.useEffect(function () {
      getWidthGetter();
    }, []);
    return /*#__PURE__*/React.createElement("th", _extends({
      style: _objectSpread2(_objectSpread2(_objectSpread2(_objectSpread2({
        position: 'relative'
      }, draggingEnabled ? {
        userSelect: 'none',
        MozUserSelect: 'none',
        WebkitUserSelect: 'none'
      } : null), {}, {
        whiteSpace: !(tableColumn && tableColumn.wordWrapEnabled) ? 'nowrap' : 'normal'
      }, draggingEnabled ? {
        cursor: 'pointer'
      } : null), dragging || tableColumn && tableColumn.draft ? {
        opacity: 0.3
      } : null), style),
      ref: function ref(node) {
        cellRef.current = node;

        if (typeof forwardedRef === 'function') {
          forwardedRef(node);
        } else if (forwardedRef) {
          // eslint-disable-next-line no-param-reassign
          forwardedRef.current = node;
        }
      }
    }, restProps), /*#__PURE__*/React.createElement("div", {
      style: {
        display: 'flex',
        flexDirection: 'row',
        alignItems: 'center'
      }
    }, children), resizingEnabled && /*#__PURE__*/React.createElement(ResizingControl, {
      onWidthChange: onWidthChange,
      onWidthDraft: onWidthDraft,
      onWidthDraftCancel: onWidthDraftCancel
    }));
  };
  process.env.NODE_ENV !== "production" ? CellLayout.propTypes = {
    tableColumn: PropTypes.object,
    tableRow: PropTypes.object,
    column: PropTypes.object,
    style: PropTypes.object,
    dragging: PropTypes.bool,
    draggingEnabled: PropTypes.bool,
    resizingEnabled: PropTypes.bool,
    onWidthChange: PropTypes.func,
    onWidthDraft: PropTypes.func,
    onWidthDraftCancel: PropTypes.func,
    className: PropTypes.string,
    children: PropTypes.node,
    getCellWidth: PropTypes.func,
    forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
  } : void 0;
  CellLayout.defaultProps = {
    column: undefined,
    tableColumn: undefined,
    tableRow: undefined,
    style: null,
    dragging: false,
    draggingEnabled: false,
    resizingEnabled: false,
    onWidthChange: undefined,
    onWidthDraft: undefined,
    onWidthDraftCancel: undefined,
    className: undefined,
    children: undefined,
    getCellWidth: function getCellWidth() {},
    forwardedRef: undefined
  };

  var TableHeaderCell = /*#__PURE__*/function (_React$PureComponent) {
    _inherits(TableHeaderCell, _React$PureComponent);

    var _super = _createSuper(TableHeaderCell);

    function TableHeaderCell(props) {
      var _this;

      _classCallCheck(this, TableHeaderCell);

      _this = _super.call(this, props);
      _this.state = {
        dragging: false
      };
      _this.dragRef = /*#__PURE__*/React.createRef();

      _this.onDragStart = function () {
        _this.setState({
          dragging: true
        });
      };

      _this.onDragEnd = function () {
        if (_this.dragRef.current) {
          _this.setState({
            dragging: false
          });
        }
      };

      return _this;
    }

    _createClass(TableHeaderCell, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            column = _this$props.column,
            draggingEnabled = _this$props.draggingEnabled;
        var dragging = this.state.dragging;
        return draggingEnabled ? /*#__PURE__*/React.createElement(dxReactCore.DragSource, {
          ref: this.dragRef,
          payload: [{
            type: 'column',
            columnName: column.name
          }],
          onStart: this.onDragStart,
          onEnd: this.onDragEnd
        }, /*#__PURE__*/React.createElement(CellLayout, _extends({}, this.props, {
          dragging: dragging
        }))) : /*#__PURE__*/React.createElement(CellLayout, _extends({}, this.props, {
          dragging: dragging
        }));
      }
    }]);

    return TableHeaderCell;
  }(React.PureComponent);
  process.env.NODE_ENV !== "production" ? TableHeaderCell.propTypes = {
    tableColumn: PropTypes.object,
    tableRow: PropTypes.object,
    column: PropTypes.object,
    style: PropTypes.object,
    draggingEnabled: PropTypes.bool,
    resizingEnabled: PropTypes.bool,
    onWidthChange: PropTypes.func,
    onWidthDraft: PropTypes.func,
    onWidthDraftCancel: PropTypes.func,
    getCellWidth: PropTypes.func,
    children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node])
  } : void 0;
  TableHeaderCell.defaultProps = {
    column: undefined,
    tableColumn: undefined,
    tableRow: undefined,
    style: null,
    draggingEnabled: false,
    resizingEnabled: false,
    onWidthChange: undefined,
    onWidthDraft: undefined,
    onWidthDraftCancel: undefined,
    children: undefined,
    getCellWidth: function getCellWidth() {}
  };

  var _excluded$H = ["align", "direction", "disabled", "children", "onSort", "getMessage", "className", "column", "style"];
  var ENTER_KEY_CODE$2 = 13;
  var SPACE_KEY_CODE$2 = 32;

  var handleMouseDown$1 = function handleMouseDown(e) {
    e.currentTarget.style.outline = 'none';
  };

  var handleBlur$1 = function handleBlur(e) {
    e.currentTarget.style.outline = '';
  };

  var _onClick = function onClick(e, onSort) {
    var isActionKeyDown = e.keyCode === ENTER_KEY_CODE$2 || e.keyCode === SPACE_KEY_CODE$2;
    var isMouseClick = e.keyCode === undefined;
    if (!(isActionKeyDown || isMouseClick)) return;
    var cancelSortingRelatedKey = e.metaKey || e.ctrlKey;
    var direction = (isMouseClick || isActionKeyDown) && cancelSortingRelatedKey ? null : undefined;
    var keepOther = e.shiftKey || cancelSortingRelatedKey;
    e.preventDefault();
    onSort({
      direction: direction,
      keepOther: keepOther
    });
  };

  var SortLabel = function SortLabel(_ref) {
    var align = _ref.align,
        direction = _ref.direction,
        disabled = _ref.disabled,
        children = _ref.children,
        onSort = _ref.onSort,
        getMessage = _ref.getMessage,
        className = _ref.className,
        column = _ref.column,
        style = _ref.style,
        restProps = _objectWithoutProperties(_ref, _excluded$H);

    return /*#__PURE__*/React.createElement("span", _extends({
      className: direction ? 'text-primary' : '',
      tabIndex: disabled ? -1 : 0 // eslint-disable-line jsx-a11y/no-noninteractive-tabindex
      ,
      onMouseDown: handleMouseDown$1,
      onBlur: handleBlur$1,
      style: _objectSpread2(_objectSpread2(_objectSpread2({
        display: 'inline-flex',
        flexDirection: 'row',
        alignItems: 'center',
        maxWidth: '100%',
        userSelect: 'none',
        MozUserSelect: 'none',
        WebkitUserSelect: 'none'
      }, !disabled ? {
        cursor: 'pointer'
      } : null), align === 'right' ? {
        flexDirection: 'row-reverse'
      } : null), style)
    }, !disabled ? {
      onKeyDown: function onKeyDown(e) {
        return _onClick(e, onSort);
      },
      onClick: function onClick(e) {
        return _onClick(e, onSort);
      }
    } : null, restProps), children, /*#__PURE__*/React.createElement(SortingIndicator, {
      key: "indicator",
      direction: direction,
      style: {
        opacity: direction ? '1' : '0',
        margin: '0 5px',
        display: 'inline-block'
      }
    }));
  };
  process.env.NODE_ENV !== "production" ? SortLabel.propTypes = {
    column: PropTypes.object,
    align: PropTypes.string,
    direction: PropTypes.oneOf(['asc', 'desc']),
    children: PropTypes.node,
    onSort: PropTypes.func.isRequired,
    disabled: PropTypes.bool,
    className: PropTypes.string,
    getMessage: PropTypes.func,
    style: PropTypes.object
  } : void 0;
  SortLabel.defaultProps = {
    column: undefined,
    direction: null,
    disabled: false,
    children: undefined,
    className: undefined,
    align: 'left',
    getMessage: function getMessage() {},
    style: null
  };

  var _excluded$I = ["disabled", "onGroup", "className", "style"];
  var GroupButton = function GroupButton(_ref) {
    var disabled = _ref.disabled,
        onGroup = _ref.onGroup,
        className = _ref.className,
        style = _ref.style,
        restProps = _objectWithoutProperties(_ref, _excluded$I);

    return /*#__PURE__*/React.createElement("i", _extends({
      className: classNames('glyphicon glyphicon-th-list', className),
      onClick: function onClick(e) {
        if (disabled) return;
        e.stopPropagation();
        onGroup();
      },
      style: _objectSpread2(_objectSpread2({
        fontSize: '9px',
        padding: '5px'
      }, !disabled ? {
        cursor: 'pointer'
      } : {
        opacity: 0.3
      }), style)
    }, restProps));
  };
  process.env.NODE_ENV !== "production" ? GroupButton.propTypes = {
    onGroup: PropTypes.func.isRequired,
    disabled: PropTypes.bool,
    className: PropTypes.string,
    style: PropTypes.object
  } : void 0;
  GroupButton.defaultProps = {
    disabled: false,
    className: undefined,
    style: null
  };

  var _excluded$J = ["children", "style"];
  var Title = function Title(_ref) {
    var children = _ref.children,
        style = _ref.style,
        restProps = _objectWithoutProperties(_ref, _excluded$J);

    return /*#__PURE__*/React.createElement("span", _extends({
      style: _objectSpread2({
        overflow: 'hidden',
        textOverflow: 'ellipsis'
      }, style)
    }, restProps), children);
  };
  process.env.NODE_ENV !== "production" ? Title.propTypes = {
    children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),
    style: PropTypes.object
  } : void 0;
  Title.defaultProps = {
    style: null,
    children: undefined
  };

  var _excluded$K = ["column", "children", "align", "style"];
  var Content$1 = function Content(_ref) {
    var column = _ref.column,
        children = _ref.children,
        align = _ref.align,
        style = _ref.style,
        restProps = _objectWithoutProperties(_ref, _excluded$K);

    return /*#__PURE__*/React.createElement("div", _extends({
      style: _objectSpread2({
        width: '100%',
        minWidth: 0,
        display: 'flex',
        flexDirection: 'row',
        alignItems: 'flex-end',
        // eslint-disable-next-line no-nested-ternary
        justifyContent: align === 'center' ? 'center' : align === 'right' ? 'flex-end' : 'flex-start'
      }, style)
    }, restProps), children);
  };
  process.env.NODE_ENV !== "production" ? Content$1.propTypes = {
    column: PropTypes.object,
    children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),
    align: PropTypes.string,
    style: PropTypes.object
  } : void 0;
  Content$1.defaultProps = {
    column: undefined,
    align: 'left',
    style: null,
    children: undefined
  };

  var TableHeaderRow = dxReactCore.withComponents({
    Cell: TableHeaderCell,
    Row: TableRow,
    Content: Content$1,
    SortLabel: SortLabel,
    Title: Title,
    GroupButton: GroupButton
  })(dxReactGrid.TableHeaderRow);
  TableHeaderRow.ROW_TYPE = dxReactGrid.TableHeaderRow.ROW_TYPE;

  var _excluded$L = ["style", "column", "value", "children", "tableRow", "tableColumn", "row", "beforeBorder", "forwardedRef"];
  var Cell$1 = /*#__PURE__*/function (_React$PureComponent) {
    _inherits(Cell, _React$PureComponent);

    var _super = _createSuper(Cell);

    function Cell() {
      _classCallCheck(this, Cell);

      return _super.apply(this, arguments);
    }

    _createClass(Cell, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            style = _this$props.style,
            column = _this$props.column,
            value = _this$props.value,
            children = _this$props.children,
            tableRow = _this$props.tableRow,
            tableColumn = _this$props.tableColumn,
            row = _this$props.row,
            beforeBorder = _this$props.beforeBorder,
            forwardedRef = _this$props.forwardedRef,
            restProps = _objectWithoutProperties(_this$props, _excluded$L);

        var borderColor = this.context.borderColor;
        return /*#__PURE__*/React.createElement("th", _extends({
          ref: forwardedRef,
          style: _objectSpread2(_objectSpread2({
            whiteSpace: 'nowrap',
            overflow: 'hidden',
            textOverflow: 'ellipsis',
            borderTop: 'none',
            borderBottom: "1px solid ".concat(borderColor),
            borderRight: "1px solid ".concat(borderColor)
          }, beforeBorder ? {
            borderLeft: "1px solid ".concat(borderColor)
          } : null), style)
        }, restProps), children);
      }
    }]);

    return Cell;
  }(React.PureComponent);
  Cell$1.contextType = StyleContext;
  process.env.NODE_ENV !== "production" ? Cell$1.propTypes = {
    style: PropTypes.object,
    value: PropTypes.any,
    column: PropTypes.object,
    row: PropTypes.any,
    children: PropTypes.node,
    tableRow: PropTypes.object,
    tableColumn: PropTypes.object,
    beforeBorder: PropTypes.bool,
    forwardedRef: PropTypes.func
  } : void 0;
  Cell$1.defaultProps = {
    style: null,
    value: undefined,
    column: undefined,
    row: undefined,
    children: undefined,
    tableRow: undefined,
    tableColumn: undefined,
    beforeBorder: false,
    forwardedRef: undefined
  };

  var _excluded$M = ["component", "style", "beforeBorder"];
  var BandedHeaderCell = /*#__PURE__*/function (_React$PureComponent) {
    _inherits(BandedHeaderCell, _React$PureComponent);

    var _super = _createSuper(BandedHeaderCell);

    function BandedHeaderCell() {
      _classCallCheck(this, BandedHeaderCell);

      return _super.apply(this, arguments);
    }

    _createClass(BandedHeaderCell, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            HeaderCellComponent = _this$props.component,
            style = _this$props.style,
            beforeBorder = _this$props.beforeBorder,
            restProps = _objectWithoutProperties(_this$props, _excluded$M);

        var borderColor = this.context.borderColor;
        return /*#__PURE__*/React.createElement(HeaderCellComponent, _extends({
          style: _objectSpread2(_objectSpread2({
            borderTop: 'none',
            borderRight: "1px solid ".concat(borderColor)
          }, beforeBorder ? {
            borderLeft: "1px solid ".concat(borderColor)
          } : null), style)
        }, restProps));
      }
    }]);

    return BandedHeaderCell;
  }(React.PureComponent);
  BandedHeaderCell.contextType = StyleContext;
  process.env.NODE_ENV !== "production" ? BandedHeaderCell.propTypes = {
    component: PropTypes.func.isRequired,
    style: PropTypes.object,
    beforeBorder: PropTypes.bool
  } : void 0;
  BandedHeaderCell.defaultProps = {
    style: null,
    beforeBorder: false
  };

  var InvisibleCell = function InvisibleCell() {
    return /*#__PURE__*/React.createElement("th", {
      style: {
        display: 'none'
      }
    });
  };

  var TableBandHeader = dxReactCore.withComponents({
    Cell: Cell$1,
    Row: TableRow,
    BandedHeaderCell: BandedHeaderCell,
    InvisibleCell: InvisibleCell
  })(dxReactGrid.TableBandHeader);
  TableBandHeader.ROW_TYPE = dxReactGrid.TableBandHeader.ROW_TYPE;

  var _excluded$N = ["column", "value", "onValueChange", "style", "children", "row", "tableRow", "tableColumn", "editingEnabled", "autoFocus", "onBlur", "onFocus", "onKeyDown", "forwardedRef"];
  var EditCell = function EditCell(_ref) {
    var column = _ref.column,
        value = _ref.value,
        onValueChange = _ref.onValueChange,
        style = _ref.style,
        children = _ref.children,
        row = _ref.row,
        tableRow = _ref.tableRow,
        tableColumn = _ref.tableColumn,
        editingEnabled = _ref.editingEnabled,
        autoFocus = _ref.autoFocus,
        onBlur = _ref.onBlur,
        onFocus = _ref.onFocus,
        onKeyDown = _ref.onKeyDown,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$N);

    var patchedChildren = children ? /*#__PURE__*/React.cloneElement(children, {
      autoFocus: autoFocus,
      onBlur: onBlur,
      onFocus: onFocus,
      onKeyDown: onKeyDown
    }) : children;
    return /*#__PURE__*/React.createElement("td", _extends({
      ref: forwardedRef,
      style: _objectSpread2({
        verticalAlign: 'middle',
        padding: '1px'
      }, style)
    }, restProps), patchedChildren || /*#__PURE__*/React.createElement("input", {
      type: "text",
      className: "form-control",
      value: value,
      onChange: function onChange(e) {
        return onValueChange(e.target.value);
      },
      readOnly: !editingEnabled,
      style: {
        width: '100%',
        textAlign: tableColumn && tableColumn.align
      } // eslint-disable-next-line jsx-a11y/no-autofocus
      ,
      autoFocus: autoFocus,
      onBlur: onBlur,
      onFocus: onFocus,
      onKeyDown: onKeyDown
    }));
  };
  process.env.NODE_ENV !== "production" ? EditCell.propTypes = {
    column: PropTypes.object,
    row: PropTypes.any,
    tableColumn: PropTypes.object,
    tableRow: PropTypes.object,
    value: PropTypes.any,
    onValueChange: PropTypes.func,
    style: PropTypes.object,
    editingEnabled: PropTypes.bool,
    children: PropTypes.node,
    autoFocus: PropTypes.bool,
    onBlur: PropTypes.func,
    onFocus: PropTypes.func,
    onKeyDown: PropTypes.func,
    forwardedRef: PropTypes.func
  } : void 0;
  EditCell.defaultProps = {
    column: undefined,
    row: undefined,
    tableColumn: undefined,
    tableRow: undefined,
    value: '',
    onValueChange: function onValueChange() {},
    style: null,
    children: undefined,
    editingEnabled: true,
    autoFocus: false,
    onBlur: function onBlur() {},
    onFocus: function onFocus() {},
    onKeyDown: function onKeyDown() {},
    forwardedRef: undefined
  };

  var TableEditRow = dxReactCore.withComponents({
    Row: TableRow,
    Cell: EditCell
  })(dxReactGrid.TableEditRow);
  TableEditRow.ADDED_ROW_TYPE = dxReactGrid.TableEditRow.ADDED_ROW_TYPE;
  TableEditRow.EDIT_ROW_TYPE = dxReactGrid.TableEditRow.EDIT_ROW_TYPE;

  var _excluded$O = ["onExecute", "text", "className"],
      _excluded2$2 = ["children", "style", "tableColumn", "tableRow", "forwardedRef"],
      _excluded3$1 = ["tableColumn", "tableRow", "row", "children", "style", "forwardedRef"];
  var CommandButton = function CommandButton(_ref) {
    var onExecute = _ref.onExecute,
        text = _ref.text,
        className = _ref.className,
        restProps = _objectWithoutProperties(_ref, _excluded$O);

    return /*#__PURE__*/React.createElement("button", _extends({
      type: "button",
      className: classNames('btn', 'btn-link', className),
      style: {
        outline: 'none'
      },
      onClick: function onClick(e) {
        e.stopPropagation();
        onExecute();
      }
    }, restProps), text);
  };
  process.env.NODE_ENV !== "production" ? CommandButton.propTypes = {
    text: PropTypes.string.isRequired,
    onExecute: PropTypes.func.isRequired,
    className: PropTypes.string
  } : void 0;
  CommandButton.defaultProps = {
    className: undefined
  };
  var EditCommandHeadingCell = function EditCommandHeadingCell(_ref2) {
    var children = _ref2.children,
        style = _ref2.style,
        tableColumn = _ref2.tableColumn,
        tableRow = _ref2.tableRow,
        forwardedRef = _ref2.forwardedRef,
        restProps = _objectWithoutProperties(_ref2, _excluded2$2);

    return /*#__PURE__*/React.createElement("th", _extends({
      ref: forwardedRef,
      style: _objectSpread2({
        whiteSpace: 'nowrap',
        textAlign: 'center',
        padding: 0
      }, style)
    }, restProps), children);
  };
  process.env.NODE_ENV !== "production" ? EditCommandHeadingCell.propTypes = {
    children: PropTypes.node,
    style: PropTypes.object,
    tableColumn: PropTypes.object,
    tableRow: PropTypes.object,
    forwardedRef: PropTypes.func
  } : void 0;
  EditCommandHeadingCell.defaultProps = {
    children: undefined,
    style: null,
    tableColumn: undefined,
    tableRow: undefined,
    forwardedRef: undefined
  };
  var EditCommandCell = function EditCommandCell(_ref3) {
    var tableColumn = _ref3.tableColumn,
        tableRow = _ref3.tableRow,
        row = _ref3.row,
        children = _ref3.children,
        style = _ref3.style,
        forwardedRef = _ref3.forwardedRef,
        restProps = _objectWithoutProperties(_ref3, _excluded3$1);

    return /*#__PURE__*/React.createElement("td", _extends({
      ref: forwardedRef,
      style: _objectSpread2({
        whiteSpace: 'nowrap',
        textAlign: 'center',
        padding: 0
      }, style)
    }, restProps), children);
  };
  process.env.NODE_ENV !== "production" ? EditCommandCell.propTypes = {
    children: PropTypes.node,
    style: PropTypes.object,
    tableColumn: PropTypes.object,
    tableRow: PropTypes.object,
    row: PropTypes.any,
    forwardedRef: PropTypes.func
  } : void 0;
  EditCommandCell.defaultProps = {
    children: undefined,
    style: null,
    tableColumn: undefined,
    tableRow: undefined,
    row: undefined,
    forwardedRef: undefined
  };

  var TableEditColumn = dxReactCore.withComponents({
    Cell: EditCommandCell,
    HeaderCell: EditCommandHeadingCell,
    Command: CommandButton
  })(dxReactGrid.TableEditColumn);
  TableEditColumn.COLUMN_TYPE = dxReactGrid.TableEditColumn.COLUMN_TYPE;

  var _excluded$P = ["getMessage", "className", "style"];
  var EmptyMessage = function EmptyMessage(_ref) {
    var getMessage = _ref.getMessage,
        className = _ref.className,
        style = _ref.style,
        restProps = _objectWithoutProperties(_ref, _excluded$P);

    return /*#__PURE__*/React.createElement("div", _extends({
      className: classNames('panel-body', className),
      style: _objectSpread2({
        textAlign: 'center',
        padding: '40px 0px'
      }, style)
    }, restProps), /*#__PURE__*/React.createElement("big", {
      className: "text-muted"
    }, getMessage('noColumns')));
  };
  process.env.NODE_ENV !== "production" ? EmptyMessage.propTypes = {
    getMessage: PropTypes.func.isRequired,
    className: PropTypes.string,
    style: PropTypes.object
  } : void 0;
  EmptyMessage.defaultProps = {
    className: undefined,
    style: null
  };

  var TableColumnVisibility = dxReactCore.withComponents({
    EmptyMessage: EmptyMessage
  })(dxReactGrid.TableColumnVisibility);

  var _excluded$Q = ["style"];
  var TableInvisibleRow = function TableInvisibleRow(_ref) {
    var style = _ref.style,
        restParams = _objectWithoutProperties(_ref, _excluded$Q);

    return /*#__PURE__*/React.createElement(TableRow, _extends({
      style: _objectSpread2({
        visibility: 'hidden'
      }, style)
    }, restParams));
  };
  process.env.NODE_ENV !== "production" ? TableInvisibleRow.propTypes = {
    style: PropTypes.object
  } : void 0;
  TableInvisibleRow.defaultProps = {
    style: null
  };

  var TableReorderingCell = function TableReorderingCell(_ref) {
    var style = _ref.style,
        getCellDimensions = _ref.getCellDimensions;

    var refHandler = function refHandler(node) {
      return node && getCellDimensions(function () {
        return dxGridCore.getCellGeometries(node);
      });
    };

    return /*#__PURE__*/React.createElement("td", {
      ref: refHandler,
      style: _objectSpread2(_objectSpread2({}, style), {}, {
        padding: 0,
        border: 'none'
      })
    });
  };
  process.env.NODE_ENV !== "production" ? TableReorderingCell.propTypes = {
    getCellDimensions: PropTypes.func.isRequired,
    style: PropTypes.object
  } : void 0;
  TableReorderingCell.defaultProps = {
    style: null
  };

  var TableColumnReordering = dxReactCore.withComponents({
    Row: TableInvisibleRow,
    Cell: TableReorderingCell
  })(dxReactGrid.TableColumnReordering);

  var _excluded$R = ["minColumnWidth", "maxColumnWidth"];
  var TableColumnResizing = /*#__PURE__*/function (_React$PureComponent) {
    _inherits(TableColumnResizing, _React$PureComponent);

    var _super = _createSuper(TableColumnResizing);

    function TableColumnResizing() {
      _classCallCheck(this, TableColumnResizing);

      return _super.apply(this, arguments);
    }

    _createClass(TableColumnResizing, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            minColumnWidth = _this$props.minColumnWidth,
            maxColumnWidth = _this$props.maxColumnWidth,
            restProps = _objectWithoutProperties(_this$props, _excluded$R);

        return /*#__PURE__*/React.createElement(dxReactGrid.TableColumnResizing, _extends({}, restProps, {
          minColumnWidth: minColumnWidth,
          maxColumnWidth: maxColumnWidth
        }));
      }
    }]);

    return TableColumnResizing;
  }(React.PureComponent);
  process.env.NODE_ENV !== "production" ? TableColumnResizing.propTypes = {
    minColumnWidth: PropTypes.number,
    maxColumnWidth: PropTypes.number
  } : void 0;
  TableColumnResizing.defaultProps = {
    minColumnWidth: 45,
    maxColumnWidth: Infinity
  };

  var _excluded$S = ["children", "className", "style", "forwardedRef"];

  var ToolbarBase = function ToolbarBase(_ref) {
    var children = _ref.children,
        className = _ref.className,
        style = _ref.style,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$S);

    return /*#__PURE__*/React.createElement("div", _extends({
      className: classNames('panel-heading', className),
      ref: forwardedRef,
      style: _objectSpread2({
        display: 'flex',
        alignItems: 'center',
        position: 'relative',
        minHeight: '55px',
        padding: '0px 15px',
        flex: 'none'
      }, style)
    }, restProps), children);
  };

  process.env.NODE_ENV !== "production" ? ToolbarBase.propTypes = {
    children: PropTypes.node.isRequired,
    className: PropTypes.string,
    style: PropTypes.object,
    forwardedRef: PropTypes.func
  } : void 0;
  ToolbarBase.defaultProps = {
    className: undefined,
    style: null,
    forwardedRef: undefined
  };
  var Toolbar = dxReactGrid.withKeyboardNavigation('toolbar', 'none')(ToolbarBase);

  var FlexibleSpace = function FlexibleSpace() {
    return /*#__PURE__*/React.createElement("div", {
      style: {
        flex: '0 0 0',
        marginLeft: 'auto'
      }
    });
  };

  var Toolbar$1 = dxReactCore.withComponents({
    Root: Toolbar,
    FlexibleSpace: FlexibleSpace
  })(dxReactGrid.Toolbar);

  var _excluded$T = ["style", "visible", "expanded", "onToggle"];
  var TableTreeExpandButton = function TableTreeExpandButton(_ref) {
    var style = _ref.style,
        visible = _ref.visible,
        expanded = _ref.expanded,
        onToggle = _ref.onToggle,
        restProps = _objectWithoutProperties(_ref, _excluded$T);

    return /*#__PURE__*/React.createElement(ExpandButton, _extends({
      visible: visible,
      expanded: expanded,
      onToggle: onToggle,
      style: _objectSpread2({
        marginRight: '8px'
      }, style)
    }, restProps));
  };
  process.env.NODE_ENV !== "production" ? TableTreeExpandButton.propTypes = {
    style: PropTypes.object,
    visible: PropTypes.bool,
    expanded: PropTypes.bool,
    onToggle: PropTypes.func
  } : void 0;
  TableTreeExpandButton.defaultProps = {
    style: null,
    visible: false,
    expanded: false,
    onToggle: function onToggle() {}
  };

  var _excluded$U = ["style", "checked", "indeterminate", "disabled", "onChange"];
  var TableTreeCheckbox = function TableTreeCheckbox(_ref) {
    var style = _ref.style,
        checked = _ref.checked,
        indeterminate = _ref.indeterminate,
        disabled = _ref.disabled,
        onChange = _ref.onChange,
        restProps = _objectWithoutProperties(_ref, _excluded$U);

    return /*#__PURE__*/React.createElement(SelectionControl, _extends({
      disabled: disabled,
      checked: checked,
      indeterminate: indeterminate,
      onChange: onChange,
      style: _objectSpread2({
        marginRight: '16px'
      }, style)
    }, restProps));
  };
  process.env.NODE_ENV !== "production" ? TableTreeCheckbox.propTypes = {
    style: PropTypes.object,
    checked: PropTypes.bool,
    indeterminate: PropTypes.bool,
    disabled: PropTypes.bool,
    onChange: PropTypes.func
  } : void 0;
  TableTreeCheckbox.defaultProps = {
    style: null,
    checked: false,
    indeterminate: false,
    disabled: false,
    onChange: function onChange() {}
  };

  var TableTreeIndent = /*#__PURE__*/React.memo(function (_ref) {
    var level = _ref.level;
    return Array.from({
      length: level
    }).map(function (value, currentLevel) {
      return /*#__PURE__*/React.createElement("span", {
        // eslint-disable-next-line react/no-array-index-key
        key: currentLevel,
        style: {
          display: 'inline-block',
          marginRight: '16px'
        }
      });
    });
  });
  TableTreeIndent.propTypes = {
    level: PropTypes.number
  };
  TableTreeIndent.defaultProps = {
    level: 0
  };

  var _excluded$V = ["column", "value", "children", "tableRow", "tableColumn", "row", "style", "forwardedRef"];
  var TableTreeCell = function TableTreeCell(_ref) {
    var column = _ref.column,
        value = _ref.value,
        children = _ref.children,
        tableRow = _ref.tableRow,
        tableColumn = _ref.tableColumn,
        row = _ref.row,
        style = _ref.style,
        forwardedRef = _ref.forwardedRef,
        restProps = _objectWithoutProperties(_ref, _excluded$V);

    return /*#__PURE__*/React.createElement("td", _extends({
      ref: forwardedRef,
      style: _objectSpread2({
        textAlign: tableColumn && tableColumn.align || 'left',
        whiteSpace: tableColumn && tableColumn.wordWrapEnabled ? 'normal' : 'nowrap'
      }, style)
    }, restProps), /*#__PURE__*/React.createElement("div", {
      style: {
        display: 'flex',
        flexDirection: 'row',
        alignItems: 'center'
      }
    }, children));
  };
  process.env.NODE_ENV !== "production" ? TableTreeCell.propTypes = {
    value: PropTypes.any,
    column: PropTypes.object,
    row: PropTypes.any,
    children: PropTypes.node,
    tableRow: PropTypes.object,
    tableColumn: PropTypes.object,
    style: PropTypes.object,
    forwardedRef: PropTypes.func
  } : void 0;
  TableTreeCell.defaultProps = {
    value: undefined,
    column: undefined,
    row: undefined,
    children: undefined,
    tableRow: undefined,
    tableColumn: undefined,
    style: null,
    forwardedRef: undefined
  };

  var _excluded$W = ["children", "style"];
  var TableTreeContent = function TableTreeContent(_ref) {
    var children = _ref.children,
        style = _ref.style,
        restProps = _objectWithoutProperties(_ref, _excluded$W);

    return /*#__PURE__*/React.createElement("div", _extends({
      style: _objectSpread2({
        width: '100%',
        overflow: 'hidden',
        textOverflow: 'ellipsis'
      }, style)
    }, restProps), children);
  };
  process.env.NODE_ENV !== "production" ? TableTreeContent.propTypes = {
    children: PropTypes.node,
    style: PropTypes.object
  } : void 0;
  TableTreeContent.defaultProps = {
    children: undefined,
    style: null
  };

  var TableTreeColumn = dxReactCore.withComponents({
    Cell: TableTreeCell,
    Content: TableTreeContent,
    Indent: TableTreeIndent,
    ExpandButton: TableTreeExpandButton,
    Checkbox: TableTreeCheckbox
  })(dxReactGrid.TableTreeColumn);

  var _excluded$X = ["onValueChange", "value", "getMessage", "style", "className", "inputRef"];
  var SearchPanelInput = function SearchPanelInput(_ref) {
    var onValueChange = _ref.onValueChange,
        value = _ref.value,
        getMessage = _ref.getMessage,
        style = _ref.style,
        className = _ref.className,
        inputRef = _ref.inputRef,
        restProps = _objectWithoutProperties(_ref, _excluded$X);

    return /*#__PURE__*/React.createElement("input", _extends({
      type: "text",
      ref: inputRef,
      className: classNames('form-control', className),
      onChange: function onChange(e) {
        return onValueChange(e.target.value);
      },
      value: value,
      style: _objectSpread2({
        maxWidth: '25%'
      }, style),
      placeholder: getMessage('searchPlaceholder')
    }, restProps));
  };
  process.env.NODE_ENV !== "production" ? SearchPanelInput.propTypes = {
    value: PropTypes.any,
    onValueChange: PropTypes.func.isRequired,
    style: PropTypes.object,
    getMessage: PropTypes.func.isRequired,
    className: PropTypes.string,
    inputRef: PropTypes.object
  } : void 0;
  SearchPanelInput.defaultProps = {
    value: null,
    style: null,
    className: undefined,
    inputRef: undefined
  };

  var SearchPanel = dxReactCore.withComponents({
    Input: SearchPanelInput
  })(dxReactGrid.SearchPanel);

  var _excluded$Y = ["component", "position", "selected", "showLeftDivider", "showRightDivider", "side", "style"];
  var FixedCell = function FixedCell(_ref) {
    var CellPlaceholder = _ref.component,
        position = _ref.position,
        selected = _ref.selected,
        showLeftDivider = _ref.showLeftDivider,
        showRightDivider = _ref.showRightDivider,
        side = _ref.side,
        style = _ref.style,
        restProps = _objectWithoutProperties(_ref, _excluded$Y);

    var _useContext = React.useContext(StyleContext),
        backgroundColor = _useContext.backgroundColor,
        borderColor = _useContext.borderColor,
        stickyPosition = _useContext.stickyPosition;

    return /*#__PURE__*/React__default.createElement(CellPlaceholder, _extends({
      style: _objectSpread2(_objectSpread2(_defineProperty({
        backgroundClip: 'padding-box',
        backgroundColor: selected ? null : backgroundColor,
        position: stickyPosition,
        zIndex: 300
      }, side, position), borderColor ? _objectSpread2(_objectSpread2({}, showLeftDivider ? {
        borderLeft: "1px solid ".concat(borderColor)
      } : null), showRightDivider ? {
        borderRight: "1px solid ".concat(borderColor)
      } : null) : null), style)
    }, restProps));
  };
  process.env.NODE_ENV !== "production" ? FixedCell.propTypes = {
    component: PropTypes.func.isRequired,
    position: PropTypes.number,
    selected: PropTypes.bool,
    showLeftDivider: PropTypes.bool,
    showRightDivider: PropTypes.bool,
    side: PropTypes.string.isRequired,
    style: PropTypes.object
  } : void 0;
  FixedCell.defaultProps = {
    position: undefined,
    selected: false,
    showLeftDivider: false,
    showRightDivider: false,
    style: null
  };

  var _excluded$Z = ["style"],
      _excluded2$3 = ["listen", "onSizeChange"];
  var TableBorderlessStubCell = function TableBorderlessStubCell(_ref) {
    var style = _ref.style,
        restParams = _objectWithoutProperties(_ref, _excluded$Z);

    return /*#__PURE__*/React.createElement(TableStubCell, _extends({
      style: _objectSpread2({
        border: 'none'
      }, style)
    }, restParams));
  };
  process.env.NODE_ENV !== "production" ? TableBorderlessStubCell.propTypes = {
    style: PropTypes.object
  } : void 0;
  TableBorderlessStubCell.defaultProps = {
    style: null
  };
  var TableListenerCell = function TableListenerCell(_ref2) {
    var listen = _ref2.listen,
        onSizeChange = _ref2.onSizeChange,
        restProps = _objectWithoutProperties(_ref2, _excluded2$3);

    return listen ? /*#__PURE__*/React.createElement(dxReactCore.Sizer, _extends({
      containerComponent: TableBorderlessStubCell,
      onSizeChange: onSizeChange
    }, restProps)) : /*#__PURE__*/React.createElement(TableBorderlessStubCell, restProps);
  };
  process.env.NODE_ENV !== "production" ? TableListenerCell.propTypes = {
    listen: PropTypes.bool.isRequired,
    onSizeChange: PropTypes.func.isRequired
  } : void 0;

  var TableFixedColumns = dxReactCore.withComponents({
    Cell: FixedCell,
    ListenerRow: TableInvisibleRow,
    ListenerCell: TableListenerCell
  })(dxReactGrid.TableFixedColumns);

  var TableSummaryRow = dxReactCore.withComponents({
    TotalRow: TableRow,
    GroupRow: TableRow,
    TreeRow: TableRow,
    TotalCell: TableCell,
    GroupCell: TableCell,
    TreeCell: TableCell,
    TableTreeCell: TableTreeCell,
    TableTreeContent: TableTreeContent,
    TableTreeIndent: TableTreeIndent,
    Item: TableSummaryItem
  })(dxReactGrid.TableSummaryRow);
  TableSummaryRow.TREE_ROW_TYPE = dxReactGrid.TableSummaryRow.TREE_ROW_TYPE;
  TableSummaryRow.GROUP_ROW_TYPE = dxReactGrid.TableSummaryRow.GROUP_ROW_TYPE;
  TableSummaryRow.TOTAL_ROW_TYPE = dxReactGrid.TableSummaryRow.TOTAL_ROW_TYPE;

  var TableInlineCellEditing = dxReactCore.withComponents({
    Cell: EditCell
  })(dxReactGrid.TableInlineCellEditing);

  var _excluded$_ = ["onToggle", "getMessage", "buttonRef", "className"];
  var ToggleButton$2 = function ToggleButton(_ref) {
    var onToggle = _ref.onToggle,
        getMessage = _ref.getMessage,
        buttonRef = _ref.buttonRef,
        className = _ref.className,
        restProps = _objectWithoutProperties(_ref, _excluded$_);

    return /*#__PURE__*/React.createElement("button", _extends({
      type: "button",
      className: classNames('btn btn-link', className),
      onClick: onToggle,
      ref: buttonRef
    }, restProps), /*#__PURE__*/React.createElement(reactBootstrap.Glyphicon, {
      glyph: "save"
    }));
  };
  process.env.NODE_ENV !== "production" ? ToggleButton$2.propTypes = {
    onToggle: PropTypes.func.isRequired,
    getMessage: PropTypes.func.isRequired,
    buttonRef: PropTypes.func.isRequired,
    className: PropTypes.string
  } : void 0;
  ToggleButton$2.defaultProps = {
    className: undefined
  };

  var _excluded$$ = ["visible", "target", "onHide", "children"];
  var Menu = function Menu(_ref) {
    var visible = _ref.visible,
        target = _ref.target,
        onHide = _ref.onHide,
        children = _ref.children,
        restProps = _objectWithoutProperties(_ref, _excluded$$);

    return /*#__PURE__*/React.createElement(Overlay, _extends({
      visible: visible,
      target: target,
      onHide: onHide,
      container: undefined
    }, restProps), /*#__PURE__*/React.createElement(reactBootstrap.ListGroup, {
      style: {
        marginBottom: 0
      }
    }, children));
  };
  process.env.NODE_ENV !== "production" ? Menu.propTypes = {
    onHide: PropTypes.func.isRequired,
    children: PropTypes.node.isRequired,
    visible: PropTypes.bool,
    target: PropTypes.oneOfType([PropTypes.object, PropTypes.func])
  } : void 0;
  Menu.defaultProps = {
    visible: false,
    target: null
  };

  var _excluded$10 = ["text", "onClick"];
  var MenuItem = function MenuItem(_ref) {
    var text = _ref.text,
        onClick = _ref.onClick,
        restProps = _objectWithoutProperties(_ref, _excluded$10);

    return /*#__PURE__*/React.createElement(reactBootstrap.ListGroupItem, _extends({
      style: {
        outline: 'none',
        whiteSpace: 'nowrap',
        display: 'flex',
        alignItems: 'center'
      },
      onClick: onClick
    }, restProps), text);
  };
  process.env.NODE_ENV !== "production" ? MenuItem.propTypes = {
    text: PropTypes.string.isRequired,
    onClick: PropTypes.func
  } : void 0;
  MenuItem.defaultProps = {
    onClick: function onClick() {}
  };

  var ExportPanel = dxReactCore.withComponents({
    ToggleButton: ToggleButton$2,
    Menu: Menu,
    MenuItem: MenuItem
  })(dxReactGrid.ExportPanel);

  var _excluded$11 = ["component", "focused", "style"];

  var FocusCellBase = function FocusCellBase(_ref) {
    var CellPlaceholder = _ref.component,
        focused = _ref.focused,
        style = _ref.style,
        restProps = _objectWithoutProperties(_ref, _excluded$11);

    var borderStyle = '1px solid #337ab7';
    var border = {
      borderTop: borderStyle,
      borderLeft: borderStyle,
      borderRight: borderStyle,
      borderBottom: borderStyle
    };
    return /*#__PURE__*/React__default.createElement(CellPlaceholder, _extends({}, restProps, {
      style: _objectSpread2(_objectSpread2({
        outline: 'none'
      }, focused ? border : null), style)
    }));
  };

  process.env.NODE_ENV !== "production" ? FocusCellBase.propTypes = {
    component: PropTypes.func.isRequired,
    focused: PropTypes.bool,
    style: PropTypes.object
  } : void 0;
  FocusCellBase.defaultProps = {
    focused: undefined,
    style: undefined
  };
  var FocusCell = dxReactGrid.withKeyboardNavigation()(FocusCellBase);

  var _excluded$12 = ["component", "focused", "className"];
  var FocusRow = /*#__PURE__*/function (_React$PureComponent) {
    _inherits(FocusRow, _React$PureComponent);

    var _super = _createSuper(FocusRow);

    function FocusRow() {
      _classCallCheck(this, FocusRow);

      return _super.apply(this, arguments);
    }

    _createClass(FocusRow, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            RowPlaceholder = _this$props.component,
            focused = _this$props.focused,
            className = _this$props.className,
            restProps = _objectWithoutProperties(_this$props, _excluded$12);

        return /*#__PURE__*/React__default.createElement(RowPlaceholder, _extends({
          className: classNames(focused ? 'active' : '', className)
        }, restProps));
      }
    }]);

    return FocusRow;
  }(React__default.PureComponent);
  process.env.NODE_ENV !== "production" ? FocusRow.propTypes = {
    className: PropTypes.string,
    component: PropTypes.func.isRequired,
    focused: PropTypes.bool
  } : void 0;
  FocusRow.defaultProps = {
    focused: undefined,
    className: undefined
  };

  var TableKeyboardNavigation = dxReactCore.withComponents({
    Cell: FocusCell,
    Row: FocusRow
  })(dxReactGrid.TableKeyboardNavigation);

  exports.ColumnChooser = ColumnChooser;
  exports.DragDropProvider = DragDropProvider;
  exports.ExportPanel = ExportPanel;
  exports.Grid = Grid;
  exports.GroupingPanel = GroupingPanel;
  exports.PagingPanel = PagingPanel;
  exports.SearchPanel = SearchPanel;
  exports.Table = Table$1;
  exports.TableBandHeader = TableBandHeader;
  exports.TableColumnReordering = TableColumnReordering;
  exports.TableColumnResizing = TableColumnResizing;
  exports.TableColumnVisibility = TableColumnVisibility;
  exports.TableEditColumn = TableEditColumn;
  exports.TableEditRow = TableEditRow;
  exports.TableFilterRow = TableFilterRow;
  exports.TableFixedColumns = TableFixedColumns;
  exports.TableGroupRow = TableGroupRow;
  exports.TableHeaderRow = TableHeaderRow;
  exports.TableInlineCellEditing = TableInlineCellEditing;
  exports.TableKeyboardNavigation = TableKeyboardNavigation;
  exports.TableRowDetail = TableRowDetail;
  exports.TableSelection = TableSelection;
  exports.TableSummaryRow = TableSummaryRow;
  exports.TableTreeColumn = TableTreeColumn;
  exports.Toolbar = Toolbar$1;
  exports.VirtualTable = VirtualTable;

  Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=dx-react-grid-bootstrap3.umd.cjs.map