@serhii.olishevskyi/docs 1.2.28 → 1.2.29

package/dist/index.mjs

@@ -19,6 +19,8 @@ import {
   UserRoleChipComponent,
   UserSettingsProvider,
   UserStatusChipComponent,
+  __commonJS,
+  __toESM,
   defaultUserSettings,
   fetchCompanySessions,
   fetchUserSessions,
@@ -43,7 +45,989 @@ import {
   useTranslationEdit,
   useTranslationNamespace,
   useUserSettings
-} from "./chunk-VFNVP7VE.mjs";
+} from "./chunk-GAPN2BVY.mjs";
+
+// node_modules/@babel/runtime/helpers/extends.js
+var require_extends = __commonJS({
+  "node_modules/@babel/runtime/helpers/extends.js"(exports, module) {
+    "use strict";
+    function _extends11() {
+      return module.exports = _extends11 = Object.assign ? Object.assign.bind() : function(n) {
+        for (var e = 1; e < arguments.length; e++) {
+          var t = arguments[e];
+          for (var r2 in t) ({}).hasOwnProperty.call(t, r2) && (n[r2] = t[r2]);
+        }
+        return n;
+      }, module.exports.__esModule = true, module.exports["default"] = module.exports, _extends11.apply(null, arguments);
+    }
+    module.exports = _extends11, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  }
+});
+
+// node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js
+var require_objectWithoutPropertiesLoose = __commonJS({
+  "node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js"(exports, module) {
+    "use strict";
+    function _objectWithoutPropertiesLoose6(r2, e) {
+      if (null == r2) return {};
+      var t = {};
+      for (var n in r2) if ({}.hasOwnProperty.call(r2, n)) {
+        if (-1 !== e.indexOf(n)) continue;
+        t[n] = r2[n];
+      }
+      return t;
+    }
+    module.exports = _objectWithoutPropertiesLoose6, module.exports.__esModule = true, module.exports["default"] = module.exports;
+  }
+});
+
+// node_modules/prop-types/node_modules/react-is/cjs/react-is.production.min.js
+var require_react_is_production_min = __commonJS({
+  "node_modules/prop-types/node_modules/react-is/cjs/react-is.production.min.js"(exports) {
+    "use strict";
+    var b = "function" === typeof Symbol && Symbol.for;
+    var c = b ? /* @__PURE__ */ Symbol.for("react.element") : 60103;
+    var d = b ? /* @__PURE__ */ Symbol.for("react.portal") : 60106;
+    var e = b ? /* @__PURE__ */ Symbol.for("react.fragment") : 60107;
+    var f = b ? /* @__PURE__ */ Symbol.for("react.strict_mode") : 60108;
+    var g = b ? /* @__PURE__ */ Symbol.for("react.profiler") : 60114;
+    var h = b ? /* @__PURE__ */ Symbol.for("react.provider") : 60109;
+    var k = b ? /* @__PURE__ */ Symbol.for("react.context") : 60110;
+    var l = b ? /* @__PURE__ */ Symbol.for("react.async_mode") : 60111;
+    var m = b ? /* @__PURE__ */ Symbol.for("react.concurrent_mode") : 60111;
+    var n = b ? /* @__PURE__ */ Symbol.for("react.forward_ref") : 60112;
+    var p = b ? /* @__PURE__ */ Symbol.for("react.suspense") : 60113;
+    var q = b ? /* @__PURE__ */ Symbol.for("react.suspense_list") : 60120;
+    var r2 = b ? /* @__PURE__ */ Symbol.for("react.memo") : 60115;
+    var t = b ? /* @__PURE__ */ Symbol.for("react.lazy") : 60116;
+    var v = b ? /* @__PURE__ */ Symbol.for("react.block") : 60121;
+    var w = b ? /* @__PURE__ */ Symbol.for("react.fundamental") : 60117;
+    var x = b ? /* @__PURE__ */ Symbol.for("react.responder") : 60118;
+    var y = b ? /* @__PURE__ */ Symbol.for("react.scope") : 60119;
+    function z(a) {
+      if ("object" === typeof a && null !== a) {
+        var u = a.$$typeof;
+        switch (u) {
+          case c:
+            switch (a = a.type, a) {
+              case l:
+              case m:
+              case e:
+              case g:
+              case f:
+              case p:
+                return a;
+              default:
+                switch (a = a && a.$$typeof, a) {
+                  case k:
+                  case n:
+                  case t:
+                  case r2:
+                  case h:
+                    return a;
+                  default:
+                    return u;
+                }
+            }
+          case d:
+            return u;
+        }
+      }
+    }
+    function A(a) {
+      return z(a) === m;
+    }
+    exports.AsyncMode = l;
+    exports.ConcurrentMode = m;
+    exports.ContextConsumer = k;
+    exports.ContextProvider = h;
+    exports.Element = c;
+    exports.ForwardRef = n;
+    exports.Fragment = e;
+    exports.Lazy = t;
+    exports.Memo = r2;
+    exports.Portal = d;
+    exports.Profiler = g;
+    exports.StrictMode = f;
+    exports.Suspense = p;
+    exports.isAsyncMode = function(a) {
+      return A(a) || z(a) === l;
+    };
+    exports.isConcurrentMode = A;
+    exports.isContextConsumer = function(a) {
+      return z(a) === k;
+    };
+    exports.isContextProvider = function(a) {
+      return z(a) === h;
+    };
+    exports.isElement = function(a) {
+      return "object" === typeof a && null !== a && a.$$typeof === c;
+    };
+    exports.isForwardRef = function(a) {
+      return z(a) === n;
+    };
+    exports.isFragment = function(a) {
+      return z(a) === e;
+    };
+    exports.isLazy = function(a) {
+      return z(a) === t;
+    };
+    exports.isMemo = function(a) {
+      return z(a) === r2;
+    };
+    exports.isPortal = function(a) {
+      return z(a) === d;
+    };
+    exports.isProfiler = function(a) {
+      return z(a) === g;
+    };
+    exports.isStrictMode = function(a) {
+      return z(a) === f;
+    };
+    exports.isSuspense = function(a) {
+      return z(a) === p;
+    };
+    exports.isValidElementType = function(a) {
+      return "string" === typeof a || "function" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || "object" === typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r2 || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);
+    };
+    exports.typeOf = z;
+  }
+});
+
+// node_modules/prop-types/node_modules/react-is/cjs/react-is.development.js
+var require_react_is_development = __commonJS({
+  "node_modules/prop-types/node_modules/react-is/cjs/react-is.development.js"(exports) {
+    "use strict";
+    if (process.env.NODE_ENV !== "production") {
+      (function() {
+        "use strict";
+        var hasSymbol = typeof Symbol === "function" && Symbol.for;
+        var REACT_ELEMENT_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.element") : 60103;
+        var REACT_PORTAL_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.portal") : 60106;
+        var REACT_FRAGMENT_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.fragment") : 60107;
+        var REACT_STRICT_MODE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.strict_mode") : 60108;
+        var REACT_PROFILER_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.profiler") : 60114;
+        var REACT_PROVIDER_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.provider") : 60109;
+        var REACT_CONTEXT_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.context") : 60110;
+        var REACT_ASYNC_MODE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.async_mode") : 60111;
+        var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.concurrent_mode") : 60111;
+        var REACT_FORWARD_REF_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.forward_ref") : 60112;
+        var REACT_SUSPENSE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.suspense") : 60113;
+        var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.suspense_list") : 60120;
+        var REACT_MEMO_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.memo") : 60115;
+        var REACT_LAZY_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.lazy") : 60116;
+        var REACT_BLOCK_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.block") : 60121;
+        var REACT_FUNDAMENTAL_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.fundamental") : 60117;
+        var REACT_RESPONDER_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.responder") : 60118;
+        var REACT_SCOPE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.scope") : 60119;
+        function isValidElementType(type) {
+          return typeof type === "string" || typeof type === "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+          type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === "object" && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+        }
+        function typeOf(object) {
+          if (typeof object === "object" && object !== null) {
+            var $$typeof = object.$$typeof;
+            switch ($$typeof) {
+              case REACT_ELEMENT_TYPE:
+                var type = object.type;
+                switch (type) {
+                  case REACT_ASYNC_MODE_TYPE:
+                  case REACT_CONCURRENT_MODE_TYPE:
+                  case REACT_FRAGMENT_TYPE:
+                  case REACT_PROFILER_TYPE:
+                  case REACT_STRICT_MODE_TYPE:
+                  case REACT_SUSPENSE_TYPE:
+                    return type;
+                  default:
+                    var $$typeofType = type && type.$$typeof;
+                    switch ($$typeofType) {
+                      case REACT_CONTEXT_TYPE:
+                      case REACT_FORWARD_REF_TYPE:
+                      case REACT_LAZY_TYPE:
+                      case REACT_MEMO_TYPE:
+                      case REACT_PROVIDER_TYPE:
+                        return $$typeofType;
+                      default:
+                        return $$typeof;
+                    }
+                }
+              case REACT_PORTAL_TYPE:
+                return $$typeof;
+            }
+          }
+          return void 0;
+        }
+        var AsyncMode = REACT_ASYNC_MODE_TYPE;
+        var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+        var ContextConsumer = REACT_CONTEXT_TYPE;
+        var ContextProvider = REACT_PROVIDER_TYPE;
+        var Element = REACT_ELEMENT_TYPE;
+        var ForwardRef = REACT_FORWARD_REF_TYPE;
+        var Fragment20 = REACT_FRAGMENT_TYPE;
+        var Lazy = REACT_LAZY_TYPE;
+        var Memo = REACT_MEMO_TYPE;
+        var Portal = REACT_PORTAL_TYPE;
+        var Profiler = REACT_PROFILER_TYPE;
+        var StrictMode = REACT_STRICT_MODE_TYPE;
+        var Suspense2 = REACT_SUSPENSE_TYPE;
+        var hasWarnedAboutDeprecatedIsAsyncMode = false;
+        function isAsyncMode(object) {
+          {
+            if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+              hasWarnedAboutDeprecatedIsAsyncMode = true;
+              console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.");
+            }
+          }
+          return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+        }
+        function isConcurrentMode(object) {
+          return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+        }
+        function isContextConsumer(object) {
+          return typeOf(object) === REACT_CONTEXT_TYPE;
+        }
+        function isContextProvider(object) {
+          return typeOf(object) === REACT_PROVIDER_TYPE;
+        }
+        function isElement(object) {
+          return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+        }
+        function isForwardRef(object) {
+          return typeOf(object) === REACT_FORWARD_REF_TYPE;
+        }
+        function isFragment(object) {
+          return typeOf(object) === REACT_FRAGMENT_TYPE;
+        }
+        function isLazy(object) {
+          return typeOf(object) === REACT_LAZY_TYPE;
+        }
+        function isMemo(object) {
+          return typeOf(object) === REACT_MEMO_TYPE;
+        }
+        function isPortal(object) {
+          return typeOf(object) === REACT_PORTAL_TYPE;
+        }
+        function isProfiler(object) {
+          return typeOf(object) === REACT_PROFILER_TYPE;
+        }
+        function isStrictMode(object) {
+          return typeOf(object) === REACT_STRICT_MODE_TYPE;
+        }
+        function isSuspense(object) {
+          return typeOf(object) === REACT_SUSPENSE_TYPE;
+        }
+        exports.AsyncMode = AsyncMode;
+        exports.ConcurrentMode = ConcurrentMode;
+        exports.ContextConsumer = ContextConsumer;
+        exports.ContextProvider = ContextProvider;
+        exports.Element = Element;
+        exports.ForwardRef = ForwardRef;
+        exports.Fragment = Fragment20;
+        exports.Lazy = Lazy;
+        exports.Memo = Memo;
+        exports.Portal = Portal;
+        exports.Profiler = Profiler;
+        exports.StrictMode = StrictMode;
+        exports.Suspense = Suspense2;
+        exports.isAsyncMode = isAsyncMode;
+        exports.isConcurrentMode = isConcurrentMode;
+        exports.isContextConsumer = isContextConsumer;
+        exports.isContextProvider = isContextProvider;
+        exports.isElement = isElement;
+        exports.isForwardRef = isForwardRef;
+        exports.isFragment = isFragment;
+        exports.isLazy = isLazy;
+        exports.isMemo = isMemo;
+        exports.isPortal = isPortal;
+        exports.isProfiler = isProfiler;
+        exports.isStrictMode = isStrictMode;
+        exports.isSuspense = isSuspense;
+        exports.isValidElementType = isValidElementType;
+        exports.typeOf = typeOf;
+      })();
+    }
+  }
+});
+
+// node_modules/prop-types/node_modules/react-is/index.js
+var require_react_is = __commonJS({
+  "node_modules/prop-types/node_modules/react-is/index.js"(exports, module) {
+    "use strict";
+    if (process.env.NODE_ENV === "production") {
+      module.exports = require_react_is_production_min();
+    } else {
+      module.exports = require_react_is_development();
+    }
+  }
+});
+
+// node_modules/object-assign/index.js
+var require_object_assign = __commonJS({
+  "node_modules/object-assign/index.js"(exports, module) {
+    "use strict";
+    var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+    var hasOwnProperty = Object.prototype.hasOwnProperty;
+    var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+    function toObject(val) {
+      if (val === null || val === void 0) {
+        throw new TypeError("Object.assign cannot be called with null or undefined");
+      }
+      return Object(val);
+    }
+    function shouldUseNative() {
+      try {
+        if (!Object.assign) {
+          return false;
+        }
+        var test1 = new String("abc");
+        test1[5] = "de";
+        if (Object.getOwnPropertyNames(test1)[0] === "5") {
+          return false;
+        }
+        var test2 = {};
+        for (var i = 0; i < 10; i++) {
+          test2["_" + String.fromCharCode(i)] = i;
+        }
+        var order2 = Object.getOwnPropertyNames(test2).map(function(n) {
+          return test2[n];
+        });
+        if (order2.join("") !== "0123456789") {
+          return false;
+        }
+        var test3 = {};
+        "abcdefghijklmnopqrst".split("").forEach(function(letter) {
+          test3[letter] = letter;
+        });
+        if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
+          return false;
+        }
+        return true;
+      } catch (err) {
+        return false;
+      }
+    }
+    module.exports = shouldUseNative() ? Object.assign : function(target, source) {
+      var from;
+      var to = toObject(target);
+      var symbols;
+      for (var s = 1; s < arguments.length; s++) {
+        from = Object(arguments[s]);
+        for (var key in from) {
+          if (hasOwnProperty.call(from, key)) {
+            to[key] = from[key];
+          }
+        }
+        if (getOwnPropertySymbols) {
+          symbols = getOwnPropertySymbols(from);
+          for (var i = 0; i < symbols.length; i++) {
+            if (propIsEnumerable.call(from, symbols[i])) {
+              to[symbols[i]] = from[symbols[i]];
+            }
+          }
+        }
+      }
+      return to;
+    };
+  }
+});
+
+// node_modules/prop-types/lib/ReactPropTypesSecret.js
+var require_ReactPropTypesSecret = __commonJS({
+  "node_modules/prop-types/lib/ReactPropTypesSecret.js"(exports, module) {
+    "use strict";
+    var ReactPropTypesSecret = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+    module.exports = ReactPropTypesSecret;
+  }
+});
+
+// node_modules/prop-types/lib/has.js
+var require_has = __commonJS({
+  "node_modules/prop-types/lib/has.js"(exports, module) {
+    "use strict";
+    module.exports = Function.call.bind(Object.prototype.hasOwnProperty);
+  }
+});
+
+// node_modules/prop-types/checkPropTypes.js
+var require_checkPropTypes = __commonJS({
+  "node_modules/prop-types/checkPropTypes.js"(exports, module) {
+    "use strict";
+    var printWarning = function() {
+    };
+    if (process.env.NODE_ENV !== "production") {
+      ReactPropTypesSecret = require_ReactPropTypesSecret();
+      loggedTypeFailures = {};
+      has = require_has();
+      printWarning = function(text) {
+        var message = "Warning: " + text;
+        if (typeof console !== "undefined") {
+          console.error(message);
+        }
+        try {
+          throw new Error(message);
+        } catch (x) {
+        }
+      };
+    }
+    var ReactPropTypesSecret;
+    var loggedTypeFailures;
+    var has;
+    function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+      if (process.env.NODE_ENV !== "production") {
+        for (var typeSpecName in typeSpecs) {
+          if (has(typeSpecs, typeSpecName)) {
+            var error;
+            try {
+              if (typeof typeSpecs[typeSpecName] !== "function") {
+                var err = Error(
+                  (componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+                );
+                err.name = "Invariant Violation";
+                throw err;
+              }
+              error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+            } catch (ex) {
+              error = ex;
+            }
+            if (error && !(error instanceof Error)) {
+              printWarning(
+                (componentName || "React class") + ": type specification of " + location + " `" + typeSpecName + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof error + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+              );
+            }
+            if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+              loggedTypeFailures[error.message] = true;
+              var stack = getStack ? getStack() : "";
+              printWarning(
+                "Failed " + location + " type: " + error.message + (stack != null ? stack : "")
+              );
+            }
+          }
+        }
+      }
+    }
+    checkPropTypes.resetWarningCache = function() {
+      if (process.env.NODE_ENV !== "production") {
+        loggedTypeFailures = {};
+      }
+    };
+    module.exports = checkPropTypes;
+  }
+});
+
+// node_modules/prop-types/factoryWithTypeCheckers.js
+var require_factoryWithTypeCheckers = __commonJS({
+  "node_modules/prop-types/factoryWithTypeCheckers.js"(exports, module) {
+    "use strict";
+    var ReactIs = require_react_is();
+    var assign = require_object_assign();
+    var ReactPropTypesSecret = require_ReactPropTypesSecret();
+    var has = require_has();
+    var checkPropTypes = require_checkPropTypes();
+    var printWarning = function() {
+    };
+    if (process.env.NODE_ENV !== "production") {
+      printWarning = function(text) {
+        var message = "Warning: " + text;
+        if (typeof console !== "undefined") {
+          console.error(message);
+        }
+        try {
+          throw new Error(message);
+        } catch (x) {
+        }
+      };
+    }
+    function emptyFunctionThatReturnsNull() {
+      return null;
+    }
+    module.exports = function(isValidElement2, throwOnDirectAccess) {
+      var ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
+      var FAUX_ITERATOR_SYMBOL = "@@iterator";
+      function getIteratorFn(maybeIterable) {
+        var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+        if (typeof iteratorFn === "function") {
+          return iteratorFn;
+        }
+      }
+      var ANONYMOUS = "<<anonymous>>";
+      var ReactPropTypes = {
+        array: createPrimitiveTypeChecker("array"),
+        bigint: createPrimitiveTypeChecker("bigint"),
+        bool: createPrimitiveTypeChecker("boolean"),
+        func: createPrimitiveTypeChecker("function"),
+        number: createPrimitiveTypeChecker("number"),
+        object: createPrimitiveTypeChecker("object"),
+        string: createPrimitiveTypeChecker("string"),
+        symbol: createPrimitiveTypeChecker("symbol"),
+        any: createAnyTypeChecker(),
+        arrayOf: createArrayOfTypeChecker,
+        element: createElementTypeChecker(),
+        elementType: createElementTypeTypeChecker(),
+        instanceOf: createInstanceTypeChecker,
+        node: createNodeChecker(),
+        objectOf: createObjectOfTypeChecker,
+        oneOf: createEnumTypeChecker,
+        oneOfType: createUnionTypeChecker,
+        shape: createShapeTypeChecker,
+        exact: createStrictShapeTypeChecker
+      };
+      function is2(x, y) {
+        if (x === y) {
+          return x !== 0 || 1 / x === 1 / y;
+        } else {
+          return x !== x && y !== y;
+        }
+      }
+      function PropTypeError(message, data) {
+        this.message = message;
+        this.data = data && typeof data === "object" ? data : {};
+        this.stack = "";
+      }
+      PropTypeError.prototype = Error.prototype;
+      function createChainableTypeChecker(validate) {
+        if (process.env.NODE_ENV !== "production") {
+          var manualPropTypeCallCache = {};
+          var manualPropTypeWarningCount = 0;
+        }
+        function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
+          componentName = componentName || ANONYMOUS;
+          propFullName = propFullName || propName;
+          if (secret !== ReactPropTypesSecret) {
+            if (throwOnDirectAccess) {
+              var err = new Error(
+                "Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types"
+              );
+              err.name = "Invariant Violation";
+              throw err;
+            } else if (process.env.NODE_ENV !== "production" && typeof console !== "undefined") {
+              var cacheKey = componentName + ":" + propName;
+              if (!manualPropTypeCallCache[cacheKey] && // Avoid spamming the console because they are often not actionable except for lib authors
+              manualPropTypeWarningCount < 3) {
+                printWarning(
+                  "You are manually calling a React.PropTypes validation function for the `" + propFullName + "` prop on `" + componentName + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."
+                );
+                manualPropTypeCallCache[cacheKey] = true;
+                manualPropTypeWarningCount++;
+              }
+            }
+          }
+          if (props[propName] == null) {
+            if (isRequired) {
+              if (props[propName] === null) {
+                return new PropTypeError("The " + location + " `" + propFullName + "` is marked as required " + ("in `" + componentName + "`, but its value is `null`."));
+              }
+              return new PropTypeError("The " + location + " `" + propFullName + "` is marked as required in " + ("`" + componentName + "`, but its value is `undefined`."));
+            }
+            return null;
+          } else {
+            return validate(props, propName, componentName, location, propFullName);
+          }
+        }
+        var chainedCheckType = checkType.bind(null, false);
+        chainedCheckType.isRequired = checkType.bind(null, true);
+        return chainedCheckType;
+      }
+      function createPrimitiveTypeChecker(expectedType) {
+        function validate(props, propName, componentName, location, propFullName, secret) {
+          var propValue = props[propName];
+          var propType = getPropType(propValue);
+          if (propType !== expectedType) {
+            var preciseType = getPreciseType(propValue);
+            return new PropTypeError(
+              "Invalid " + location + " `" + propFullName + "` of type " + ("`" + preciseType + "` supplied to `" + componentName + "`, expected ") + ("`" + expectedType + "`."),
+              { expectedType }
+            );
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createAnyTypeChecker() {
+        return createChainableTypeChecker(emptyFunctionThatReturnsNull);
+      }
+      function createArrayOfTypeChecker(typeChecker) {
+        function validate(props, propName, componentName, location, propFullName) {
+          if (typeof typeChecker !== "function") {
+            return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside arrayOf.");
+          }
+          var propValue = props[propName];
+          if (!Array.isArray(propValue)) {
+            var propType = getPropType(propValue);
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an array."));
+          }
+          for (var i = 0; i < propValue.length; i++) {
+            var error = typeChecker(propValue, i, componentName, location, propFullName + "[" + i + "]", ReactPropTypesSecret);
+            if (error instanceof Error) {
+              return error;
+            }
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createElementTypeChecker() {
+        function validate(props, propName, componentName, location, propFullName) {
+          var propValue = props[propName];
+          if (!isValidElement2(propValue)) {
+            var propType = getPropType(propValue);
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement."));
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createElementTypeTypeChecker() {
+        function validate(props, propName, componentName, location, propFullName) {
+          var propValue = props[propName];
+          if (!ReactIs.isValidElementType(propValue)) {
+            var propType = getPropType(propValue);
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected a single ReactElement type."));
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createInstanceTypeChecker(expectedClass) {
+        function validate(props, propName, componentName, location, propFullName) {
+          if (!(props[propName] instanceof expectedClass)) {
+            var expectedClassName = expectedClass.name || ANONYMOUS;
+            var actualClassName = getClassName(props[propName]);
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + actualClassName + "` supplied to `" + componentName + "`, expected ") + ("instance of `" + expectedClassName + "`."));
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createEnumTypeChecker(expectedValues) {
+        if (!Array.isArray(expectedValues)) {
+          if (process.env.NODE_ENV !== "production") {
+            if (arguments.length > 1) {
+              printWarning(
+                "Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z])."
+              );
+            } else {
+              printWarning("Invalid argument supplied to oneOf, expected an array.");
+            }
+          }
+          return emptyFunctionThatReturnsNull;
+        }
+        function validate(props, propName, componentName, location, propFullName) {
+          var propValue = props[propName];
+          for (var i = 0; i < expectedValues.length; i++) {
+            if (is2(propValue, expectedValues[i])) {
+              return null;
+            }
+          }
+          var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
+            var type = getPreciseType(value);
+            if (type === "symbol") {
+              return String(value);
+            }
+            return value;
+          });
+          return new PropTypeError("Invalid " + location + " `" + propFullName + "` of value `" + String(propValue) + "` " + ("supplied to `" + componentName + "`, expected one of " + valuesString + "."));
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createObjectOfTypeChecker(typeChecker) {
+        function validate(props, propName, componentName, location, propFullName) {
+          if (typeof typeChecker !== "function") {
+            return new PropTypeError("Property `" + propFullName + "` of component `" + componentName + "` has invalid PropType notation inside objectOf.");
+          }
+          var propValue = props[propName];
+          var propType = getPropType(propValue);
+          if (propType !== "object") {
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an object."));
+          }
+          for (var key in propValue) {
+            if (has(propValue, key)) {
+              var error = typeChecker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
+              if (error instanceof Error) {
+                return error;
+              }
+            }
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createUnionTypeChecker(arrayOfTypeCheckers) {
+        if (!Array.isArray(arrayOfTypeCheckers)) {
+          process.env.NODE_ENV !== "production" ? printWarning("Invalid argument supplied to oneOfType, expected an instance of array.") : void 0;
+          return emptyFunctionThatReturnsNull;
+        }
+        for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+          var checker = arrayOfTypeCheckers[i];
+          if (typeof checker !== "function") {
+            printWarning(
+              "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + getPostfixForTypeWarning(checker) + " at index " + i + "."
+            );
+            return emptyFunctionThatReturnsNull;
+          }
+        }
+        function validate(props, propName, componentName, location, propFullName) {
+          var expectedTypes = [];
+          for (var i2 = 0; i2 < arrayOfTypeCheckers.length; i2++) {
+            var checker2 = arrayOfTypeCheckers[i2];
+            var checkerResult = checker2(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
+            if (checkerResult == null) {
+              return null;
+            }
+            if (checkerResult.data && has(checkerResult.data, "expectedType")) {
+              expectedTypes.push(checkerResult.data.expectedType);
+            }
+          }
+          var expectedTypesMessage = expectedTypes.length > 0 ? ", expected one of type [" + expectedTypes.join(", ") + "]" : "";
+          return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`" + expectedTypesMessage + "."));
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createNodeChecker() {
+        function validate(props, propName, componentName, location, propFullName) {
+          if (!isNode(props[propName])) {
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` supplied to " + ("`" + componentName + "`, expected a ReactNode."));
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function invalidValidatorError(componentName, location, propFullName, key, type) {
+        return new PropTypeError(
+          (componentName || "React class") + ": " + location + " type `" + propFullName + "." + key + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + type + "`."
+        );
+      }
+      function createShapeTypeChecker(shapeTypes) {
+        function validate(props, propName, componentName, location, propFullName) {
+          var propValue = props[propName];
+          var propType = getPropType(propValue);
+          if (propType !== "object") {
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
+          }
+          for (var key in shapeTypes) {
+            var checker = shapeTypes[key];
+            if (typeof checker !== "function") {
+              return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+            }
+            var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
+            if (error) {
+              return error;
+            }
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function createStrictShapeTypeChecker(shapeTypes) {
+        function validate(props, propName, componentName, location, propFullName) {
+          var propValue = props[propName];
+          var propType = getPropType(propValue);
+          if (propType !== "object") {
+            return new PropTypeError("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
+          }
+          var allKeys = assign({}, props[propName], shapeTypes);
+          for (var key in allKeys) {
+            var checker = shapeTypes[key];
+            if (has(shapeTypes, key) && typeof checker !== "function") {
+              return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
+            }
+            if (!checker) {
+              return new PropTypeError(
+                "Invalid " + location + " `" + propFullName + "` key `" + key + "` supplied to `" + componentName + "`.\nBad object: " + JSON.stringify(props[propName], null, "  ") + "\nValid keys: " + JSON.stringify(Object.keys(shapeTypes), null, "  ")
+              );
+            }
+            var error = checker(propValue, key, componentName, location, propFullName + "." + key, ReactPropTypesSecret);
+            if (error) {
+              return error;
+            }
+          }
+          return null;
+        }
+        return createChainableTypeChecker(validate);
+      }
+      function isNode(propValue) {
+        switch (typeof propValue) {
+          case "number":
+          case "string":
+          case "undefined":
+            return true;
+          case "boolean":
+            return !propValue;
+          case "object":
+            if (Array.isArray(propValue)) {
+              return propValue.every(isNode);
+            }
+            if (propValue === null || isValidElement2(propValue)) {
+              return true;
+            }
+            var iteratorFn = getIteratorFn(propValue);
+            if (iteratorFn) {
+              var iterator = iteratorFn.call(propValue);
+              var step;
+              if (iteratorFn !== propValue.entries) {
+                while (!(step = iterator.next()).done) {
+                  if (!isNode(step.value)) {
+                    return false;
+                  }
+                }
+              } else {
+                while (!(step = iterator.next()).done) {
+                  var entry = step.value;
+                  if (entry) {
+                    if (!isNode(entry[1])) {
+                      return false;
+                    }
+                  }
+                }
+              }
+            } else {
+              return false;
+            }
+            return true;
+          default:
+            return false;
+        }
+      }
+      function isSymbol(propType, propValue) {
+        if (propType === "symbol") {
+          return true;
+        }
+        if (!propValue) {
+          return false;
+        }
+        if (propValue["@@toStringTag"] === "Symbol") {
+          return true;
+        }
+        if (typeof Symbol === "function" && propValue instanceof Symbol) {
+          return true;
+        }
+        return false;
+      }
+      function getPropType(propValue) {
+        var propType = typeof propValue;
+        if (Array.isArray(propValue)) {
+          return "array";
+        }
+        if (propValue instanceof RegExp) {
+          return "object";
+        }
+        if (isSymbol(propType, propValue)) {
+          return "symbol";
+        }
+        return propType;
+      }
+      function getPreciseType(propValue) {
+        if (typeof propValue === "undefined" || propValue === null) {
+          return "" + propValue;
+        }
+        var propType = getPropType(propValue);
+        if (propType === "object") {
+          if (propValue instanceof Date) {
+            return "date";
+          } else if (propValue instanceof RegExp) {
+            return "regexp";
+          }
+        }
+        return propType;
+      }
+      function getPostfixForTypeWarning(value) {
+        var type = getPreciseType(value);
+        switch (type) {
+          case "array":
+          case "object":
+            return "an " + type;
+          case "boolean":
+          case "date":
+          case "regexp":
+            return "a " + type;
+          default:
+            return type;
+        }
+      }
+      function getClassName(propValue) {
+        if (!propValue.constructor || !propValue.constructor.name) {
+          return ANONYMOUS;
+        }
+        return propValue.constructor.name;
+      }
+      ReactPropTypes.checkPropTypes = checkPropTypes;
+      ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
+      ReactPropTypes.PropTypes = ReactPropTypes;
+      return ReactPropTypes;
+    };
+  }
+});
+
+// node_modules/prop-types/factoryWithThrowingShims.js
+var require_factoryWithThrowingShims = __commonJS({
+  "node_modules/prop-types/factoryWithThrowingShims.js"(exports, module) {
+    "use strict";
+    var ReactPropTypesSecret = require_ReactPropTypesSecret();
+    function emptyFunction() {
+    }
+    function emptyFunctionWithReset() {
+    }
+    emptyFunctionWithReset.resetWarningCache = emptyFunction;
+    module.exports = function() {
+      function shim(props, propName, componentName, location, propFullName, secret) {
+        if (secret === ReactPropTypesSecret) {
+          return;
+        }
+        var err = new Error(
+          "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types"
+        );
+        err.name = "Invariant Violation";
+        throw err;
+      }
+      ;
+      shim.isRequired = shim;
+      function getShim() {
+        return shim;
+      }
+      ;
+      var ReactPropTypes = {
+        array: shim,
+        bigint: shim,
+        bool: shim,
+        func: shim,
+        number: shim,
+        object: shim,
+        string: shim,
+        symbol: shim,
+        any: shim,
+        arrayOf: getShim,
+        element: shim,
+        elementType: shim,
+        instanceOf: getShim,
+        node: shim,
+        objectOf: getShim,
+        oneOf: getShim,
+        oneOfType: getShim,
+        shape: getShim,
+        exact: getShim,
+        checkPropTypes: emptyFunctionWithReset,
+        resetWarningCache: emptyFunction
+      };
+      ReactPropTypes.PropTypes = ReactPropTypes;
+      return ReactPropTypes;
+    };
+  }
+});
+
+// node_modules/prop-types/index.js
+var require_prop_types = __commonJS({
+  "node_modules/prop-types/index.js"(exports, module) {
+    "use strict";
+    if (process.env.NODE_ENV !== "production") {
+      ReactIs = require_react_is();
+      throwOnDirectAccess = true;
+      module.exports = require_factoryWithTypeCheckers()(ReactIs.isElement, throwOnDirectAccess);
+    } else {
+      module.exports = require_factoryWithThrowingShims()();
+    }
+    var ReactIs;
+    var throwOnDirectAccess;
+  }
+});
 
 // src/UI/components/inputs/TextFieldComponent.tsx
 import { useState } from "react";
@@ -1985,7 +2969,7 @@ var RefreshButtonComponent = ({
 import { useState as useState9, useEffect as useEffect5, lazy, Suspense } from "react";
 import { Avatar, Tooltip as Tooltip5, Typography as Typography3 } from "@mui/material";
 import { Fragment as Fragment6, jsx as jsx12, jsxs as jsxs7 } from "react/jsx-runtime";
-var LazyUserPopover = lazy(() => import("./UserPopoverComponent-VFSZ5ZO2.mjs"));
+var LazyUserPopover = lazy(() => import("./UserPopoverComponent-VYJOTERW.mjs"));
 var getInitials = (name) => {
   if (!name) return "?";
   const parts = name.trim().split(" ");
@@ -2847,6 +3831,46 @@ var PageComponent = ({
 import React13 from "react";
 import { Grid as Grid2, Paper } from "@mui/material";
 import { jsx as jsx18 } from "react/jsx-runtime";
+var widthToGridColumns = (width) => {
+  switch (width) {
+    case "25%":
+      return 3;
+    case "33%":
+      return 4;
+    case "50%":
+      return 6;
+    case "66%":
+      return 8;
+    case "75%":
+      return 9;
+    case "100%":
+    default:
+      return 12;
+  }
+};
+var createGridSize = (desktopWidth, mobileWidth = "100%") => {
+  return {
+    xs: widthToGridColumns(mobileWidth),
+    md: widthToGridColumns(desktopWidth)
+  };
+};
+var FilterSection = ({
+  width = "100%",
+  mobileWidth = "100%",
+  itemWidth = "50%",
+  itemMobileWidth = "100%",
+  children
+}) => {
+  const sectionGridSize = createGridSize(width, mobileWidth);
+  const itemGridSize = createGridSize(itemWidth, itemMobileWidth);
+  return /* @__PURE__ */ jsx18(Grid2, { size: sectionGridSize, children: /* @__PURE__ */ jsx18(Grid2, { container: true, spacing: 2, sx: { alignItems: "center" }, children: React13.Children.map(children, (child) => {
+    if (!child) return null;
+    return (
+      /* Автоматическая обертка каждого дочернего элемента в Grid size */
+      /* @__PURE__ */ jsx18(Grid2, { size: itemGridSize, children: child })
+    );
+  }) }) });
+};
 var FilterContainerComponent = ({
   sections,
   children,
@@ -3427,29 +4451,2762 @@ var TablePaginationComponent = ({
   );
 };
 
-// src/services/index.ts
-var Services = {
-  SessionService: {
-    fetchCompanySessions,
-    trackUserSession,
-    trackUserSessionByRoute,
-    fetchUserSessions,
-    isCurrentSessionValid,
-    groupSessionsByUser,
-    getUserLastSeenAt,
-    getUsersLastSeenMap
-  }
-};
-
+// src/UI/components/tables/TableComponent.tsx
+import React42, { useState as useState22, useEffect as useEffect14, useCallback as useCallback11, useMemo as useMemo9, useImperativeHandle, forwardRef as forwardRef4, useRef as useRef9, isValidElement, memo } from "react";
+import {
+  DataGridPremium,
+  GridOverlay,
+  useGridApiRef
+} from "@mui/x-data-grid-premium";
+import {
+  Box as Box16,
+  IconButton as IconButton13,
+  Menu as Menu4,
+  MenuItem as MenuItem8,
+  ListItemIcon as ListItemIcon5,
+  ListItemText as ListItemText6,
+  Stack as Stack4,
+  Paper as Paper3,
+  Typography as Typography15,
+  Divider as Divider9,
+  Collapse as Collapse2
+} from "@mui/material";
+import SortByAlphaIcon from "@mui/icons-material/SortByAlpha";
+import MoreVertIcon2 from "@mui/icons-material/MoreVert";
+import RefreshIcon2 from "@mui/icons-material/Refresh";
+import FilterListIcon from "@mui/icons-material/FilterList";
+
+// src/UI/components/tables/TableCustomPagination.tsx
+import { gridRowCountSelector, gridPaginationModelSelector, useGridApiContext, useGridRootProps, useGridSelector } from "@mui/x-data-grid-premium";
+import { Box as Box13 } from "@mui/material";
+import { jsx as jsx23 } from "react/jsx-runtime";
+var TableCustomPagination = ({}) => {
+  const apiRef = useGridApiContext();
+  const rootProps = useGridRootProps();
+  const totalRowCount = useGridSelector(apiRef, gridRowCountSelector);
+  const paginationModel = useGridSelector(apiRef, gridPaginationModelSelector);
+  return /* @__PURE__ */ jsx23(Box13, { sx: { display: "flex", justifyContent: "flex-end", p: 1 }, children: /* @__PURE__ */ jsx23(
+    TablePaginationComponent,
+    {
+      count: totalRowCount,
+      rowsPerPage: paginationModel.pageSize,
+      rowsPerPageOptions: rootProps.pageSizeOptions,
+      page: paginationModel.page,
+      onPageChange: (_, newPage) => {
+        apiRef.current.setPage(newPage);
+      },
+      onRowsPerPageChange: (event) => {
+        const newPageSize = parseInt(event.target.value, 10);
+        apiRef.current.setPageSize(newPageSize);
+      }
+    }
+  ) });
+};
+
+// src/UI/components/tables/TableCustomColumnMenu.tsx
+import { FormatAlignCenter, FormatAlignLeft, FormatAlignRight, Restore } from "@mui/icons-material";
+import { Divider as Divider5, ListItemIcon as ListItemIcon3, ListItemText as ListItemText4, MenuItem as MenuItem5, ToggleButton, ToggleButtonGroup, Typography as Typography12 } from "@mui/material";
+
+// node_modules/clsx/dist/clsx.mjs
+function r(e) {
+  var t, f, n = "";
+  if ("string" == typeof e || "number" == typeof e) n += e;
+  else if ("object" == typeof e) if (Array.isArray(e)) {
+    var o = e.length;
+    for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+  } else for (f in e) e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+var clsx_default = clsx;
+
+// node_modules/@mui/utils/useForkRef/useForkRef.mjs
+import * as React16 from "react";
+function useForkRef(...refs) {
+  const cleanupRef = React16.useRef(void 0);
+  const refEffect = React16.useCallback((instance) => {
+    const cleanups = refs.map((ref) => {
+      if (ref == null) {
+        return null;
+      }
+      if (typeof ref === "function") {
+        const refCallback = ref;
+        const refCleanup = refCallback(instance);
+        return typeof refCleanup === "function" ? refCleanup : () => {
+          refCallback(null);
+        };
+      }
+      ref.current = instance;
+      return () => {
+        ref.current = null;
+      };
+    });
+    return () => {
+      cleanups.forEach((refCleanup) => refCleanup?.());
+    };
+  }, refs);
+  return React16.useMemo(() => {
+    if (refs.every((ref) => ref == null)) {
+      return null;
+    }
+    return (value) => {
+      if (cleanupRef.current) {
+        cleanupRef.current();
+        cleanupRef.current = void 0;
+      }
+      if (value != null) {
+        cleanupRef.current = refEffect(value);
+      }
+    };
+  }, refs);
+}
+
+// node_modules/@mui/utils/useEnhancedEffect/useEnhancedEffect.mjs
+import * as React17 from "react";
+var useEnhancedEffect = typeof window !== "undefined" ? React17.useLayoutEffect : React17.useEffect;
+var useEnhancedEffect_default = useEnhancedEffect;
+
+// node_modules/@mui/x-internals/forwardRef/forwardRef.mjs
+import * as React19 from "react";
+
+// node_modules/@base-ui/utils/reactVersion.mjs
+import * as React18 from "react";
+var majorVersion = parseInt(React18.version, 10);
+function isReactVersionAtLeast(reactVersionToCheck) {
+  return majorVersion >= reactVersionToCheck;
+}
+
+// node_modules/@mui/x-internals/forwardRef/forwardRef.mjs
+var forwardRef3 = (render) => {
+  if (isReactVersionAtLeast(19)) {
+    const Component = (props) => render(props, props.ref ?? null);
+    Component.displayName = render.displayName ?? render.name;
+    return Component;
+  }
+  return /* @__PURE__ */ React19.forwardRef(render);
+};
+if (process.env.NODE_ENV !== "production") forwardRef3.displayName = "forwardRef";
+
+// node_modules/@mui/utils/useId/useId.mjs
+import * as React20 from "react";
+var globalId = 0;
+function useGlobalId(idOverride) {
+  const [defaultId, setDefaultId] = React20.useState(idOverride);
+  const id = idOverride || defaultId;
+  React20.useEffect(() => {
+    if (defaultId == null) {
+      globalId += 1;
+      setDefaultId(`mui-${globalId}`);
+    }
+  }, [defaultId]);
+  return id;
+}
+var safeReact = {
+  ...React20
+};
+var maybeReactUseId = safeReact.useId;
+function useId(idOverride) {
+  if (maybeReactUseId !== void 0) {
+    const reactId = maybeReactUseId();
+    return idOverride ?? reactId;
+  }
+  return useGlobalId(idOverride);
+}
+
+// node_modules/@base-ui/utils/formatErrorMessage.mjs
+function createFormatErrorMessage(baseUrl, prefix) {
+  return function formatErrorMessage2(code, ...args) {
+    const url = new URL(baseUrl);
+    url.searchParams.set("code", code.toString());
+    args.forEach((arg) => url.searchParams.append("args[]", arg));
+    return `${prefix} error #${code}; visit ${url} for the full message.`;
+  };
+}
+var formatErrorMessage = createFormatErrorMessage("https://base-ui.com/production-error", "Base UI");
+var formatErrorMessage_default = formatErrorMessage;
+
+// node_modules/@mui/x-internals/formatErrorMessage/index.mjs
+var formatErrorMessage_default2 = createFormatErrorMessage("https://mui.com/x/production-error", "MUI X");
+
+// node_modules/@mui/x-data-grid/hooks/utils/useGridRootProps.mjs
+import * as React22 from "react";
+
+// node_modules/@mui/x-data-grid/context/GridRootPropsContext.mjs
+import * as React21 from "react";
+var GridRootPropsContext = /* @__PURE__ */ React21.createContext(void 0);
+if (process.env.NODE_ENV !== "production") GridRootPropsContext.displayName = "GridRootPropsContext";
+
+// node_modules/@mui/x-data-grid/hooks/utils/useGridRootProps.mjs
+var useGridRootProps2 = () => {
+  const contextValue = React22.useContext(GridRootPropsContext);
+  if (!contextValue) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "MUI X Data Grid: useGridRootProps should only be used inside a Data Grid component. The component must be a child of DataGrid, DataGridPro, or DataGridPremium. Ensure your component is properly nested within a Data Grid." : formatErrorMessage_default2(70));
+  }
+  return contextValue;
+};
+
+// node_modules/@mui/x-data-grid/hooks/utils/useGridApiContext.mjs
+import * as React24 from "react";
+
+// node_modules/@mui/x-data-grid/components/GridApiContext.mjs
+import * as React23 from "react";
+var GridApiContext = /* @__PURE__ */ React23.createContext(void 0);
+if (process.env.NODE_ENV !== "production") GridApiContext.displayName = "GridApiContext";
+
+// node_modules/@mui/x-data-grid/hooks/utils/useGridApiContext.mjs
+function useGridApiContext2() {
+  const apiRef = React24.useContext(GridApiContext);
+  if (apiRef === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "MUI X Data Grid: Could not find the Data Grid context. This happens when a component is rendered outside of a DataGrid, DataGridPro, or DataGridPremium parent component. Ensure your component is a child of a Data Grid component. This can also happen if you are bundling multiple versions of the Data Grid." : formatErrorMessage_default2(67));
+  }
+  return apiRef;
+}
+
+// node_modules/@mui/utils/ClassNameGenerator/ClassNameGenerator.mjs
+var defaultGenerator = (componentName) => componentName;
+var createClassNameGenerator = () => {
+  let generate = defaultGenerator;
+  return {
+    configure(generator) {
+      generate = generator;
+    },
+    generate(componentName) {
+      return generate(componentName);
+    },
+    reset() {
+      generate = defaultGenerator;
+    }
+  };
+};
+var ClassNameGenerator = createClassNameGenerator();
+var ClassNameGenerator_default = ClassNameGenerator;
+
+// node_modules/@mui/utils/generateUtilityClass/generateUtilityClass.mjs
+var globalStateClasses = {
+  active: "active",
+  checked: "checked",
+  completed: "completed",
+  disabled: "disabled",
+  error: "error",
+  expanded: "expanded",
+  focused: "focused",
+  focusVisible: "focusVisible",
+  open: "open",
+  readOnly: "readOnly",
+  required: "required",
+  selected: "selected"
+};
+function generateUtilityClass(componentName, slot, globalStatePrefix = "Mui") {
+  const globalStateClass = globalStateClasses[slot];
+  return globalStateClass ? `${globalStatePrefix}-${globalStateClass}` : `${ClassNameGenerator_default.generate(componentName)}-${slot}`;
+}
+
+// node_modules/@mui/utils/generateUtilityClasses/generateUtilityClasses.mjs
+function generateUtilityClasses(componentName, slots, globalStatePrefix = "Mui") {
+  const result = {};
+  slots.forEach((slot) => {
+    result[slot] = generateUtilityClass(componentName, slot, globalStatePrefix);
+  });
+  return result;
+}
+
+// node_modules/@mui/x-data-grid/constants/gridClasses.mjs
+var gridClassesOverrides = {
+  root: ["autoHeight", "autosizing", "root--densityStandard", "root--densityComfortable", "root--densityCompact", "root--disableUserSelection", "root--noToolbar", "withVerticalBorder"],
+  children: [
+    "actionsCell",
+    "booleanCell",
+    "cell",
+    "cell--editable",
+    "cell--editing",
+    "cell--flex",
+    "cell--pinnedLeft",
+    "cell--pinnedRight",
+    "cell--rangeBottom",
+    "cell--rangeLeft",
+    "cell--rangeRight",
+    "cell--rangeTop",
+    "cell--withFillHandle",
+    "cell--fillPreview",
+    "cell--fillPreviewTop",
+    "cell--fillPreviewBottom",
+    "cell--fillPreviewLeft",
+    "cell--fillPreviewRight",
+    "cell--selectionMode",
+    "cell--textCenter",
+    "cell--textLeft",
+    "cell--textRight",
+    "cell--withLeftBorder",
+    "cell--withRightBorder",
+    "cellCheckbox",
+    "cellEmpty",
+    "cellOffsetLeft",
+    "cellSkeleton",
+    "checkboxInput",
+    "columnHeader",
+    "columnHeader--alignCenter",
+    "columnHeader--alignLeft",
+    "columnHeader--alignRight",
+    "columnHeader--dragging",
+    "columnHeader--emptyGroup",
+    "columnHeader--filledGroup",
+    "columnHeader--filtered",
+    "columnHeader--last",
+    "columnHeader--moving",
+    "columnHeader--numeric",
+    "columnHeader--pinnedLeft",
+    "columnHeader--pinnedRight",
+    "columnHeader--siblingFocused",
+    "columnHeader--sortable",
+    "columnHeader--sorted",
+    "columnHeader--withLeftBorder",
+    "columnHeader--withRightBorder",
+    "columnHeaderCheckbox",
+    "columnHeaderDraggableContainer",
+    "columnHeaderTitleContainer",
+    "columnHeaderTitleContainerContent",
+    "columnSeparator",
+    "columnSeparator--resizable",
+    "columnSeparator--resizing",
+    "columnSeparator--sideLeft",
+    "columnSeparator--sideRight",
+    "container--bottom",
+    "container--top",
+    "detailPanelToggleCell",
+    "detailPanelToggleCell--expanded",
+    "editBooleanCell",
+    "filterIcon",
+    "filler--borderBottom",
+    "filler--pinnedLeft",
+    "filler--pinnedRight",
+    "groupingCriteriaCell",
+    "groupingCriteriaCellLoadingContainer",
+    "groupingCriteriaCellToggle",
+    "headerFilterRow",
+    "iconSeparator",
+    "menuIcon",
+    "menuIconButton",
+    "menuList",
+    "menuOpen",
+    "overlayWrapperInner",
+    "pinnedRows",
+    "pinnedRows--bottom",
+    "pinnedRows--top",
+    "row",
+    "row--borderBottom",
+    "row--detailPanelExpanded",
+    // TODO v9: Rename to `cell--dragging`
+    "row--dragging",
+    "row--dynamicHeight",
+    "row--editable",
+    "row--editing",
+    "row--firstVisible",
+    "row--lastVisible",
+    "rowReorderCell",
+    "rowReorderCell--draggable",
+    "rowReorderCellContainer",
+    "rowReorderCellPlaceholder",
+    "rowSkeleton",
+    "scrollbar",
+    "scrollbar--horizontal",
+    "scrollbar--vertical",
+    "scrollbarFiller",
+    "scrollbarFiller--pinnedRight",
+    "sortIcon",
+    "treeDataGroupingCell",
+    "treeDataGroupingCellLoadingContainer",
+    "treeDataGroupingCellToggle",
+    "withBorderColor",
+    "row--beingDragged"
+  ]
+};
+var gridClasses = generateUtilityClasses("MuiDataGrid", [...gridClassesOverrides.root, ...gridClassesOverrides.children, "aiAssistantPanel", "aiAssistantPanelHeader", "aiAssistantPanelTitleContainer", "aiAssistantPanelTitle", "aiAssistantPanelBody", "aiAssistantPanelEmptyText", "aiAssistantPanelFooter", "aiAssistantPanelConversation", "aiAssistantPanelConversationList", "aiAssistantPanelConversationTitle", "aiAssistantPanelSuggestions", "aiAssistantPanelSuggestionsList", "aiAssistantPanelSuggestionsItem", "aiAssistantPanelSuggestionsLabel", "aggregationColumnHeader", "aggregationColumnHeader--alignLeft", "aggregationColumnHeader--alignCenter", "aggregationColumnHeader--alignRight", "aggregationColumnHeaderLabel", "aggregationRowOverlayWrapper", "formulaColumnHeaderLetter", "formulaRowNumberCell", "formulaBar", "mainContent", "withSidePanel", "collapsible", "collapsibleTrigger", "collapsibleIcon", "collapsiblePanel", "columnHeader--filter", "columnHeaderFilterInput", "columnHeaderFilterOperatorLabel", "columnHeaderTitle", "columnHeaders", "columnsManagement", "columnsManagementRow", "columnsManagementHeader", "columnsManagementSearchInput", "columnsManagementFooter", "columnsManagementScrollArea", "columnsManagementEmptyText", "contentFiller", "detailPanel", "footerCell", "panel", "panelHeader", "panelWrapper", "panelContent", "panelFooter", "paper", "editInputCell", "longTextCell", "longTextCellContent", "longTextCellExpandButton", "longTextCellCollapseButton", "longTextCellPopup", "longTextCellPopperContent", "editLongTextCell", "editLongTextCellValue", "editLongTextCellPopup", "editLongTextCellPopperContent", "editLongTextCellTextarea", "multiSelectCell", "multiSelectCellChip", "multiSelectCellChip--hidden", "multiSelectCellOverflow", "multiSelectCellPopup", "multiSelectCellPopperContent", "editMultiSelectCell", "editMultiSelectCellChip", "editMultiSelectCellChip--hidden", "editMultiSelectCellOverflow", "editMultiSelectCellPopup", "editMultiSelectCellPopperContent", "filler", "filterForm", "filterFormDeleteIcon", "filterFormLogicOperatorInput", "filterFormColumnInput", "filterFormOperatorInput", "filterFormValueInput", "filler--horizontal", "footerContainer", "iconButtonContainer", "main", "main--hasPinnedRight", "main--hiddenContent", "menu", "overlay", "overlayWrapper", "root", "virtualizer--layoutControlled", "rowCount", "rowReorderIcon", "scrollArea--left", "scrollArea--right", "scrollArea--up", "scrollArea--down", "scrollArea", "scrollShadow", "scrollShadow--vertical", "scrollShadow--horizontal", "selectedRowCount", "sortButton", "shadowScrollArea", "sidebar", "sidebarHeader", "toolbarContainer", "toolbar", "toolbarLabel", "toolbarDivider", "toolbarFilterList", "toolbarQuickFilter", "toolbarQuickFilterTrigger", "toolbarQuickFilterControl", "virtualScroller", "virtualScroller--hasScrollX", "virtualScrollerContent", "virtualScrollerContent--overflowed", "virtualScrollerRenderZone", "pivotPanelAvailableFields", "pivotPanelField", "pivotPanelField--sorted", "pivotPanelFieldActionContainer", "pivotPanelFieldCheckbox", "pivotPanelFieldDragIcon", "pivotPanelFieldList", "pivotPanelFieldName", "pivotPanelHeader", "pivotPanelPlaceholder", "pivotPanelScrollArea", "pivotPanelSearchContainer", "pivotPanelSection", "pivotPanelSectionTitle", "pivotPanelSections", "pivotPanelSwitch", "pivotPanelSwitchLabel", "prompt", "promptContent", "promptText", "promptFeedback", "promptChangeList", "promptChangesToggle", "promptChangesToggleIcon", "promptIcon", "promptIconContainer", "promptError", "promptAction", "resizablePanelHandle", "resizablePanelHandle--horizontal", "resizablePanelHandle--vertical"]);
+
+// node_modules/@mui/x-data-grid/hooks/utils/useGridSelector.mjs
+import * as React26 from "react";
+
+// node_modules/@base-ui/utils/fastObjectShallowCompare.mjs
+var is = Object.is;
+function fastObjectShallowCompare(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (!(a instanceof Object) || !(b instanceof Object)) {
+    return false;
+  }
+  let aLength = 0;
+  let bLength = 0;
+  for (const key in a) {
+    aLength += 1;
+    if (!is(a[key], b[key])) {
+      return false;
+    }
+    if (!(key in b)) {
+      return false;
+    }
+  }
+  for (const _ in b) {
+    bLength += 1;
+  }
+  return aLength === bLength;
+}
+
+// node_modules/@base-ui/utils/createLogOnce.mjs
+var loggedMessages;
+if (process.env.NODE_ENV !== "production") {
+  loggedMessages = /* @__PURE__ */ new Set();
+}
+function createLogOnce(severity, prefix) {
+  return function logOnce(...messages) {
+    if (process.env.NODE_ENV !== "production") {
+      const message = messages.join(" ");
+      const output = prefix ? `${prefix}: ${message}` : message;
+      const key = `${severity}:${output}`;
+      if (!loggedMessages.has(key)) {
+        loggedMessages.add(key);
+        if (severity === "warn") {
+          console.warn(output);
+        } else {
+          console.error(output);
+        }
+      }
+    }
+  };
+}
+
+// node_modules/@mui/x-internals/warning/index.mjs
+var warnOnce = createLogOnce("warn");
+var errorOnce = createLogOnce("error");
+
+// node_modules/@mui/utils/useLazyRef/useLazyRef.mjs
+import * as React25 from "react";
+var UNINITIALIZED = {};
+function useLazyRef(init, initArg) {
+  const ref = React25.useRef(UNINITIALIZED);
+  if (ref.current === UNINITIALIZED) {
+    ref.current = init(initArg);
+  }
+  return ref;
+}
+
+// node_modules/@mui/x-data-grid/hooks/utils/useGridSelector.mjs
+var defaultCompare = Object.is;
+var objectShallowCompare = fastObjectShallowCompare;
+var arrayShallowCompare = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  return a.length === b.length && a.every((v, i) => v === b[i]);
+};
+var argsEqual = (prev, curr) => {
+  let fn = Object.is;
+  if (curr instanceof Array) {
+    fn = arrayShallowCompare;
+  } else if (curr instanceof Object) {
+    fn = objectShallowCompare;
+  }
+  return fn(prev, curr);
+};
+var createRefs = () => ({
+  state: null,
+  equals: null,
+  selector: null,
+  args: void 0,
+  storeState: null
+});
+var EMPTY = [];
+function useGridSelector2(apiRef, selector, args = void 0, equals = defaultCompare) {
+  if (process.env.NODE_ENV !== "production" && !apiRef.current.state) {
+    warnOnce(["MUI X: `useGridSelector` has been called before the initialization of the state.", "This hook can only be used inside the context of the grid."].join("\n"));
+  }
+  const refs = useLazyRef(createRefs);
+  const didInit = refs.current.selector !== null;
+  const [state, setState] = React26.useState(
+    // We don't use an initialization function to avoid allocations
+    didInit ? null : selector(apiRef, args)
+  );
+  refs.current.state = state;
+  if (!didInit) {
+    refs.current.storeState = apiRef.current.store.state;
+  }
+  refs.current.equals = equals;
+  refs.current.selector = selector;
+  const prevArgs = refs.current.args;
+  refs.current.args = args;
+  if (didInit && !argsEqual(prevArgs, args)) {
+    const newState = refs.current.selector(apiRef, refs.current.args);
+    if (!refs.current.equals(refs.current.state, newState)) {
+      refs.current.state = newState;
+      setState(newState);
+    }
+    refs.current.storeState = apiRef.current.store.state;
+  }
+  const updateState = React26.useCallback(
+    () => {
+      const storeState = apiRef.current.store.state;
+      if (refs.current.storeState !== storeState) {
+        const newState = refs.current.selector(apiRef, refs.current.args);
+        refs.current.storeState = storeState;
+        if (!refs.current.equals(refs.current.state, newState)) {
+          refs.current.state = newState;
+          setState(newState);
+        }
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps, react-hooks/use-memo
+    EMPTY
+  );
+  useEnhancedEffect_default(() => {
+    updateState();
+    return apiRef.current.store.subscribe(updateState);
+  }, EMPTY);
+  return state;
+}
+
+// node_modules/@mui/x-data-grid/hooks/utils/useGridPrivateApiContext.mjs
+import * as React27 from "react";
+var GridPrivateApiContext = /* @__PURE__ */ React27.createContext(void 0);
+if (process.env.NODE_ENV !== "production") GridPrivateApiContext.displayName = "GridPrivateApiContext";
+function useGridPrivateApiContext() {
+  const privateApiRef = React27.useContext(GridPrivateApiContext);
+  if (privateApiRef === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "MUI X Data Grid: Could not find the Data Grid private context. This happens when a component is rendered outside of a DataGrid, DataGridPro, or DataGridPremium parent component. Ensure your component is a child of a Data Grid component. This can also happen if you are bundling multiple versions of the Data Grid." : formatErrorMessage_default2(69));
+  }
+  return privateApiRef;
+}
+
+// node_modules/@base-ui/utils/store/createSelector.mjs
+var createSelector = (a, b, c, d, e, f, g, h, ...other) => {
+  if (other.length > 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Unsupported number of selectors" : formatErrorMessage_default(1));
+  }
+  let selector;
+  if (a && b && c && d && e && f && g && h) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      const vc = c(state, a1, a2, a3);
+      const vd = d(state, a1, a2, a3);
+      const ve = e(state, a1, a2, a3);
+      const vf = f(state, a1, a2, a3);
+      const vg = g(state, a1, a2, a3);
+      return h(va, vb, vc, vd, ve, vf, vg, a1, a2, a3);
+    };
+  } else if (a && b && c && d && e && f && g) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      const vc = c(state, a1, a2, a3);
+      const vd = d(state, a1, a2, a3);
+      const ve = e(state, a1, a2, a3);
+      const vf = f(state, a1, a2, a3);
+      return g(va, vb, vc, vd, ve, vf, a1, a2, a3);
+    };
+  } else if (a && b && c && d && e && f) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      const vc = c(state, a1, a2, a3);
+      const vd = d(state, a1, a2, a3);
+      const ve = e(state, a1, a2, a3);
+      return f(va, vb, vc, vd, ve, a1, a2, a3);
+    };
+  } else if (a && b && c && d && e) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      const vc = c(state, a1, a2, a3);
+      const vd = d(state, a1, a2, a3);
+      return e(va, vb, vc, vd, a1, a2, a3);
+    };
+  } else if (a && b && c && d) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      const vc = c(state, a1, a2, a3);
+      return d(va, vb, vc, a1, a2, a3);
+    };
+  } else if (a && b && c) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      const vb = b(state, a1, a2, a3);
+      return c(va, vb, a1, a2, a3);
+    };
+  } else if (a && b) {
+    selector = (state, a1, a2, a3) => {
+      const va = a(state, a1, a2, a3);
+      return b(va, a1, a2, a3);
+    };
+  } else if (a) {
+    selector = a;
+  } else {
+    throw (
+      /* minify-error-disabled */
+      new Error("Missing arguments")
+    );
+  }
+  return selector;
+};
+
+// node_modules/reselect/dist/reselect.mjs
+var CACHE_SIZE_CHECK_THRESHOLD = 1e3;
+var runCacheSizeCheck = (cacheSize, funcName) => {
+  let stack = void 0;
+  try {
+    throw new Error();
+  } catch (e) {
+    ;
+    ({ stack } = e);
+  }
+  console.warn(
+    `A function memoized with weakMapMemoize${funcName ? ` (\`${funcName}\`)` : ""} has seen over ${cacheSize} distinct values for the same primitive argument position.
+Results keyed by primitive arguments are held strongly and are only released by \`clearCache()\`, so this cache will keep growing for as long as the function keeps seeing new values.
+If it is called with ever-changing primitives (ids, offsets, timestamps), pass the \`maxSize\` option to bound the cache, switch to \`lruMemoize\`, or call \`.clearCache()\` at a suitable point.
+See https://reselect.js.org/api/development-only-checks#cachesizecheck for details.`,
+    { stack }
+  );
+};
+var globalDevModeChecks = {
+  inputStabilityCheck: "once",
+  identityFunctionCheck: "once",
+  cacheSizeCheck: "once"
+};
+var StrongRef = class {
+  constructor(value) {
+    this.value = value;
+  }
+  deref() {
+    return this.value;
+  }
+};
+var getWeakRef = () => typeof WeakRef === "undefined" ? StrongRef : WeakRef;
+var Ref = /* @__PURE__ */ getWeakRef();
+var UNTERMINATED = 0;
+var TERMINATED = 1;
+function createCacheNode() {
+  return {
+    s: UNTERMINATED,
+    v: void 0,
+    o: null,
+    p: null
+  };
+}
+function maybeDeref(r2) {
+  if (r2 instanceof Ref) {
+    return r2.deref();
+  }
+  return r2;
+}
+function weakMapMemoize(func, options = {}) {
+  let fnNode = createCacheNode();
+  const { resultEqualityCheck, maxSize } = options;
+  const useGenerations = maxSize !== void 0;
+  if (useGenerations && (!Number.isInteger(maxSize) || maxSize < 1)) {
+    throw new TypeError(
+      `maxSize must be a positive integer, received: ${maxSize}`
+    );
+  }
+  let prevNode = null;
+  let insertionCount = 0;
+  let lastResult;
+  let resultsCount = 0;
+  let hasWarnedAboutCacheSize = false;
+  function maybeFlipGenerations() {
+    if (insertionCount >= maxSize) {
+      prevNode = fnNode;
+      fnNode = createCacheNode();
+      insertionCount = 0;
+    }
+  }
+  function memoized() {
+    let cacheNode = fnNode;
+    const { length } = arguments;
+    for (let i = 0, l = length; i < l; i++) {
+      const arg = arguments[i];
+      if (typeof arg === "function" || typeof arg === "object" && arg !== null) {
+        let objectCache = cacheNode.o;
+        if (objectCache === null) {
+          cacheNode.o = objectCache = /* @__PURE__ */ new WeakMap();
+        }
+        const objectNode = objectCache.get(arg);
+        if (objectNode === void 0) {
+          cacheNode = createCacheNode();
+          objectCache.set(arg, cacheNode);
+        } else {
+          cacheNode = objectNode;
+        }
+      } else {
+        let primitiveCache = cacheNode.p;
+        if (primitiveCache === null) {
+          cacheNode.p = primitiveCache = /* @__PURE__ */ new Map();
+        }
+        const primitiveNode = primitiveCache.get(arg);
+        if (primitiveNode === void 0) {
+          cacheNode = createCacheNode();
+          primitiveCache.set(arg, cacheNode);
+          insertionCount++;
+          if (process.env.NODE_ENV !== "production") {
+            if (primitiveCache.size > CACHE_SIZE_CHECK_THRESHOLD) {
+              const { cacheSizeCheck } = globalDevModeChecks;
+              if (cacheSizeCheck === "always" || cacheSizeCheck === "once" && !hasWarnedAboutCacheSize) {
+                hasWarnedAboutCacheSize = true;
+                runCacheSizeCheck(primitiveCache.size, func.name);
+              }
+            }
+          }
+        } else {
+          cacheNode = primitiveNode;
+        }
+      }
+    }
+    if (cacheNode.s === TERMINATED) {
+      return cacheNode.v;
+    }
+    if (prevNode !== null) {
+      let prevCacheNode = prevNode;
+      for (let i = 0, l = length; i < l; i++) {
+        const arg = arguments[i];
+        let next;
+        if (typeof arg === "function" || typeof arg === "object" && arg !== null) {
+          const prevObjectCache = prevCacheNode.o;
+          next = prevObjectCache !== null ? prevObjectCache.get(arg) : void 0;
+        } else {
+          const prevPrimitiveCache = prevCacheNode.p;
+          next = prevPrimitiveCache !== null ? prevPrimitiveCache.get(arg) : void 0;
+        }
+        if (next === void 0) {
+          prevCacheNode = null;
+          break;
+        }
+        prevCacheNode = next;
+      }
+      if (prevCacheNode !== null && prevCacheNode.s === TERMINATED) {
+        const promotedNode = cacheNode;
+        promotedNode.s = TERMINATED;
+        promotedNode.v = prevCacheNode.v;
+        maybeFlipGenerations();
+        return prevCacheNode.v;
+      }
+    }
+    const terminatedNode = cacheNode;
+    let result = func.apply(null, arguments);
+    resultsCount++;
+    if (resultEqualityCheck) {
+      const lastResultValue = maybeDeref(lastResult);
+      if (lastResultValue != null && resultEqualityCheck(lastResultValue, result)) {
+        result = lastResultValue;
+        resultsCount !== 0 && resultsCount--;
+      }
+      const needsWeakRef = typeof result === "object" && result !== null || typeof result === "function";
+      lastResult = needsWeakRef ? /* @__PURE__ */ new Ref(result) : result;
+    }
+    terminatedNode.s = TERMINATED;
+    terminatedNode.v = result;
+    if (useGenerations) {
+      maybeFlipGenerations();
+    }
+    return result;
+  }
+  memoized.clearCache = () => {
+    fnNode = createCacheNode();
+    prevNode = null;
+    insertionCount = 0;
+    memoized.resetResultsCount();
+    if (process.env.NODE_ENV !== "production") {
+      hasWarnedAboutCacheSize = false;
+    }
+  };
+  memoized.resultsCount = () => resultsCount;
+  memoized.resetResultsCount = () => {
+    resultsCount = 0;
+  };
+  return memoized;
+}
+var runIdentityFunctionCheck = (resultFunc, inputSelectorsResults, outputSelectorResult) => {
+  if (inputSelectorsResults.length === 1 && inputSelectorsResults[0] === outputSelectorResult) {
+    let isInputSameAsOutput = false;
+    try {
+      const emptyObject = {};
+      if (resultFunc(emptyObject) === emptyObject) isInputSameAsOutput = true;
+    } catch {
+    }
+    if (isInputSameAsOutput) {
+      let stack = void 0;
+      try {
+        throw new Error();
+      } catch (e) {
+        ;
+        ({ stack } = e);
+      }
+      console.warn(
+        "The result function returned its own inputs without modification. e.g\n`createSelector([state => state.todos], todos => todos)`\nThis could lead to inefficient memoization and unnecessary re-renders.\nEnsure transformation logic is in the result function, and extraction logic is in the input selectors.",
+        { stack }
+      );
+    }
+  }
+};
+var withoutResultEqualityCheck = (option) => {
+  if (option === null || typeof option !== "object" || !("resultEqualityCheck" in option)) {
+    return option;
+  }
+  const optionCopy = { ...option };
+  delete optionCopy.resultEqualityCheck;
+  return optionCopy;
+};
+var runInputStabilityCheck = (inputSelectorResultsObject, options, inputSelectorArgs) => {
+  const { memoize, memoizeOptions } = options;
+  const { inputSelectorResults, inputSelectorResultsCopy } = inputSelectorResultsObject;
+  const probeMemoizeOptions = [];
+  const { length } = memoizeOptions;
+  for (let i = 0; i < length; i++) {
+    probeMemoizeOptions.push(withoutResultEqualityCheck(memoizeOptions[i]));
+  }
+  const createAnEmptyObject = memoize(() => ({}), ...probeMemoizeOptions);
+  const areInputSelectorResultsEqual = createAnEmptyObject.apply(null, inputSelectorResults) === createAnEmptyObject.apply(null, inputSelectorResultsCopy);
+  if (!areInputSelectorResultsEqual) {
+    let stack = void 0;
+    try {
+      throw new Error();
+    } catch (e) {
+      ;
+      ({ stack } = e);
+    }
+    console.warn(
+      "An input selector returned a different result when passed same arguments.\nThis means your output selector will likely run more frequently than intended.\nAvoid returning a new reference inside your input selector, e.g.\n`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)`",
+      {
+        arguments: inputSelectorArgs,
+        firstInputs: inputSelectorResults,
+        secondInputs: inputSelectorResultsCopy,
+        stack
+      }
+    );
+  }
+};
+var NOT_FOUND = /* @__PURE__ */ Symbol("NOT_FOUND");
+function assertIsFunction(func, errorMessage = `expected a function, instead received ${typeof func}`) {
+  if (typeof func !== "function") {
+    throw new TypeError(errorMessage);
+  }
+}
+function assertIsArrayOfFunctions(array, errorMessage = `expected all items to be functions, instead received the following types: `) {
+  if (!array.every((item) => typeof item === "function")) {
+    const itemTypes = array.map(
+      (item) => typeof item === "function" ? `function ${item.name || "unnamed"}()` : typeof item
+    ).join(", ");
+    throw new TypeError(`${errorMessage}[${itemTypes}]`);
+  }
+}
+var ensureIsArray = (item) => {
+  return Array.isArray(item) ? item : [item];
+};
+function getDependencies(createSelectorArgs) {
+  const dependencies = Array.isArray(createSelectorArgs[0]) ? createSelectorArgs[0] : createSelectorArgs;
+  assertIsArrayOfFunctions(
+    dependencies,
+    `createSelector expects all input-selectors to be functions, but received the following types: `
+  );
+  return dependencies;
+}
+function collectInputSelectorResults(dependencies, inputSelectorArgs) {
+  const inputSelectorResults = [];
+  const { length } = dependencies;
+  for (let i = 0; i < length; i++) {
+    inputSelectorResults.push(dependencies[i].apply(null, inputSelectorArgs));
+  }
+  return inputSelectorResults;
+}
+function createSelectorCreator(memoizeOrOptions, ...memoizeOptionsFromArgs) {
+  const createSelectorCreatorOptions = typeof memoizeOrOptions === "function" ? {
+    memoize: memoizeOrOptions,
+    memoizeOptions: memoizeOptionsFromArgs
+  } : memoizeOrOptions;
+  const createSelector22 = (...createSelectorArgs) => {
+    let recomputations = 0;
+    let dependencyRecomputations = 0;
+    let lastResult;
+    let directlyPassedOptions = {};
+    let resultFunc = createSelectorArgs.pop();
+    if (typeof resultFunc === "object") {
+      directlyPassedOptions = resultFunc;
+      resultFunc = createSelectorArgs.pop();
+    }
+    assertIsFunction(
+      resultFunc,
+      `createSelector expects an output function after the inputs, but received: [${typeof resultFunc}]`
+    );
+    const combinedOptions = {
+      ...createSelectorCreatorOptions,
+      ...directlyPassedOptions
+    };
+    const {
+      memoize,
+      memoizeOptions = [],
+      argsMemoize = weakMapMemoize,
+      argsMemoizeOptions = []
+    } = combinedOptions;
+    const finalMemoizeOptions = ensureIsArray(memoizeOptions);
+    const finalArgsMemoizeOptions = ensureIsArray(argsMemoizeOptions);
+    const dependencies = getDependencies(createSelectorArgs);
+    const memoizedResultFunc = memoize(function recomputationWrapper() {
+      recomputations++;
+      return resultFunc.apply(
+        null,
+        arguments
+      );
+    }, ...finalMemoizeOptions);
+    let firstRun = true;
+    const selector = argsMemoize(function dependenciesChecker() {
+      dependencyRecomputations++;
+      const { length } = dependencies;
+      const inputSelectorResults = new Array(length);
+      for (let i = 0; i < length; i++) {
+        inputSelectorResults[i] = dependencies[i].apply(null, arguments);
+      }
+      lastResult = memoizedResultFunc.apply(null, inputSelectorResults);
+      if (process.env.NODE_ENV !== "production") {
+        const { devModeChecks } = combinedOptions;
+        const identityFunctionCheck = devModeChecks !== void 0 && Object.prototype.hasOwnProperty.call(
+          devModeChecks,
+          "identityFunctionCheck"
+        ) ? devModeChecks.identityFunctionCheck : globalDevModeChecks.identityFunctionCheck;
+        const inputStabilityCheck = devModeChecks !== void 0 && Object.prototype.hasOwnProperty.call(
+          devModeChecks,
+          "inputStabilityCheck"
+        ) ? devModeChecks.inputStabilityCheck : globalDevModeChecks.inputStabilityCheck;
+        if (identityFunctionCheck === "always" || identityFunctionCheck === "once" && firstRun) {
+          runIdentityFunctionCheck(
+            resultFunc,
+            inputSelectorResults,
+            lastResult
+          );
+        }
+        if (inputStabilityCheck === "always" || inputStabilityCheck === "once" && firstRun) {
+          const inputSelectorResultsCopy = collectInputSelectorResults(
+            dependencies,
+            arguments
+          );
+          runInputStabilityCheck(
+            { inputSelectorResults, inputSelectorResultsCopy },
+            { memoize, memoizeOptions: finalMemoizeOptions },
+            arguments
+          );
+        }
+        if (firstRun) firstRun = false;
+      }
+      return lastResult;
+    }, ...finalArgsMemoizeOptions);
+    return Object.assign(selector, {
+      resultFunc,
+      memoizedResultFunc,
+      dependencies,
+      dependencyRecomputations: () => dependencyRecomputations,
+      resetDependencyRecomputations: () => {
+        dependencyRecomputations = 0;
+      },
+      lastResult: () => lastResult,
+      recomputations: () => recomputations,
+      resetRecomputations: () => {
+        recomputations = 0;
+      },
+      memoize,
+      argsMemoize
+    });
+  };
+  Object.assign(createSelector22, {
+    withTypes: () => createSelector22
+  });
+  return createSelector22;
+}
+function createSingletonCache(equals) {
+  let entry;
+  return {
+    get(key) {
+      if (entry && equals(entry.key, key)) {
+        return entry.value;
+      }
+      return NOT_FOUND;
+    },
+    put(key, value) {
+      entry = { key, value };
+    },
+    findMatchingEntry(value, resultEqualityCheck) {
+      const current = entry;
+      return current !== void 0 && resultEqualityCheck(current.value, value) ? current : void 0;
+    },
+    clear() {
+      entry = void 0;
+    }
+  };
+}
+function createLruCache(maxSize, equals) {
+  let entries = [];
+  function get(key) {
+    const cacheIndex = entries.findIndex((entry) => equals(entry.key, key));
+    if (cacheIndex > -1) {
+      const entry = entries[cacheIndex];
+      if (cacheIndex > 0) {
+        entries.splice(cacheIndex, 1);
+        entries.unshift(entry);
+      }
+      return entry.value;
+    }
+    return NOT_FOUND;
+  }
+  function put(key, value) {
+    entries.unshift({ key, value });
+    if (entries.length > maxSize) {
+      entries.pop();
+    }
+  }
+  function findMatchingEntry(value, resultEqualityCheck) {
+    const currentEntries = entries;
+    const { length } = currentEntries;
+    for (let i = 0; i < length; i++) {
+      const entry = currentEntries[i];
+      if (resultEqualityCheck(entry.value, value)) {
+        return entry;
+      }
+    }
+    return void 0;
+  }
+  function clear() {
+    entries = [];
+  }
+  return { get, put, findMatchingEntry, clear };
+}
+var referenceEqualityCheck = (a, b) => a === b;
+function createCacheKeyComparator(equalityCheck) {
+  return function areArgumentsShallowlyEqual(prev, next) {
+    if (prev === null || next === null || prev.length !== next.length) {
+      return false;
+    }
+    const { length } = prev;
+    for (let i = 0; i < length; i++) {
+      if (!equalityCheck(prev[i], next[i])) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+function lruMemoize(func, equalityCheckOrOptions) {
+  const providedOptions = typeof equalityCheckOrOptions === "object" ? equalityCheckOrOptions : { equalityCheck: equalityCheckOrOptions };
+  const {
+    equalityCheck = referenceEqualityCheck,
+    maxSize = 1,
+    resultEqualityCheck
+  } = providedOptions;
+  const comparator = createCacheKeyComparator(equalityCheck);
+  let resultsCount = 0;
+  const cache = maxSize <= 1 ? createSingletonCache(comparator) : createLruCache(maxSize, comparator);
+  function memoized() {
+    let value = cache.get(arguments);
+    if (value === NOT_FOUND) {
+      value = func.apply(null, arguments);
+      resultsCount++;
+      if (resultEqualityCheck) {
+        const matchingEntry = cache.findMatchingEntry(
+          value,
+          resultEqualityCheck
+        );
+        if (matchingEntry) {
+          value = matchingEntry.value;
+          resultsCount !== 0 && resultsCount--;
+        }
+      }
+      cache.put(arguments, value);
+    }
+    return value;
+  }
+  memoized.clearCache = () => {
+    cache.clear();
+    memoized.resetResultsCount();
+  };
+  memoized.resultsCount = () => resultsCount;
+  memoized.resetResultsCount = () => {
+    resultsCount = 0;
+  };
+  return memoized;
+}
+
+// node_modules/@base-ui/utils/store/createSelectorMemoized.mjs
+var MEMOIZE_OPTIONS = {
+  maxSize: 1,
+  equalityCheck: Object.is
+};
+var reselectCreateSelector = createSelectorCreator({
+  memoize: lruMemoize,
+  memoizeOptions: MEMOIZE_OPTIONS
+});
+var createSelectorMemoizedWithOptions = (options) => {
+  const memoizeOptions = options?.memoizeOptions;
+  let resolvedOptions = options;
+  if (options !== void 0) {
+    if (options.memoize !== void 0) {
+      if (memoizeOptions === void 0) {
+        resolvedOptions = {
+          ...options,
+          memoizeOptions: void 0
+        };
+      }
+    } else if (typeof memoizeOptions === "object" && memoizeOptions !== null && !Array.isArray(memoizeOptions)) {
+      resolvedOptions = {
+        ...options,
+        memoizeOptions: {
+          ...MEMOIZE_OPTIONS,
+          ...memoizeOptions
+        }
+      };
+    }
+  }
+  return (...inputs) => {
+    const cache = /* @__PURE__ */ new WeakMap();
+    let nextCacheId = 1;
+    const combiner = inputs[inputs.length - 1];
+    const selectors = inputs.length === 1 ? [(x) => x, combiner] : inputs;
+    const nSelectors = selectors.length - 1;
+    const argsLength = combiner.length === 0 ? 0 : combiner.length - nSelectors;
+    if (argsLength < 0 || argsLength > 3) {
+      throw new Error(process.env.NODE_ENV !== "production" ? "Unsupported number of arguments" : formatErrorMessage_default(2));
+    }
+    const selector = (state, a1, a2, a3) => {
+      let cacheKey = state.__cacheKey__;
+      if (!cacheKey) {
+        cacheKey = {
+          id: nextCacheId
+        };
+        state.__cacheKey__ = cacheKey;
+        nextCacheId += 1;
+      }
+      let fn = cache.get(cacheKey);
+      if (!fn) {
+        let reselectArgs = selectors;
+        const selectorArgs = [void 0, void 0, void 0];
+        switch (argsLength) {
+          case 0:
+            break;
+          case 1: {
+            reselectArgs = [...selectors.slice(0, -1), () => selectorArgs[0], combiner];
+            break;
+          }
+          case 2: {
+            reselectArgs = [...selectors.slice(0, -1), () => selectorArgs[0], () => selectorArgs[1], combiner];
+            break;
+          }
+          default: {
+            reselectArgs = [...selectors.slice(0, -1), () => selectorArgs[0], () => selectorArgs[1], () => selectorArgs[2], combiner];
+            break;
+          }
+        }
+        if (resolvedOptions) {
+          reselectArgs = [...reselectArgs, resolvedOptions];
+        }
+        fn = reselectCreateSelector(...reselectArgs);
+        fn.selectorArgs = selectorArgs;
+        cache.set(cacheKey, fn);
+      }
+      switch (argsLength) {
+        case 3:
+          fn.selectorArgs[2] = a3;
+        case 2:
+          fn.selectorArgs[1] = a2;
+        case 1:
+          fn.selectorArgs[0] = a1;
+        case 0:
+        default:
+      }
+      switch (argsLength) {
+        case 0:
+          return fn(state);
+        case 1:
+          return fn(state, a1);
+        case 2:
+          return fn(state, a1, a2);
+        default:
+          return fn(state, a1, a2, a3);
+      }
+    };
+    return selector;
+  };
+};
+var createSelectorMemoized = createSelectorMemoizedWithOptions();
+
+// node_modules/@mui/x-data-grid/utils/createSelector.mjs
+var createSelector2 = (...args) => {
+  const baseSelector = createSelector(...args);
+  const selector = (apiRef, a1, a2, a3) => baseSelector(unwrapIfNeeded(apiRef), a1, a2, a3);
+  return selector;
+};
+var createSelectorMemoized2 = (...args) => {
+  const baseSelector = createSelectorMemoized(...args);
+  const selector = (apiRef, a1, a2, a3) => baseSelector(unwrapIfNeeded(apiRef), a1, a2, a3);
+  return selector;
+};
+var createRootSelector = (fn) => (apiRef, args) => fn(unwrapIfNeeded(apiRef), args);
+function unwrapIfNeeded(refOrState) {
+  if ("current" in refOrState) {
+    return refOrState.current.state;
+  }
+  return refOrState;
+}
+
+// node_modules/@mui/x-data-grid/hooks/features/rows/gridRowsSelector.mjs
+var gridRowsStateSelector = createRootSelector((state) => state.rows);
+var gridRowCountSelector2 = createSelector2(gridRowsStateSelector, (rows) => rows.totalRowCount);
+var gridRowsLoadingSelector = createSelector2(gridRowsStateSelector, (rows) => rows.loading);
+var gridTopLevelRowCountSelector = createSelector2(gridRowsStateSelector, (rows) => rows.totalTopLevelRowCount);
+var gridRowsLookupSelector = createSelector2(gridRowsStateSelector, (rows) => rows.dataRowIdToModelLookup);
+var gridRowSelector = createSelector2(gridRowsLookupSelector, (rows, id) => rows[id]);
+var gridRowTreeSelector = createSelector2(gridRowsStateSelector, (rows) => rows.tree);
+var gridRowNodeSelector = createSelector2(gridRowTreeSelector, (rowTree, rowId) => rowTree[rowId]);
+var gridRowGroupsToFetchSelector = createSelector2(gridRowsStateSelector, (rows) => rows.groupsToFetch);
+var gridRowGroupingNameSelector = createSelector2(gridRowsStateSelector, (rows) => rows.groupingName);
+var gridRowTreeDepthsSelector = createSelector2(gridRowsStateSelector, (rows) => rows.treeDepths);
+var gridRowMaximumTreeDepthSelector = createSelectorMemoized2(gridRowsStateSelector, (rows) => {
+  const entries = Object.entries(rows.treeDepths);
+  if (entries.length === 0) {
+    return 1;
+  }
+  return (entries.filter(([, nodeCount]) => nodeCount > 0).map(([depth]) => Number(depth)).sort((a, b) => b - a)[0] ?? 0) + 1;
+});
+var gridDataRowIdsSelector = createSelector2(gridRowsStateSelector, (rows) => rows.dataRowIds);
+var gridDataRowsSelector = createSelectorMemoized2(gridDataRowIdsSelector, gridRowsLookupSelector, (dataRowIds, rowsLookup) => dataRowIds.reduce((acc, id) => {
+  if (!rowsLookup[id]) {
+    return acc;
+  }
+  acc.push(rowsLookup[id]);
+  return acc;
+}, []));
+var gridAdditionalRowGroupsSelector = createSelector2(gridRowsStateSelector, (rows) => rows?.additionalRowGroups);
+var gridPinnedRowsSelector = createSelectorMemoized2(gridAdditionalRowGroupsSelector, (additionalRowGroups) => {
+  const rawPinnedRows = additionalRowGroups?.pinnedRows;
+  return {
+    bottom: rawPinnedRows?.bottom?.map((rowEntry) => ({
+      id: rowEntry.id,
+      model: rowEntry.model ?? {}
+    })) ?? [],
+    top: rawPinnedRows?.top?.map((rowEntry) => ({
+      id: rowEntry.id,
+      model: rowEntry.model ?? {}
+    })) ?? []
+  };
+});
+var gridPinnedRowsCountSelector = createSelector2(gridPinnedRowsSelector, (pinnedRows) => {
+  return (pinnedRows?.top?.length || 0) + (pinnedRows?.bottom?.length || 0);
+});
+
+// node_modules/@mui/x-data-grid/hooks/features/rows/gridRowsUtils.mjs
+var import_extends = __toESM(require_extends(), 1);
+var GRID_ID_AUTOGENERATED = /* @__PURE__ */ Symbol("mui.id_autogenerated");
+var isAutogeneratedRowNode = (rowNode) => rowNode.type === "skeletonRow" || rowNode.type === "footer" || rowNode.type === "group" && rowNode.isAutoGenerated || rowNode.type === "pinnedRow" && rowNode.isAutoGenerated;
+var rowHeightWarning = [`MUI X: The \`rowHeight\` prop should be a number greater than 0.`, `The default value will be used instead.`].join("\n");
+
+// node_modules/@mui/x-data-grid/utils/assert.mjs
+function NotRendered(_props) {
+  throw new Error(process.env.NODE_ENV !== "production" ? "MUI X: Failed assertion: should not be rendered" : formatErrorMessage_default2(57));
+}
+
+// node_modules/@mui/x-data-grid/hooks/features/columns/gridColumnsInterfaces.mjs
+var EMPTY_PINNED_COLUMN_FIELDS = {
+  left: [],
+  right: []
+};
+
+// node_modules/@mui/x-data-grid/hooks/features/listView/gridListViewSelectors.mjs
+var gridListViewSelector = createRootSelector((state) => state.props.listView ?? false);
+var gridListColumnSelector = createRootSelector((state) => state.listViewColumn);
+
+// node_modules/@mui/x-data-grid/hooks/features/columns/gridColumnsSelector.mjs
+var gridColumnsStateSelector = createRootSelector((state) => state.columns);
+var gridColumnFieldsSelector = createSelector2(gridColumnsStateSelector, (columnsState) => columnsState.orderedFields);
+var gridColumnLookupSelector = createSelector2(gridColumnsStateSelector, (columnsState) => columnsState.lookup);
+var gridColumnDefinitionsSelector = createSelectorMemoized2(gridColumnFieldsSelector, gridColumnLookupSelector, (allFields, lookup) => allFields.map((field) => lookup[field]));
+var gridColumnVisibilityModelSelector = createSelector2(gridColumnsStateSelector, (columnsState) => columnsState.columnVisibilityModel);
+var gridInitialColumnVisibilityModelSelector = createSelector2(gridColumnsStateSelector, (columnsState) => columnsState.initialColumnVisibilityModel);
+var gridVisibleColumnDefinitionsSelector = createSelectorMemoized2(gridColumnDefinitionsSelector, gridColumnVisibilityModelSelector, gridListViewSelector, gridListColumnSelector, (columns, columnVisibilityModel, listView, listColumn) => listView && listColumn ? [listColumn] : columns.filter((column) => columnVisibilityModel[column.field] !== false));
+var gridVisibleColumnFieldsSelector = createSelectorMemoized2(gridVisibleColumnDefinitionsSelector, (visibleColumns) => visibleColumns.map((column) => column.field));
+var gridPinnedColumnsSelector = createRootSelector((state) => state.pinnedColumns);
+var gridExistingPinnedColumnSelector = createSelectorMemoized2(gridPinnedColumnsSelector, gridColumnFieldsSelector, (model, orderedFields) => filterMissingColumns(model, orderedFields));
+var gridVisiblePinnedColumnDefinitionsSelector = createSelectorMemoized2(gridColumnsStateSelector, gridPinnedColumnsSelector, gridVisibleColumnFieldsSelector, gridListViewSelector, (columnsState, model, visibleColumnFields, listView) => {
+  if (listView) {
+    return EMPTY_PINNED_COLUMN_FIELDS;
+  }
+  const visiblePinnedFields = filterMissingColumns(model, visibleColumnFields);
+  const visiblePinnedColumns = {
+    left: visiblePinnedFields.left.map((field) => columnsState.lookup[field]),
+    right: visiblePinnedFields.right.map((field) => columnsState.lookup[field])
+  };
+  return visiblePinnedColumns;
+});
+function filterMissingColumns(pinnedColumns, columns) {
+  if (!Array.isArray(pinnedColumns.left) && !Array.isArray(pinnedColumns.right)) {
+    return EMPTY_PINNED_COLUMN_FIELDS;
+  }
+  if (pinnedColumns.left?.length === 0 && pinnedColumns.right?.length === 0) {
+    return EMPTY_PINNED_COLUMN_FIELDS;
+  }
+  const filter = (newPinnedColumns, remainingColumns) => {
+    if (!Array.isArray(newPinnedColumns)) {
+      return [];
+    }
+    return newPinnedColumns.filter((field) => remainingColumns.includes(field));
+  };
+  const leftPinnedColumns = filter(pinnedColumns.left, columns);
+  const columnsWithoutLeftPinnedColumns = columns.filter((field) => !leftPinnedColumns.includes(field));
+  const rightPinnedColumns = filter(pinnedColumns.right, columnsWithoutLeftPinnedColumns);
+  return {
+    left: leftPinnedColumns,
+    right: rightPinnedColumns
+  };
+}
+var gridColumnPositionsSelector = createSelectorMemoized2(gridVisibleColumnDefinitionsSelector, (visibleColumns) => {
+  const positions = [];
+  let currentPosition = 0;
+  for (let i = 0; i < visibleColumns.length; i += 1) {
+    positions.push(currentPosition);
+    currentPosition += visibleColumns[i].computedWidth;
+  }
+  return positions;
+});
+var gridFilterableColumnDefinitionsSelector = createSelectorMemoized2(gridColumnDefinitionsSelector, (columns) => columns.filter((col) => col.filterable));
+var gridFilterableColumnLookupSelector = createSelectorMemoized2(gridColumnDefinitionsSelector, (columns) => columns.reduce((acc, col) => {
+  if (col.filterable) {
+    acc[col.field] = col;
+  }
+  return acc;
+}, {}));
+var gridHasColSpanSelector = createSelectorMemoized2(gridColumnDefinitionsSelector, (columns) => columns.some((column) => column.colSpan !== void 0));
+
+// node_modules/@mui/x-data-grid/utils/keyboardUtils.mjs
+var isHideMenuKey = (key) => key === "Tab" || key === "Escape";
+
+// node_modules/@mui/x-data-grid/hooks/features/sorting/gridSortingSelector.mjs
+var gridSortingStateSelector = createRootSelector((state) => state.sorting);
+var gridSortedRowIdsSelector = createSelector2(gridSortingStateSelector, (sortingState) => sortingState.sortedRows);
+var gridSortedRowEntriesSelector = createSelectorMemoized2(gridSortedRowIdsSelector, gridRowsLookupSelector, gridRowTreeSelector, (sortedIds, idRowsLookup, rowTree) => sortedIds.reduce((acc, id) => {
+  const model = idRowsLookup[id];
+  if (model) {
+    acc.push({
+      id,
+      model
+    });
+  } else {
+    const rowNode = rowTree[id];
+    if (rowNode && isAutogeneratedRowNode(rowNode)) {
+      acc.push({
+        id,
+        model: {
+          [GRID_ID_AUTOGENERATED]: id
+        }
+      });
+    }
+  }
+  return acc;
+}, []));
+var gridSortModelSelector = createSelector2(gridSortingStateSelector, (sorting) => sorting.sortModel);
+var gridSortColumnLookupSelector = createSelectorMemoized2(gridSortModelSelector, (sortModel) => {
+  const result = sortModel.reduce((res, sortItem, index) => {
+    res[sortItem.field] = {
+      sortDirection: sortItem.sort,
+      sortIndex: sortModel.length > 1 ? index + 1 : void 0
+    };
+    return res;
+  }, {});
+  return result;
+});
+var gridSortedRowIndexLookupSelector = createSelectorMemoized2(gridSortedRowIdsSelector, (sortedIds) => {
+  return sortedIds.reduce((acc, id, index) => {
+    acc[id] = index;
+    return acc;
+  }, /* @__PURE__ */ Object.create(null));
+});
+
+// node_modules/@mui/x-data-grid/hooks/features/preferencesPanel/gridPreferencePanelSelector.mjs
+var gridPreferencePanelStateSelector = createRootSelector((state) => state.preferencePanel);
+var gridPreferencePanelSelectorWithLabel = createSelector2(gridPreferencePanelStateSelector, (panel, labelId) => {
+  if (panel.open && panel.labelId === labelId) {
+    return true;
+  }
+  return false;
+});
+
+// node_modules/@mui/x-data-grid/hooks/features/preferencesPanel/gridPreferencePanelsValue.mjs
+var GridPreferencePanelsValue = /* @__PURE__ */ (function(GridPreferencePanelsValue2) {
+  GridPreferencePanelsValue2["filters"] = "filters";
+  GridPreferencePanelsValue2["columns"] = "columns";
+  GridPreferencePanelsValue2["aiAssistant"] = "aiAssistant";
+  return GridPreferencePanelsValue2;
+})(GridPreferencePanelsValue || {});
+
+// node_modules/@mui/x-data-grid/components/panel/GridPanelContext.mjs
+var import_extends2 = __toESM(require_extends(), 1);
+import * as React28 from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
+var GridPanelContext = /* @__PURE__ */ React28.createContext(void 0);
+if (process.env.NODE_ENV !== "production") GridPanelContext.displayName = "GridPanelContext";
+function useGridPanelContext() {
+  const context = React28.useContext(GridPanelContext);
+  if (context === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "MUI X: Missing context." : formatErrorMessage_default2(61));
+  }
+  return context;
+}
+
+// node_modules/@mui/x-internals/useComponentRenderer/useComponentRenderer.mjs
+var import_extends3 = __toESM(require_extends(), 1);
+import * as React29 from "react";
+function useComponentRenderer(defaultElement, render, props, state = {}) {
+  if (typeof render === "function") {
+    return render(props, state);
+  }
+  if (render) {
+    if (render.props.className) {
+      props.className = mergeClassNames(render.props.className, props.className);
+    }
+    if (render.props.style || props.style) {
+      props.style = (0, import_extends3.default)({}, props.style, render.props.style);
+    }
+    return /* @__PURE__ */ React29.cloneElement(render, props);
+  }
+  return /* @__PURE__ */ React29.createElement(defaultElement, props);
+}
+function mergeClassNames(className, otherClassName) {
+  if (!className || !otherClassName) {
+    return className || otherClassName;
+  }
+  return `${className} ${otherClassName}`;
+}
+
+// node_modules/@mui/x-internals/ToolbarContext/ToolbarContext.mjs
+import * as React30 from "react";
+import { jsx as _jsx2 } from "react/jsx-runtime";
+var ToolbarContext = /* @__PURE__ */ React30.createContext(void 0);
+if (process.env.NODE_ENV !== "production") ToolbarContext.displayName = "ToolbarContext";
+function useToolbarContext() {
+  const context = React30.useContext(ToolbarContext);
+  if (context === void 0) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "MUI X: Missing context. Toolbar subcomponents must be placed within a <Toolbar /> component." : formatErrorMessage_default2(63));
+  }
+  return context;
+}
+
+// node_modules/@mui/x-internals/ToolbarContext/useRegisterToolbarButton.mjs
+import * as React31 from "react";
+function useRegisterToolbarButton(props, ref) {
+  const {
+    onKeyDown,
+    onFocus,
+    onBlur,
+    disabled,
+    "aria-disabled": ariaDisabled
+  } = props;
+  const id = useId();
+  const {
+    focusableItemId,
+    registerItem,
+    unregisterItem,
+    onItemKeyDown,
+    onItemFocus,
+    onItemBlur,
+    onItemDisabled
+  } = useToolbarContext();
+  const handleKeyDown = (event) => {
+    onItemKeyDown(event);
+    onKeyDown?.(event);
+  };
+  const handleFocus = (event) => {
+    onItemFocus(id);
+    onFocus?.(event);
+  };
+  const handleBlur = (event) => {
+    onItemBlur(id, event);
+    onBlur?.(event);
+  };
+  React31.useEffect(() => {
+    registerItem(id, ref);
+    return () => unregisterItem(id);
+  }, [id, ref, registerItem, unregisterItem]);
+  const previousDisabled = React31.useRef(disabled);
+  React31.useEffect(() => {
+    if (previousDisabled.current !== disabled && disabled === true) {
+      onItemDisabled(id);
+    }
+    previousDisabled.current = disabled;
+  }, [disabled, id, onItemDisabled]);
+  const previousAriaDisabled = React31.useRef(ariaDisabled);
+  React31.useEffect(() => {
+    if (previousAriaDisabled.current !== ariaDisabled && ariaDisabled === true) {
+      onItemDisabled(id);
+    }
+    previousAriaDisabled.current = ariaDisabled;
+  }, [ariaDisabled, id, onItemDisabled]);
+  return {
+    tabIndex: focusableItemId === id ? 0 : -1,
+    disabled,
+    "aria-disabled": ariaDisabled,
+    onKeyDown: handleKeyDown,
+    onFocus: handleFocus,
+    onBlur: handleBlur
+  };
+}
+
+// node_modules/@mui/x-data-grid/components/toolbarV8/ToolbarButton.mjs
+var import_extends4 = __toESM(require_extends(), 1);
+var import_objectWithoutPropertiesLoose = __toESM(require_objectWithoutPropertiesLoose(), 1);
+var import_prop_types = __toESM(require_prop_types(), 1);
+import * as React32 from "react";
+import { jsx as _jsx3 } from "react/jsx-runtime";
+var _excluded = ["render", "onKeyDown", "onFocus", "onBlur", "disabled", "aria-disabled"];
+var _excluded2 = ["tabIndex"];
+var ToolbarButton = forwardRef3(function ToolbarButton2(props, ref) {
+  const {
+    render
+  } = props, other = (0, import_objectWithoutPropertiesLoose.default)(props, _excluded);
+  const rootProps = useGridRootProps2();
+  const buttonRef = React32.useRef(null);
+  const handleRef = useForkRef(buttonRef, ref);
+  const _useRegisterToolbarBu = useRegisterToolbarButton(props, buttonRef), {
+    tabIndex
+  } = _useRegisterToolbarBu, toolbarButtonProps = (0, import_objectWithoutPropertiesLoose.default)(_useRegisterToolbarBu, _excluded2);
+  const element = useComponentRenderer(rootProps.slots.baseIconButton, render, (0, import_extends4.default)({}, rootProps.slotProps?.baseIconButton, {
+    tabIndex
+  }, other, toolbarButtonProps, {
+    ref: handleRef
+  }));
+  return /* @__PURE__ */ _jsx3(React32.Fragment, {
+    children: element
+  });
+});
+if (process.env.NODE_ENV !== "production") ToolbarButton.displayName = "ToolbarButton";
+process.env.NODE_ENV !== "production" ? ToolbarButton.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  className: import_prop_types.default.string,
+  color: import_prop_types.default.oneOf(["default", "inherit", "primary"]),
+  /**
+   * The component used for the root node. Either a string to use an HTML element or a component.
+   */
+  component: import_prop_types.default.elementType,
+  disabled: import_prop_types.default.bool,
+  edge: import_prop_types.default.oneOf(["end", "start", false]),
+  /**
+   * The URL to link to. If set, and `component` is not set, the component renders as an anchor tag.
+   */
+  href: import_prop_types.default.string,
+  id: import_prop_types.default.string,
+  label: import_prop_types.default.string,
+  /**
+   * The relationship of the linked URL.
+   * Set it to `noopener noreferrer` when `target` is set to `_blank` to avoid a security issue.
+   */
+  rel: import_prop_types.default.string,
+  /**
+   * A function to customize rendering of the component.
+   */
+  render: import_prop_types.default.oneOfType([import_prop_types.default.element, import_prop_types.default.func]),
+  role: import_prop_types.default.string,
+  size: import_prop_types.default.oneOf(["large", "medium", "small"]),
+  style: import_prop_types.default.object,
+  tabIndex: import_prop_types.default.number,
+  /**
+   * Where to display the linked URL, as the name for a browsing context.
+   */
+  target: import_prop_types.default.string,
+  title: import_prop_types.default.string,
+  touchRippleRef: import_prop_types.default.any
+} : void 0;
+
+// node_modules/@mui/x-data-grid/hooks/features/columnMenu/getColumnMenuItemKeys.mjs
+var import_extends5 = __toESM(require_extends(), 1);
+function getColumnMenuItemKeys(params) {
+  const {
+    apiRef,
+    colDef,
+    defaultSlots,
+    defaultSlotProps,
+    slots = {},
+    slotProps = {}
+  } = params;
+  const processedComponents = (0, import_extends5.default)({}, defaultSlots, slots);
+  let processedSlotProps = defaultSlotProps;
+  if (slotProps && Object.keys(slotProps).length > 0) {
+    const mergedProps = (0, import_extends5.default)({}, slotProps);
+    Object.entries(defaultSlotProps).forEach(([key, currentSlotProps]) => {
+      mergedProps[key] = (0, import_extends5.default)({}, currentSlotProps, slotProps[key] || {});
+    });
+    processedSlotProps = mergedProps;
+  }
+  const defaultItems = apiRef.current.unstable_applyPipeProcessors("columnMenu", [], colDef);
+  const defaultComponentKeys = Object.keys(defaultSlots);
+  const userItems = Object.keys(slots).filter((key) => !defaultComponentKeys.includes(key));
+  const uniqueItems = Array.from(/* @__PURE__ */ new Set([...defaultItems, ...userItems]));
+  const cleansedItems = uniqueItems.filter((key) => processedComponents[key] != null);
+  return cleansedItems.sort((a, b) => {
+    const leftItemProps = processedSlotProps[a];
+    const rightItemProps = processedSlotProps[b];
+    const leftDisplayOrder = Number.isFinite(leftItemProps?.displayOrder) ? leftItemProps.displayOrder : 100;
+    const rightDisplayOrder = Number.isFinite(rightItemProps?.displayOrder) ? rightItemProps.displayOrder : 100;
+    return leftDisplayOrder - rightDisplayOrder;
+  });
+}
+
+// node_modules/@mui/x-data-grid/components/menu/columnMenu/GridColumnMenuContainer.mjs
+var import_extends6 = __toESM(require_extends(), 1);
+var import_objectWithoutPropertiesLoose2 = __toESM(require_objectWithoutPropertiesLoose(), 1);
+var import_prop_types2 = __toESM(require_prop_types(), 1);
+import * as React33 from "react";
+import { styled as styled3 } from "@mui/material/styles";
+import { jsx as _jsx4 } from "react/jsx-runtime";
+var _excluded3 = ["hideMenu", "colDef", "id", "labelledby", "className", "children", "open"];
+var StyledMenuList = styled3(NotRendered, {
+  slot: "internal"
+})(() => ({
+  minWidth: 248
+}));
+function handleMenuScrollCapture(event) {
+  if (!event.currentTarget.contains(event.target)) {
+    return;
+  }
+  event.stopPropagation();
+}
+var GridColumnMenuContainer = forwardRef3(function GridColumnMenuContainer2(props, ref) {
+  const {
+    hideMenu,
+    id,
+    labelledby,
+    className,
+    children,
+    open
+  } = props, other = (0, import_objectWithoutPropertiesLoose2.default)(props, _excluded3);
+  const rootProps = useGridRootProps2();
+  const handleListKeyDown = React33.useCallback((event) => {
+    if (event.key === "Tab") {
+      event.preventDefault();
+    }
+    if (isHideMenuKey(event.key)) {
+      hideMenu(event);
+    }
+  }, [hideMenu]);
+  return /* @__PURE__ */ _jsx4(StyledMenuList, (0, import_extends6.default)({
+    as: rootProps.slots.baseMenuList,
+    id,
+    className: clsx_default(gridClasses.menuList, className),
+    "aria-labelledby": labelledby,
+    onKeyDown: handleListKeyDown,
+    onWheel: handleMenuScrollCapture,
+    onTouchMove: handleMenuScrollCapture,
+    autoFocus: open
+  }, other, {
+    ref,
+    children
+  }));
+});
+if (process.env.NODE_ENV !== "production") GridColumnMenuContainer.displayName = "GridColumnMenuContainer";
+process.env.NODE_ENV !== "production" ? GridColumnMenuContainer.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  colDef: import_prop_types2.default.object.isRequired,
+  hideMenu: import_prop_types2.default.func.isRequired,
+  id: import_prop_types2.default.string,
+  labelledby: import_prop_types2.default.string,
+  open: import_prop_types2.default.bool.isRequired
+} : void 0;
+
+// node_modules/@mui/x-data-grid/components/menu/columnMenu/GridColumnMenu.mjs
+var import_extends9 = __toESM(require_extends(), 1);
+var import_objectWithoutPropertiesLoose4 = __toESM(require_objectWithoutPropertiesLoose(), 1);
+var import_prop_types8 = __toESM(require_prop_types(), 1);
+
+// node_modules/@mui/x-data-grid/hooks/features/columnMenu/useGridColumnMenuSlots.mjs
+var import_objectWithoutPropertiesLoose3 = __toESM(require_objectWithoutPropertiesLoose(), 1);
+var import_extends7 = __toESM(require_extends(), 1);
+import * as React34 from "react";
+var _excluded4 = ["displayOrder"];
+var useGridColumnMenuSlots = (props) => {
+  const apiRef = useGridPrivateApiContext();
+  const rootProps = useGridRootProps2();
+  const {
+    defaultSlots,
+    defaultSlotProps,
+    slots = {},
+    slotProps = {},
+    hideMenu,
+    colDef,
+    addDividers = true
+  } = props;
+  const processedComponents = React34.useMemo(() => (0, import_extends7.default)({}, defaultSlots, slots), [defaultSlots, slots]);
+  const processedSlotProps = React34.useMemo(() => {
+    if (!slotProps || Object.keys(slotProps).length === 0) {
+      return defaultSlotProps;
+    }
+    const mergedProps = (0, import_extends7.default)({}, slotProps);
+    Object.entries(defaultSlotProps).forEach(([key, currentSlotProps]) => {
+      mergedProps[key] = (0, import_extends7.default)({}, currentSlotProps, slotProps[key] || {});
+    });
+    return mergedProps;
+  }, [defaultSlotProps, slotProps]);
+  return React34.useMemo(() => {
+    const sortedKeys = getColumnMenuItemKeys({
+      apiRef,
+      colDef,
+      defaultSlots,
+      defaultSlotProps,
+      slots,
+      slotProps
+    });
+    return sortedKeys.reduce((acc, key, index) => {
+      let itemProps = {
+        colDef,
+        onClick: hideMenu
+      };
+      const processedComponentProps = processedSlotProps[key];
+      if (processedComponentProps) {
+        const customProps = (0, import_objectWithoutPropertiesLoose3.default)(processedComponentProps, _excluded4);
+        itemProps = (0, import_extends7.default)({}, itemProps, customProps);
+      }
+      return addDividers && index !== sortedKeys.length - 1 ? [...acc, [processedComponents[key], itemProps], [rootProps.slots.baseDivider, {}]] : [...acc, [processedComponents[key], itemProps]];
+    }, []);
+  }, [addDividers, apiRef, colDef, defaultSlotProps, defaultSlots, hideMenu, processedComponents, processedSlotProps, slotProps, slots, rootProps.slots.baseDivider]);
+};
+
+// node_modules/@mui/x-data-grid/components/menu/columnMenu/menuItems/GridColumnMenuColumnsItem.mjs
+var import_extends8 = __toESM(require_extends(), 1);
+var import_prop_types5 = __toESM(require_prop_types(), 1);
+import * as React37 from "react";
+
+// node_modules/@mui/x-data-grid/components/menu/columnMenu/menuItems/GridColumnMenuHideItem.mjs
+var import_prop_types3 = __toESM(require_prop_types(), 1);
+import * as React35 from "react";
+import { jsx as _jsx5 } from "react/jsx-runtime";
+function GridColumnMenuHideItem(props) {
+  const {
+    colDef,
+    onClick
+  } = props;
+  const apiRef = useGridApiContext2();
+  const rootProps = useGridRootProps2();
+  const visibleColumns = gridVisibleColumnDefinitionsSelector(apiRef);
+  const columnsWithMenu = visibleColumns.filter((col) => col.disableColumnMenu !== true);
+  const disabled = columnsWithMenu.length === 1;
+  const toggleColumn = React35.useCallback((event) => {
+    if (disabled) {
+      return;
+    }
+    apiRef.current.setColumnVisibility(colDef.field, false);
+    onClick(event);
+  }, [apiRef, colDef.field, onClick, disabled]);
+  if (rootProps.disableColumnSelector) {
+    return null;
+  }
+  if (colDef.hideable === false) {
+    return null;
+  }
+  return /* @__PURE__ */ _jsx5(rootProps.slots.baseMenuItem, {
+    onClick: toggleColumn,
+    disabled,
+    iconStart: /* @__PURE__ */ _jsx5(rootProps.slots.columnMenuHideIcon, {
+      fontSize: "small"
+    }),
+    children: apiRef.current.getLocaleText("columnMenuHideColumn")
+  });
+}
+process.env.NODE_ENV !== "production" ? GridColumnMenuHideItem.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  colDef: import_prop_types3.default.object.isRequired,
+  onClick: import_prop_types3.default.func.isRequired
+} : void 0;
+
+// node_modules/@mui/x-data-grid/components/menu/columnMenu/menuItems/GridColumnMenuManageItem.mjs
+var import_prop_types4 = __toESM(require_prop_types(), 1);
+import * as React36 from "react";
+import { jsx as _jsx6 } from "react/jsx-runtime";
+function GridColumnMenuManageItem(props) {
+  const {
+    onClick
+  } = props;
+  const apiRef = useGridApiContext2();
+  const rootProps = useGridRootProps2();
+  const showColumns = React36.useCallback((event) => {
+    onClick(event);
+    apiRef.current.showPreferences(GridPreferencePanelsValue.columns);
+  }, [apiRef, onClick]);
+  if (rootProps.disableColumnSelector) {
+    return null;
+  }
+  return /* @__PURE__ */ _jsx6(rootProps.slots.baseMenuItem, {
+    onClick: showColumns,
+    iconStart: /* @__PURE__ */ _jsx6(rootProps.slots.columnMenuManageColumnsIcon, {
+      fontSize: "small"
+    }),
+    children: apiRef.current.getLocaleText("columnMenuManageColumns")
+  });
+}
+process.env.NODE_ENV !== "production" ? GridColumnMenuManageItem.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  colDef: import_prop_types4.default.object.isRequired,
+  onClick: import_prop_types4.default.func.isRequired
+} : void 0;
+
+// node_modules/@mui/x-data-grid/components/menu/columnMenu/menuItems/GridColumnMenuColumnsItem.mjs
+import { jsx as _jsx7, jsxs as _jsxs } from "react/jsx-runtime";
+function GridColumnMenuColumnsItem(props) {
+  return /* @__PURE__ */ _jsxs(React37.Fragment, {
+    children: [/* @__PURE__ */ _jsx7(GridColumnMenuHideItem, (0, import_extends8.default)({}, props)), /* @__PURE__ */ _jsx7(GridColumnMenuManageItem, (0, import_extends8.default)({}, props))]
+  });
+}
+process.env.NODE_ENV !== "production" ? GridColumnMenuColumnsItem.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  colDef: import_prop_types5.default.object.isRequired,
+  onClick: import_prop_types5.default.func.isRequired
+} : void 0;
+
+// node_modules/@mui/x-data-grid/components/menu/columnMenu/menuItems/GridColumnMenuFilterItem.mjs
+var import_prop_types6 = __toESM(require_prop_types(), 1);
+import * as React38 from "react";
+import { jsx as _jsx8 } from "react/jsx-runtime";
+function GridColumnMenuFilterItem(props) {
+  const {
+    colDef,
+    onClick
+  } = props;
+  const apiRef = useGridApiContext2();
+  const rootProps = useGridRootProps2();
+  const showFilter = React38.useCallback((event) => {
+    onClick(event);
+    apiRef.current.showFilterPanel(colDef.field);
+  }, [apiRef, colDef.field, onClick]);
+  if (rootProps.disableColumnFilter || !colDef.filterable) {
+    return null;
+  }
+  return /* @__PURE__ */ _jsx8(rootProps.slots.baseMenuItem, {
+    onClick: showFilter,
+    iconStart: /* @__PURE__ */ _jsx8(rootProps.slots.columnMenuFilterIcon, {
+      fontSize: "small"
+    }),
+    children: apiRef.current.getLocaleText("columnMenuFilter")
+  });
+}
+process.env.NODE_ENV !== "production" ? GridColumnMenuFilterItem.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  colDef: import_prop_types6.default.object.isRequired,
+  onClick: import_prop_types6.default.func.isRequired
+} : void 0;
+
+// node_modules/@mui/x-data-grid/components/menu/columnMenu/menuItems/GridColumnMenuSortItem.mjs
+var import_prop_types7 = __toESM(require_prop_types(), 1);
+import * as React39 from "react";
+import { jsx as _jsx9, jsxs as _jsxs2 } from "react/jsx-runtime";
+function GridColumnMenuSortItem(props) {
+  const {
+    colDef,
+    onClick
+  } = props;
+  const apiRef = useGridApiContext2();
+  const sortModel = useGridSelector2(apiRef, gridSortModelSelector);
+  const rootProps = useGridRootProps2();
+  const sortDirection = React39.useMemo(() => {
+    if (!colDef) {
+      return null;
+    }
+    const sortItem = sortModel.find((item) => item.field === colDef.field);
+    return sortItem?.sort;
+  }, [colDef, sortModel]);
+  const sortingOrder = colDef.sortingOrder ?? rootProps.sortingOrder;
+  const onSortMenuItemClick = React39.useCallback((event) => {
+    onClick(event);
+    const direction = event.currentTarget.getAttribute("data-value") || null;
+    const allowMultipleSorting = rootProps.multipleColumnsSortingMode === "always";
+    apiRef.current.sortColumn(colDef.field, direction === sortDirection ? null : direction, allowMultipleSorting);
+  }, [apiRef, colDef, onClick, sortDirection, rootProps.multipleColumnsSortingMode]);
+  if (rootProps.disableColumnSorting || !colDef || !colDef.sortable || !sortingOrder.some((item) => !!item)) {
+    return null;
+  }
+  const getLabel = (key) => {
+    const label = apiRef.current.getLocaleText(key);
+    return typeof label === "function" ? label(colDef) : label;
+  };
+  return /* @__PURE__ */ _jsxs2(React39.Fragment, {
+    children: [sortingOrder.includes("asc") && sortDirection !== "asc" ? /* @__PURE__ */ _jsx9(rootProps.slots.baseMenuItem, {
+      onClick: onSortMenuItemClick,
+      "data-value": "asc",
+      iconStart: /* @__PURE__ */ _jsx9(rootProps.slots.columnMenuSortAscendingIcon, {
+        fontSize: "small"
+      }),
+      children: getLabel("columnMenuSortAsc")
+    }) : null, sortingOrder.includes("desc") && sortDirection !== "desc" ? /* @__PURE__ */ _jsx9(rootProps.slots.baseMenuItem, {
+      onClick: onSortMenuItemClick,
+      "data-value": "desc",
+      iconStart: /* @__PURE__ */ _jsx9(rootProps.slots.columnMenuSortDescendingIcon, {
+        fontSize: "small"
+      }),
+      children: getLabel("columnMenuSortDesc")
+    }) : null, sortingOrder.includes(null) && sortDirection != null ? /* @__PURE__ */ _jsx9(rootProps.slots.baseMenuItem, {
+      onClick: onSortMenuItemClick,
+      iconStart: rootProps.slots.columnMenuUnsortIcon ? /* @__PURE__ */ _jsx9(rootProps.slots.columnMenuUnsortIcon, {
+        fontSize: "small"
+      }) : /* @__PURE__ */ _jsx9("span", {}),
+      children: apiRef.current.getLocaleText("columnMenuUnsort")
+    }) : null]
+  });
+}
+process.env.NODE_ENV !== "production" ? GridColumnMenuSortItem.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  colDef: import_prop_types7.default.object.isRequired,
+  onClick: import_prop_types7.default.func.isRequired
+} : void 0;
+
+// node_modules/@mui/x-data-grid/components/menu/columnMenu/GridColumnMenu.mjs
+import { jsx as _jsx10 } from "react/jsx-runtime";
+var _excluded5 = ["defaultSlots", "defaultSlotProps", "slots", "slotProps"];
+var GRID_COLUMN_MENU_SLOTS = {
+  columnMenuSortItem: GridColumnMenuSortItem,
+  columnMenuFilterItem: GridColumnMenuFilterItem,
+  columnMenuColumnsItem: GridColumnMenuColumnsItem
+};
+var GRID_COLUMN_MENU_SLOT_PROPS = {
+  columnMenuSortItem: {
+    displayOrder: 10
+  },
+  columnMenuFilterItem: {
+    displayOrder: 20
+  },
+  columnMenuColumnsItem: {
+    displayOrder: 30
+  }
+};
+var GridGenericColumnMenu = forwardRef3(function GridGenericColumnMenu2(props, ref) {
+  const {
+    defaultSlots,
+    defaultSlotProps,
+    slots,
+    slotProps
+  } = props, other = (0, import_objectWithoutPropertiesLoose4.default)(props, _excluded5);
+  const orderedSlots = useGridColumnMenuSlots((0, import_extends9.default)({}, other, {
+    defaultSlots,
+    defaultSlotProps,
+    slots,
+    slotProps
+  }));
+  return /* @__PURE__ */ _jsx10(GridColumnMenuContainer, (0, import_extends9.default)({}, other, {
+    ref,
+    children: orderedSlots.map(([Component, otherProps], index) => /* @__PURE__ */ _jsx10(Component, (0, import_extends9.default)({}, otherProps), index))
+  }));
+});
+if (process.env.NODE_ENV !== "production") GridGenericColumnMenu.displayName = "GridGenericColumnMenu";
+process.env.NODE_ENV !== "production" ? GridGenericColumnMenu.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  colDef: import_prop_types8.default.object.isRequired,
+  /**
+   * Initial `slotProps` - it is internal, to be overrriden by Pro or Premium packages
+   * @ignore - do not document.
+   */
+  defaultSlotProps: import_prop_types8.default.object.isRequired,
+  /**
+   * Initial `slots` - it is internal, to be overrriden by Pro or Premium packages
+   * @ignore - do not document.
+   */
+  defaultSlots: import_prop_types8.default.object.isRequired,
+  hideMenu: import_prop_types8.default.func.isRequired,
+  id: import_prop_types8.default.string,
+  labelledby: import_prop_types8.default.string,
+  open: import_prop_types8.default.bool.isRequired,
+  /**
+   * Could be used to pass new props or override props specific to a column menu component
+   * e.g. `displayOrder`
+   */
+  slotProps: import_prop_types8.default.object,
+  /**
+   * `slots` could be used to add new and (or) override default column menu items
+   * If you register a nee component you must pass it's `displayOrder` in `slotProps`
+   * or it will be placed in the end of the list
+   */
+  slots: import_prop_types8.default.object
+} : void 0;
+var GridColumnMenu = forwardRef3(function GridColumnMenu2(props, ref) {
+  return /* @__PURE__ */ _jsx10(GridGenericColumnMenu, (0, import_extends9.default)({}, props, {
+    ref,
+    defaultSlots: GRID_COLUMN_MENU_SLOTS,
+    defaultSlotProps: GRID_COLUMN_MENU_SLOT_PROPS
+  }));
+});
+if (process.env.NODE_ENV !== "production") GridColumnMenu.displayName = "GridColumnMenu";
+GridColumnMenu.defaultSlots = GRID_COLUMN_MENU_SLOTS;
+GridColumnMenu.defaultSlotProps = GRID_COLUMN_MENU_SLOT_PROPS;
+process.env.NODE_ENV !== "production" ? GridColumnMenu.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  colDef: import_prop_types8.default.object.isRequired,
+  hideMenu: import_prop_types8.default.func.isRequired,
+  id: import_prop_types8.default.string,
+  labelledby: import_prop_types8.default.string,
+  open: import_prop_types8.default.bool.isRequired,
+  /**
+   * Could be used to pass new props or override props specific to a column menu component
+   * e.g. `displayOrder`
+   */
+  slotProps: import_prop_types8.default.object,
+  /**
+   * `slots` could be used to add new and (or) override default column menu items
+   * If you register a nee component you must pass it's `displayOrder` in `slotProps`
+   * or it will be placed in the end of the list
+   */
+  slots: import_prop_types8.default.object
+} : void 0;
+
+// node_modules/@mui/x-data-grid/components/columnsPanel/ColumnsPanelTrigger.mjs
+var import_extends10 = __toESM(require_extends(), 1);
+var import_objectWithoutPropertiesLoose5 = __toESM(require_objectWithoutPropertiesLoose(), 1);
+var import_prop_types9 = __toESM(require_prop_types(), 1);
+import * as React40 from "react";
+import { jsx as _jsx11 } from "react/jsx-runtime";
+var _excluded6 = ["render", "className", "onClick", "onPointerUp"];
+var ColumnsPanelTrigger = forwardRef3(function ColumnsPanelTrigger2(props, ref) {
+  const {
+    render,
+    className,
+    onClick,
+    onPointerUp
+  } = props, other = (0, import_objectWithoutPropertiesLoose5.default)(props, _excluded6);
+  const rootProps = useGridRootProps2();
+  const buttonId = useId();
+  const panelId = useId();
+  const apiRef = useGridApiContext2();
+  const panelState = useGridSelector2(apiRef, gridPreferencePanelStateSelector);
+  const open = panelState.open && panelState.openedPanelValue === GridPreferencePanelsValue.columns;
+  const state = {
+    open
+  };
+  const resolvedClassName = typeof className === "function" ? className(state) : className;
+  const {
+    triggers
+  } = useGridPanelContext();
+  const handleRef = useForkRef(ref, triggers.columnsPanel.setRef);
+  const handleClick = (event) => {
+    if (open) {
+      apiRef.current.hidePreferences();
+    } else {
+      apiRef.current.showPreferences(GridPreferencePanelsValue.columns, panelId, buttonId);
+    }
+    onClick?.(event);
+  };
+  const handlePointerUp = (event) => {
+    if (open) {
+      event.stopPropagation();
+    }
+    onPointerUp?.(event);
+  };
+  const element = useComponentRenderer(rootProps.slots.baseButton, render, (0, import_extends10.default)({}, rootProps.slotProps?.baseButton, {
+    id: buttonId,
+    "aria-haspopup": "true",
+    "aria-expanded": open ? "true" : void 0,
+    "aria-controls": open ? panelId : void 0,
+    className: resolvedClassName
+  }, other, {
+    onPointerUp: handlePointerUp,
+    onClick: handleClick,
+    ref: handleRef
+  }), state);
+  return /* @__PURE__ */ _jsx11(React40.Fragment, {
+    children: element
+  });
+});
+if (process.env.NODE_ENV !== "production") ColumnsPanelTrigger.displayName = "ColumnsPanelTrigger";
+process.env.NODE_ENV !== "production" ? ColumnsPanelTrigger.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  className: import_prop_types9.default.oneOfType([import_prop_types9.default.func, import_prop_types9.default.string]),
+  disabled: import_prop_types9.default.bool,
+  id: import_prop_types9.default.string,
+  /**
+   * A function to customize rendering of the component.
+   */
+  render: import_prop_types9.default.oneOfType([import_prop_types9.default.element, import_prop_types9.default.func]),
+  role: import_prop_types9.default.string,
+  size: import_prop_types9.default.oneOf(["large", "medium", "small"]),
+  startIcon: import_prop_types9.default.node,
+  style: import_prop_types9.default.object,
+  tabIndex: import_prop_types9.default.number,
+  title: import_prop_types9.default.string,
+  touchRippleRef: import_prop_types9.default.any
+} : void 0;
+
+// src/UI/components/tables/TableCustomColumnMenu.tsx
+import { Fragment as Fragment16, jsx as jsx24, jsxs as jsxs16 } from "react/jsx-runtime";
+var CustomButtonGroupItem = (columnProps, handleSetColumnAlign) => {
+  const { hideMenu, colDef } = columnProps;
+  const handleAlignmentChange = (event, value) => {
+    if (event) handleSetColumnAlign(colDef.field, value);
+    hideMenu();
+  };
+  return /* @__PURE__ */ jsxs16(MenuItem5, { disableRipple: true, style: { pointerEvents: "auto", display: "block" }, onClick: (e) => e.stopPropagation(), children: [
+    /* @__PURE__ */ jsxs16(Typography12, { variant: "body2", component: "div", sx: { mb: 1 }, children: [
+      /* @__PURE__ */ jsx24(TranslateText, { children: "Column align" }),
+      ":"
+    ] }),
+    /* @__PURE__ */ jsxs16(
+      ToggleButtonGroup,
+      {
+        value: colDef.align,
+        exclusive: true,
+        onChange: handleAlignmentChange,
+        "aria-label": "text alignment",
+        size: "small",
+        children: [
+          /* @__PURE__ */ jsxs16(ToggleButton, { value: "left", size: "small", "aria-label": "left aligned", color: "primary", children: [
+            /* @__PURE__ */ jsx24(FormatAlignLeft, { fontSize: "small", style: { marginRight: "8px" } }),
+            /* @__PURE__ */ jsx24(TranslateText, { children: "Left" })
+          ] }),
+          /* @__PURE__ */ jsxs16(ToggleButton, { value: "center", "aria-label": "centered", color: "primary", children: [
+            /* @__PURE__ */ jsx24(FormatAlignCenter, { fontSize: "small", style: { marginRight: "8px" } }),
+            /* @__PURE__ */ jsx24(TranslateText, { children: "Center" })
+          ] }),
+          /* @__PURE__ */ jsxs16(ToggleButton, { value: "right", "aria-label": "right aligned", color: "primary", children: [
+            /* @__PURE__ */ jsx24(FormatAlignRight, { fontSize: "small", style: { marginRight: "8px" } }),
+            /* @__PURE__ */ jsx24(TranslateText, { children: "Right" })
+          ] })
+        ]
+      }
+    )
+  ] });
+};
+var CustomResetSettingsItem = (columnProps, handleResetToDefaultSettings) => {
+  const { hideMenu } = columnProps;
+  return /* @__PURE__ */ jsxs16(Fragment16, { children: [
+    /* @__PURE__ */ jsx24(Divider5, {}),
+    /* @__PURE__ */ jsxs16(
+      MenuItem5,
+      {
+        onClick: () => {
+          hideMenu();
+          handleResetToDefaultSettings();
+        },
+        children: [
+          /* @__PURE__ */ jsx24(ListItemIcon3, { children: /* @__PURE__ */ jsx24(Restore, { fontSize: "small" }) }),
+          /* @__PURE__ */ jsx24(ListItemText4, { children: /* @__PURE__ */ jsx24(TranslateText, { children: "Set default view settings" }) })
+        ]
+      }
+    )
+  ] });
+};
+var TableCustomColumnMenu = (props, handleSetColumnAlign, handleResetToDefaultSettings) => {
+  return /* @__PURE__ */ jsx24(
+    GridColumnMenu,
+    {
+      ...props,
+      slots: {
+        columnMenuButtonGroup: (columnProps) => CustomButtonGroupItem(columnProps, handleSetColumnAlign),
+        // 👈 Регистрируем пункт сброса в слотах
+        customResetSettings: (columnProps) => CustomResetSettingsItem(columnProps, handleResetToDefaultSettings)
+      },
+      slotProps: {
+        columnMenuButtonGroup: {
+          displayOrder: 15,
+          hideMenu: props.hideMenu,
+          colDef: props.colDef
+        },
+        // 👈 Указываем порядковый номер отобажения внизу меню
+        customResetSettings: {
+          displayOrder: 200,
+          hideMenu: props.hideMenu
+        }
+      }
+    }
+  );
+};
+
+// src/UI/components/tables/TableCustomToolbar.tsx
+import { Toolbar } from "@mui/x-data-grid-premium";
+
+// src/UI/components/tables/TableCustomToolbarOverlays.tsx
+import { Check, Close, Deselect, FileDownload, Save, SelectAll, Settings as Settings2, Sort, SortByAlpha, SwapVert, Tune, ViewColumn } from "@mui/icons-material";
+import { Box as Box14, Button as Button8, Dialog, DialogActions, DialogContent, DialogTitle, Divider as Divider6, FormControl as FormControl2, IconButton as IconButton11, InputLabel as InputLabel2, ListItemIcon as ListItemIcon4, ListItemText as ListItemText5, Menu as Menu3, MenuItem as MenuItem6, Select as Select3, Stack as Stack2, Tooltip as Tooltip9, Typography as Typography13, useMediaQuery as useMediaQuery2, useTheme as useTheme3 } from "@mui/material";
+import { ExportExcel } from "@mui/x-data-grid-premium";
+import { useEffect as useEffect12, useMemo as useMemo8, useRef as useRef7, useState as useState20 } from "react";
+import { Fragment as Fragment17, jsx as jsx25, jsxs as jsxs17 } from "react/jsx-runtime";
+var ToolbarRefreshButton = ({ apiRef, isLoading, handleRefreshTable }) => {
+  const renderIcon = () => /* @__PURE__ */ jsx25(AnimatedRefreshIcon, { fontSize: "small", isSpinning: isLoading });
+  return /* @__PURE__ */ jsx25(TranslatableTooltipComponent, { title: "Refresh", children: /* @__PURE__ */ jsx25(
+    ToolbarButton,
+    {
+      id: "refresh-table-trigger",
+      disabled: isLoading,
+      onClick: () => {
+        handleRefreshTable();
+        apiRef.current?.setRowSelectionModel({
+          type: "include",
+          ids: /* @__PURE__ */ new Set()
+        });
+      },
+      children: renderIcon()
+    }
+  ) });
+};
+var ToolbarSelectAllButton = ({ rows, handleSelectAll }) => {
+  return /* @__PURE__ */ jsx25(TranslatableTooltipComponent, { title: "Select all rows", children: /* @__PURE__ */ jsx25(ToolbarButton, { id: "select-all-rows", onClick: () => handleSelectAll(), disabled: !rows.length, children: /* @__PURE__ */ jsx25(SelectAll, { fontSize: "small" }) }) });
+};
+var ToolbarClearSelectionButton = ({ rows, handleClearSelection }) => {
+  return /* @__PURE__ */ jsx25(TranslatableTooltipComponent, { title: "Clear selection", children: /* @__PURE__ */ jsx25(ToolbarButton, { id: "deselect-all-rows", onClick: () => handleClearSelection(), disabled: !rows.length, children: /* @__PURE__ */ jsx25(Deselect, { fontSize: "small" }) }) });
+};
+var ToolbarManageColumnsButton = () => {
+  return /* @__PURE__ */ jsx25(TranslatableTooltipComponent, { title: "Manage columns", children: /* @__PURE__ */ jsx25(ColumnsPanelTrigger, { render: /* @__PURE__ */ jsx25(ToolbarButton, {}), children: /* @__PURE__ */ jsx25(ViewColumn, { fontSize: "small" }) }) });
+};
+var ToolbarSaveSettingsButton = ({ tableSettingsChanged, handleSaveTableSettings }) => {
+  return /* @__PURE__ */ jsx25(Tooltip9, { title: "Save table settings" + (!tableSettingsChanged ? ": saved" : ""), children: /* @__PURE__ */ jsx25("span", { children: /* @__PURE__ */ jsx25(
+    ToolbarButton,
+    {
+      id: "save-table-settings",
+      disabled: !tableSettingsChanged,
+      color: tableSettingsChanged ? "primary" : "inherit",
+      onClick: () => handleSaveTableSettings(),
+      children: /* @__PURE__ */ jsx25(Save, { fontSize: "small" })
+    }
+  ) }) });
+};
+var ToolbarExportEntireTableButton = ({ excelOptions }) => {
+  const [exportMenuOpen, setExportMenuOpen] = useState20(false);
+  const exportMenuTriggerRef = useRef7(null);
+  return /* @__PURE__ */ jsxs17(Fragment17, { children: [
+    /* @__PURE__ */ jsx25(TranslatableTooltipComponent, { title: "Export", children: /* @__PURE__ */ jsx25(
+      ToolbarButton,
+      {
+        ref: exportMenuTriggerRef,
+        id: "export-menu-trigger",
+        "aria-controls": "export-menu",
+        "aria-haspopup": "true",
+        "aria-expanded": exportMenuOpen ? "true" : void 0,
+        onClick: () => setExportMenuOpen(true),
+        children: /* @__PURE__ */ jsx25(FileDownload, { fontSize: "small" })
+      }
+    ) }),
+    /* @__PURE__ */ jsx25(
+      Menu3,
+      {
+        id: "export-menu",
+        anchorEl: exportMenuTriggerRef.current,
+        open: exportMenuOpen,
+        onClose: () => setExportMenuOpen(false),
+        anchorOrigin: { vertical: "bottom", horizontal: "right" },
+        transformOrigin: { vertical: "top", horizontal: "right" },
+        children: /* @__PURE__ */ jsx25(
+          ExportExcel,
+          {
+            render: /* @__PURE__ */ jsx25(MenuItem6, {}),
+            options: {
+              fileName: excelOptions?.fileName || "excel-export",
+              allColumns: excelOptions?.allColumns,
+              includeHeaders: excelOptions?.includeHeaders
+            },
+            children: /* @__PURE__ */ jsx25(TranslateText, { children: "Export to Excel" })
+          }
+        )
+      }
+    )
+  ] });
+};
+var DENSITY_OPTIONS = [
+  { label: "Compact density", value: "compact" },
+  { label: "Standard density", value: "standard" },
+  { label: "Comfortable density", value: "comfortable" }
+];
+var ToolbarTableSettingsButton = ({
+  tableSettingsChanged,
+  handleSetTableDensitySettings
+}) => {
+  const theme = useTheme3();
+  const isMobile = useMediaQuery2(theme.breakpoints.down("sm"));
+  const [settingsMenuOpen, setSettingsMenuOpen] = useState20(false);
+  const settingsMenuTriggerRef = useRef7(null);
+  return /* @__PURE__ */ jsxs17(Fragment17, { children: [
+    /* @__PURE__ */ jsx25(Tooltip9, { title: "Settings", children: /* @__PURE__ */ jsx25(
+      ToolbarButton,
+      {
+        ref: settingsMenuTriggerRef,
+        id: "settings-menu-trigger",
+        "aria-controls": "settings-menu",
+        "aria-haspopup": "true",
+        "aria-expanded": settingsMenuOpen ? "true" : void 0,
+        onClick: () => setSettingsMenuOpen(true),
+        children: /* @__PURE__ */ jsx25(Settings2, { fontSize: "small", sx: { ml: "auto" } })
+      }
+    ) }),
+    /* @__PURE__ */ jsx25(Tooltip9, { title: "Settings", children: /* @__PURE__ */ jsxs17(
+      Menu3,
+      {
+        id: "settings-menu",
+        anchorEl: settingsMenuTriggerRef.current,
+        open: settingsMenuOpen,
+        onClose: () => setSettingsMenuOpen(false),
+        anchorOrigin: { vertical: "bottom", horizontal: "right" },
+        transformOrigin: { vertical: "top", horizontal: "right" },
+        slotProps: {
+          list: {
+            "aria-labelledby": "settings-menu-trigger"
+          }
+        },
+        children: [
+          DENSITY_OPTIONS.map((option) => /* @__PURE__ */ jsx25(MenuItem6, { onClick: () => handleSetTableDensitySettings(option.value), children: /* @__PURE__ */ jsx25(ListItemText5, { children: option.label }) }, option.value)),
+          !isMobile && /* @__PURE__ */ jsx25(Divider6, {}),
+          !isMobile && /* @__PURE__ */ jsx25(MenuItem6, { children: /* @__PURE__ */ jsx25(ListItemText5, { children: "Show column borders" }) }),
+          !isMobile && /* @__PURE__ */ jsx25(MenuItem6, { children: /* @__PURE__ */ jsx25(ListItemText5, { children: "Show cell borders" }) }),
+          /* @__PURE__ */ jsx25(Divider6, {}),
+          /* @__PURE__ */ jsxs17(
+            MenuItem6,
+            {
+              children: [
+                /* @__PURE__ */ jsx25(ListItemIcon4, { children: /* @__PURE__ */ jsx25(Tune, { fontSize: "small" }) }),
+                /* @__PURE__ */ jsx25(ListItemText5, { children: "Apply default settings" })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs17(
+            MenuItem6,
+            {
+              disabled: !tableSettingsChanged,
+              color: tableSettingsChanged ? "primary" : "inherit",
+              children: [
+                /* @__PURE__ */ jsx25(ListItemIcon4, { children: /* @__PURE__ */ jsx25(Save, { fontSize: "small", color: tableSettingsChanged ? "primary" : "inherit" }) }),
+                /* @__PURE__ */ jsx25(ListItemText5, { children: "Save settings" })
+              ]
+            }
+          )
+        ]
+      }
+    ) })
+  ] });
+};
+var ToolbarTableSortDialog = ({
+  open,
+  onClose,
+  columns,
+  defaultSortModel,
+  sortModel,
+  onSortModelChange
+}) => {
+  const { displayState } = useAppTheme();
+  const [selectedField, setSelectedField] = useState20("");
+  const [selectedOrder, setSelectedOrder] = useState20("asc");
+  const sortableColumns = useMemo8(() => {
+    return columns.filter((col) => col.sortable !== false && col.field !== "__actions__");
+  }, [columns]);
+  useEffect12(() => {
+    if (!open) return;
+    const activeSort = sortModel && sortModel.length > 0 ? sortModel[0] : defaultSortModel && defaultSortModel.length > 0 ? defaultSortModel[0] : null;
+    const activeField = activeSort?.field || "";
+    const isFieldAvailable = sortableColumns.some((col) => col.field === activeField);
+    if (activeField && isFieldAvailable) {
+      setSelectedField(activeField);
+      setSelectedOrder(activeSort?.sort || "asc");
+    } else {
+      setSelectedField("");
+      setSelectedOrder("asc");
+    }
+  }, [open, sortModel, defaultSortModel, sortableColumns]);
+  const handleApply = () => {
+    if (selectedField) {
+      onSortModelChange([{ field: selectedField, sort: selectedOrder }]);
+    } else {
+      onSortModelChange([]);
+    }
+    onClose();
+  };
+  const handleReset = () => {
+    if (defaultSortModel && defaultSortModel.length > 0) {
+      onSortModelChange([{ field: defaultSortModel[0].field, sort: defaultSortModel[0].sort }]);
+    } else {
+      onSortModelChange([]);
+    }
+    onClose();
+  };
+  return /* @__PURE__ */ jsxs17(Dialog, { open, onClose, fullWidth: true, maxWidth: "xs", children: [
+    /* @__PURE__ */ jsxs17(DialogTitle, { sx: { m: 0, p: 2, display: "flex", alignItems: "center", justifyContent: "space-between" }, children: [
+      /* @__PURE__ */ jsxs17(Stack2, { direction: "row", spacing: 1, sx: { alignItems: "center" }, children: [
+        /* @__PURE__ */ jsx25(Sort, { color: "primary" }),
+        displayState.isMobile ? /* @__PURE__ */ jsx25(Typography13, { variant: "h6", children: /* @__PURE__ */ jsx25(TranslateText, { children: "Sorting" }) }) : /* @__PURE__ */ jsx25(Typography13, { variant: "h6", children: /* @__PURE__ */ jsx25(TranslateText, { children: "Sort Settings" }) })
+      ] }),
+      /* @__PURE__ */ jsx25(IconButton11, { onClick: onClose, size: "small", children: /* @__PURE__ */ jsx25(Close, {}) })
+    ] }),
+    /* @__PURE__ */ jsx25(Divider6, {}),
+    /* @__PURE__ */ jsx25(DialogContent, { sx: { py: 3 }, children: /* @__PURE__ */ jsxs17(Stack2, { spacing: 3, children: [
+      /* @__PURE__ */ jsxs17(
+        FormControl2,
+        {
+          fullWidth: true,
+          variant: "outlined",
+          children: [
+            /* @__PURE__ */ jsx25(InputLabel2, { id: "sort-field-label", children: /* @__PURE__ */ jsx25(TranslateText, { children: "Sort Column" }) }),
+            /* @__PURE__ */ jsxs17(
+              Select3,
+              {
+                labelId: "sort-field-label",
+                value: selectedField,
+                label: /* @__PURE__ */ jsx25(TranslateText, { children: "Sort Column" }),
+                onChange: (e) => setSelectedField(e.target.value),
+                startAdornment: /* @__PURE__ */ jsx25(Box14, { sx: { mr: 1, display: "flex" }, children: /* @__PURE__ */ jsx25(SwapVert, { fontSize: "small", color: "action" }) }),
+                slotProps: {},
+                children: [
+                  /* @__PURE__ */ jsx25(MenuItem6, { value: "", children: /* @__PURE__ */ jsx25("em", { children: /* @__PURE__ */ jsx25(TranslateText, { children: "None" }) }) }),
+                  sortableColumns.map((col) => /* @__PURE__ */ jsx25(MenuItem6, { value: col.field, children: typeof col.headerName === "string" ? col.headerName : col.field }, col.field))
+                ]
+              }
+            )
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs17(FormControl2, { fullWidth: true, variant: "outlined", disabled: !selectedField, children: [
+        /* @__PURE__ */ jsx25(InputLabel2, { id: "sort-order-label", children: /* @__PURE__ */ jsx25(TranslateText, { children: "Sort Order" }) }),
+        /* @__PURE__ */ jsxs17(
+          Select3,
+          {
+            labelId: "sort-order-label",
+            value: selectedOrder || "asc",
+            label: /* @__PURE__ */ jsx25(TranslateText, { children: "Sort Order" }),
+            onChange: (e) => setSelectedOrder(e.target.value),
+            children: [
+              /* @__PURE__ */ jsxs17(MenuItem6, { value: "asc", children: [
+                /* @__PURE__ */ jsx25(TranslateText, { children: "Ascending" }),
+                " (A-Z, 0-9)"
+              ] }),
+              /* @__PURE__ */ jsxs17(MenuItem6, { value: "desc", children: [
+                /* @__PURE__ */ jsx25(TranslateText, { children: "Descending" }),
+                " (Z-A, 9-0)"
+              ] })
+            ]
+          }
+        )
+      ] })
+    ] }) }),
+    displayState.isMobile && /* @__PURE__ */ jsx25(DialogActions, { sx: { p: 2 }, children: /* @__PURE__ */ jsx25(Button8, { onClick: handleReset, color: "inherit", children: /* @__PURE__ */ jsx25(TranslateText, { children: "Reset" }) }) }),
+    /* @__PURE__ */ jsxs17(DialogActions, { sx: { p: 2 }, children: [
+      !displayState.isMobile && /* @__PURE__ */ jsx25(Button8, { onClick: handleReset, color: "inherit", children: /* @__PURE__ */ jsx25(TranslateText, { children: "Reset" }) }),
+      /* @__PURE__ */ jsx25(Box14, { sx: { flexGrow: 1 } }),
+      /* @__PURE__ */ jsx25(Button8, { onClick: onClose, color: "inherit", variant: "text", children: /* @__PURE__ */ jsx25(TranslateText, { children: "Cancel" }) }),
+      /* @__PURE__ */ jsx25(Button8, { onClick: handleApply, variant: "contained", startIcon: /* @__PURE__ */ jsx25(Check, {}), disableElevation: true, size: "small", children: /* @__PURE__ */ jsx25(TranslateText, { children: "Apply" }) })
+    ] })
+  ] });
+};
+var ToolbarTableSortDialogButton = ({
+  columns,
+  defaultSortModel,
+  sortModel,
+  onSortModelChange
+}) => {
+  const sortMenuTriggerRef = useRef7(null);
+  const [isDialogOpen, setIsDialogOpen] = useState20(false);
+  return /* @__PURE__ */ jsxs17(Fragment17, { children: [
+    /* @__PURE__ */ jsx25(TranslatableTooltipComponent, { title: "Sorting", children: /* @__PURE__ */ jsx25(
+      ToolbarButton,
+      {
+        ref: sortMenuTriggerRef,
+        id: "table-sort-dialog",
+        onClick: (event) => {
+          event.currentTarget.blur();
+          setIsDialogOpen(true);
+        },
+        children: /* @__PURE__ */ jsx25(SortByAlpha, { fontSize: "small", sx: { ml: "auto" } })
+      }
+    ) }),
+    /* @__PURE__ */ jsx25(
+      ToolbarTableSortDialog,
+      {
+        open: isDialogOpen,
+        onClose: () => setIsDialogOpen(false),
+        columns,
+        defaultSortModel,
+        sortModel,
+        onSortModelChange: (newModel) => onSortModelChange(newModel)
+      }
+    )
+  ] });
+};
+var TableCoreComponentOverlays = {
+  RefreshButton: ToolbarRefreshButton,
+  SelectAllButton: ToolbarSelectAllButton,
+  ClearSelectionButton: ToolbarClearSelectionButton,
+  ManageColumnsButton: ToolbarManageColumnsButton,
+  SaveSettingsButton: ToolbarSaveSettingsButton,
+  ExportEntireTableButton: ToolbarExportEntireTableButton,
+  TableSettingsButton: ToolbarTableSettingsButton,
+  SortDialogButton: ToolbarTableSortDialogButton,
+  SortDialog: ToolbarTableSortDialog
+};
+
+// src/UI/components/tables/TableCustomToolbar.tsx
+import { Divider as Divider7 } from "@mui/material";
+import { Fragment as Fragment18, jsx as jsx26, jsxs as jsxs18 } from "react/jsx-runtime";
+var TableCustomToolbar = (props) => {
+  const {
+    apiRef,
+    options,
+    excelOptions,
+    columns,
+    columnVisibilityModel,
+    defaultSortModel,
+    sortModel,
+    setSortModel,
+    handleRefresh,
+    isLoading,
+    handleSelectAll,
+    handleClearSelection,
+    rows
+  } = props;
+  const { displayState } = useAppTheme();
+  return /* @__PURE__ */ jsx26(Fragment18, { children: /* @__PURE__ */ jsxs18(Toolbar, { children: [
+    !options?.hideRefreshButton && /* @__PURE__ */ jsx26(TableCoreComponentOverlays.RefreshButton, { apiRef, isLoading, handleRefreshTable: handleRefresh }),
+    (!options?.disableSelecting && !options?.hideSelectAllButton || !options?.disableSelecting && !options?.hideClearSelectionButton || !options?.disableSelecting && (!options?.hideSelectAllButton || !options?.hideClearSelectionButton)) && /* @__PURE__ */ jsx26(Divider7, { orientation: "vertical", variant: "middle", flexItem: true, sx: { mx: 0.5 } }),
+    !options?.disableSelecting && !options?.hideSelectAllButton && /* @__PURE__ */ jsx26(TableCoreComponentOverlays.SelectAllButton, { rows, handleSelectAll }),
+    !options?.disableSelecting && !options?.hideClearSelectionButton && /* @__PURE__ */ jsx26(TableCoreComponentOverlays.ClearSelectionButton, { rows, handleClearSelection }),
+    !options?.disableSelecting && (!options?.hideSelectAllButton || !options?.hideClearSelectionButton) && /* @__PURE__ */ jsx26(Divider7, { orientation: "vertical", variant: "middle", flexItem: true, sx: { mx: 0.5 } }),
+    !options?.disableSorting && !options?.hideSortDialog && /* @__PURE__ */ jsx26(
+      TableCoreComponentOverlays.SortDialogButton,
+      {
+        columns,
+        columnVisibilityModel,
+        defaultSortModel,
+        sortModel,
+        onSortModelChange: (newModel) => {
+          setSortModel(newModel);
+          apiRef.current?.setSortModel(newModel);
+        }
+      }
+    ),
+    (!displayState.isMobile && !options?.disableManageColumns && !options?.hideManageColumnsButton || !options?.disableExcelExport && !options?.hideExcelExportButton) && /* @__PURE__ */ jsx26(Divider7, { orientation: "vertical", variant: "middle", flexItem: true, sx: { mx: 0.5 } }),
+    !displayState.isMobile && !options?.disableManageColumns && !options?.hideManageColumnsButton && /* @__PURE__ */ jsx26(TableCoreComponentOverlays.ManageColumnsButton, {}),
+    !options?.disableExcelExport && !options?.hideExcelExportButton && /* @__PURE__ */ jsx26(TableCoreComponentOverlays.ExportEntireTableButton, { excelOptions })
+  ] }) });
+};
+
+// src/UI/components/tables/TableComponent.tsx
+import { useTranslation as useTranslation4 } from "react-i18next";
+
+// src/UI/components/tables/TableBatchActionBar.tsx
+import {
+  Paper as Paper2,
+  Stack as Stack3,
+  Typography as Typography14,
+  Button as Button9,
+  IconButton as IconButton12,
+  Divider as Divider8,
+  Slide,
+  Box as Box15,
+  Chip,
+  useTheme as useTheme4
+} from "@mui/material";
+import CloseIcon2 from "@mui/icons-material/Close";
+import CheckCircleOutlineIcon from "@mui/icons-material/CheckCircle";
+import { jsx as jsx27, jsxs as jsxs19 } from "react/jsx-runtime";
+function TableBatchActionBar({
+  selectedRows,
+  selectedIds,
+  onClearSelection,
+  renderBatchActions
+}) {
+  const theme = useTheme4();
+  const selectedCount = selectedRows.length;
+  const open = selectedCount > 0;
+  return /* @__PURE__ */ jsx27(Slide, { direction: "up", in: open, mountOnEnter: true, unmountOnExit: true, children: /* @__PURE__ */ jsx27(
+    Paper2,
+    {
+      elevation: 8,
+      sx: {
+        position: "fixed",
+        bottom: 24,
+        left: "50%",
+        transform: "translateX(-50%) !important",
+        zIndex: theme.zIndex.drawer + 1,
+        px: 2.5,
+        py: 1.5,
+        borderRadius: 1,
+        backgroundColor: theme.palette.mode === "dark" ? "grey.900" : "grey.900",
+        color: "common.white",
+        boxShadow: "0px 8px 24px rgba(0, 0, 0, 0.25)"
+      },
+      children: /* @__PURE__ */ jsxs19(Stack3, { direction: "row", sx: { alignItems: "center" }, spacing: 2, children: [
+        /* @__PURE__ */ jsxs19(Stack3, { direction: "row", sx: { alignItems: "center" }, spacing: 1, children: [
+          /* @__PURE__ */ jsx27(
+            Chip,
+            {
+              icon: /* @__PURE__ */ jsx27(CheckCircleOutlineIcon, { style: { color: "#fff" } }),
+              label: selectedCount,
+              color: "primary",
+              size: "small",
+              sx: { fontWeight: "bold" }
+            }
+          ),
+          /* @__PURE__ */ jsx27(Typography14, { variant: "body2", sx: { fontWeight: 500, whiteSpace: "nowrap" }, children: /* @__PURE__ */ jsx27(TranslateText, { children: "Selected items" }) })
+        ] }),
+        /* @__PURE__ */ jsx27(Divider8, { orientation: "vertical", flexItem: true, sx: { borderColor: "rgba(255,255,255,0.2)" } }),
+        /* @__PURE__ */ jsx27(Box15, { sx: { display: "flex", alignItems: "center", gap: 1 }, children: renderBatchActions ? renderBatchActions(selectedIds, selectedRows) : null }),
+        /* @__PURE__ */ jsx27(Divider8, { orientation: "vertical", flexItem: true, sx: { borderColor: "rgba(255,255,255,0.2)" } }),
+        /* @__PURE__ */ jsx27(
+          Button9,
+          {
+            size: "small",
+            color: "inherit",
+            onClick: onClearSelection,
+            sx: {
+              color: "grey.300",
+              textTransform: "none",
+              "&:hover": { color: "common.white" }
+            },
+            children: /* @__PURE__ */ jsx27(TranslateText, { children: "Reset" })
+          }
+        ),
+        /* @__PURE__ */ jsx27(IconButton12, { size: "small", onClick: onClearSelection, sx: { color: "grey.400" }, children: /* @__PURE__ */ jsx27(CloseIcon2, { fontSize: "small" }) })
+      ] })
+    }
+  ) });
+}
+
+// src/UI/components/tables/TableFilterContainer.tsx
+import React41 from "react";
+import { FormControl as FormControl3, InputLabel as InputLabel3, Select as Select4, MenuItem as MenuItem7 } from "@mui/material";
+import SearchIcon from "@mui/icons-material/Search";
+import { jsx as jsx28, jsxs as jsxs20 } from "react/jsx-runtime";
+var TableFilterContainer = ({
+  namespace,
+  filters
+}) => {
+  if (!filters || filters.length === 0) return null;
+  return /* @__PURE__ */ jsx28(FilterContainerComponent, { sx: { mb: 2 }, children: filters.map((section, sIndex) => /* @__PURE__ */ jsx28(
+    FilterSection,
+    {
+      width: section.width ?? "100%",
+      itemWidth: section.itemWidth ?? "100%",
+      children: section.items.map((item) => {
+        if (item.type === "search") {
+          return /* @__PURE__ */ jsx28(
+            SearchComponent,
+            {
+              fullWidth: true,
+              size: "small",
+              placeholderKey: item.placeholderKey || "Search",
+              value: item.value,
+              onChange: (e) => item.onChange(e.target.value),
+              onClear: () => item.onChange(""),
+              slotProps: {
+                input: {
+                  startAdornment: /* @__PURE__ */ jsx28(SearchIcon, { color: "action", sx: { mr: 1 } })
+                }
+              }
+            },
+            item.id
+          );
+        }
+        if (item.type === "select") {
+          return /* @__PURE__ */ jsxs20(FormControl3, { fullWidth: true, size: "small", children: [
+            item.label && /* @__PURE__ */ jsx28(InputLabel3, { children: item.label }),
+            /* @__PURE__ */ jsx28(
+              Select4,
+              {
+                value: item.value,
+                label: item.label,
+                onChange: (e) => item.onChange(e.target.value),
+                children: item.options?.map((opt, oIndex) => /* @__PURE__ */ jsx28(MenuItem7, { value: opt.value, children: typeof opt.label === "string" ? /* @__PURE__ */ jsx28(TranslateText, { children: opt.label }) : opt.label }, oIndex))
+              }
+            )
+          ] }, item.id);
+        }
+        if (item.type === "custom" && item.renderCustom) {
+          return /* @__PURE__ */ jsx28(React41.Fragment, { children: item.renderCustom() }, item.id);
+        }
+        return null;
+      })
+    },
+    sIndex
+  )) });
+};
+
+// src/UI/components/tables/tableSettings.utils.ts
+function mergeTableSettings(saved, currentColumns, defaultSortModel = []) {
+  const currentFields = new Set(currentColumns.map((c) => c.field));
+  const visibility = {};
+  currentColumns.forEach((col) => {
+    if (saved?.columnVisibility && col.field in saved.columnVisibility) {
+      visibility[col.field] = saved.columnVisibility[col.field];
+    } else {
+      visibility[col.field] = !col.defaultHidden;
+    }
+  });
+  let sortModel = defaultSortModel;
+  if (saved?.sortModel && saved.sortModel.length > 0) {
+    const validSort = saved.sortModel.filter((s) => {
+      const col = currentColumns.find((c) => c.field === s.field);
+      return col && col.sortable !== false;
+    });
+    if (validSort.length > 0) {
+      sortModel = validSort;
+    }
+  }
+  const alignments = {};
+  if (saved?.columnAlignments) {
+    Object.keys(saved.columnAlignments).forEach((field) => {
+      if (currentFields.has(field)) {
+        alignments[field] = saved.columnAlignments[field];
+      }
+    });
+  }
+  let columnOrder = [];
+  if (saved?.columnOrder && Array.isArray(saved.columnOrder)) {
+    columnOrder = saved.columnOrder.filter((field) => currentFields.has(field));
+    currentColumns.forEach((col) => {
+      if (!columnOrder.includes(col.field)) {
+        columnOrder.push(col.field);
+      }
+    });
+  }
+  const widths = {};
+  if (saved?.columnWidths) {
+    Object.keys(saved.columnWidths).forEach((field) => {
+      if (currentFields.has(field) && typeof saved.columnWidths[field] === "number") {
+        widths[field] = saved.columnWidths[field];
+      }
+    });
+  }
+  const pageSize = typeof saved?.pageSize === "number" ? saved.pageSize : void 0;
+  return { visibility, sortModel, alignments, columnOrder, columnWidths: widths, pageSize };
+}
+
 // src/hooks/useUserStatus.ts
-import { useEffect as useEffect8, useRef as useRef2, useState as useState16 } from "react";
+import { useEffect as useEffect13, useRef as useRef8, useState as useState21 } from "react";
 var ONLINE_THRESHOLD_MINUTES = 2;
 var AWAY_THRESHOLD_MINUTES = 15;
 var useUserStatus = (userId, initialLastSeenAt, currentAuthUserId) => {
   const supabase = useSupabase();
-  const [status, setStatus] = useState16("offline");
-  const [lastSeen, setLastSeen] = useState16(initialLastSeenAt ?? null);
-  const lastSeenRef = useRef2(initialLastSeenAt ?? null);
+  const [status, setStatus] = useState21("offline");
+  const [lastSeen, setLastSeen] = useState21(initialLastSeenAt ?? null);
+  const lastSeenRef = useRef8(initialLastSeenAt ?? null);
   lastSeenRef.current = lastSeen;
   const calculateStatus = (isOnline, lastSeenIso) => {
     if (isOnline) return "online";
@@ -3465,7 +7222,7 @@ var useUserStatus = (userId, initialLastSeenAt, currentAuthUserId) => {
     }
     return "offline";
   };
-  useEffect8(() => {
+  useEffect13(() => {
     if (!userId) return;
     let isMounted = true;
     const isSelf = currentAuthUserId && userId === currentAuthUserId;
@@ -3536,6 +7293,841 @@ var Hooks = {
   useUserStatus
 };
 
+// src/UI/components/tables/TableComponent.tsx
+import { Fragment as Fragment19, jsx as jsx29, jsxs as jsxs21 } from "react/jsx-runtime";
+function ActionsCell({
+  row,
+  rowActions
+}) {
+  const [anchorEl, setAnchorEl] = useState22(null);
+  const open = Boolean(anchorEl);
+  const items = typeof rowActions === "function" ? rowActions(row) : rowActions || [];
+  if (!items.length) return null;
+  return /* @__PURE__ */ jsxs21(Fragment19, { children: [
+    /* @__PURE__ */ jsx29(
+      IconButton13,
+      {
+        size: "small",
+        onClick: (e) => {
+          e.stopPropagation();
+          setAnchorEl(e.currentTarget);
+        },
+        children: /* @__PURE__ */ jsx29(MoreVertIcon2, { fontSize: "small" })
+      }
+    ),
+    /* @__PURE__ */ jsx29(
+      Menu4,
+      {
+        anchorEl,
+        open,
+        onClose: () => setAnchorEl(null),
+        onClick: (e) => e.stopPropagation(),
+        children: items.filter((f) => !f.hidden).map((item, index) => /* @__PURE__ */ jsxs21(React42.Fragment, { children: [
+          /* @__PURE__ */ jsxs21(
+            MenuItem8,
+            {
+              disabled: item.disabled,
+              onClick: () => {
+                setAnchorEl(null);
+                item.onClick(row);
+              },
+              children: [
+                item.icon && /* @__PURE__ */ jsx29(ListItemIcon5, { children: item.icon }),
+                /* @__PURE__ */ jsx29(ListItemText6, { color: item.color, children: item.label })
+              ]
+            }
+          ),
+          item.divider && /* @__PURE__ */ jsx29(Divider9, { sx: { my: 0.5 } })
+        ] }, index))
+      }
+    )
+  ] });
+}
+var CustomNoRowsOverlay = memo(({ namespace, noRowsText, ...props }) => /* @__PURE__ */ jsx29(GridOverlay, { ...props, children: /* @__PURE__ */ jsx29(Box16, { sx: { textAlign: "center" }, children: /* @__PURE__ */ jsx29(Typography15, { variant: "body2", sx: { mt: 1 }, children: /* @__PURE__ */ jsx29(TranslateText, { children: noRowsText || "No rows" }) }) }) }));
+function TableComponentInner(props, ref) {
+  const {
+    id,
+    schemaVersion = 1,
+    namespace,
+    filters,
+    options,
+    columns,
+    fetchData,
+    getRowId,
+    initialPageSize = 10,
+    pageSizeOptions = [5, 10, 25, 50],
+    defaultSortModel = [],
+    rowActions,
+    renderBatchActions,
+    renderMobileCard,
+    onRefresh,
+    height,
+    // = 550,
+    rowHeight = 65,
+    dialogs,
+    onLoadingChange,
+    onAllSelected,
+    onSelectingChange,
+    disableSaveSettings
+  } = props;
+  const supabase = useSupabase();
+  const isInitialRender = useRef9(true);
+  const storageKey = `dictionary_table_${id}`;
+  const apiRef = useGridApiRef();
+  const timerRef = useRef9(null);
+  const LONG_PRESS_THRESHOLD = 500;
+  const { displayState } = useAppTheme();
+  const { t } = useTranslation4([namespace]);
+  const [isSettingsLoaded, setIsSettingsLoaded] = useState22(() => disableSaveSettings);
+  const [rows, setRows] = useState22([]);
+  const [totalRows, setTotalRows] = useState22(0);
+  const [loading, setLoading] = useState22(false);
+  const [showMobileFilters, setShowMobileFilters] = useState22(false);
+  const [columnWidths, setColumnWidths] = useState22(() => {
+    if (disableSaveSettings) return {};
+    try {
+      const local = localStorage.getItem(storageKey);
+      if (local) {
+        const parsed = JSON.parse(local);
+        return mergeTableSettings(parsed, columns, defaultSortModel).columnWidths || {};
+      }
+    } catch (e) {
+    }
+    return {};
+  });
+  const [columnOrder, setColumnOrder] = useState22(() => {
+    if (disableSaveSettings) return [];
+    try {
+      const local = localStorage.getItem(storageKey);
+      if (local) {
+        const parsed = JSON.parse(local);
+        return mergeTableSettings(parsed, columns, defaultSortModel).columnOrder || [];
+      }
+    } catch (e) {
+    }
+    return [];
+  });
+  const handleSetColumnAlign = useCallback11((field, align) => {
+    setColumnAlignments((prev) => ({
+      ...prev,
+      [field]: align
+    }));
+  }, []);
+  const [paginationModel, setPaginationModel] = useState22(() => {
+    let initialSize = initialPageSize;
+    if (!disableSaveSettings) {
+      try {
+        const local = localStorage.getItem(storageKey);
+        if (local) {
+          const parsed = JSON.parse(local);
+          const merged = mergeTableSettings(parsed, columns, defaultSortModel);
+          if (merged.pageSize) {
+            initialSize = merged.pageSize;
+          }
+        }
+      } catch (e) {
+        console.error("Error reading localStorage for pageSize:", e);
+      }
+    }
+    return { page: 0, pageSize: initialSize };
+  });
+  const [rowSelectionModel, setRowSelectionModel] = useState22({
+    type: "include",
+    ids: /* @__PURE__ */ new Set()
+  });
+  const [refreshIndex, setRefreshIndex] = useState22(0);
+  const [isMobileSortOpen, setIsMobileSortOpen] = useState22(false);
+  const initialColumnVisibilityModel = useMemo9(() => {
+    const visibilityMap = {};
+    columns.forEach((col) => {
+      if (col.defaultHidden) {
+        visibilityMap[col.field] = false;
+      }
+    });
+    return visibilityMap;
+  }, [columns]);
+  const [columnVisibilityModel, setColumnVisibilityModel] = useState22(() => {
+    if (disableSaveSettings) return initialColumnVisibilityModel;
+    try {
+      const local = localStorage.getItem(storageKey);
+      if (local) {
+        const parsed = JSON.parse(local);
+        return mergeTableSettings(parsed, columns, defaultSortModel).visibility;
+      }
+    } catch (e) {
+      console.error("Error reading localStorage:", e);
+    }
+    return initialColumnVisibilityModel;
+  });
+  const [sortModel, setSortModel] = useState22(() => {
+    if (disableSaveSettings) return defaultSortModel;
+    try {
+      const local = localStorage.getItem(storageKey);
+      if (local) {
+        const parsed = JSON.parse(local);
+        return mergeTableSettings(parsed, columns, defaultSortModel).sortModel;
+      }
+    } catch (e) {
+    }
+    return defaultSortModel;
+  });
+  const [columnAlignments, setColumnAlignments] = useState22(() => {
+    if (disableSaveSettings) return {};
+    try {
+      const local = localStorage.getItem(storageKey);
+      if (local) {
+        const parsed = JSON.parse(local);
+        return mergeTableSettings(parsed, columns, defaultSortModel).alignments;
+      }
+    } catch (e) {
+    }
+    return {};
+  });
+  const columnsRef = useRef9(columns);
+  useEffect14(() => {
+    columnsRef.current = columns;
+  }, [columns]);
+  const defaultSortModelRef = useRef9(defaultSortModel);
+  useEffect14(() => {
+    defaultSortModelRef.current = defaultSortModel;
+  }, [defaultSortModel]);
+  useEffect14(() => {
+    if (disableSaveSettings) {
+      setIsSettingsLoaded(true);
+      return;
+    }
+    let isMounted = true;
+    async function loadServerSettings() {
+      try {
+        const { data: { user } } = await supabase.auth.getUser();
+        if (!user) {
+          if (isMounted) setIsSettingsLoaded(true);
+          return;
+        }
+        const { data, error } = await supabase.from("user_table_settings").select("settings").eq("table_id", id).maybeSingle();
+        if (error || !data?.settings) {
+          if (isMounted) setIsSettingsLoaded(true);
+          return;
+        }
+        const serverSettings = data.settings;
+        const merged = mergeTableSettings(
+          serverSettings,
+          columnsRef.current,
+          defaultSortModelRef.current
+        );
+        if (isMounted) {
+          if (merged.visibility) {
+            setColumnVisibilityModel(
+              (prev) => JSON.stringify(prev) !== JSON.stringify(merged.visibility) ? merged.visibility : prev
+            );
+          }
+          if (merged.sortModel) {
+            setSortModel(
+              (prev) => JSON.stringify(prev) !== JSON.stringify(merged.sortModel) ? merged.sortModel : prev
+            );
+          }
+          if (merged.alignments) {
+            setColumnAlignments(
+              (prev) => JSON.stringify(prev) !== JSON.stringify(merged.alignments) ? merged.alignments : prev
+            );
+          }
+          if (merged.columnOrder?.length) {
+            setColumnOrder(
+              (prev) => JSON.stringify(prev) !== JSON.stringify(merged.columnOrder) ? merged.columnOrder : prev
+            );
+          }
+          if (merged.columnWidths) {
+            setColumnWidths(
+              (prev) => JSON.stringify(prev) !== JSON.stringify(merged.columnWidths) ? merged.columnWidths : prev
+            );
+          }
+          if (merged.pageSize) {
+            const newPageSize = merged.pageSize;
+            setPaginationModel(
+              (prev) => prev.pageSize !== newPageSize ? { ...prev, pageSize: newPageSize } : prev
+            );
+          }
+          localStorage.setItem(storageKey, JSON.stringify({
+            version: schemaVersion,
+            columnVisibility: merged.visibility,
+            sortModel: merged.sortModel,
+            columnAlignments: merged.alignments,
+            pageSize: merged.pageSize || paginationModel.pageSize
+          }));
+        }
+      } catch (err) {
+        console.error("Failed to sync settings from server:", err);
+      } finally {
+        if (isMounted) {
+          setIsSettingsLoaded(true);
+        }
+      }
+    }
+    loadServerSettings();
+    return () => {
+      isMounted = false;
+    };
+  }, [id, schemaVersion, disableSaveSettings, storageKey]);
+  const serializedSettings = useMemo9(() => JSON.stringify({
+    version: schemaVersion,
+    columnVisibility: columnVisibilityModel,
+    sortModel,
+    columnAlignments,
+    columnWidths,
+    columnOrder,
+    pageSize: paginationModel.pageSize
+  }), [schemaVersion, columnVisibilityModel, sortModel, columnAlignments, columnWidths, columnOrder, paginationModel.pageSize]);
+  const [debouncedSerializedSettings] = Hooks.useDebounce(serializedSettings, 1e3);
+  useEffect14(() => {
+    if (!disableSaveSettings) {
+      localStorage.setItem(storageKey, serializedSettings);
+    }
+  }, [serializedSettings, storageKey, disableSaveSettings]);
+  useEffect14(() => {
+    if (disableSaveSettings) return;
+    if (isInitialRender.current) {
+      isInitialRender.current = false;
+      return;
+    }
+    async function saveToServer() {
+      try {
+        const { data: { user } } = await supabase.auth.getUser();
+        if (!user) return;
+        const settingsObj = JSON.parse(debouncedSerializedSettings);
+        await supabase.from("user_table_settings").upsert({
+          user_id: user.id,
+          table_id: id,
+          settings: settingsObj
+        }, { onConflict: "user_id,table_id" });
+      } catch (err) {
+        console.error("Failed to save table settings to server:", err);
+      }
+    }
+    saveToServer();
+  }, [debouncedSerializedSettings, id, disableSaveSettings]);
+  const refresh = useCallback11(() => {
+    setPaginationModel((prev) => ({
+      ...prev,
+      page: 0
+    }));
+    setRefreshIndex((prev) => prev + 1);
+  }, []);
+  const onLoadingChangeRef = useRef9(onLoadingChange);
+  useEffect14(() => {
+    onLoadingChangeRef.current = onLoadingChange;
+  }, [onLoadingChange]);
+  const fetchDataRef = useRef9(fetchData);
+  useEffect14(() => {
+    fetchDataRef.current = fetchData;
+  }, [fetchData]);
+  useEffect14(() => {
+    if (!isSettingsLoaded) return;
+    let isCancelled = false;
+    const runFetch = async () => {
+      setLoading(true);
+      queueMicrotask(() => {
+        onLoadingChangeRef.current?.(true);
+      });
+      try {
+        const params = {
+          page: paginationModel.page,
+          pageSize: paginationModel.pageSize,
+          sortModel
+        };
+        const response = await fetchDataRef.current(params);
+        if (!isCancelled) {
+          setRows(response.data);
+          setTotalRows(response.totalRows);
+        }
+      } catch (error) {
+        console.error("Failed to load table data:", error);
+      } finally {
+        if (!isCancelled) {
+          setLoading(false);
+          queueMicrotask(() => {
+            onLoadingChangeRef.current?.(false);
+          });
+        }
+      }
+    };
+    runFetch();
+    return () => {
+      isCancelled = true;
+    };
+  }, [paginationModel, sortModel, refreshIndex, isSettingsLoaded]);
+  const handleRefresh = useCallback11(() => {
+    setRowSelectionModel({
+      type: "include",
+      ids: /* @__PURE__ */ new Set()
+    });
+    apiRef.current?.setRowSelectionModel({
+      type: "include",
+      ids: /* @__PURE__ */ new Set()
+    });
+    setPaginationModel((prev) => ({
+      ...prev,
+      page: 0
+    }));
+    refresh();
+    if (onRefresh) onRefresh();
+  }, [refresh, onRefresh, apiRef]);
+  const handleSelectRowOnMobile = (rowId) => {
+    const getSelected = () => {
+      const newIds = new Set(rowSelectionModel.ids);
+      if (newIds.has(rowId)) {
+        newIds.delete(rowId);
+      } else {
+        newIds.add(rowId);
+      }
+      return {
+        ids: newIds
+      };
+    };
+    const ids = getSelected().ids;
+    apiRef.current?.setRowSelectionModel({ type: "include", ids });
+  };
+  const handleLongTouchStart = (rowId) => {
+    timerRef.current = setTimeout(() => {
+      handleSelectRowOnMobile(rowId);
+      if (window.navigator.vibrate) window.navigator.vibrate(50);
+    }, LONG_PRESS_THRESHOLD);
+  };
+  const extractStringFromReactNode = (node) => {
+    if (typeof node === "string") return node;
+    if (typeof node === "number") return String(node);
+    if (isValidElement(node)) {
+      const children = node.props.children;
+      if (typeof children === "string") return children;
+      if (Array.isArray(children)) {
+        return children.map(extractStringFromReactNode).join("");
+      }
+    }
+    return "";
+  };
+  const gridColumns = useMemo9(() => {
+    const formattedCols = columns.map((col) => {
+      const stringHeader = extractStringFromReactNode(col.headerName);
+      const currentAlign = columnAlignments[col.field] || col.align || "left";
+      const currentHeaderAlign = col.headerAlign || currentAlign;
+      const currentWidth = columnWidths[col.field] ?? col.width;
+      const colDef = {
+        field: col.field,
+        headerName: t(stringHeader) || col.field,
+        align: currentAlign,
+        headerAlign: currentHeaderAlign,
+        width: currentWidth,
+        flex: currentWidth !== void 0 ? void 0 : col.flex ?? 1,
+        sortable: col.sortable ?? true,
+        filterable: col.filterable ?? true,
+        resizable: col.resizable,
+        // 👈 Пробрасываем resizable
+        disableReorder: col.disableReorder,
+        // 👈 Пробрасываем reorderable
+        hideable: col.hideable,
+        // 👈 Пробрасываем hideable
+        disableExport: col.exportable === false,
+        // 👈 Передаем флаг запрета экспорта в MUI DataGrid
+        valueGetter: col.valueGetter,
+        sortComparator: col.sortComparator,
+        renderCell: col.renderField ? (params) => col.renderField(params.row, params.value) : void 0
+      };
+      if (col.renderHeader) {
+        colDef.renderHeader = col.renderHeader;
+      } else if (isValidElement(col.headerName)) {
+        colDef.renderHeader = () => col.headerName;
+      }
+      return colDef;
+    });
+    if (rowActions) {
+      formattedCols.push({
+        field: "__actions__",
+        headerName: t("Actions"),
+        renderHeader: () => /* @__PURE__ */ jsx29(Typography15, { variant: "subtitle2", sx: { fontWeight: 500, width: "100%", textAlign: "center" }, children: /* @__PURE__ */ jsx29(TranslateText, { children: "Actions" }) }),
+        width: 80,
+        align: "center",
+        headerAlign: "center",
+        sortable: false,
+        disableReorder: true,
+        // 👈 Запрет перетаскивания колонки
+        resizable: false,
+        // Запрет изменение размера
+        hideable: false,
+        // Запрет скрытия
+        filterable: false,
+        disableExport: true,
+        renderCell: (params) => /* @__PURE__ */ jsx29(ActionsCell, { row: params.row, rowActions })
+      });
+    }
+    if (columnOrder && columnOrder.length > 0) {
+      const orderMap = new Map(columnOrder.map((field, idx) => [field, idx]));
+      formattedCols.sort((a, b) => {
+        const indexA = orderMap.has(a.field) ? orderMap.get(a.field) : Infinity;
+        const indexB = orderMap.has(b.field) ? orderMap.get(b.field) : Infinity;
+        return indexA - indexB;
+      });
+    }
+    return formattedCols;
+  }, [columns, rowActions, columnAlignments, columnWidths, t]);
+  const selectedRows = useMemo9(() => {
+    if (!rowSelectionModel?.ids) return [];
+    return rows.filter((r2) => rowSelectionModel.ids.has(r2.id));
+  }, [rows, rowSelectionModel]);
+  const handleSelectAll = useCallback11(() => {
+    const allRowIds = new Set(rows.map((row) => row.id));
+    const newSelection = {
+      type: "include",
+      ids: allRowIds
+    };
+    setRowSelectionModel(newSelection);
+    apiRef.current?.setRowSelectionModel(newSelection);
+    if (onAllSelected) onAllSelected(true);
+  }, [rows, apiRef]);
+  const handleClearSelection = useCallback11(() => {
+    const emptySelection = {
+      type: "include",
+      ids: /* @__PURE__ */ new Set()
+    };
+    setRowSelectionModel(emptySelection);
+    apiRef.current?.setRowSelectionModel(emptySelection);
+    if (onAllSelected) onAllSelected(false);
+  }, [apiRef]);
+  const handleRowSelectionModelChange = useCallback11((newSelectionModel) => {
+    setRowSelectionModel(newSelectionModel);
+    if (onSelectingChange) {
+      onSelectingChange(getSelectedRowIds(newSelectionModel));
+    }
+  }, [onSelectingChange]);
+  const pinnedColumns = useMemo9(() => {
+    const leftPinned = columns.filter((col) => col.pinned === "left").map((col) => col.field);
+    const rightPinned = columns.filter((col) => col.pinned === "right").map((col) => col.field);
+    if (rowActions && !rightPinned.includes("__actions__")) {
+      rightPinned.push("__actions__");
+    }
+    return {
+      left: leftPinned,
+      right: rightPinned
+    };
+  }, [columns, rowActions]);
+  const handleResetToDefaultSettings = useCallback11(async () => {
+    if (!disableSaveSettings) {
+      localStorage.removeItem(storageKey);
+    }
+    setColumnVisibilityModel(initialColumnVisibilityModel);
+    setSortModel(defaultSortModel);
+    setColumnAlignments({});
+    setColumnWidths({});
+    setColumnOrder([]);
+    setPaginationModel((prev) => ({
+      ...prev,
+      pageSize: initialPageSize
+    }));
+    if (!disableSaveSettings) {
+      try {
+        const { data: { user } } = await supabase.auth.getUser();
+        if (user) {
+          await supabase.from("user_table_settings").delete().eq("user_id", user.id).eq("table_id", id);
+        }
+      } catch (err) {
+        console.error("Failed to delete settings from server:", err);
+      }
+    }
+    refresh();
+  }, [
+    disableSaveSettings,
+    storageKey,
+    initialColumnVisibilityModel,
+    defaultSortModel,
+    initialPageSize,
+    id,
+    refresh
+  ]);
+  const handleColumnMenu = useCallback11(
+    (props2) => TableCustomColumnMenu(props2, handleSetColumnAlign, handleResetToDefaultSettings),
+    [handleSetColumnAlign, handleResetToDefaultSettings]
+  );
+  const handleSortModelChange = useCallback11((newModel) => {
+    Promise.resolve().then(() => {
+      setSortModel(newModel);
+    });
+  }, []);
+  function getSelectedRowIds(selectionModel) {
+    if (!selectionModel) return [];
+    if (Array.isArray(selectionModel)) {
+      return selectionModel.map(String);
+    }
+    if (typeof selectionModel === "object" && "ids" in selectionModel) {
+      const rawIds = selectionModel.ids;
+      if (rawIds instanceof Set) {
+        return Array.from(rawIds).map(String);
+      }
+      if (Array.isArray(rawIds)) {
+        return rawIds.map(String);
+      }
+      if (rawIds instanceof Map) {
+        return Array.from(rawIds.keys()).map(String);
+      }
+      if (rawIds && typeof rawIds[Symbol.iterator] === "function") {
+        return Array.from(rawIds).map(String);
+      }
+    }
+    return [];
+  }
+  const exportToExcel = useCallback11(
+    (customOptions) => {
+      if (!apiRef.current || !apiRef.current.exportDataAsExcel) {
+        console.warn("DataGrid apiRef is not fully initialized yet");
+        return;
+      }
+      const defaultExcelOptions = options?.excelOptions;
+      const shouldExportAllColumns = customOptions?.allColumns ?? defaultExcelOptions?.allColumns ?? true;
+      const exportableFields = gridColumns.filter((col) => col.field !== "__actions__").filter((col) => col.disableExport === false).map((col) => col.field);
+      apiRef.current.exportDataAsExcel({
+        fileName: customOptions?.fileName || defaultExcelOptions?.fileName || "excel-export",
+        allColumns: shouldExportAllColumns,
+        includeHeaders: customOptions?.includeHeaders ?? defaultExcelOptions?.includeHeaders ?? true,
+        fields: exportableFields
+        // 👈 Передаем полный список полей
+      });
+    },
+    [apiRef, options?.excelOptions, gridColumns]
+  );
+  useImperativeHandle(ref, () => ({
+    refresh,
+    handleSelectAll,
+    handleClearSelection,
+    resetToDefaultSettings: handleResetToDefaultSettings,
+    selectedIds: getSelectedRowIds(rowSelectionModel),
+    exportToExcel,
+    loading
+  }));
+  if (displayState.isMobile && renderMobileCard) {
+    return /* @__PURE__ */ jsxs21(Stack4, { spacing: 2, children: [
+      /* @__PURE__ */ jsxs21(Paper3, { sx: { p: 1.5, display: "flex", justifyContent: "space-between", alignItems: "center" }, children: [
+        /* @__PURE__ */ jsxs21(Typography15, { variant: "subtitle2", children: [
+          /* @__PURE__ */ jsx29(TranslateText, { children: "Total" }),
+          ": ",
+          totalRows
+        ] }),
+        /* @__PURE__ */ jsxs21(Box16, { sx: { display: "flex", gap: 1, alignItems: "center" }, children: [
+          !options?.disableSorting && !options?.hideSortDialog && /* @__PURE__ */ jsx29(
+            IconButton13,
+            {
+              onClick: () => setIsMobileSortOpen(true),
+              color: sortModel.length > 0 ? "primary" : "default",
+              size: "small",
+              children: /* @__PURE__ */ jsx29(SortByAlphaIcon, { fontSize: "small" })
+            }
+          ),
+          filters && filters.length > 0 && /* @__PURE__ */ jsx29(
+            IconButton13,
+            {
+              onClick: () => setShowMobileFilters((prev) => !prev),
+              color: showMobileFilters ? "primary" : "default",
+              size: "small",
+              children: /* @__PURE__ */ jsx29(FilterListIcon, { fontSize: "small" })
+            }
+          ),
+          /* @__PURE__ */ jsx29(IconButton13, { onClick: handleRefresh, color: "primary", size: "small", children: /* @__PURE__ */ jsx29(RefreshIcon2, { fontSize: "small" }) })
+        ] })
+      ] }),
+      filters && filters.length > 0 && /* @__PURE__ */ jsx29(Collapse2, { in: showMobileFilters, unmountOnExit: true, children: /* @__PURE__ */ jsx29(Box16, { sx: { mb: 1 }, children: /* @__PURE__ */ jsx29(TableFilterContainer, { namespace, filters }) }) }),
+      loading ? /* @__PURE__ */ jsxs21(Typography15, { sx: { p: 2, textAlign: "center" }, children: [
+        /* @__PURE__ */ jsx29(TranslateText, { children: "Loading" }),
+        "..."
+      ] }) : rows.map((row) => /* @__PURE__ */ jsxs21(Paper3, { variant: "outlined", sx: { p: 2, position: "relative" }, children: [
+        renderMobileCard(row),
+        rowActions && /* @__PURE__ */ jsx29(Box16, { sx: { position: "absolute", top: 8, right: 8 }, children: /* @__PURE__ */ jsx29(ActionsCell, { row, rowActions }) })
+      ] }, row.id)),
+      !loading && totalRows > 0 && /* @__PURE__ */ jsx29(Paper3, { variant: "outlined", sx: { p: 1, display: "flex", justifyContent: "center" }, children: /* @__PURE__ */ jsx29(
+        TablePaginationComponent,
+        {
+          count: totalRows,
+          page: paginationModel.page,
+          rowsPerPage: paginationModel.pageSize,
+          rowsPerPageOptions: pageSizeOptions,
+          onPageChange: (_, newPage) => {
+            setPaginationModel((prev) => ({ ...prev, page: newPage }));
+          },
+          onRowsPerPageChange: (event) => {
+            const newSize = parseInt(event.target.value, 10);
+            setPaginationModel({ page: 0, pageSize: newSize });
+          }
+        }
+      ) }),
+      !options?.disableSorting && !options?.hideSortDialog && /* @__PURE__ */ jsx29(
+        TableCoreComponentOverlays.SortDialog,
+        {
+          open: isMobileSortOpen,
+          onClose: () => setIsMobileSortOpen(false),
+          columns: gridColumns,
+          defaultSortModel,
+          sortModel,
+          onSortModelChange: (newModel) => {
+            handleSortModelChange(newModel);
+          }
+        }
+      ),
+      dialogs
+    ] });
+  }
+  return /* @__PURE__ */ jsxs21(Box16, { sx: { height, width: "100%" }, children: [
+    filters && filters.length > 0 && /* @__PURE__ */ jsx29(TableFilterContainer, { namespace, filters }),
+    /* @__PURE__ */ jsx29(
+      DataGridPremium,
+      {
+        apiRef,
+        rows,
+        columns: gridColumns,
+        columnVisibilityModel,
+        onColumnVisibilityModelChange: (newModel) => setColumnVisibilityModel(newModel),
+        rowCount: totalRows,
+        loading,
+        pinnedColumns,
+        getRowId,
+        disableColumnFilter: true,
+        disableColumnReorder: options?.disableManageColumns,
+        disableColumnResize: options?.disableManageColumns,
+        disableColumnSelector: options?.disableManageColumns,
+        showToolbar: !options?.hideToolbar,
+        pagination: true,
+        paginationMode: "server",
+        paginationModel,
+        onPaginationModelChange: setPaginationModel,
+        pageSizeOptions,
+        disableColumnSorting: options?.disableSorting,
+        sortingMode: "server",
+        sortModel,
+        onSortModelChange: handleSortModelChange,
+        checkboxSelection: options?.checkboxSelection && !options?.disableSelecting,
+        checkboxSelectionVisibleOnly: true,
+        rowSelectionModel,
+        onRowSelectionModelChange: handleRowSelectionModelChange,
+        disableRowSelectionOnClick: true,
+        onColumnWidthChange: (params) => {
+          setColumnWidths((prev) => ({
+            ...prev,
+            [params.colDef.field]: params.width
+          }));
+        },
+        onColumnOrderChange: () => {
+          const allCols = apiRef.current?.getAllColumns();
+          if (allCols) {
+            setColumnOrder(allCols.map((col) => col.field));
+          }
+        },
+        slots: {
+          pagination: TableCustomPagination,
+          columnMenu: handleColumnMenu,
+          noRowsOverlay: CustomNoRowsOverlay,
+          toolbar: TableCustomToolbar
+        },
+        slotProps: {
+          noRowsOverlay: {
+            namespace,
+            noRowsText: options?.noRowsText
+          },
+          row: {
+            onTouchStart: (e) => {
+              const id2 = e.currentTarget.getAttribute("data-id");
+              if (!id2) return;
+              const rowId = isNaN(Number(id2)) ? id2 : Number(id2);
+              timerRef.current = setTimeout(() => {
+                handleLongTouchStart(rowId);
+              }, 500);
+            },
+            onTouchEnd: () => clearTimeout(timerRef.current),
+            onTouchMove: () => clearTimeout(timerRef.current)
+          },
+          loadingOverlay: {
+            variant: "linear-progress",
+            noRowsVariant: "skeleton"
+          },
+          toolbar: {
+            apiRef,
+            options,
+            columns: gridColumns,
+            columnVisibilityModel,
+            defaultSortModel,
+            sortModel,
+            setSortModel,
+            excelOptions: {
+              disableToolbarButton: options?.excelOptions?.disableExport || false,
+              fileName: options?.excelOptions?.fileName || "excel-export",
+              allColumns: options?.excelOptions?.allColumns || false,
+              includeHeaders: options?.excelOptions?.includeHeaders || true
+            },
+            handleRefresh,
+            isLoading: loading,
+            handleSelectAll,
+            handleClearSelection,
+            rows
+          }
+        },
+        rowHeight,
+        sx: {
+          "& .MuiDataGrid-cell": {
+            display: "flex",
+            alignItems: "center"
+          },
+          "& .MuiDataGrid-columnHeader": {
+            display: "flex",
+            alignItems: "center"
+          },
+          "& .MuiDataGrid-columnHeader--pinnedRight, & .MuiDataGrid-cell--pinnedRight": {
+            backgroundColor: "background.paper"
+          },
+          borderRadius: 1
+        },
+        localeText: {
+          // Управление колонками и меню
+          columnMenuHideColumn: t("Hide column", { ns: "table_component" }),
+          columnMenuManageColumns: t("Manage columns", { ns: "table_component" }),
+          columnMenuShowColumns: t("Show columns", { ns: "table_component" }),
+          columnMenuUnsort: t("Cancel sorting", { ns: "table_component" }),
+          columnMenuSortAsc: t("Sort by ascending", { ns: "table_component" }),
+          columnMenuSortDesc: t("Sort by descending", { ns: "table_component" }),
+          columnHeaderSortIconLabel: t("Sort", { ns: "table_component" }),
+          columnMenuFilter: t("Filter", { ns: "table_component" }),
+          // Тексты панели управления колонками (Manage columns)
+          columnsManagementSearchTitle: t("Search", { ns: "table_component" }),
+          columnsManagementShowHideAllText: t("Show/Hide All", { ns: "table_component" }),
+          columnsManagementReset: t("Reset", { ns: "table_component" }),
+          // Экспорт
+          toolbarExportExcel: t("Export to Excel", { ns: "table_component" }),
+          footerRowSelected: (formattedCount) => {
+            return t("Selected", { ns: "table_component" }) + ": " + formattedCount.toString();
+          }
+        }
+      }
+    ),
+    renderBatchActions && /* @__PURE__ */ jsx29(
+      TableBatchActionBar,
+      {
+        selectedRows,
+        selectedIds: rowSelectionModel,
+        onClearSelection: handleClearSelection,
+        renderBatchActions
+      }
+    ),
+    dialogs
+  ] });
+}
+var TableComponent = forwardRef4(TableComponentInner);
+
+// src/services/index.ts
+var Services = {
+  SessionService: {
+    fetchCompanySessions,
+    trackUserSession,
+    trackUserSessionByRoute,
+    fetchUserSessions,
+    isCurrentSessionValid,
+    groupSessionsByUser,
+    getUserLastSeenAt,
+    getUsersLastSeenMap
+  }
+};
+
 // src/utils/session.events.ts
 var channel = typeof window !== "undefined" ? new BroadcastChannel("session_activity") : null;
 var notifySessionChange = () => {
@@ -3591,6 +8183,7 @@ export {
   Services,
   SupabaseProvider,
   SwitchComponent,
+  TableComponent,
   TablePaginationComponent,
   TextFieldComponent,
   ThemeProvider,
@@ -3622,3 +8215,41 @@ export {
   useTranslationNamespace,
   useUserSettings
 };
+/*! Bundled license information:
+
+react-is/cjs/react-is.production.min.js:
+  (** @license React v16.13.1
+   * react-is.production.min.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+
+react-is/cjs/react-is.development.js:
+  (** @license React v16.13.1
+   * react-is.development.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+
+object-assign/index.js:
+  (*
+  object-assign
+  (c) Sindre Sorhus
+  @license MIT
+  *)
+
+@mui/x-data-grid/index.mjs:
+  (**
+   * @mui/x-data-grid v9.15.0
+   *
+   * @license MIT
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+*/