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

'use strict';

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

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

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var React = require('react');
var PropTypes = _interopDefault(require('prop-types'));
var dxReactGrid = require('@devexpress/dx-react-grid');
var classNames = _interopDefault(require('clsx'));
var material = require('@mui/material');
var dxReactCore = require('@devexpress/dx-react-core');
var VisibilityOff = _interopDefault(require('@mui/icons-material/VisibilityOff'));
var ChevronLeft = _interopDefault(require('@mui/icons-material/ChevronLeft'));
var ChevronRight = _interopDefault(require('@mui/icons-material/ChevronRight'));
var dxGridCore = require('@devexpress/dx-grid-core');
var ExpandMore = _interopDefault(require('@mui/icons-material/ExpandMore'));
var ExpandLess = _interopDefault(require('@mui/icons-material/ExpandLess'));
var SearchIcon = _interopDefault(require('@mui/icons-material/Search'));
var List = _interopDefault(require('@mui/icons-material/List'));
var Save = _interopDefault(require('@mui/icons-material/Save'));

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.");
}

var _excluded = ["children", "className", "rootRef"];
var PREFIX = 'Layout';
var classes = {
  root: "".concat(PREFIX, "-root")
};
var StyledDiv = material.styled('div')(function () {
  return _defineProperty({}, "&.".concat(classes.root), {
    display: 'flex',
    flexDirection: 'column'
  });
});
var Root = function Root(_ref2) {
  var children = _ref2.children,
      className = _ref2.className,
      rootRef = _ref2.rootRef,
      restProps = _objectWithoutProperties(_ref2, _excluded);

  return /*#__PURE__*/React.createElement(StyledDiv, _extends({
    className: classNames(classes.root, className),
    ref: rootRef
  }, restProps), children);
};
process.env.NODE_ENV !== "production" ? Root.propTypes = {
  children: PropTypes.node.isRequired,
  className: PropTypes.string,
  rootRef: PropTypes.object
} : void 0;
Root.defaultProps = {
  className: undefined,
  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 _excluded$2 = ["visible", "onHide", "children", "target"];
var Overlay = function Overlay(_ref) {
  var visible = _ref.visible,
      onHide = _ref.onHide,
      children = _ref.children,
      target = _ref.target,
      restProps = _objectWithoutProperties(_ref, _excluded$2);

  return /*#__PURE__*/React.createElement(material.Popover, _extends({
    open: visible,
    anchorEl: target,
    onClose: onHide,
    anchorOrigin: {
      vertical: 'top',
      horizontal: 'right'
    },
    transformOrigin: {
      vertical: 'top',
      horizontal: 'right'
    }
  }, restProps), children);
};
process.env.NODE_ENV !== "production" ? Overlay.propTypes = {
  onHide: PropTypes.func.isRequired,
  children: PropTypes.node.isRequired,
  visible: PropTypes.bool,
  target: PropTypes.oneOfType([PropTypes.object, PropTypes.func])
} : void 0;
Overlay.defaultProps = {
  visible: false,
  target: null
};

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

  return /*#__PURE__*/React.createElement(material.List, _extends({
    dense: true
  }, restProps), children);
};
process.env.NODE_ENV !== "production" ? Container.propTypes = {
  children: PropTypes.node.isRequired
} : void 0;

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

  return /*#__PURE__*/React.createElement(material.Tooltip, {
    title: getMessage('showColumnChooser'),
    placement: "bottom",
    enterDelay: 300
  }, /*#__PURE__*/React.createElement(material.IconButton, _extends({
    onClick: onToggle,
    ref: buttonRef
  }, restProps, {
    size: "large"
  }), /*#__PURE__*/React.createElement(VisibilityOff, null)));
};
process.env.NODE_ENV !== "production" ? ToggleButton.propTypes = {
  onToggle: PropTypes.func.isRequired,
  getMessage: PropTypes.func.isRequired,
  buttonRef: PropTypes.func.isRequired,
  active: PropTypes.bool
} : void 0;
ToggleButton.defaultProps = {
  active: false
};

var _excluded$5 = ["item", "disabled", "onToggle"];
var PREFIX$1 = 'Item';
var classes$1 = {
  checkbox: "".concat(PREFIX$1, "-checkbox"),
  itemText: "".concat(PREFIX$1, "-itemText")
};
var StyledListItem = material.styled(material.ListItem)(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "& .".concat(classes$1.itemText), {
    paddingLeft: theme.spacing(1)
  }), _defineProperty(_ref2, "& .".concat(classes$1.checkbox), {
    padding: 0
  }), _ref2;
});
var Item = function Item(_ref3) {
  var _ref3$item = _ref3.item,
      column = _ref3$item.column,
      hidden = _ref3$item.hidden,
      disabled = _ref3.disabled,
      onToggle = _ref3.onToggle,
      restProps = _objectWithoutProperties(_ref3, _excluded$5);

  return /*#__PURE__*/React.createElement(StyledListItem, _extends({
    key: column.name,
    button: !disabled,
    component: "li",
    disabled: disabled,
    onClick: !disabled ? onToggle : null
  }, restProps), /*#__PURE__*/React.createElement(material.Checkbox, {
    checked: !hidden,
    tabIndex: -1,
    disableRipple: true,
    disabled: disabled,
    className: classes$1.checkbox
  }), /*#__PURE__*/React.createElement(material.ListItemText, {
    className: classes$1.itemText,
    primary: 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
} : void 0;
Item.defaultProps = {
  onToggle: function onToggle() {},
  disabled: false
};

var withPatchedProps = function withPatchedProps(patchProps) {
  return function (Target) {
    var Patched = /*#__PURE__*/function (_React$PureComponent) {
      _inherits(Patched, _React$PureComponent);

      var _super = _createSuper(Patched);

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

        return _super.apply(this, arguments);
      }

      _createClass(Patched, [{
        key: "render",
        value: function render() {
          return /*#__PURE__*/React.createElement(Target, patchProps(this.props));
        }
      }]);

      return Patched;
    }(React.PureComponent);

    return Patched;
  };
};

var _excluded$6 = ["messages"];
var defaultMessages = {
  showColumnChooser: 'Show Column Chooser'
};
var ColumnChooserWithMessages = withPatchedProps(function (_ref) {
  var messages = _ref.messages,
      restProps = _objectWithoutProperties(_ref, _excluded$6);

  return _objectSpread2({
    messages: _objectSpread2(_objectSpread2({}, defaultMessages), messages)
  }, restProps);
})(dxReactGrid.ColumnChooser);
ColumnChooserWithMessages.propTypes = {
  messages: PropTypes.shape({
    hiddenColumnNames: PropTypes.string
  })
};
ColumnChooserWithMessages.defaultProps = {
  messages: {}
};
ColumnChooserWithMessages.components = dxReactGrid.ColumnChooser.components;
var ColumnChooser = dxReactCore.withComponents({
  Container: Container,
  Item: Item,
  Overlay: Overlay,
  ToggleButton: ToggleButton
})(ColumnChooserWithMessages);

var _excluded$7 = ["clientOffset", "style", "className", "children"],
    _excluded2 = ["column", "className"];
var PREFIX$2 = 'DragDrop';
var classes$2 = {
  container: "".concat(PREFIX$2, "-container"),
  column: "".concat(PREFIX$2, "-column")
};
var StyledDiv$1 = material.styled('div')(function () {
  return _defineProperty({}, "&.".concat(classes$2.container), {
    position: 'fixed',
    zIndex: 1000,
    left: 0,
    top: 0,
    display: 'inline-block'
  });
});
var Container$1 = function Container(_ref2) {
  var clientOffset = _ref2.clientOffset,
      style = _ref2.style,
      className = _ref2.className,
      children = _ref2.children,
      restProps = _objectWithoutProperties(_ref2, _excluded$7);

  return /*#__PURE__*/React.createElement(StyledDiv$1, _extends({
    className: classNames(classes$2.container, className),
    style: _objectSpread2({
      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,
  children: PropTypes.node,
  style: PropTypes.object,
  className: PropTypes.string
} : void 0;
Container$1.defaultProps = {
  style: null,
  className: undefined,
  children: undefined
};
var StyledChip = material.styled(material.Chip)(function (_ref3) {
  var theme = _ref3.theme;
  return _defineProperty({}, "&.".concat(classes$2.column), {
    paddingLeft: theme.spacing(2),
    paddingRight: theme.spacing(2),
    float: 'right',
    cursor: 'move'
  });
});
var Column = /*#__PURE__*/React.memo(function (_ref5) {
  var column = _ref5.column,
      className = _ref5.className,
      restProps = _objectWithoutProperties(_ref5, _excluded2);

  return /*#__PURE__*/React.createElement(StyledChip, _extends({
    className: classNames(classes$2.column, className),
    label: column.title
  }, restProps));
});
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 IS_LEGACY_EDGE_MEDIA_QUERY = '@media screen and (-ms-high-contrast: active), (-ms-high-contrast: none)';

var PREFIX$3 = 'PageSizeSelector';
var classes$3 = {
  pageSizeSelector: "".concat(PREFIX$3, "-pageSizeSelector"),
  label: "".concat(PREFIX$3, "-label"),
  selectIcon: "".concat(PREFIX$3, "-selectIcon"),
  selectMenu: "".concat(PREFIX$3, "-selectMenu"),
  inputRoot: "".concat(PREFIX$3, "-inputRoot")
};
var StyledDiv$2 = material.styled('div')(function (_ref) {
  var _mediaMaxWidth, _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$3.pageSizeSelector), _objectSpread2(_objectSpread2({}, theme.typography.caption), {}, {
    paddingRight: theme.spacing(5),
    // NOTE: fixes vertical alignment in FF
    display: 'flex',
    alignItems: 'center'
  })), _defineProperty(_ref2, "& .".concat(classes$3.label), {
    paddingRight: theme.spacing(3)
  }), _defineProperty(_ref2, "& .".concat(classes$3.selectIcon), {
    top: 2
  }), _defineProperty(_ref2, "& .".concat(classes$3.selectMenu), _defineProperty({}, "".concat(IS_LEGACY_EDGE_MEDIA_QUERY), {
    position: 'absolute !important'
  })), _defineProperty(_ref2, "& .".concat(classes$3.inputRoot), {
    fontSize: theme.spacing(1.75),
    textAlign: 'right'
  }), _defineProperty(_ref2, '@media (max-width: 768px)', (_mediaMaxWidth = {}, _defineProperty(_mediaMaxWidth, "&.".concat(classes$3.pageSizeSelector), {
    paddingRight: theme.spacing(2)
  }), _defineProperty(_mediaMaxWidth, "& .".concat(classes$3.label), {
    display: 'none'
  }), _mediaMaxWidth)), _ref2;
});
var PageSizeSelector = function PageSizeSelector(_ref3) {
  var pageSize = _ref3.pageSize,
      onPageSizeChange = _ref3.onPageSizeChange,
      pageSizes = _ref3.pageSizes,
      getMessage = _ref3.getMessage;
  var showAll = getMessage('showAll');
  return /*#__PURE__*/React.createElement(StyledDiv$2, {
    className: classes$3.pageSizeSelector
  }, /*#__PURE__*/React.createElement("span", {
    className: classes$3.label
  }, getMessage('rowsPerPage')), /*#__PURE__*/React.createElement(material.Select, {
    value: pageSize,
    onChange: function onChange(event) {
      return onPageSizeChange(event.target.value);
    },
    classes: {
      icon: classes$3.selectIcon
    },
    MenuProps: {
      className: classes$3.selectMenu
    },
    input: /*#__PURE__*/React.createElement(material.Input, {
      disableUnderline: true,
      classes: {
        root: classes$3.inputRoot
      }
    })
  }, pageSizes.map(function (item) {
    return /*#__PURE__*/React.createElement(material.MenuItem, {
      key: item,
      value: item
    }, item !== 0 ? 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 PREFIX$4 = 'Pagination';
var classes$4 = {
  button: "".concat(PREFIX$4, "-button"),
  activeButton: "".concat(PREFIX$4, "-activeButton"),
  text: "".concat(PREFIX$4, "-text"),
  pagination: "".concat(PREFIX$4, "-pagination"),
  rowsLabel: "".concat(PREFIX$4, "-rowsLabel")
};
var StyledButton = material.styled(material.Button)(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$4.button), {
    minWidth: theme.spacing(2)
  }), _defineProperty(_ref2, "&.".concat(classes$4.activeButton), {
    fontWeight: 'bold',
    cursor: 'default'
  }), _defineProperty(_ref2, "&.".concat(classes$4.text), {
    color: 'rgba(0, 0, 0, 0.87)'
  }), _defineProperty(_ref2, '@media(max-width: 768px)', _defineProperty({}, "&.".concat(classes$4.button), {
    display: 'none'
  })), _ref2;
});
var StyledDiv$3 = material.styled('div')(function (_ref3) {
  var _mediaMaxWidth2, _ref4;

  var theme = _ref3.theme;
  return _ref4 = {}, _defineProperty(_ref4, "&.".concat(classes$4.pagination), {
    margin: 0
  }), _defineProperty(_ref4, "& .".concat(classes$4.rowsLabel), _objectSpread2(_objectSpread2({}, theme.typography.caption), {}, {
    paddingRight: theme.spacing(5)
  })), _defineProperty(_ref4, "& .".concat(classes$4.arrowButton), {
    display: 'inline-block',
    transform: theme.direction === 'rtl' ? 'rotate(180deg)' : null,
    msTransform: theme.direction === 'rtl' ? 'rotate(180deg)' : null
  }), _defineProperty(_ref4, "& .".concat(classes$4.prev), {
    marginRight: 0
  }), _defineProperty(_ref4, "& .".concat(classes$4.next), {
    marginLeft: 0
  }), _defineProperty(_ref4, '@media(max-width: 768px)', (_mediaMaxWidth2 = {}, _defineProperty(_mediaMaxWidth2, "& .".concat(classes$4.rowsLabel), {
    paddingRight: theme.spacing(2)
  }), _defineProperty(_mediaMaxWidth2, "& .".concat(classes$4.prev), {
    marginRight: theme.spacing(1)
  }), _defineProperty(_mediaMaxWidth2, "& .".concat(classes$4.next), {
    marginLeft: theme.spacing(1)
  }), _mediaMaxWidth2)), _ref4;
});

var PageButton = function PageButton(_ref5) {
  var _classNames;

  var text = _ref5.text,
      isActive = _ref5.isActive,
      isDisabled = _ref5.isDisabled,
      onClick = _ref5.onClick;
  var buttonClasses = classNames((_classNames = {}, _defineProperty(_classNames, classes$4.button, true), _defineProperty(_classNames, classes$4.activeButton, isActive), _defineProperty(_classNames, classes$4.text, true), _classNames));
  return /*#__PURE__*/React.createElement(StyledButton, _extends({
    className: buttonClasses,
    disabled: isDisabled,
    onClick: onClick
  }, isActive ? {
    tabIndex: -1
  } : null), text);
};

process.env.NODE_ENV !== "production" ? PageButton.propTypes = {
  text: PropTypes.string.isRequired,
  isActive: PropTypes.bool,
  isDisabled: PropTypes.bool,
  onClick: PropTypes.func
} : void 0;
PageButton.defaultProps = {
  onClick: function onClick() {},
  isDisabled: false,
  isActive: false
};
var ellipsisSymbol = "\u2026";

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(PageButton, {
      key: 1,
      text: String(1),
      onClick: function onClick() {
        return onCurrentPageChange(0);
      }
    }));

    if (startPage > 2) {
      pageButtons.push( /*#__PURE__*/React.createElement(PageButton, {
        key: "ellipsisStart",
        text: ellipsisSymbol,
        isDisabled: true
      }));
    }
  }

  var _loop = function _loop(page) {
    pageButtons.push( /*#__PURE__*/React.createElement(PageButton, {
      key: page,
      text: String(page),
      isActive: page === currentPage + 1,
      classes: classes$4,
      onClick: function onClick() {
        return onCurrentPageChange(page - 1);
      },
      isDisabled: startPage === endPage
    }));
  };

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

  if (endPage < totalPageCount) {
    if (endPage < totalPageCount - 1) {
      pageButtons.push( /*#__PURE__*/React.createElement(PageButton, {
        key: "ellipsisEnd",
        text: ellipsisSymbol,
        classes: classes$4,
        isDisabled: true
      }));
    }

    pageButtons.push( /*#__PURE__*/React.createElement(PageButton, {
      key: totalPageCount,
      text: String(totalPageCount),
      classes: classes$4,
      onClick: function onClick() {
        return onCurrentPageChange(totalPageCount - 1);
      }
    }));
  }

  return pageButtons;
};

var Pagination = function Pagination(_ref6) {
  var totalPages = _ref6.totalPages,
      totalCount = _ref6.totalCount,
      pageSize = _ref6.pageSize,
      currentPage = _ref6.currentPage,
      onCurrentPageChange = _ref6.onCurrentPageChange,
      getMessage = _ref6.getMessage;
  var from = dxGridCore.firstRowOnPage(currentPage, pageSize, totalCount);
  var to = dxGridCore.lastRowOnPage(currentPage, pageSize, totalCount);
  return /*#__PURE__*/React.createElement(StyledDiv$3, {
    className: classes$4.pagination
  }, /*#__PURE__*/React.createElement("span", {
    className: classes$4.rowsLabel
  }, getMessage('info', {
    from: from,
    to: to,
    count: totalCount
  })), /*#__PURE__*/React.createElement(material.IconButton, {
    className: classNames(classes$4.arrowButton, classes$4.prev),
    disabled: currentPage === 0,
    onClick: function onClick() {
      return currentPage > 0 && onCurrentPageChange(currentPage - 1);
    },
    "aria-label": "Previous",
    size: "large"
  }, /*#__PURE__*/React.createElement(ChevronLeft, null)), RenderPageButtons(currentPage, totalPages, onCurrentPageChange), /*#__PURE__*/React.createElement(material.IconButton, {
    className: classNames(classes$4.arrowButton, classes$4.next),
    disabled: currentPage === totalPages - 1 || totalCount === 0,
    onClick: function onClick() {
      return currentPage < totalPages - 1 && onCurrentPageChange(currentPage + 1);
    },
    "aria-label": "Next",
    size: "large"
  }, /*#__PURE__*/React.createElement(ChevronRight, null)));
};
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$8 = ["currentPage", "pageSizes", "totalPages", "pageSize", "onCurrentPageChange", "onPageSizeChange", "totalCount", "getMessage", "className", "forwardedRef"];
var PREFIX$5 = 'Pager';
var classes$5 = {
  pager: "".concat(PREFIX$5, "-pager")
};
var StyledDiv$4 = material.styled('div')(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$5.pager), {
    overflow: 'hidden',
    padding: theme.spacing(1.5),
    display: 'flex',
    flex: 'none',
    alignItems: 'center',
    justifyContent: 'flex-end'
  });
});

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

  return /*#__PURE__*/React.createElement(StyledDiv$4, _extends({
    className: classNames(classes$5.pager, className),
    ref: forwardedRef
  }, 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,
  totalPages: PropTypes.number.isRequired,
  pageSizes: PropTypes.arrayOf(PropTypes.number).isRequired,
  pageSize: PropTypes.number.isRequired,
  onCurrentPageChange: PropTypes.func.isRequired,
  onPageSizeChange: PropTypes.func.isRequired,
  totalCount: PropTypes.number.isRequired,
  getMessage: PropTypes.func.isRequired,
  className: PropTypes.string,
  forwardedRef: PropTypes.func
} : void 0;
PagerBase.defaultProps = {
  className: undefined,
  forwardedRef: undefined
};
var Pager = dxReactGrid.withKeyboardNavigation('paging', 'none')(PagerBase);

var _excluded$9 = ["messages"];
var defaultMessages$1 = {
  rowsPerPage: 'Rows per page:'
};
var PagingPanelWithMessages = withPatchedProps(function (_ref) {
  var messages = _ref.messages,
      restProps = _objectWithoutProperties(_ref, _excluded$9);

  return _objectSpread2({
    messages: _objectSpread2(_objectSpread2({}, defaultMessages$1), messages)
  }, restProps);
})(dxReactGrid.PagingPanel);
PagingPanelWithMessages.propTypes = {
  messages: PropTypes.shape({
    showAll: PropTypes.string,
    rowsPerPage: PropTypes.string,
    info: PropTypes.oneOfType([PropTypes.string, PropTypes.func])
  })
};
PagingPanelWithMessages.defaultProps = {
  messages: {}
};
PagingPanelWithMessages.components = dxReactGrid.PagingPanel.components;
var PagingPanel = dxReactCore.withComponents({
  Container: Pager
})(PagingPanelWithMessages);

var _excluded$a = ["children", "className", "forwardedRef"];
var PREFIX$6 = 'GroupPanelContainer';
var classes$6 = {
  panel: "".concat(PREFIX$6, "-panel")
};
var StyledDiv$5 = material.styled('div')(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$6.panel), {
    display: 'flex',
    flexWrap: 'wrap',
    width: '100%',
    marginTop: theme.spacing(1.5)
  });
});
var GroupPanelContainer = function GroupPanelContainer(_ref3) {
  var children = _ref3.children,
      className = _ref3.className,
      forwardedRef = _ref3.forwardedRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$a);

  return /*#__PURE__*/React.createElement(StyledDiv$5, _extends({
    ref: forwardedRef,
    className: classNames(classes$6.panel, className)
  }, restProps), children);
};
process.env.NODE_ENV !== "production" ? GroupPanelContainer.propTypes = {
  children: PropTypes.node,
  className: PropTypes.string,
  forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
} : void 0;
GroupPanelContainer.defaultProps = {
  children: undefined,
  className: undefined,
  forwardedRef: undefined
};

var _excluded$b = ["item", "onGroup", "showGroupingControls", "showSortingControls", "sortingDirection", "onSort", "sortingEnabled", "groupingEnabled", "className", "forwardedRef"];
var PREFIX$7 = 'GroupPanelItem';
var classes$7 = {
  button: "".concat(PREFIX$7, "-button"),
  withoutIcon: "".concat(PREFIX$7, "-withoutIcon"),
  draftCell: "".concat(PREFIX$7, "-draftCell")
};
var StyledChip$1 = material.styled(material.Chip)(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$7.button), {
    marginRight: theme.spacing(1),
    marginBottom: theme.spacing(1.5)
  }), _defineProperty(_ref2, "&.".concat(classes$7.withoutIcon), {
    paddingRight: '13px',
    paddingLeft: '13px'
  }), _defineProperty(_ref2, "&.".concat(classes$7.draftCell), {
    opacity: 0.3
  }), _ref2;
});
var ENTER_KEY_CODE = 13;
var SPACE_KEY_CODE = 32;

var label = function label(showSortingControls, sortingEnabled, sortingDirection, column, hovered) {
  var title = column.title || column.name;
  return showSortingControls ? /*#__PURE__*/React.createElement(material.TableSortLabel, {
    active: !!sortingDirection,
    direction: sortingDirection === null ? undefined : sortingDirection,
    disabled: !sortingEnabled,
    hideSortIcon: !hovered,
    tabIndex: -1
  }, title) : title;
};

var GroupPanelItem = function GroupPanelItem(_ref3) {
  var _classNames;

  var _ref3$item = _ref3.item,
      column = _ref3$item.column,
      draft = _ref3$item.draft,
      onGroup = _ref3.onGroup,
      showGroupingControls = _ref3.showGroupingControls,
      showSortingControls = _ref3.showSortingControls,
      sortingDirection = _ref3.sortingDirection,
      onSort = _ref3.onSort,
      sortingEnabled = _ref3.sortingEnabled,
      groupingEnabled = _ref3.groupingEnabled,
      className = _ref3.className,
      forwardedRef = _ref3.forwardedRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$b);

  var _React$useState = React.useState(false),
      _React$useState2 = _slicedToArray(_React$useState, 2),
      hovered = _React$useState2[0],
      setHovered = _React$useState2[1];

  var chipClassNames = classNames((_classNames = {}, _defineProperty(_classNames, classes$7.button, true), _defineProperty(_classNames, classes$7.withoutIcon, !showSortingControls || !hovered && sortingDirection === null), _defineProperty(_classNames, classes$7.draftCell, draft), _classNames), className);

  var onClick = function onClick(e) {
    var isActionKeyDown = e.keyCode === ENTER_KEY_CODE || e.keyCode === SPACE_KEY_CODE;
    var isMouseClick = e.keyCode === undefined;
    var cancelSortingRelatedKey = e.metaKey || e.ctrlKey;
    var direction = (isMouseClick || isActionKeyDown) && cancelSortingRelatedKey ? null : undefined;
    onSort({
      direction: direction,
      keepOther: cancelSortingRelatedKey
    });
  };

  return /*#__PURE__*/React.createElement(StyledChip$1, _extends({
    ref: forwardedRef,
    label: label(showSortingControls, sortingEnabled, sortingDirection, column, hovered),
    className: chipClassNames
  }, showGroupingControls ? {
    onDelete: groupingEnabled ? onGroup : null
  } : null, showSortingControls ? {
    onClick: sortingEnabled ? onClick : null,
    onMouseEnter: function onMouseEnter() {
      return setHovered(true);
    },
    onMouseLeave: function onMouseLeave() {
      return setHovered(false);
    }
  } : null, restProps));
};
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]),
  onSort: PropTypes.func,
  onGroup: PropTypes.func,
  showGroupingControls: PropTypes.bool,
  className: PropTypes.string,
  sortingEnabled: PropTypes.bool,
  groupingEnabled: PropTypes.bool,
  forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
} : void 0;
GroupPanelItem.defaultProps = {
  showSortingControls: false,
  sortingEnabled: false,
  sortingDirection: undefined,
  onSort: undefined,
  onGroup: undefined,
  showGroupingControls: false,
  groupingEnabled: false,
  className: undefined,
  forwardedRef: undefined
};

var _excluded$c = ["getMessage", "className", "forwardedRef"];
var PREFIX$8 = 'GroupPanelEmptyMessage';
var classes$8 = {
  groupInfo: "".concat(PREFIX$8, "-groupInfo")
};
var StyledDiv$6 = material.styled('div')(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$8.groupInfo), {
    color: theme.typography.caption.color,
    fontFamily: theme.typography.fontFamily,
    fontSize: theme.typography.fontSize
  });
});
var GroupPanelEmptyMessage = function GroupPanelEmptyMessage(_ref3) {
  var getMessage = _ref3.getMessage,
      className = _ref3.className,
      forwardedRef = _ref3.forwardedRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$c);

  return /*#__PURE__*/React.createElement(StyledDiv$6, _extends({
    ref: forwardedRef,
    className: classNames(classes$8.groupInfo, className)
  }, restProps), getMessage('groupByColumn'));
};
process.env.NODE_ENV !== "production" ? GroupPanelEmptyMessage.propTypes = {
  getMessage: PropTypes.func.isRequired,
  className: PropTypes.string,
  forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
} : void 0;
GroupPanelEmptyMessage.defaultProps = {
  className: undefined,
  forwardedRef: undefined
};

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

var _excluded$d = ["style", "expanded", "onToggle", "tableColumn", "tableRow", "row", "className", "forwardedRef"];
var PREFIX$9 = 'TableDetailToggleCell';
var classes$9 = {
  toggleCell: "".concat(PREFIX$9, "-toggleCell"),
  toggleCellButton: "".concat(PREFIX$9, "-toggleCellButton")
};
var StyledTableCell = material.styled(material.TableCell)(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$9.toggleCell), {
    textAlign: 'center',
    textOverflow: 'initial',
    paddingTop: 0,
    paddingBottom: 0,
    paddingLeft: theme.spacing(1)
  });
});
var TableDetailToggleCell = function TableDetailToggleCell(_ref3) {
  var style = _ref3.style,
      expanded = _ref3.expanded,
      onToggle = _ref3.onToggle,
      tableColumn = _ref3.tableColumn,
      tableRow = _ref3.tableRow,
      row = _ref3.row,
      className = _ref3.className,
      forwardedRef = _ref3.forwardedRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$d);

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

  return /*#__PURE__*/React.createElement(StyledTableCell, _extends({
    className: classNames(classes$9.toggleCell, className),
    style: style,
    ref: forwardedRef
  }, restProps), /*#__PURE__*/React.createElement(material.IconButton, {
    onClick: handleClick
  }, expanded ? /*#__PURE__*/React.createElement(ExpandLess, null) : /*#__PURE__*/React.createElement(ExpandMore, null)));
};
process.env.NODE_ENV !== "production" ? TableDetailToggleCell.propTypes = {
  style: PropTypes.object,
  expanded: PropTypes.bool,
  onToggle: PropTypes.func,
  className: PropTypes.string,
  tableColumn: PropTypes.object,
  tableRow: PropTypes.object,
  row: PropTypes.any,
  forwardedRef: PropTypes.func
} : void 0;
TableDetailToggleCell.defaultProps = {
  style: null,
  expanded: false,
  onToggle: function onToggle() {},
  className: undefined,
  tableColumn: undefined,
  tableRow: undefined,
  row: undefined,
  forwardedRef: undefined
};

var _excluded$e = ["colSpan", "style", "children", "className", "forwardedRef", "tableColumn", "tableRow", "row"];
var PREFIX$a = 'TableDetailCell';
var classes$a = {
  active: "".concat(PREFIX$a, "-active")
};
var StyledTableCell$1 = material.styled(material.TableCell)(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$a.active), {
    backgroundColor: theme.palette.background.default
  });
});
var TableDetailCell = function TableDetailCell(_ref3) {
  var colSpan = _ref3.colSpan,
      style = _ref3.style,
      children = _ref3.children,
      className = _ref3.className,
      forwardedRef = _ref3.forwardedRef,
      tableColumn = _ref3.tableColumn,
      tableRow = _ref3.tableRow,
      row = _ref3.row,
      restProps = _objectWithoutProperties(_ref3, _excluded$e);

  return /*#__PURE__*/React.createElement(StyledTableCell$1, _extends({
    style: style,
    colSpan: colSpan,
    ref: forwardedRef,
    className: classNames(classes$a.active, className)
  }, restProps), children);
};
process.env.NODE_ENV !== "production" ? TableDetailCell.propTypes = {
  style: PropTypes.object,
  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 = {
  style: null,
  colSpan: 1,
  className: undefined,
  tableColumn: undefined,
  tableRow: undefined,
  row: undefined,
  children: undefined,
  forwardedRef: undefined
};

var _excluded$f = ["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$f);

  return /*#__PURE__*/React.createElement(material.TableRow, _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: 48
  }, 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$g = ["contentComponent", "iconComponent", "containerComponent", "inlineSummaryComponent", "inlineSummaryItemComponent", "inlineSummaries", "getMessage", "style", "colSpan", "row", "column", "expanded", "onToggle", "children", "className", "tableRow", "forwardedRef", "tableColumn", "side", "position"];
var PREFIX$b = 'TableGroupCell';
var classes$b = {
  cell: "".concat(PREFIX$b, "-cell"),
  cellNoWrap: "".concat(PREFIX$b, "-cellNoWrap")
};
var StyledTableCell$2 = material.styled(material.TableCell)(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$b.cell), {
    cursor: 'pointer',
    paddingLeft: theme.spacing(1),
    paddingRight: theme.spacing(1),
    paddingTop: theme.spacing(0.5),
    paddingBottom: theme.spacing(0.5)
  }), _defineProperty(_ref2, "&.".concat(classes$b.cellNoWrap), {
    whiteSpace: 'nowrap'
  }), _ref2;
});
var Cell = function Cell(_ref3) {
  var _classNames;

  var Content = _ref3.contentComponent,
      Icon = _ref3.iconComponent,
      Container = _ref3.containerComponent,
      InlineSummary = _ref3.inlineSummaryComponent,
      InlineSummaryItem = _ref3.inlineSummaryItemComponent,
      inlineSummaries = _ref3.inlineSummaries,
      getMessage = _ref3.getMessage,
      style = _ref3.style,
      colSpan = _ref3.colSpan,
      row = _ref3.row,
      column = _ref3.column,
      expanded = _ref3.expanded,
      onToggle = _ref3.onToggle,
      children = _ref3.children,
      className = _ref3.className,
      tableRow = _ref3.tableRow,
      forwardedRef = _ref3.forwardedRef,
      tableColumn = _ref3.tableColumn,
      side = _ref3.side,
      position = _ref3.position,
      restProps = _objectWithoutProperties(_ref3, _excluded$g);

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

  return /*#__PURE__*/React.createElement(StyledTableCell$2, _extends({
    colSpan: colSpan,
    style: style,
    className: classNames((_classNames = {}, _defineProperty(_classNames, classes$b.cell, true), _defineProperty(_classNames, classes$b.cellNoWrap, !(tableColumn && tableColumn.wordWrapEnabled)), _classNames), className),
    ref: forwardedRef,
    onClick: handleClick
  }, restProps), /*#__PURE__*/React.createElement(Container, {
    side: side,
    position: position
  }, /*#__PURE__*/React.createElement(Icon, {
    expanded: expanded
  }), /*#__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" ? Cell.propTypes = {
  // oneOfType is a workaround because withStyles returns react object
  contentComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).isRequired,
  iconComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).isRequired,
  containerComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).isRequired,
  inlineSummaryComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).isRequired,
  inlineSummaryItemComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).isRequired,
  style: PropTypes.object,
  colSpan: PropTypes.number,
  row: PropTypes.any,
  column: PropTypes.object,
  expanded: PropTypes.bool,
  onToggle: PropTypes.func,
  getMessage: PropTypes.func.isRequired,
  children: PropTypes.node,
  className: PropTypes.string,
  tableRow: PropTypes.object,
  tableColumn: PropTypes.object,
  inlineSummaries: PropTypes.array,
  side: PropTypes.string,
  position: PropTypes.string,
  forwardedRef: PropTypes.func
} : void 0;
Cell.defaultProps = {
  style: null,
  colSpan: 1,
  row: {},
  column: {},
  expanded: false,
  inlineSummaries: [],
  onToggle: function onToggle() {},
  children: undefined,
  className: undefined,
  tableRow: undefined,
  tableColumn: undefined,
  side: 'left',
  position: '',
  forwardedRef: undefined
};

var _excluded$h = ["column", "row", "className", "children"];
var PREFIX$c = 'Content';
var classes$c = {
  columnTitle: "".concat(PREFIX$c, "-columnTitle")
};
var StyledSpan = material.styled('span')(function () {
  return _defineProperty({}, "&.".concat(classes$c.columnTitle), {
    verticalAlign: 'middle'
  });
});
var Content = function Content(_ref2) {
  var column = _ref2.column,
      row = _ref2.row,
      className = _ref2.className,
      children = _ref2.children,
      restProps = _objectWithoutProperties(_ref2, _excluded$h);

  return /*#__PURE__*/React.createElement(StyledSpan, _extends({
    className: classNames(classes$c.columnTitle, className)
  }, 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,
  className: PropTypes.string
} : void 0;
Content.defaultProps = {
  row: {},
  column: {},
  children: undefined,
  className: undefined
};

var getBorder = function getBorder(theme) {
  return "1px solid ".concat(theme.palette.mode === 'light' ? material.lighten(material.alpha(theme.palette.divider, 1), 0.88) : material.darken(material.alpha(theme.palette.divider, 1), 0.68));
};
var getStickyStyles = function getStickyStyles(theme) {
  var zIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 300;
  return {
    position: 'sticky',
    background: theme.palette.background.paper,
    zIndex: zIndex
  };
};
var getStickyCellStyle = function getStickyCellStyle(theme) {
  return _objectSpread2(_objectSpread2({}, getStickyStyles(theme)), {}, {
    backgroundClip: 'padding-box'
  });
};

var _excluded$i = ["children", "style", "className", "side", "position"];
var PREFIX$d = 'Container';
var classes$d = {
  wrapper: "".concat(PREFIX$d, "-wrapper")
};
var StyledDiv$7 = material.styled('div')(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$d.wrapper), _objectSpread2(_objectSpread2({}, getStickyCellStyle(theme)), {}, {
    float: 'left',
    maxWidth: '100%',
    overflowX: 'hidden',
    textOverflow: 'ellipsis'
  }));
});
var Container$2 = function Container(_ref3) {
  var children = _ref3.children,
      style = _ref3.style,
      className = _ref3.className,
      side = _ref3.side,
      position = _ref3.position,
      restProps = _objectWithoutProperties(_ref3, _excluded$i);

  return /*#__PURE__*/React.createElement(StyledDiv$7, _extends({
    className: classNames(classes$d.wrapper, className),
    style: _objectSpread2(_objectSpread2({}, style), {}, _defineProperty({}, side, position))
  }, restProps), children);
};
process.env.NODE_ENV !== "production" ? Container$2.propTypes = {
  children: PropTypes.node,
  className: PropTypes.string,
  style: PropTypes.object,
  side: PropTypes.string,
  position: PropTypes.string
} : void 0;
Container$2.defaultProps = {
  children: undefined,
  className: undefined,
  style: null,
  side: 'left',
  position: ''
};

var _excluded$j = ["tableRow", "tableColumn", "row", "column", "style", "className", "position", "side", "forwardedRef"];
var PREFIX$e = 'IndentCell';
var classes$e = {
  indentCell: "".concat(PREFIX$e, "-indentCell")
};
var StyledTableCell$3 = material.styled(material.TableCell)(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$e.indentCell), _objectSpread2(_objectSpread2({}, getStickyCellStyle(theme)), {}, {
    borderBottom: getBorder(theme)
  }));
});
var IndentCell = function IndentCell(_ref3) {
  var tableRow = _ref3.tableRow,
      tableColumn = _ref3.tableColumn,
      row = _ref3.row,
      column = _ref3.column,
      style = _ref3.style,
      className = _ref3.className,
      position = _ref3.position,
      side = _ref3.side,
      forwardedRef = _ref3.forwardedRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$j);

  return /*#__PURE__*/React.createElement(StyledTableCell$3, _extends({
    className: classNames(classes$e.indentCell, className),
    ref: forwardedRef,
    style: _objectSpread2(_objectSpread2({}, style), {}, _defineProperty({}, side, position))
  }, restProps));
};
process.env.NODE_ENV !== "production" ? IndentCell.propTypes = {
  tableRow: PropTypes.object,
  tableColumn: PropTypes.object,
  row: PropTypes.any,
  column: PropTypes.object,
  style: PropTypes.object,
  className: PropTypes.string,
  side: PropTypes.string,
  position: PropTypes.number,
  forwardedRef: PropTypes.func
} : void 0;
IndentCell.defaultProps = {
  tableRow: undefined,
  tableColumn: undefined,
  row: {},
  column: {},
  style: null,
  className: undefined,
  side: 'left',
  position: undefined,
  forwardedRef: undefined
};

var _excluded$k = ["expanded", "className"];
var Icon = /*#__PURE__*/React.memo(function (_ref) {
  var expanded = _ref.expanded,
      className = _ref.className,
      restProps = _objectWithoutProperties(_ref, _excluded$k);

  return /*#__PURE__*/React.createElement(material.IconButton, _extends({
    className: className
  }, restProps), expanded ? /*#__PURE__*/React.createElement(ExpandMore, null) : /*#__PURE__*/React.createElement(ChevronRight, null));
});
Icon.propTypes = {
  expanded: PropTypes.bool.isRequired,
  className: PropTypes.string
};
Icon.defaultProps = {
  className: undefined
};

var _excluded$l = ["children", "className"];
var PREFIX$f = 'Row';
var classes$f = {
  row: "".concat(PREFIX$f, "-row")
};
var StyledTableRow = material.styled(TableRow)(function () {
  return _defineProperty({}, "&.".concat(classes$f.row), {
    cursor: 'pointer'
  });
});
var Row = function Row(_ref2) {
  var children = _ref2.children,
      className = _ref2.className,
      restProps = _objectWithoutProperties(_ref2, _excluded$l);

  return /*#__PURE__*/React.createElement(StyledTableRow, _extends({}, restProps, {
    className: classNames(classes$f.row, className)
  }), children);
};
process.env.NODE_ENV !== "production" ? Row.propTypes = {
  children: PropTypes.node,
  className: PropTypes.string
} : void 0;
Row.defaultProps = {
  children: null,
  className: undefined
};

var _excluded$m = ["inlineSummaries", "getMessage", "inlineSummaryItemComponent", "className"];
var PREFIX$g = 'InlineSummary';
var classes$g = {
  inlineSummary: "".concat(PREFIX$g, "-inlineSummary")
};
var StyledSpan$1 = material.styled('span')(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$g.inlineSummary), {
    marginLeft: theme.spacing(1),
    verticalAlign: 'middle'
  });
});
var InlineSummary = function InlineSummary(_ref3) {
  var inlineSummaries = _ref3.inlineSummaries,
      getMessage = _ref3.getMessage,
      InlineSummaryItem = _ref3.inlineSummaryItemComponent,
      className = _ref3.className,
      restProps = _objectWithoutProperties(_ref3, _excluded$m);

  return /*#__PURE__*/React.createElement(StyledSpan$1, _extends({
    className: classNames(classes$g.inlineSummary, className)
  }, 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 = {
  className: PropTypes.string,
  getMessage: PropTypes.func.isRequired,
  inlineSummaries: PropTypes.array,
  inlineSummaryItemComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).isRequired
} : void 0;
InlineSummary.defaultProps = {
  className: undefined,
  inlineSummaries: []
};

var _excluded$n = ["column", "value", "children", "tableRow", "tableColumn", "row", "className", "forwardedRef"];
var PREFIX$h = 'TableCell';
var classes$h = {
  cell: "".concat(PREFIX$h, "-cell"),
  footer: "".concat(PREFIX$h, "-footer"),
  cellRightAlign: "".concat(PREFIX$h, "-cellRightAlign"),
  cellCenterAlign: "".concat(PREFIX$h, "-cellCenterAlign"),
  cellNoWrap: "".concat(PREFIX$h, "-cellNoWrap")
};
var StyledTableCellMUI = material.styled(material.TableCell)(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$h.cell), {
    paddingRight: theme.spacing(1),
    paddingLeft: theme.spacing(1),
    '&:first-of-type': {
      paddingLeft: theme.spacing(3)
    },
    overflow: 'hidden',
    textOverflow: 'ellipsis'
  }), _defineProperty(_ref2, "&.".concat(classes$h.footer), {
    borderTop: getBorder(theme)
  }), _defineProperty(_ref2, "&.".concat(classes$h.cellRightAlign), {
    textAlign: 'right'
  }), _defineProperty(_ref2, "&.".concat(classes$h.cellCenterAlign), {
    textAlign: 'center'
  }), _defineProperty(_ref2, "&.".concat(classes$h.cellNoWrap), {
    whiteSpace: 'nowrap'
  }), _ref2;
});
var TableCell = function TableCell(_ref3) {
  var _classNames;

  var column = _ref3.column,
      value = _ref3.value,
      children = _ref3.children,
      tableRow = _ref3.tableRow,
      tableColumn = _ref3.tableColumn,
      row = _ref3.row,
      className = _ref3.className,
      forwardedRef = _ref3.forwardedRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$n);

  return /*#__PURE__*/React.createElement(StyledTableCellMUI, _extends({
    className: classNames((_classNames = {}, _defineProperty(_classNames, classes$h.cell, true), _defineProperty(_classNames, classes$h.cellRightAlign, tableColumn && tableColumn.align === 'right'), _defineProperty(_classNames, classes$h.cellCenterAlign, tableColumn && tableColumn.align === 'center'), _defineProperty(_classNames, classes$h.cellNoWrap, !(tableColumn && tableColumn.wordWrapEnabled)), _classNames), className),
    classes: {
      footer: classes$h.footer
    },
    ref: forwardedRef
  }, restProps), children || value);
};
process.env.NODE_ENV !== "production" ? TableCell.propTypes = {
  value: PropTypes.any,
  column: PropTypes.object,
  row: PropTypes.any,
  children: PropTypes.node,
  tableRow: PropTypes.object,
  tableColumn: PropTypes.object,
  className: PropTypes.string,
  forwardedRef: PropTypes.func
} : void 0;
TableCell.defaultProps = {
  value: undefined,
  column: undefined,
  row: undefined,
  children: undefined,
  tableRow: undefined,
  tableColumn: undefined,
  className: undefined,
  forwardedRef: undefined
};

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

  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$p = ["children", "type", "value", "getMessage", "className"];
var PREFIX$i = 'TableSummaryItem';
var classes$i = {
  item: "".concat(PREFIX$i, "-item")
};
var StyledDiv$8 = material.styled('div')(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$i.item), {
    fontWeight: theme.typography.fontWeightBold,
    color: theme.palette.text.primary,
    fontSize: theme.typography.pxToRem(13)
  });
});
var TableSummaryItem = function TableSummaryItem(_ref3) {
  var children = _ref3.children,
      type = _ref3.type,
      value = _ref3.value,
      getMessage = _ref3.getMessage,
      className = _ref3.className,
      restProps = _objectWithoutProperties(_ref3, _excluded$p);

  return /*#__PURE__*/React.createElement(StyledDiv$8, _extends({
    className: classNames([classes$i.item], className)
  }, 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,
  className: PropTypes.string
} : void 0;
TableSummaryItem.defaultProps = {
  value: null,
  children: undefined,
  className: undefined
};

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

TableGroupRowWithIndent.components = dxReactGrid.TableGroupRow.components;
var StubCell = SummaryCell;
var TableGroupRow = dxReactCore.withComponents({
  Row: Row,
  Cell: Cell,
  IndentCell: IndentCell,
  Container: Container$2,
  Content: Content,
  Icon: Icon,
  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$q = ["allSelected", "someSelected", "disabled", "onToggle", "className", "tableRow", "tableColumn", "rowSpan", "forwardedRef"];
var PREFIX$j = 'TableSelectAllCell';
var classes$j = {
  cell: "".concat(PREFIX$j, "-cell"),
  checkbox: "".concat(PREFIX$j, "-checkbox"),
  alignWithRowSpan: "".concat(PREFIX$j, "-alignWithRowSpan"),
  pointer: "".concat(PREFIX$j, "-pointer")
};
var StyledTableCell$4 = material.styled(material.TableCell)(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$j.cell), {
    overflow: 'visible',
    paddingRight: 0,
    paddingLeft: theme.spacing(1),
    textAlign: 'center'
  }), _defineProperty(_ref2, "&.".concat(classes$j.pointer), {
    cursor: 'pointer'
  }), _defineProperty(_ref2, "&.".concat(classes$j.alignWithRowSpan), {
    verticalAlign: 'bottom',
    paddingBottom: theme.spacing(0.5)
  }), _defineProperty(_ref2, "& .".concat(classes$j.checkbox), {
    padding: theme.spacing(1)
  }), _ref2;
});
var TableSelectAllCell = function TableSelectAllCell(_ref3) {
  var _classNames;

  var allSelected = _ref3.allSelected,
      someSelected = _ref3.someSelected,
      disabled = _ref3.disabled,
      onToggle = _ref3.onToggle,
      className = _ref3.className,
      tableRow = _ref3.tableRow,
      tableColumn = _ref3.tableColumn,
      rowSpan = _ref3.rowSpan,
      forwardedRef = _ref3.forwardedRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$q);

  var cellClasses = classNames((_classNames = {}, _defineProperty(_classNames, classes$j.cell, true), _defineProperty(_classNames, classes$j.pointer, !disabled), _defineProperty(_classNames, classes$j.alignWithRowSpan, rowSpan > 1), _classNames), className);
  return /*#__PURE__*/React.createElement(StyledTableCell$4, _extends({
    padding: "checkbox",
    className: cellClasses,
    rowSpan: rowSpan,
    ref: forwardedRef
  }, restProps), /*#__PURE__*/React.createElement(material.Checkbox, {
    checked: allSelected,
    className: classes$j.checkbox,
    indeterminate: someSelected,
    disabled: disabled,
    onClick: function onClick(e) {
      if (disabled) return;
      e.stopPropagation();
      onToggle();
    }
  }));
};
process.env.NODE_ENV !== "production" ? TableSelectAllCell.propTypes = {
  allSelected: PropTypes.bool,
  someSelected: PropTypes.bool,
  disabled: PropTypes.bool,
  onToggle: PropTypes.func,
  className: PropTypes.string,
  tableRow: PropTypes.object,
  tableColumn: PropTypes.object,
  rowSpan: PropTypes.number,
  forwardedRef: PropTypes.func
} : void 0;
TableSelectAllCell.defaultProps = {
  allSelected: false,
  someSelected: false,
  disabled: false,
  onToggle: function onToggle() {},
  className: undefined,
  tableRow: undefined,
  tableColumn: undefined,
  rowSpan: undefined,
  forwardedRef: undefined
};

var _excluded$r = ["style", "selected", "onToggle", "className", "row", "tableRow", "tableColumn", "forwardedRef"];
var PREFIX$k = 'TableSelectCell';
var classes$k = {
  cell: "".concat(PREFIX$k, "-cell"),
  checkbox: "".concat(PREFIX$k, "-checkbox")
};
var StyledTableCell$5 = material.styled(material.TableCell)(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$k.cell), {
    overflow: 'visible',
    paddingRight: 0,
    paddingLeft: theme.spacing(1),
    textAlign: 'center'
  }), _defineProperty(_ref2, "& .".concat(classes$k.checkbox), {
    marginTop: '-1px',
    marginBottom: '-1px',
    padding: theme.spacing(1)
  }), _ref2;
});
var TableSelectCell = function TableSelectCell(_ref3) {
  var style = _ref3.style,
      selected = _ref3.selected,
      onToggle = _ref3.onToggle,
      className = _ref3.className,
      row = _ref3.row,
      tableRow = _ref3.tableRow,
      tableColumn = _ref3.tableColumn,
      forwardedRef = _ref3.forwardedRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$r);

  return /*#__PURE__*/React.createElement(StyledTableCell$5, _extends({
    padding: "checkbox",
    style: style,
    ref: forwardedRef,
    className: classNames(classes$k.cell, className)
  }, restProps), /*#__PURE__*/React.createElement(material.Checkbox, {
    className: classes$k.checkbox,
    checked: selected,
    onClick: function onClick(e) {
      e.stopPropagation();
      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,
  className: PropTypes.string,
  forwardedRef: PropTypes.func
} : void 0;
TableSelectCell.defaultProps = {
  style: null,
  selected: false,
  onToggle: function onToggle() {},
  row: undefined,
  tableRow: undefined,
  tableColumn: undefined,
  className: undefined,
  forwardedRef: undefined
};

var getSelectionColor = (function (theme) {
  return theme.palette.mode === 'light' ? material.lighten(material.alpha(theme.palette.action.selected, 1), 0.96) : material.darken(material.alpha(theme.palette.action.selected, 1), 0.68);
});

var _excluded$s = ["children", "className", "onToggle", "row", "selectByRowClick", "highlighted", "tableColumn", "tableRow", "forwardedRef"];
var PREFIX$l = 'TableSelectRow';
var classes$l = {
  selected: "".concat(PREFIX$l, "-selected")
};
var StyledTableRow$1 = material.styled(material.TableRow)(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$l.selected), {
    backgroundColor: getSelectionColor(theme)
  });
});
var TableSelectRow = function TableSelectRow(_ref3) {
  var children = _ref3.children,
      className = _ref3.className,
      onToggle = _ref3.onToggle,
      row = _ref3.row,
      selectByRowClick = _ref3.selectByRowClick,
      highlighted = _ref3.highlighted,
      tableColumn = _ref3.tableColumn,
      tableRow = _ref3.tableRow,
      forwardedRef = _ref3.forwardedRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$s);

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

var TableSelectionWithWidth = function TableSelectionWithWidth(props) {
  return /*#__PURE__*/React.createElement(dxReactGrid.TableSelection, _extends({
    selectionColumnWidth: 58
  }, 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", "className"],
    _excluded2$1 = ["isFixed"],
    _excluded3 = ["isFixed"];
var PREFIX$m = 'TableParts';
var classes$m = {
  fixedHeader: "".concat(PREFIX$m, "-fixedHeader"),
  fixedFooter: "".concat(PREFIX$m, "-fixedFooter")
};
var StyledHead = material.styled(material.TableHead)(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$m.fixedHeader), _objectSpread2(_objectSpread2({}, getStickyStyles(theme, 500)), {}, {
    top: 0
  }));
});
var StyledFooter = material.styled(material.TableFooter)(function (_ref3) {
  var theme = _ref3.theme;
  return _defineProperty({}, "&.".concat(classes$m.fixedFooter), _objectSpread2(_objectSpread2({}, getStickyStyles(theme)), {}, {
    bottom: 0
  }));
});
var Head = function Head(_ref5) {
  var isFixed = _ref5.isFixed,
      className = _ref5.className,
      restProps = _objectWithoutProperties(_ref5, _excluded$t);

  return /*#__PURE__*/React.createElement(StyledHead, _extends({
    className: classNames(_defineProperty({}, classes$m.fixedHeader, isFixed), className)
  }, restProps));
};
process.env.NODE_ENV !== "production" ? Head.propTypes = {
  className: PropTypes.string,
  isFixed: PropTypes.bool
} : void 0;
Head.defaultProps = {
  isFixed: undefined,
  className: undefined
};
var Body = function Body(_ref6) {
  var isFixed = _ref6.isFixed,
      props = _objectWithoutProperties(_ref6, _excluded2$1);

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

  return /*#__PURE__*/React.createElement(StyledFooter, _extends({
    className: classNames(_defineProperty({}, classes$m.fixedFooter, isFixed))
  }, props));
};
process.env.NODE_ENV !== "production" ? Footer.propTypes = {
  isFixed: PropTypes.bool
} : void 0;
Footer.defaultProps = {
  isFixed: undefined
};

var _excluded$u = ["children", "className", "use", "forwardedRef"];
var PREFIX$n = 'Table';
var classes$n = {
  table: "".concat(PREFIX$n, "-table"),
  stickyTable: "".concat(PREFIX$n, "-stickyTable"),
  headTable: "".concat(PREFIX$n, "-headTable"),
  footTable: "".concat(PREFIX$n, "-footTable")
};
var StyledTableMUI = material.styled(material.Table)(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$n.table), {
    tableLayout: 'fixed',
    borderCollapse: 'separate'
  }), _defineProperty(_ref2, "&.".concat(classes$n.stickyTable), _objectSpread2(_objectSpread2({}, getStickyStyles(theme)), {}, {
    overflow: 'visible',
    fallbacks: {
      position: '-webkit-sticky'
    }
  })), _defineProperty(_ref2, "&.".concat(classes$n.headTable), {
    top: 0
  }), _defineProperty(_ref2, "&.".concat(classes$n.footTable), {
    borderTop: getBorder(theme),
    bottom: 0
  }), _ref2;
});
var Table = function Table(_ref3) {
  var _classNames;

  var children = _ref3.children,
      className = _ref3.className,
      use = _ref3.use,
      forwardedRef = _ref3.forwardedRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$u);

  return /*#__PURE__*/React.createElement(StyledTableMUI, _extends({
    ref: forwardedRef,
    className: classNames((_classNames = {}, _defineProperty(_classNames, classes$n.table, true), _defineProperty(_classNames, classes$n.stickyTable, !!use), _defineProperty(_classNames, classes$n.headTable, use === 'head'), _defineProperty(_classNames, classes$n.footTable, use === 'foot'), _classNames), className)
  }, restProps), children);
};
process.env.NODE_ENV !== "production" ? Table.propTypes = {
  use: PropTypes.oneOf(['head', 'foot']),
  children: PropTypes.node.isRequired,
  className: PropTypes.string,
  forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
} : void 0;
Table.defaultProps = {
  use: undefined,
  className: undefined,
  forwardedRef: 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$v = ["className", "tableRow", "tableColumn", "forwardedRef"];
var PREFIX$o = 'TableStubCell';
var classes$o = {
  cell: "".concat(PREFIX$o, "-cell"),
  footer: "".concat(PREFIX$o, "-footer")
};
var StyledTableCell$6 = material.styled(material.TableCell)(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$o.cell), {
    padding: 0
  }), _defineProperty(_ref2, "&.".concat(classes$o.footer), {
    borderTop: getBorder(theme)
  }), _ref2;
});
var TableStubCell = function TableStubCell(_ref3) {
  var className = _ref3.className,
      tableRow = _ref3.tableRow,
      tableColumn = _ref3.tableColumn,
      forwardedRef = _ref3.forwardedRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$v);

  return /*#__PURE__*/React.createElement(StyledTableCell$6, _extends({
    ref: forwardedRef,
    className: classNames(classes$o.cell, className),
    classes: {
      footer: classes$o.footer
    }
  }, restProps));
};
process.env.NODE_ENV !== "production" ? TableStubCell.propTypes = {
  className: PropTypes.string,
  tableRow: PropTypes.object,
  tableColumn: PropTypes.object,
  forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
} : void 0;
TableStubCell.defaultProps = {
  className: undefined,
  tableRow: undefined,
  tableColumn: undefined,
  forwardedRef: undefined
};

var _excluded$w = ["style", "colSpan", "getMessage", "className", "tableRow", "tableColumn"];
var PREFIX$p = 'TableNoDataCell';
var classes$p = {
  cell: "".concat(PREFIX$p, "-cell"),
  textContainer: "".concat(PREFIX$p, "-textContainer"),
  text: "".concat(PREFIX$p, "-text")
};
var StyledTableCell$7 = material.styled(material.TableCell)(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$p.cell), {
    padding: theme.spacing(6, 0),
    position: 'static !important'
  }), _defineProperty(_ref2, "& .".concat(classes$p.text), {
    transform: 'translateX(-50%)',
    msTransform: 'translateX(-50%)',
    display: 'inline-block'
  }), _defineProperty(_ref2, "& .".concat(classes$p.textContainer), {
    display: 'inline-block',
    position: 'sticky',
    left: '50%'
  }), _ref2;
});
var TableNoDataCell = function TableNoDataCell(_ref3) {
  var style = _ref3.style,
      colSpan = _ref3.colSpan,
      getMessage = _ref3.getMessage,
      className = _ref3.className,
      tableRow = _ref3.tableRow,
      tableColumn = _ref3.tableColumn,
      restProps = _objectWithoutProperties(_ref3, _excluded$w);

  return /*#__PURE__*/React.createElement(StyledTableCell$7, _extends({
    style: style,
    className: classNames(classes$p.cell, className),
    colSpan: colSpan
  }, restProps), /*#__PURE__*/React.createElement("div", {
    className: classes$p.textContainer
  }, /*#__PURE__*/React.createElement("big", {
    className: classes$p.text
  }, getMessage('noData'))));
};
process.env.NODE_ENV !== "production" ? TableNoDataCell.propTypes = {
  style: PropTypes.object,
  colSpan: PropTypes.number,
  getMessage: PropTypes.func.isRequired,
  className: PropTypes.string,
  tableRow: PropTypes.object,
  tableColumn: PropTypes.object
} : void 0;
TableNoDataCell.defaultProps = {
  style: null,
  colSpan: 1,
  className: undefined,
  tableRow: undefined,
  tableColumn: undefined
};

var _excluded$x = ["children", "className", "forwardedRef"];
var PREFIX$q = 'TableContainer';
var classes$q = {
  root: "".concat(PREFIX$q, "-root")
};
var StyledDiv$9 = material.styled('div')(function () {
  return _defineProperty({}, "&.".concat(classes$q.root), {
    flexGrow: 1,
    overflow: 'auto',
    WebkitOverflowScrolling: 'touch',
    // NOTE: fix sticky positioning in Safari
    width: '100%'
  });
});
var TableContainer = function TableContainer(_ref2) {
  var children = _ref2.children,
      className = _ref2.className,
      forwardedRef = _ref2.forwardedRef,
      restProps = _objectWithoutProperties(_ref2, _excluded$x);

  return /*#__PURE__*/React.createElement(StyledDiv$9, _extends({
    ref: forwardedRef,
    className: classNames(classes$q.root, className)
  }, restProps), /*#__PURE__*/React.createElement("div", null, children));
};
process.env.NODE_ENV !== "production" ? TableContainer.propTypes = {
  children: PropTypes.node.isRequired,
  className: PropTypes.string,
  forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
} : void 0;
TableContainer.defaultProps = {
  className: undefined,
  forwardedRef: undefined
};

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

  return /*#__PURE__*/React.createElement(material.TableRow, _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: Head,
  TableBody: Body,
  TableFooter: Footer,
  Container: TableContainer,
  Layout: TableLayout,
  Row: TableRow,
  Cell: TableCell,
  NoDataRow: TableRow,
  NoDataCell: TableNoDataCell,
  StubRow: TableStubRow,
  StubCell: TableStubCell,
  StubHeaderCell: TableStubCell
})(dxReactGrid.Table);
Table$1.components = dxReactGrid.Table.components;
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 _excluded$z = ["className", "tableRow", "tableColumn"];
var PREFIX$r = 'TableSceletonCell';
var classes$r = {
  cell: "".concat(PREFIX$r, "-cell")
};
var StyledTableCell$8 = material.styled(material.TableCell)(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$r.cell), {
    padding: theme.spacing(1),
    backgroundImage: 'url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAACqCAYAAABbAOqQAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAA39pVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuNi1jMTQyIDc5LjE2MDkyNCwgMjAxNy8wNy8xMy0wMTowNjozOSAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iIHhtcE1NOk9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRpZDpjYWQ2ODE5MS00ZDMxLWRjNGYtOTU0NC1jNjJkMTIxMjY2M2IiIHhtcE1NOkRvY3VtZW50SUQ9InhtcC5kaWQ6MjY1RUVFQzAzRDYzMTFFODlFNThCOUJBQjU4Q0EzRDgiIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5paWQ6MjY1RUVFQkYzRDYzMTFFODlFNThCOUJBQjU4Q0EzRDgiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENDIChXaW5kb3dzKSI+IDx4bXBNTTpEZXJpdmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOjVlMjM1Y2U0LTc5ZWUtNGI0NC05ZjlkLTk2NTZmZGFjNjhhNCIgc3RSZWY6ZG9jdW1lbnRJRD0iYWRvYmU6ZG9jaWQ6cGhvdG9zaG9wOjk1OTQ2MjBiLTUyMTQtYTM0Yy04Nzc5LTEwMmEyMTY4MTlhOSIvPiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gPD94cGFja2V0IGVuZD0iciI/PvLbJKYAAADrSURBVHja7N3BDYBACABBsQn7L48q0BoMD5SZxAZuc74gF1V1MMfpCARBEEEQRBAEEQRBdovnuxxDq3RD/LIQRBAEQRBBEEQQBBEEQQQBAAAAAAAAABhi8gZVbgxi6kQQBBEEQQRBEEEQRBAEQRBBAAAAAAAAAAAabX2Daux2lqkTQRBEEAQRBEEEQRBBEARBBAEAAAAAAAAAaLR1g2osUyeCIIggCCIIggiCIIIgCIIIAgAAAAAAAADQ6KsbVPnXIKZOBEEQQRBEEAQRBEEEQRAEEYRXoqqcghuCIIIgiCAIIgiCCMIUtwADALYCCr92l++TAAAAAElFTkSuQmCC)',
    backgroundRepeat: 'no-repeat repeat',
    backgroundOrigin: 'content-box'
  });
});
var TableSkeletonCell = function TableSkeletonCell(_ref3) {
  var className = _ref3.className,
      tableRow = _ref3.tableRow,
      tableColumn = _ref3.tableColumn,
      restProps = _objectWithoutProperties(_ref3, _excluded$z);

  return /*#__PURE__*/React.createElement(StyledTableCell$8, _extends({
    className: classNames(classes$r.cell, className)
  }, restProps));
};
process.env.NODE_ENV !== "production" ? TableSkeletonCell.propTypes = {
  className: PropTypes.string,
  tableRow: PropTypes.object,
  tableColumn: PropTypes.object
} : void 0;
TableSkeletonCell.defaultProps = {
  className: undefined,
  tableRow: undefined,
  tableColumn: undefined
};

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 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: 53,
  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$A = ["filter", "getMessage", "onFilter", "children", "className", "tableRow", "tableColumn", "column", "filteringEnabled", "forwardedRef"];
var PREFIX$s = 'TableFilterCell';
var classes$s = {
  cell: "".concat(PREFIX$s, "-cell"),
  flexContainer: "".concat(PREFIX$s, "-flexContainer")
};
var StyledTableCell$9 = material.styled(material.TableCell)(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$s.cell), {
    padding: 0,
    '&:first-of-type': {
      paddingLeft: theme.spacing(3)
    }
  }), _defineProperty(_ref2, "& .".concat(classes$s.flexContainer), {
    width: '100%',
    display: 'flex',
    alignItems: 'center'
  }), _ref2;
});
var TableFilterCell = function TableFilterCell(_ref3) {
  var filter = _ref3.filter,
      getMessage = _ref3.getMessage,
      onFilter = _ref3.onFilter,
      children = _ref3.children,
      className = _ref3.className,
      tableRow = _ref3.tableRow,
      tableColumn = _ref3.tableColumn,
      column = _ref3.column,
      filteringEnabled = _ref3.filteringEnabled,
      forwardedRef = _ref3.forwardedRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$A);

  return /*#__PURE__*/React.createElement(StyledTableCell$9, _extends({
    className: classNames(classes$s.cell, className),
    ref: forwardedRef
  }, restProps), /*#__PURE__*/React.createElement("div", {
    className: classes$s.flexContainer
  }, children));
};
process.env.NODE_ENV !== "production" ? TableFilterCell.propTypes = {
  filter: PropTypes.object,
  onFilter: PropTypes.func,
  children: PropTypes.node,
  getMessage: PropTypes.func.isRequired,
  className: PropTypes.string,
  tableRow: PropTypes.object,
  tableColumn: PropTypes.object,
  column: PropTypes.object,
  filteringEnabled: PropTypes.bool,
  forwardedRef: PropTypes.func
} : void 0;
TableFilterCell.defaultProps = {
  filter: null,
  onFilter: function onFilter() {},
  children: undefined,
  className: undefined,
  tableRow: undefined,
  tableColumn: undefined,
  column: undefined,
  filteringEnabled: true,
  forwardedRef: undefined
};

var _excluded$B = ["value", "disabled", "getMessage", "onChange"];
var PREFIX$t = 'Editor';
var classes$t = {
  input: "".concat(PREFIX$t, "-input"),
  root: "".concat(PREFIX$t, "-root")
};
var StyledInput = material.styled(material.Input)(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "& .".concat(classes$t.input), {
    width: '100%',
    fontSize: '14px'
  }), _defineProperty(_ref2, "&.".concat(classes$t.root), {
    margin: theme.spacing(1)
  }), _ref2;
});
var Editor = function Editor(_ref3) {
  var value = _ref3.value,
      disabled = _ref3.disabled,
      getMessage = _ref3.getMessage,
      _onChange = _ref3.onChange,
      restProps = _objectWithoutProperties(_ref3, _excluded$B);

  return /*#__PURE__*/React.createElement(StyledInput, _extends({
    classes: {
      input: classes$t.input,
      root: classes$t.root
    },
    fullWidth: true,
    disabled: disabled,
    value: value,
    onChange: function onChange(event) {
      return _onChange(event.target.value);
    },
    placeholder: getMessage('filterPlaceholder')
  }, restProps));
};
process.env.NODE_ENV !== "production" ? Editor.propTypes = {
  value: PropTypes.any,
  disabled: PropTypes.bool,
  onChange: PropTypes.func,
  getMessage: PropTypes.func.isRequired
} : void 0;
Editor.defaultProps = {
  value: '',
  disabled: false,
  onChange: function onChange() {}
};

var PREFIX$u = 'FilterSelector';
var classes$u = {
  icon: "".concat(PREFIX$u, "-icon"),
  iconItem: "".concat(PREFIX$u, "-iconItem"),
  selectMenu: "".concat(PREFIX$u, "-selectMenu")
};
var StyledMenu = material.styled(material.Menu)(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$u.selectMenu), {
    position: 'absolute !important'
  }), _defineProperty(_ref2, "& .".concat(classes$u.iconItem), {
    minWidth: theme.spacing(2)
  }), _ref2;
});
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.setButtonRef = function (buttonRef) {
      _this.buttonRef = buttonRef;
    };

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

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

    _this.handleMenuItemClick = function (nextValue) {
      var onChange = _this.props.onChange;

      _this.setState({
        opened: false
      });

      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;
      var opened = this.state.opened;
      var StyledIcon = material.styled(Icon)(function (_ref3) {
        var theme = _ref3.theme;
        return _defineProperty({}, "&.".concat(classes$u.icon), {
          marginRight: theme.spacing(1)
        });
      });
      return availableValues.length ? /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(ToggleButton, {
        buttonRef: this.setButtonRef,
        onToggle: this.handleButtonClick,
        disabled: disabled || availableValues.length === 1
      }, /*#__PURE__*/React.createElement(Icon, {
        type: value
      })), /*#__PURE__*/React.createElement(StyledMenu, {
        anchorEl: this.buttonRef,
        open: opened,
        onClose: this.handleMenuClose,
        MenuListProps: {
          dense: true
        },
        className: classes$u.selectMenu
      }, availableValues.map(function (valueItem) {
        return /*#__PURE__*/React.createElement(material.MenuItem, {
          key: valueItem,
          selected: valueItem === value,
          onClick: function onClick() {
            return _this2.handleMenuItemClick(valueItem);
          }
        }, /*#__PURE__*/React.createElement(material.ListItemIcon, {
          className: classes$u.iconItem
        }, /*#__PURE__*/React.createElement(StyledIcon, {
          type: valueItem,
          className: classes$u.icon,
          fontSize: "small"
        })), /*#__PURE__*/React.createElement(material.ListItemText, null, 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,
  // oneOfType is a workaround because withStyles returns react object
  toggleButtonComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.object]).isRequired,
  getMessage: PropTypes.func.isRequired
} : void 0;
FilterSelector.defaultProps = {
  value: undefined,
  availableValues: [],
  onChange: function onChange() {},
  disabled: false
};

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

  return /*#__PURE__*/React.createElement(material.IconButton, _extends({
    ref: buttonRef,
    onClick: onToggle,
    disabled: disabled
  }, restProps, {
    size: "large"
  }), children);
};
process.env.NODE_ENV !== "production" ? ToggleButton$1.propTypes = {
  buttonRef: PropTypes.func.isRequired,
  onToggle: PropTypes.func.isRequired,
  children: PropTypes.node,
  disabled: PropTypes.bool
} : void 0;
ToggleButton$1.defaultProps = {
  children: undefined,
  disabled: false
};

var _excluded$D = ["type"];
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$1 = /*#__PURE__*/React.memo(function (_ref) {
  var type = _ref.type,
      restProps = _objectWithoutProperties(_ref, _excluded$D);

  var path = AVAILABLE_PATHS[type];
  return path ? /*#__PURE__*/React.createElement(material.SvgIcon, _extends({
    viewBox: "0 0 32 32",
    fontSize: "small"
  }, restProps), /*#__PURE__*/React.createElement("path", {
    d: path
  })) : /*#__PURE__*/React.createElement(SearchIcon, restProps);
});
process.env.NODE_ENV !== "production" ? Icon$1.propTypes = {
  type: PropTypes.string
} : void 0;
Icon$1.defaultProps = {
  type: undefined
};

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

var _excluded$E = ["children", "forwardedRef"];
var PREFIX$v = 'ResizingControl';
var classes$v = {
  resizeHandle: "".concat(PREFIX$v, "-resizeHandle"),
  resizeHandleLine: "".concat(PREFIX$v, "-resizeHandleLine"),
  resizeHandleFirstLine: "".concat(PREFIX$v, "-resizeHandleFirstLine"),
  resizeHandleSecondLine: "".concat(PREFIX$v, "-resizeHandleSecondLine"),
  resizeHandleLineActive: "".concat(PREFIX$v, "-resizeHandleLineActive")
};
var StyledDiv$a = material.styled('div')(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$v.resizeHandle), {
    position: 'absolute',
    userSelect: 'none',
    MozUserSelect: 'none',
    WebkitUserSelect: 'none',
    width: theme.spacing(2),
    top: 0,
    right: theme.spacing(-1),
    height: '100%',
    cursor: 'col-resize',
    zIndex: 100
  }), _defineProperty(_ref2, "&.".concat(classes$v.resizeHandleLine), {
    position: 'absolute',
    backgroundColor: theme.palette.primary.light,
    height: '50%',
    width: '1px',
    top: '25%',
    transition: 'all linear 100ms'
  }), _defineProperty(_ref2, "&.".concat(classes$v.resizeHandleFirstLine), {
    left: "calc(".concat(theme.spacing(1), " - 1px)")
  }), _defineProperty(_ref2, "&.".concat(classes$v.resizeHandleSecondLine), {
    left: "calc(".concat(theme.spacing(1), " + 1px)")
  }), _defineProperty(_ref2, "&.".concat(classes$v.resizeHandleLineActive), {
    left: theme.spacing(1),
    opacity: 1,
    backgroundColor: theme.palette.primary.light,
    height: 'calc(100% - 4px)',
    top: '2px'
  }), _ref2;
});

var ResizeHandle = function ResizeHandle(_ref3) {
  var children = _ref3.children,
      forwardedRef = _ref3.forwardedRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$E);

  return /*#__PURE__*/React.createElement(StyledDiv$a, _extends({
    ref: forwardedRef
  }, restProps), children);
};

process.env.NODE_ENV !== "production" ? ResizeHandle.propTypes = {
  children: PropTypes.node,
  forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
} : void 0;
ResizeHandle.defaultProps = {
  children: undefined,
  forwardedRef: undefined
};
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 (_ref4) {
      var x = _ref4.x;
      _this.resizeStartingX = x;

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

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

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

    _this.onResizeEnd = function (_ref6) {
      var x = _ref6.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 _classNames, _classNames2, _classNames3;

      var _this$props2 = this.props,
          resizeHandleOpacityClass = _this$props2.resizeHandleOpacityClass,
          resizeLastHandleClass = _this$props2.resizeLastHandleClass;
      var resizing = this.state.resizing;
      return /*#__PURE__*/React.createElement(dxReactCore.Draggable, {
        onStart: this.onResizeStart,
        onUpdate: this.onResizeUpdate,
        onEnd: this.onResizeEnd
      }, /*#__PURE__*/React.createElement(ResizeHandle, {
        className: classNames((_classNames = {}, _defineProperty(_classNames, classes$v.resizeHandle, true), _defineProperty(_classNames, resizeLastHandleClass, true), _classNames))
      }, /*#__PURE__*/React.createElement(StyledDiv$a, {
        className: classNames((_classNames2 = {}, _defineProperty(_classNames2, resizeHandleOpacityClass, true), _defineProperty(_classNames2, classes$v.resizeHandleLine, true), _defineProperty(_classNames2, classes$v.resizeHandleFirstLine, true), _defineProperty(_classNames2, classes$v.resizeHandleLineActive, resizing), _classNames2))
      }), /*#__PURE__*/React.createElement(StyledDiv$a, {
        className: classNames((_classNames3 = {}, _defineProperty(_classNames3, resizeHandleOpacityClass, true), _defineProperty(_classNames3, classes$v.resizeHandleLine, true), _defineProperty(_classNames3, classes$v.resizeHandleSecondLine, true), _defineProperty(_classNames3, classes$v.resizeHandleLineActive, resizing), _classNames3))
      })));
    }
  }]);

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

var _excluded$F = ["style", "column", "tableColumn", "draggingEnabled", "resizingEnabled", "dragging", "onWidthChange", "onWidthDraft", "onWidthDraftCancel", "getCellWidth", "tableRow", "className", "children", "forwardedRef"];
var PREFIX$w = 'CellLayout';
var classes$w = {
  cell: "".concat(PREFIX$w, "-cell"),
  cellRight: "".concat(PREFIX$w, "-cellRight"),
  cellCenter: "".concat(PREFIX$w, "-cellCenter"),
  cellNoWrap: "".concat(PREFIX$w, "-cellNoWrap"),
  cellNoUserSelect: "".concat(PREFIX$w, "-cellNoUserSelect"),
  cellDraggable: "".concat(PREFIX$w, "-cellDraggable"),
  cellDimmed: "".concat(PREFIX$w, "-cellDimmed"),
  container: "".concat(PREFIX$w, "-container"),
  resizeHandle: "".concat(PREFIX$w, "-resizeHandle"),
  resizeHandleLine: "".concat(PREFIX$w, "-resizeHandleLine")
};
var StyledTableCell$a = material.styled(material.TableCell)(function (_ref) {
  var _mediaPointerFin, _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$w.cell), {
    outline: 'none',
    position: 'relative',
    overflow: 'visible',
    paddingRight: theme.spacing(1),
    paddingLeft: theme.spacing(1),
    '&:first-of-type': {
      paddingLeft: theme.spacing(3)
    },
    '&:hover': _defineProperty({}, "& .".concat(classes$w.resizeHandleLine), {
      opacity: 1
    }),
    '&:nth-last-of-type(2)': _defineProperty({}, "& .".concat(classes$w.resizeHandle), {
      width: theme.spacing(1),
      right: '1px'
    })
  }), _defineProperty(_ref2, "&.".concat(classes$w.cellRight), {
    paddingLeft: theme.spacing(1),
    paddingRight: theme.spacing(1),
    textAlign: 'right'
  }), _defineProperty(_ref2, "&.".concat(classes$w.cellCenter), {
    textAlign: 'center'
  }), _defineProperty(_ref2, "&.".concat(classes$w.cellNoWrap), {
    whiteSpace: 'nowrap'
  }), _defineProperty(_ref2, "&.".concat(classes$w.cellNoUserSelect), {
    userSelect: 'none',
    MozUserSelect: 'none',
    WebkitUserSelect: 'none'
  }), _defineProperty(_ref2, "&.".concat(classes$w.cellDraggable), {
    cursor: 'pointer'
  }), _defineProperty(_ref2, "&.".concat(classes$w.cellDimmed), {
    '&:after': {
      content: '""',
      position: 'absolute',
      top: 0,
      right: 0,
      bottom: 0,
      left: 0,
      backgroundColor: theme.palette.background.paper,
      opacity: 0.7,
      pointerEvents: 'none',
      zIndex: 400
    }
  }), _defineProperty(_ref2, "& .".concat(classes$w.container), {
    display: 'flex',
    flexDirection: 'row',
    alignItems: 'center'
  }), _defineProperty(_ref2, "& .".concat(classes$w.resizeHandle), {}), _defineProperty(_ref2, "& .".concat(classes$w.resizeHandleLine), {
    opacity: 0
  }), _defineProperty(_ref2, '@media (pointer: fine)', (_mediaPointerFin = {}, _defineProperty(_mediaPointerFin, "& .".concat(classes$w.resizeHandleLine), {
    opacity: 0
  }), _defineProperty(_mediaPointerFin, "& .".concat(classes$w.resizeHandle), {
    '&:hover': _defineProperty({}, "& .".concat(classes$w.resizeHandleLine), {
      opacity: 1
    })
  }), _mediaPointerFin)), _ref2;
});
var CellLayout = function CellLayout(_ref3) {
  var _classNames;

  var style = _ref3.style,
      column = _ref3.column,
      tableColumn = _ref3.tableColumn,
      draggingEnabled = _ref3.draggingEnabled,
      resizingEnabled = _ref3.resizingEnabled,
      dragging = _ref3.dragging,
      onWidthChange = _ref3.onWidthChange,
      onWidthDraft = _ref3.onWidthDraft,
      onWidthDraftCancel = _ref3.onWidthDraftCancel,
      getCellWidth = _ref3.getCellWidth,
      tableRow = _ref3.tableRow,
      className = _ref3.className,
      children = _ref3.children,
      forwardedRef = _ref3.forwardedRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$F);

  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();
  }, []);
  var align = tableColumn && tableColumn.align || 'left';
  return /*#__PURE__*/React.createElement(StyledTableCell$a, _extends({
    style: style,
    className: classNames((_classNames = {}, _defineProperty(_classNames, classes$w.cell, true), _defineProperty(_classNames, classes$w.cellRight, align === 'right'), _defineProperty(_classNames, classes$w.cellCenter, align === 'center'), _defineProperty(_classNames, classes$w.cellNoUserSelect, draggingEnabled), _defineProperty(_classNames, classes$w.cellDraggable, draggingEnabled), _defineProperty(_classNames, classes$w.cellDimmed, dragging || tableColumn && tableColumn.draft), _defineProperty(_classNames, classes$w.cellNoWrap, !(tableColumn && tableColumn.wordWrapEnabled)), _classNames), className),
    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", {
    className: classes$w.container
  }, children), resizingEnabled && /*#__PURE__*/React.createElement(ResizingControl, {
    onWidthChange: onWidthChange,
    onWidthDraft: onWidthDraft,
    onWidthDraftCancel: onWidthDraftCancel,
    resizeLastHandleClass: classes$w.resizeHandle,
    resizeHandleOpacityClass: classes$w.resizeHandleLine
  }));
};
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,
  className: PropTypes.string,
  children: PropTypes.node,
  getCellWidth: PropTypes.func
} : void 0;
TableHeaderCell.defaultProps = {
  column: undefined,
  tableColumn: undefined,
  tableRow: undefined,
  style: null,
  draggingEnabled: false,
  resizingEnabled: false,
  onWidthChange: undefined,
  onWidthDraft: undefined,
  onWidthDraftCancel: undefined,
  className: undefined,
  children: undefined,
  getCellWidth: function getCellWidth() {}
};

var _excluded$G = ["column", "align", "direction", "children", "onSort", "getMessage", "disabled", "className"];
var ENTER_KEY_CODE$1 = 13;
var SPACE_KEY_CODE$1 = 32;
var PREFIX$x = 'ResizingControl';
var classes$x = {
  root: "".concat(PREFIX$x, "-root"),
  tooltipRoot: "".concat(PREFIX$x, "-tooltipRoot"),
  sortLabelRoot: "".concat(PREFIX$x, "-sortLabelRoot"),
  sortLabelRight: "".concat(PREFIX$x, "-sortLabelRight"),
  sortLabelActive: "".concat(PREFIX$x, "-sortLabelActive")
};
var StyledDiv$b = material.styled('div')(function () {
  var _ref;

  return _ref = {}, _defineProperty(_ref, "&.".concat(classes$x.root), {
    width: '100%',
    userSelect: 'none',
    MozUserSelect: 'none',
    WebkitUserSelect: 'none'
  }), _defineProperty(_ref, "& .".concat(classes$x.sortLabelRoot), {
    maxWidth: '100%'
  }), _defineProperty(_ref, "& .".concat(classes$x.sortLabelRight), {
    flexDirection: 'row-reverse'
  }), _defineProperty(_ref, "& .".concat(classes$x.sortLabelActive), {
    color: 'inherit'
  }), _defineProperty(_ref, "& .".concat(classes$x.tooltipRoot), {
    display: 'block',
    whiteSpace: 'nowrap',
    overflow: 'hidden',
    textOverflow: 'ellipsis'
  }), _ref;
});

var _onClick = function onClick(e, onSort) {
  var isActionKeyDown = e.keyCode === ENTER_KEY_CODE$1 || e.keyCode === SPACE_KEY_CODE$1;
  var isMouseClick = e.keyCode === undefined;
  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(_ref2) {
  var _classNames;

  var column = _ref2.column,
      align = _ref2.align,
      direction = _ref2.direction,
      children = _ref2.children,
      onSort = _ref2.onSort,
      getMessage = _ref2.getMessage,
      disabled = _ref2.disabled,
      className = _ref2.className,
      restProps = _objectWithoutProperties(_ref2, _excluded$G);

  return /*#__PURE__*/React.createElement(StyledDiv$b, _extends({
    className: classNames(classes$x.root, className)
  }, restProps), /*#__PURE__*/React.createElement(material.Tooltip, {
    title: getMessage('sortingHint'),
    placement: align === 'right' ? 'bottom-end' : 'bottom-start',
    enterDelay: 300,
    classes: {
      tooltip: classes$x.tooltipRoot
    }
  }, /*#__PURE__*/React.createElement(material.TableSortLabel, {
    active: !!direction,
    direction: direction === null ? undefined : direction,
    onClick: function onClick(e) {
      return _onClick(e, onSort);
    },
    disabled: disabled,
    classes: {
      root: classNames((_classNames = {}, _defineProperty(_classNames, classes$x.sortLabelRoot, true), _defineProperty(_classNames, classes$x.sortLabelRight, align === 'right'), _classNames)),
      active: classes$x.sortLabelActive
    }
  }, children)));
};
process.env.NODE_ENV !== "production" ? SortLabel.propTypes = {
  column: PropTypes.object,
  align: PropTypes.string,
  direction: PropTypes.oneOf(['asc', 'desc', null]),
  children: PropTypes.node,
  onSort: PropTypes.func.isRequired,
  getMessage: PropTypes.func.isRequired,
  disabled: PropTypes.bool,
  className: PropTypes.string
} : void 0;
SortLabel.defaultProps = {
  column: undefined,
  direction: undefined,
  disabled: false,
  align: 'left',
  className: null,
  children: undefined
};

var _excluded$H = ["disabled", "onGroup", "className"];
var PREFIX$y = 'GroupButton';
var classes$y = {
  root: "".concat(PREFIX$y, "-root"),
  disabled: "".concat(PREFIX$y, "-disabled")
};
var StyledDiv$c = material.styled('div')(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$y.root), {
    paddingLeft: 0,
    height: theme.spacing(3),
    cursor: 'pointer'
  }), _defineProperty(_ref2, "&.".concat(classes$y.disabled), {
    cursor: 'default',
    opacity: 0.3
  }), _ref2;
});
var GroupButton = function GroupButton(_ref3) {
  var _classNames;

  var disabled = _ref3.disabled,
      onGroup = _ref3.onGroup,
      className = _ref3.className,
      restProps = _objectWithoutProperties(_ref3, _excluded$H);

  return /*#__PURE__*/React.createElement(StyledDiv$c, _extends({
    onClick: function onClick(e) {
      if (disabled) return;
      e.stopPropagation();
      onGroup(e);
    },
    className: classNames((_classNames = {}, _defineProperty(_classNames, classes$y.root, true), _defineProperty(_classNames, classes$y.disabled, disabled), _classNames), className)
  }, restProps), /*#__PURE__*/React.createElement(List, null));
};
process.env.NODE_ENV !== "production" ? GroupButton.propTypes = {
  onGroup: PropTypes.func.isRequired,
  disabled: PropTypes.bool,
  className: PropTypes.string
} : void 0;
GroupButton.defaultProps = {
  disabled: false,
  className: undefined
};

var _excluded$I = ["children", "className"];
var PREFIX$z = 'Title';
var classes$z = {
  title: "".concat(PREFIX$z, "-title")
};
var StyledSpan$2 = material.styled('span')(function () {
  return _defineProperty({}, "&.".concat(classes$z.title), {
    overflow: 'hidden',
    textOverflow: 'ellipsis'
  });
});
var Title = function Title(_ref2) {
  var children = _ref2.children,
      className = _ref2.className,
      restProps = _objectWithoutProperties(_ref2, _excluded$I);

  return /*#__PURE__*/React.createElement(StyledSpan$2, _extends({
    className: classNames(classes$z.title, className)
  }, restProps), children);
};
process.env.NODE_ENV !== "production" ? Title.propTypes = {
  children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),
  className: PropTypes.string
} : void 0;
Title.defaultProps = {
  className: null,
  children: undefined
};

var _excluded$J = ["column", "align", "children", "className"];
var PREFIX$A = 'Content';
var classes$A = {
  content: "".concat(PREFIX$A, "-content"),
  alignCenter: "".concat(PREFIX$A, "-alignCenter"),
  alignRight: "".concat(PREFIX$A, "-alignRight")
};
var StyledDiv$d = material.styled('div')(function () {
  var _ref;

  return _ref = {}, _defineProperty(_ref, "&.".concat(classes$A.content), {
    width: '100%',
    minWidth: 0,
    display: 'flex',
    flexDirection: 'row',
    alignItems: 'center',
    justifyContent: 'flex-start'
  }), _defineProperty(_ref, "&.".concat(classes$A.alignCenter), {
    justifyContent: 'center'
  }), _defineProperty(_ref, "&.".concat(classes$A.alignRight), {
    justifyContent: 'flex-end'
  }), _ref;
});
var Content$1 = function Content(_ref2) {
  var _classNames;

  var column = _ref2.column,
      align = _ref2.align,
      children = _ref2.children,
      className = _ref2.className,
      restProps = _objectWithoutProperties(_ref2, _excluded$J);

  return /*#__PURE__*/React.createElement(StyledDiv$d, _extends({
    className: classNames((_classNames = {}, _defineProperty(_classNames, classes$A.content, true), _defineProperty(_classNames, classes$A.alignCenter, align === 'center'), _defineProperty(_classNames, classes$A.alignRight, align === 'right'), _classNames), className)
  }, restProps), children);
};
process.env.NODE_ENV !== "production" ? Content$1.propTypes = {
  column: PropTypes.object,
  align: PropTypes.string,
  children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),
  className: PropTypes.string
} : void 0;
Content$1.defaultProps = {
  column: undefined,
  align: 'left',
  className: null,
  children: undefined
};

var _excluded$K = ["messages"];
var defaultMessages$2 = {
  sortingHint: 'Sort'
};
var TableHeaderRowWithMessages = withPatchedProps(function (_ref) {
  var messages = _ref.messages,
      restProps = _objectWithoutProperties(_ref, _excluded$K);

  return _objectSpread2({
    messages: _objectSpread2(_objectSpread2({}, defaultMessages$2), messages)
  }, restProps);
})(dxReactGrid.TableHeaderRow);
TableHeaderRowWithMessages.propTypes = {
  messages: PropTypes.shape({
    sortingHint: PropTypes.string
  })
};
TableHeaderRowWithMessages.defaultProps = {
  messages: {}
};
TableHeaderRowWithMessages.components = dxReactGrid.TableHeaderRow.components;
var TableHeaderRow = dxReactCore.withComponents({
  Cell: TableHeaderCell,
  Row: TableRow,
  Content: Content$1,
  SortLabel: SortLabel,
  Title: Title,
  GroupButton: GroupButton
})(TableHeaderRowWithMessages);
TableHeaderRow.ROW_TYPE = dxReactGrid.TableHeaderRow.ROW_TYPE;

var _excluded$L = ["column", "value", "children", "tableRow", "tableColumn", "row", "className", "beforeBorder", "forwardedRef"];
var PREFIX$B = 'Cell';
var classes$B = {
  cell: "".concat(PREFIX$B, "-cell"),
  beforeBorder: "".concat(PREFIX$B, "-beforeBorder")
};
var StyledTableCell$b = material.styled(material.TableCell)(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$B.cell), {
    paddingRight: theme.spacing(1),
    paddingLeft: theme.spacing(1),
    '&:first-of-type': {
      paddingLeft: theme.spacing(3)
    },
    '&:last-child': {
      paddingRight: theme.spacing(3),
      borderRight: 0
    },
    overflow: 'hidden',
    textOverflow: 'ellipsis',
    whiteSpace: 'nowrap',
    borderBottom: getBorder(theme),
    borderRight: getBorder(theme)
  }), _defineProperty(_ref2, "&.".concat(classes$B.beforeBorder), {
    borderLeft: getBorder(theme)
  }), _ref2;
});
var Cell$1 = function Cell(_ref3) {
  var _classNames;

  var column = _ref3.column,
      value = _ref3.value,
      children = _ref3.children,
      tableRow = _ref3.tableRow,
      tableColumn = _ref3.tableColumn,
      row = _ref3.row,
      className = _ref3.className,
      beforeBorder = _ref3.beforeBorder,
      forwardedRef = _ref3.forwardedRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$L);

  return /*#__PURE__*/React.createElement(StyledTableCell$b, _extends({
    className: classNames((_classNames = {}, _defineProperty(_classNames, classes$B.cell, true), _defineProperty(_classNames, classes$B.beforeBorder, beforeBorder), _classNames), className)
  }, restProps, {
    ref: forwardedRef
  }), children);
};
process.env.NODE_ENV !== "production" ? Cell$1.propTypes = {
  value: PropTypes.any,
  column: PropTypes.object,
  row: PropTypes.any,
  children: PropTypes.node,
  tableRow: PropTypes.object,
  tableColumn: PropTypes.object,
  className: PropTypes.string,
  beforeBorder: PropTypes.bool,
  forwardedRef: PropTypes.func
} : void 0;
Cell$1.defaultProps = {
  value: undefined,
  column: undefined,
  row: undefined,
  children: undefined,
  tableRow: undefined,
  tableColumn: undefined,
  className: undefined,
  beforeBorder: false,
  forwardedRef: undefined
};

var _excluded$M = ["component", "className", "beforeBorder"];
var PREFIX$C = 'BandedHeaderCell';
var classes$C = {
  headerCellBorder: "".concat(PREFIX$C, "-headerCellBorder"),
  beforeBorder: "".concat(PREFIX$C, "-beforeBorder")
};

var styles = function styles(_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$C.headerCellBorder), {
    borderRight: getBorder(theme),
    borderTop: 'none',
    '&:last-child': {
      borderRight: 0
    },
    verticalAlign: 'bottom',
    paddingBottom: theme.spacing(2)
  }), _defineProperty(_ref2, "&.".concat(classes$C.beforeBorder), {
    borderLeft: getBorder(theme)
  }), _ref2;
};

var BandedHeaderCellBase = function BandedHeaderCellBase(_ref3) {
  var _classNames;

  var HeaderCellComponent = _ref3.component,
      className = _ref3.className,
      beforeBorder = _ref3.beforeBorder,
      restProps = _objectWithoutProperties(_ref3, _excluded$M);

  return /*#__PURE__*/React.createElement(HeaderCellComponent, _extends({
    className: classNames((_classNames = {}, _defineProperty(_classNames, classes$C.headerCellBorder, true), _defineProperty(_classNames, classes$C.beforeBorder, beforeBorder), _classNames), className)
  }, restProps));
};

process.env.NODE_ENV !== "production" ? BandedHeaderCellBase.propTypes = {
  component: PropTypes.func.isRequired,
  className: PropTypes.string,
  beforeBorder: PropTypes.bool
} : void 0;
BandedHeaderCellBase.defaultProps = {
  className: undefined,
  beforeBorder: false
};
var BandedHeaderCell = material.styled(BandedHeaderCellBase)(styles);

var PREFIX$D = 'InvisibleCell';
var classes$D = {
  emptyCell: "".concat(PREFIX$D, "-emptyCell")
};
var StyledTableCell$c = material.styled(material.TableCell)(function () {
  return _defineProperty({}, "&.".concat(classes$D.emptyCell), {
    display: 'none'
  });
});
var InvisibleCell = function InvisibleCell() {
  return /*#__PURE__*/React.createElement(StyledTableCell$c, {
    className: classes$D.emptyCell
  });
};

var _excluded$N = ["children", "className", "row", "tableRow", "tableColumn", "forwardedRef"];
var PREFIX$E = 'Row';
var classes$E = {
  row: "".concat(PREFIX$E, "-row")
};
var StyledTableRow$2 = material.styled(material.TableRow)(function () {
  return _defineProperty({}, "&.".concat(classes$E.row), {
    height: 'auto'
  });
});
var Row$1 = function Row(_ref2) {
  var children = _ref2.children,
      className = _ref2.className,
      row = _ref2.row,
      tableRow = _ref2.tableRow,
      tableColumn = _ref2.tableColumn,
      forwardedRef = _ref2.forwardedRef,
      restProps = _objectWithoutProperties(_ref2, _excluded$N);

  return /*#__PURE__*/React.createElement(StyledTableRow$2, _extends({
    className: classNames(classes$E.row, className)
  }, restProps), children);
};
process.env.NODE_ENV !== "production" ? Row$1.propTypes = {
  children: PropTypes.node,
  row: PropTypes.any,
  tableRow: PropTypes.object,
  tableColumn: PropTypes.object,
  className: PropTypes.string,
  forwardedRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
} : void 0;
Row$1.defaultProps = {
  children: undefined,
  row: undefined,
  tableRow: undefined,
  tableColumn: undefined,
  className: undefined,
  forwardedRef: undefined
};

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

var _excluded$O = ["column", "value", "onValueChange", "style", "children", "row", "tableRow", "tableColumn", "editingEnabled", "className", "autoFocus", "onBlur", "onFocus", "onKeyDown", "forwardedRef"];
var PREFIX$F = 'TableEditCell';
var classes$F = {
  cell: "".concat(PREFIX$F, "-cell"),
  inputRoot: "".concat(PREFIX$F, "-inputRoot"),
  disabledInput: "".concat(PREFIX$F, "-disabledInput"),
  inputRight: "".concat(PREFIX$F, "-inputRight"),
  inputCenter: "".concat(PREFIX$F, "-inputCenter")
};
var StyledTableCell$d = material.styled(material.TableCell)(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$F.cell), {
    padding: theme.spacing(1),
    // NOTE: without the TableEditColumn first EditCell changes size
    // (because first TableCell and EditCell have different paddings)
    '&:first-of-type': {
      paddingLeft: theme.spacing(3)
    }
  });
});
var StyledInput$1 = material.styled(material.Input)(function (_ref3) {
  var _ref4;

  var theme = _ref3.theme;
  return _ref4 = {}, _defineProperty(_ref4, "&.".concat(classes$F.inputRoot), {
    width: '100%'
  }), _defineProperty(_ref4, "&.".concat(classes$F.disabledInput), {
    color: theme.palette.action.disabled,
    '&:before': {
      borderBottom: '1px dotted',
      borderBottomColor: theme.palette.action.disabled
    },
    '&&:hover:before': {
      borderBottom: '1px dotted',
      borderBottomColor: theme.palette.action.disabled
    },
    '&:after': {
      borderBottom: '0px'
    }
  }), _defineProperty(_ref4, "& .".concat(classes$F.inputRight), {
    textAlign: 'right'
  }), _defineProperty(_ref4, "& .".concat(classes$F.inputCenter), {
    textAlign: 'center'
  }), _ref4;
});
var EditCell = function EditCell(_ref5) {
  var _classNames, _classNames2;

  var column = _ref5.column,
      value = _ref5.value,
      onValueChange = _ref5.onValueChange,
      style = _ref5.style,
      children = _ref5.children,
      row = _ref5.row,
      tableRow = _ref5.tableRow,
      tableColumn = _ref5.tableColumn,
      editingEnabled = _ref5.editingEnabled,
      className = _ref5.className,
      autoFocus = _ref5.autoFocus,
      onBlur = _ref5.onBlur,
      onFocus = _ref5.onFocus,
      onKeyDown = _ref5.onKeyDown,
      forwardedRef = _ref5.forwardedRef,
      restProps = _objectWithoutProperties(_ref5, _excluded$O);

  var inputClasses = classNames((_classNames = {}, _defineProperty(_classNames, classes$F.inputRight, tableColumn && tableColumn.align === 'right'), _defineProperty(_classNames, classes$F.inputCenter, tableColumn && tableColumn.align === 'center'), _classNames));
  var patchedChildren = children ? /*#__PURE__*/React.cloneElement(children, {
    autoFocus: autoFocus,
    onBlur: onBlur,
    onFocus: onFocus,
    onKeyDown: onKeyDown
  }) : children;
  return /*#__PURE__*/React.createElement(StyledTableCell$d, _extends({
    className: classNames(classes$F.cell, className),
    style: style,
    ref: forwardedRef
  }, restProps), patchedChildren || /*#__PURE__*/React.createElement(StyledInput$1, {
    className: classNames((_classNames2 = {}, _defineProperty(_classNames2, classes$F.inputRoot, true), _defineProperty(_classNames2, classes$F.disabledInput, !editingEnabled), _classNames2)),
    classes: {
      input: inputClasses
    },
    value: value,
    readOnly: !editingEnabled,
    onChange: function onChange(e) {
      return onValueChange(e.target.value);
    } // 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,
  tableRow: PropTypes.object,
  tableColumn: PropTypes.object,
  value: PropTypes.any,
  onValueChange: PropTypes.func,
  style: PropTypes.object,
  editingEnabled: PropTypes.bool,
  children: PropTypes.node,
  className: PropTypes.string,
  autoFocus: PropTypes.bool,
  onBlur: PropTypes.func,
  onFocus: PropTypes.func,
  onKeyDown: PropTypes.func,
  forwardedRef: PropTypes.func
} : void 0;
EditCell.defaultProps = {
  column: undefined,
  row: undefined,
  tableRow: undefined,
  tableColumn: undefined,
  value: '',
  style: null,
  children: undefined,
  className: undefined,
  editingEnabled: true,
  autoFocus: false,
  onValueChange: function onValueChange() {},
  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$P = ["onExecute", "text", "className"],
    _excluded2$2 = ["children", "className", "tableRow", "tableColumn", "rowSpan", "forwardedRef"],
    _excluded3$1 = ["tableRow", "tableColumn", "row", "children", "className", "forwardedRef"];
var PREFIX$G = 'TableEditCommandCell';
var classes$G = {
  button: "".concat(PREFIX$G, "-button"),
  headingCell: "".concat(PREFIX$G, "-headingCell"),
  cell: "".concat(PREFIX$G, "-cell"),
  alignWithRowSpan: "".concat(PREFIX$G, "-alignWithRowSpan")
};
var StyledButton$1 = material.styled(material.Button)(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$G.button), {
    padding: theme.spacing(1),
    minWidth: 40
  });
});
var StyledTableCell$e = material.styled(material.TableCell)(function (_ref3) {
  var _ref4;

  var theme = _ref3.theme;
  return _ref4 = {}, _defineProperty(_ref4, "&.".concat(classes$G.headingCell), {
    whiteSpace: 'nowrap',
    textAlign: 'center',
    padding: theme.spacing(0, 2, 0, 3)
  }), _defineProperty(_ref4, "&.".concat(classes$G.cell), {
    whiteSpace: 'nowrap',
    textAlign: 'center',
    padding: theme.spacing(0, 2, 0, 3)
  }), _defineProperty(_ref4, "&.".concat(classes$G.alignWithRowSpan), {
    verticalAlign: 'bottom',
    paddingBottom: theme.spacing(1.25)
  }), _ref4;
});
var CommandButton = function CommandButton(_ref5) {
  var onExecute = _ref5.onExecute,
      text = _ref5.text,
      className = _ref5.className,
      restProps = _objectWithoutProperties(_ref5, _excluded$P);

  return /*#__PURE__*/React.createElement(StyledButton$1, _extends({
    color: "primary",
    className: classNames(classes$G.button, className),
    onClick: function onClick(e) {
      e.stopPropagation();
      onExecute();
    }
  }, restProps), text);
};
process.env.NODE_ENV !== "production" ? CommandButton.propTypes = {
  onExecute: PropTypes.func.isRequired,
  text: PropTypes.string.isRequired,
  className: PropTypes.string
} : void 0;
CommandButton.defaultProps = {
  className: undefined
};
var EditCommandHeadingCell = function EditCommandHeadingCell(_ref6) {
  var _classNames;

  var children = _ref6.children,
      className = _ref6.className,
      tableRow = _ref6.tableRow,
      tableColumn = _ref6.tableColumn,
      rowSpan = _ref6.rowSpan,
      forwardedRef = _ref6.forwardedRef,
      restProps = _objectWithoutProperties(_ref6, _excluded2$2);

  return /*#__PURE__*/React.createElement(StyledTableCell$e, _extends({
    className: classNames((_classNames = {}, _defineProperty(_classNames, classes$G.headingCell, true), _defineProperty(_classNames, classes$G.alignWithRowSpan, rowSpan > 1), _classNames), className),
    rowSpan: rowSpan,
    ref: forwardedRef
  }, restProps), children);
};
process.env.NODE_ENV !== "production" ? EditCommandHeadingCell.propTypes = {
  children: PropTypes.node,
  className: PropTypes.string,
  tableRow: PropTypes.object,
  tableColumn: PropTypes.object,
  rowSpan: PropTypes.number,
  forwardedRef: PropTypes.func
} : void 0;
EditCommandHeadingCell.defaultProps = {
  children: undefined,
  className: undefined,
  tableRow: undefined,
  tableColumn: undefined,
  rowSpan: undefined,
  forwardedRef: undefined
};
var EditCommandCell = function EditCommandCell(_ref7) {
  var tableRow = _ref7.tableRow,
      tableColumn = _ref7.tableColumn,
      row = _ref7.row,
      children = _ref7.children,
      className = _ref7.className,
      forwardedRef = _ref7.forwardedRef,
      restProps = _objectWithoutProperties(_ref7, _excluded3$1);

  return /*#__PURE__*/React.createElement(StyledTableCell$e, _extends({
    className: classNames(classes$G.cell, className),
    ref: forwardedRef
  }, restProps), children);
};
process.env.NODE_ENV !== "production" ? EditCommandCell.propTypes = {
  children: PropTypes.node,
  className: PropTypes.string,
  tableRow: PropTypes.object,
  tableColumn: PropTypes.object,
  row: PropTypes.any,
  forwardedRef: PropTypes.func
} : void 0;
EditCommandCell.defaultProps = {
  children: undefined,
  className: undefined,
  tableRow: undefined,
  tableColumn: undefined,
  row: undefined,
  forwardedRef: undefined
};

var TableEditColumnWithWidth = withPatchedProps(function (props) {
  return _objectSpread2({
    width: 150
  }, props);
})(dxReactGrid.TableEditColumn);
TableEditColumnWithWidth.components = dxReactGrid.TableEditColumn.components;
var TableEditColumn = dxReactCore.withComponents({
  Cell: EditCommandCell,
  HeaderCell: EditCommandHeadingCell,
  Command: CommandButton
})(TableEditColumnWithWidth);
TableEditColumn.COLUMN_TYPE = dxReactGrid.TableEditColumn.COLUMN_TYPE;

var _excluded$Q = ["getMessage"];
var PREFIX$H = 'EmotyMessage';
var classes$H = {
  emptyMessage: "".concat(PREFIX$H, "-emptyMessage")
};
var StyledBig = material.styled('big')(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$H.emptyMessage), {
    margin: '0 auto',
    padding: theme.spacing(5, 0),
    fontFamily: theme.typography.fontFamily,
    color: theme.typography.subtitle1.color,
    fontSize: theme.typography.subtitle1.fontSize
  });
});
var EmptyMessage = function EmptyMessage(_ref3) {
  var getMessage = _ref3.getMessage,
      restProps = _objectWithoutProperties(_ref3, _excluded$Q);

  return /*#__PURE__*/React.createElement(material.Toolbar, restProps, /*#__PURE__*/React.createElement(StyledBig, {
    className: classes$H.emptyMessage
  }, getMessage('noColumns')));
};
process.env.NODE_ENV !== "production" ? EmptyMessage.propTypes = {
  getMessage: PropTypes.func.isRequired
} : void 0;

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

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
    })
  });
};
process.env.NODE_ENV !== "production" ? TableReorderingCell.propTypes = {
  getCellDimensions: PropTypes.func.isRequired,
  style: PropTypes.object
} : void 0;
TableReorderingCell.defaultProps = {
  style: null
};

var _excluded$R = ["className"];
var PREFIX$I = 'TableInvisibleRow';
var classes$I = {
  row: "".concat(PREFIX$I, "-row")
};
var StyledTableRow$3 = material.styled(TableRow)(function () {
  return _defineProperty({}, "&.".concat(classes$I.row), {
    visibility: 'hidden'
  });
});
var TableInvisibleRow = function TableInvisibleRow(_ref2) {
  var className = _ref2.className,
      restParams = _objectWithoutProperties(_ref2, _excluded$R);

  return /*#__PURE__*/React.createElement(StyledTableRow$3, _extends({
    className: classNames(classes$I.row, className)
  }, restParams));
};
process.env.NODE_ENV !== "production" ? TableInvisibleRow.propTypes = {
  className: PropTypes.string
} : void 0;
TableInvisibleRow.defaultProps = {
  className: undefined
};

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

var _excluded$S = ["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$S);

      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: 40,
  maxColumnWidth: Infinity
};

var _excluded$T = ["children", "className", "style", "forwardedRef"];
var PREFIX$J = 'Toolbar';
var classes$J = {
  toolbar: "".concat(PREFIX$J, "-toolbar")
};
var StyledToolbarMUI = material.styled(material.Toolbar)(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$J.toolbar), {
    borderBottom: getBorder(theme),
    flex: 'none'
  });
});

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

  return /*#__PURE__*/React.createElement(StyledToolbarMUI, _extends({
    style: style,
    className: classNames(classes$J.toolbar, className),
    ref: forwardedRef
  }, 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$U = ["visible", "expanded", "onToggle", "className"];
var PREFIX$K = 'TableTreeExpandButton';
var classes$K = {
  button: "".concat(PREFIX$K, "-button"),
  hidden: "".concat(PREFIX$K, "-hidden")
};
var StyledIconButton = material.styled(material.IconButton)(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$K.button), {
    marginTop: '-1px',
    marginBottom: '-1px',
    marginLeft: "-".concat(theme.spacing(1)),
    marginRight: theme.spacing(2),
    padding: theme.spacing(1)
  }), _defineProperty(_ref2, "&.".concat(classes$K.hidden), {
    cursor: 'default',
    opacity: 0
  }), _ref2;
});
var TableTreeExpandButton = function TableTreeExpandButton(_ref3) {
  var _classNames;

  var visible = _ref3.visible,
      expanded = _ref3.expanded,
      onToggle = _ref3.onToggle,
      className = _ref3.className,
      restProps = _objectWithoutProperties(_ref3, _excluded$U);

  return /*#__PURE__*/React.createElement(StyledIconButton, _extends({
    className: classNames((_classNames = {}, _defineProperty(_classNames, classes$K.button, true), _defineProperty(_classNames, classes$K.hidden, !visible), _classNames), className),
    onClick: function onClick(e) {
      if (!visible) return;
      e.stopPropagation();
      onToggle();
    },
    tabIndex: visible ? 0 : -1
  }, restProps), expanded ? /*#__PURE__*/React.createElement(ExpandMore, null) : /*#__PURE__*/React.createElement(ChevronRight, null));
};
process.env.NODE_ENV !== "production" ? TableTreeExpandButton.propTypes = {
  visible: PropTypes.bool,
  expanded: PropTypes.bool,
  onToggle: PropTypes.func,
  className: PropTypes.string
} : void 0;
TableTreeExpandButton.defaultProps = {
  visible: false,
  expanded: false,
  onToggle: function onToggle() {},
  className: undefined
};

var _excluded$V = ["disabled", "checked", "indeterminate", "onChange", "className"];
var PREFIX$L = 'TableTreeCheckbox';
var classes$L = {
  checkbox: "".concat(PREFIX$L, "-checkbox")
};
var StyledCheckboxMUI = material.styled(material.Checkbox)(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$L.checkbox), {
    marginTop: '-1px',
    marginBottom: '-1px',
    marginRight: theme.spacing(2),
    marginLeft: "-".concat(theme.spacing(2)),
    padding: theme.spacing(1)
  });
});
var TableTreeCheckbox = function TableTreeCheckbox(_ref3) {
  var disabled = _ref3.disabled,
      checked = _ref3.checked,
      indeterminate = _ref3.indeterminate,
      onChange = _ref3.onChange,
      className = _ref3.className,
      restProps = _objectWithoutProperties(_ref3, _excluded$V);

  return /*#__PURE__*/React.createElement(StyledCheckboxMUI, _extends({
    className: classNames(classes$L.checkbox, className),
    checked: checked,
    indeterminate: indeterminate,
    disabled: disabled,
    onClick: function onClick(e) {
      if (disabled) return;
      e.stopPropagation();
      onChange();
    }
  }, restProps));
};
process.env.NODE_ENV !== "production" ? TableTreeCheckbox.propTypes = {
  disabled: PropTypes.bool,
  checked: PropTypes.bool,
  indeterminate: PropTypes.bool,
  onChange: PropTypes.func,
  className: PropTypes.string
} : void 0;
TableTreeCheckbox.defaultProps = {
  disabled: false,
  checked: false,
  indeterminate: false,
  onChange: function onChange() {},
  className: undefined
};

var PREFIX$M = 'TableTreeIndent';
var classes$M = {
  indent: "".concat(PREFIX$M, "-indent")
};
var StyledSpan$3 = material.styled('span')(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$M.indent), {
    marginLeft: theme.spacing(3)
  });
});
var TableTreeIndent = /*#__PURE__*/React.memo(function (_ref3) {
  var level = _ref3.level;
  return Array.from({
    length: level
  }).map(function (value, currentLevel) {
    return /*#__PURE__*/React.createElement(StyledSpan$3 // eslint-disable-next-line react/no-array-index-key
    , {
      key: currentLevel,
      className: classes$M.indent
    });
  });
});
TableTreeIndent.propTypes = {
  level: PropTypes.number
};
TableTreeIndent.defaultProps = {
  level: 0
};

var _excluded$W = ["children", "className"];
var PREFIX$N = 'TableTreeContent';
var classes$N = {
  content: "".concat(PREFIX$N, "-content")
};
var StyledDiv$e = material.styled('div')(function () {
  return _defineProperty({}, "&.".concat(classes$N.content), {
    width: '100%',
    overflow: 'hidden',
    textOverflow: 'ellipsis'
  });
});
var TableTreeContent = function TableTreeContent(_ref2) {
  var children = _ref2.children,
      className = _ref2.className,
      restProps = _objectWithoutProperties(_ref2, _excluded$W);

  return /*#__PURE__*/React.createElement(StyledDiv$e, _extends({
    className: classNames([classes$N.content], className)
  }, restProps), children);
};
process.env.NODE_ENV !== "production" ? TableTreeContent.propTypes = {
  children: PropTypes.node,
  className: PropTypes.string
} : void 0;
TableTreeContent.defaultProps = {
  children: undefined,
  className: undefined
};

var _excluded$X = ["column", "value", "children", "tableRow", "tableColumn", "row", "className", "forwardedRef"];
var PREFIX$O = 'TableTreeCell';
var classes$O = {
  cell: "".concat(PREFIX$O, "-cell"),
  container: "".concat(PREFIX$O, "-container"),
  cellNoWrap: "".concat(PREFIX$O, "-cellNoWrap"),
  cellRightAlign: "".concat(PREFIX$O, "-cellRightAlign"),
  cellCenterAlign: "".concat(PREFIX$O, "-cellCenterAlign")
};
var StyledTableCellMUI$1 = material.styled(material.TableCell)(function (_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$O.cell), {
    padding: theme.spacing(0.5, 1),
    '&:first-of-type': {
      paddingLeft: theme.spacing(3)
    }
  }), _defineProperty(_ref2, "&.".concat(classes$O.cellNoWrap), {
    whiteSpace: 'nowrap'
  }), _defineProperty(_ref2, "&.".concat(classes$O.cellRightAlign), {
    textAlign: 'right'
  }), _defineProperty(_ref2, "&.".concat(classes$O.cellCenterAlign), {
    textAlign: 'center'
  }), _defineProperty(_ref2, "& .".concat(classes$O.container), {
    display: 'flex',
    flexDirection: 'row',
    alignItems: 'center'
  }), _ref2;
});
var TableTreeCell = function TableTreeCell(_ref3) {
  var _classNames;

  var column = _ref3.column,
      value = _ref3.value,
      children = _ref3.children,
      tableRow = _ref3.tableRow,
      tableColumn = _ref3.tableColumn,
      row = _ref3.row,
      className = _ref3.className,
      forwardedRef = _ref3.forwardedRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$X);

  return /*#__PURE__*/React.createElement(StyledTableCellMUI$1, _extends({
    className: classNames((_classNames = {}, _defineProperty(_classNames, classes$O.cell, true), _defineProperty(_classNames, classes$O.cellNoWrap, !(tableColumn && tableColumn.wordWrapEnabled)), _defineProperty(_classNames, classes$O.cellRightAlign, tableColumn && tableColumn.align === 'right'), _defineProperty(_classNames, classes$O.cellCenterAlign, tableColumn && tableColumn.align === 'center'), _classNames), className),
    ref: forwardedRef
  }, restProps), /*#__PURE__*/React.createElement("div", {
    className: classes$O.container
  }, 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,
  className: PropTypes.string,
  forwardedRef: PropTypes.func
} : void 0;
TableTreeCell.defaultProps = {
  value: undefined,
  column: undefined,
  row: undefined,
  children: undefined,
  tableRow: undefined,
  tableColumn: undefined,
  className: undefined,
  forwardedRef: undefined
};

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

var _excluded$Y = ["onValueChange", "value", "getMessage", "inputRef"];
var PREFIX$P = 'SearchPanelInput';
var classes$P = {
  root: "".concat(PREFIX$P, "-root")
};
var StyledInput$2 = material.styled(material.Input)(function (_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$P.root), {
    display: 'flex',
    alignItems: 'center',
    color: theme.palette.action.active
  });
});
var SearchPanelInput = function SearchPanelInput(_ref3) {
  var onValueChange = _ref3.onValueChange,
      value = _ref3.value,
      getMessage = _ref3.getMessage,
      inputRef = _ref3.inputRef,
      restProps = _objectWithoutProperties(_ref3, _excluded$Y);

  return /*#__PURE__*/React.createElement(StyledInput$2, _extends({
    className: classes$P.root,
    ref: inputRef,
    onChange: function onChange(e) {
      return onValueChange(e.target.value);
    },
    value: value,
    type: "text",
    placeholder: getMessage('searchPlaceholder')
  }, restProps, {
    startAdornment: /*#__PURE__*/React.createElement(material.InputAdornment, {
      position: "start"
    }, /*#__PURE__*/React.createElement(SearchIcon, null))
  }));
};
process.env.NODE_ENV !== "production" ? SearchPanelInput.propTypes = {
  onValueChange: PropTypes.func.isRequired,
  value: PropTypes.string,
  getMessage: PropTypes.func.isRequired,
  inputRef: PropTypes.object
} : void 0;
SearchPanelInput.defaultProps = {
  value: '',
  inputRef: undefined
};

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

var _excluded$Z = ["className", "component", "position", "selected", "showLeftDivider", "showRightDivider", "side", "style"];
var PREFIX$Q = 'TableFixedCell';
var classes$Q = {
  dividerRight: "".concat(PREFIX$Q, "-dividerRight"),
  dividerLeft: "".concat(PREFIX$Q, "-dividerLeft"),
  fixedCell: "".concat(PREFIX$Q, "-fixedCell"),
  selected: "".concat(PREFIX$Q, "-selected")
};

var styles$1 = function styles(_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$Q.dividerRight), {
    borderRight: getBorder(theme)
  }), _defineProperty(_ref2, "&.".concat(classes$Q.dividerLeft), {
    borderLeft: getBorder(theme)
  }), _defineProperty(_ref2, "&.".concat(classes$Q.fixedCell), getStickyCellStyle(theme)), _defineProperty(_ref2, "&.".concat(classes$Q.selected), {
    backgroundColor: 'inherit'
  }), _ref2;
};

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

  var _super = _createSuper(FixedCellBase);

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

    return _super.apply(this, arguments);
  }

  _createClass(FixedCellBase, [{
    key: "render",
    value: function render() {
      var _classNames;

      var _this$props = this.props,
          className = _this$props.className,
          CellPlaceholder = _this$props.component,
          position = _this$props.position,
          selected = _this$props.selected,
          showLeftDivider = _this$props.showLeftDivider,
          showRightDivider = _this$props.showRightDivider,
          side = _this$props.side,
          style = _this$props.style,
          restProps = _objectWithoutProperties(_this$props, _excluded$Z);

      return /*#__PURE__*/React.createElement(CellPlaceholder, _extends({
        className: classNames((_classNames = {}, _defineProperty(_classNames, classes$Q.dividerLeft, showLeftDivider), _defineProperty(_classNames, classes$Q.dividerRight, showRightDivider), _defineProperty(_classNames, classes$Q.fixedCell, true), _defineProperty(_classNames, classes$Q.selected, selected), _classNames), className),
        style: _objectSpread2(_objectSpread2({}, style), {}, _defineProperty({}, side, position))
      }, restProps));
    }
  }]);

  return FixedCellBase;
}(React.PureComponent);

process.env.NODE_ENV !== "production" ? FixedCellBase.propTypes = {
  component: PropTypes.func.isRequired,
  className: PropTypes.string,
  position: PropTypes.number,
  selected: PropTypes.bool,
  showLeftDivider: PropTypes.bool,
  showRightDivider: PropTypes.bool,
  side: PropTypes.string.isRequired,
  style: PropTypes.object
} : void 0;
FixedCellBase.defaultProps = {
  className: undefined,
  position: undefined,
  selected: false,
  showLeftDivider: false,
  showRightDivider: false,
  style: null
};
var FixedCell = material.styled(FixedCellBase)(styles$1);

var _excluded$_ = ["className"],
    _excluded2$3 = ["listen", "onSizeChange"];
var PREFIX$R = 'TableListenerCell';
var classes$R = {
  cell: "".concat(PREFIX$R, "-cell")
};
var StyledTableStubCell = material.styled(TableStubCell)(function () {
  return _defineProperty({}, "&.".concat(classes$R.cell), {
    border: 0
  });
});

var TableBorderlessStubCell = function TableBorderlessStubCell(_ref2) {
  var className = _ref2.className,
      restProps = _objectWithoutProperties(_ref2, _excluded$_);

  return /*#__PURE__*/React.createElement(StyledTableStubCell, _extends({
    className: classNames(classes$R.cell, className)
  }, restProps));
};

process.env.NODE_ENV !== "production" ? TableBorderlessStubCell.propTypes = {
  className: PropTypes.string
} : void 0;
TableBorderlessStubCell.defaultProps = {
  className: undefined
};
var TableListenerCell = function TableListenerCell(_ref3) {
  var listen = _ref3.listen,
      onSizeChange = _ref3.onSizeChange,
      restProps = _objectWithoutProperties(_ref3, _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"];
var ToggleButton$2 = function ToggleButton(_ref) {
  var onToggle = _ref.onToggle,
      getMessage = _ref.getMessage,
      buttonRef = _ref.buttonRef,
      restProps = _objectWithoutProperties(_ref, _excluded$$);

  return /*#__PURE__*/React.createElement(material.Tooltip, {
    title: getMessage('showExportMenu'),
    placement: "bottom",
    enterDelay: 300
  }, /*#__PURE__*/React.createElement(material.IconButton, _extends({
    onClick: onToggle,
    ref: buttonRef
  }, restProps, {
    size: "large"
  }), /*#__PURE__*/React.createElement(Save, null)));
};
process.env.NODE_ENV !== "production" ? ToggleButton$2.propTypes = {
  onToggle: PropTypes.func.isRequired,
  getMessage: PropTypes.func.isRequired,
  buttonRef: PropTypes.func.isRequired
} : void 0;

var _excluded$10 = ["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$10);

  return /*#__PURE__*/React.createElement(material.Menu, _extends({
    keepMounted: true,
    open: visible,
    anchorEl: target,
    onClose: onHide
  }, restProps), 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$11 = ["text", "onClick"];
var MenuItem = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
  var text = _ref.text,
      onClick = _ref.onClick,
      restProps = _objectWithoutProperties(_ref, _excluded$11);

  return /*#__PURE__*/React.createElement(material.MenuItem, _extends({
    onClick: onClick,
    ref: ref
  }, restProps), text);
});
MenuItem.propTypes = {
  text: PropTypes.string.isRequired,
  onClick: PropTypes.func
};
MenuItem.defaultProps = {
  onClick: function onClick() {}
};

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

var _excluded$12 = ["className", "focused", "component"];
var PREFIX$S = 'TableFocusCell';
var classes$S = {
  focusedCell: "".concat(PREFIX$S, "-focusedCell"),
  simpleCell: "".concat(PREFIX$S, "-simpleCell")
};

var styles$2 = function styles(_ref) {
  var _ref2;

  var theme = _ref.theme;
  return _ref2 = {}, _defineProperty(_ref2, "&.".concat(classes$S.focusedCell), {
    border: "1px solid ".concat(theme.palette.primary.light, "!important")
  }), _defineProperty(_ref2, "&.".concat(classes$S.simpleCell), {
    outline: 'none'
  }), _ref2;
};

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

  var _super = _createSuper(FocusCellBase);

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

    return _super.apply(this, arguments);
  }

  _createClass(FocusCellBase, [{
    key: "render",
    value: function render() {
      var _classNames;

      var _this$props = this.props,
          className = _this$props.className,
          focused = _this$props.focused,
          CellPlaceholder = _this$props.component,
          restProps = _objectWithoutProperties(_this$props, _excluded$12);

      return /*#__PURE__*/React.createElement(CellPlaceholder, _extends({
        className: classNames((_classNames = {}, _defineProperty(_classNames, classes$S.focusedCell, !!focused), _defineProperty(_classNames, classes$S.simpleCell, true), _classNames), className)
      }, restProps));
    }
  }]);

  return FocusCellBase;
}(React.PureComponent);

process.env.NODE_ENV !== "production" ? FocusCellBase.propTypes = {
  component: PropTypes.func.isRequired,
  className: PropTypes.string,
  focused: PropTypes.bool
} : void 0;
FocusCellBase.defaultProps = {
  className: undefined,
  focused: undefined
};
var FocusCell = dxReactGrid.withKeyboardNavigation()(material.styled(FocusCellBase)(styles$2));

var _excluded$13 = ["className", "component", "focused"];
var PREFIX$T = 'TableFocusRow';
var classes$T = {
  focusedRow: "".concat(PREFIX$T, "-focusedRow")
};

var styles$3 = function styles(_ref) {
  var theme = _ref.theme;
  return _defineProperty({}, "&.".concat(classes$T.focusedRow), {
    backgroundColor: getSelectionColor(theme)
  });
};

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

  var _super = _createSuper(FocusRowBase);

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

    return _super.apply(this, arguments);
  }

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

      return /*#__PURE__*/React.createElement(RowPlaceholder, _extends({
        className: classNames(_defineProperty({}, classes$T.focusedRow, !!focused), className)
      }, restProps));
    }
  }]);

  return FocusRowBase;
}(React.PureComponent);

process.env.NODE_ENV !== "production" ? FocusRowBase.propTypes = {
  component: PropTypes.func.isRequired,
  className: PropTypes.string,
  focused: PropTypes.bool
} : void 0;
FocusRowBase.defaultProps = {
  className: undefined,
  focused: undefined
};
var FocusRow = material.styled(FocusRowBase)(styles$3);

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;
//# sourceMappingURL=dx-react-grid-material-ui.cjs.cjs.map