dynamic-mui 2.0.26 → 2.2.0

package/dist/index-CThMfvtJ.mjs

@@ -0,0 +1,2555 @@
+import { h as oe, c as re, g as ae, u as he, a as N, j as b, _ as y, s as J, P as e, e as ye, w as Be, m as Oe, n as be, b as Ee } from "./index-BhaKvHkU.mjs";
+import * as R from "react";
+import { u as Fe, b as se, A as ge, d as ce, g as xe, c as ze, k as _e, l as He, m as Xe, n as Ge, f as me, e as Ye, C as Ke, h as Ue, i as Ve, j as We } from "./ChartsWrapper-CO5_Z6BD.mjs";
+import { j as w, u as le, a as ue, b as Q, l as Ze, m as Je, f as Qe, s as et, d as ee, n as tt, c as nt } from "./useAxis-SiNBMMWq.mjs";
+import { u as it, C as ot, a as rt, b as at } from "./ChartsGrid-C_HT7qpL.mjs";
+import { H as Te, I as ke, J as st, K as ct, L as Re, M as lt, N as ut, O as de, P as ve, Q as dt, R as ft, z as bt, A as mt, S as pt, B as ht, D as yt, E as Ot, u as gt, C as xt, a as Tt } from "./useChartContainerProps-Bl3hO-r1.mjs";
+import { a as kt } from "./createSelector-B-9FwV16.mjs";
+import { C as Rt } from "./ChartsAxis-CANvBdY9.mjs";
+function vt(t) {
+  return ae("MuiBarElement", t);
+}
+const jt = oe("MuiBarElement", ["root", "highlighted", "faded", "series"]), qt = (t) => {
+  const {
+    classes: i,
+    id: o,
+    isHighlighted: n,
+    isFaded: a
+  } = t, r = {
+    root: ["root", `series-${o}`, n && "highlighted", a && "faded"]
+  };
+  return re(r, vt, i);
+};
+function je() {
+  return Fe("bar");
+}
+function Pt(t, i) {
+  const o = w(t.x, i.x), n = w(t.y, i.y), a = w(t.width, i.width), r = w(t.height, i.height);
+  return (l) => ({
+    x: o(l),
+    y: n(l),
+    width: a(l),
+    height: r(l)
+  });
+}
+function It(t) {
+  const i = {
+    x: t.layout === "vertical" ? t.x : t.xOrigin,
+    y: t.layout === "vertical" ? t.yOrigin : t.y,
+    width: t.layout === "vertical" ? t.width : 0,
+    height: t.layout === "vertical" ? 0 : t.height
+  };
+  return se({
+    x: t.x,
+    y: t.y,
+    width: t.width,
+    height: t.height
+  }, {
+    createInterpolator: Pt,
+    applyProps(o, n) {
+      o.setAttribute("x", n.x.toString()), o.setAttribute("y", n.y.toString()), o.setAttribute("width", n.width.toString()), o.setAttribute("height", n.height.toString());
+    },
+    transformProps: (o) => o,
+    initialProps: i,
+    skip: t.skipAnimation,
+    ref: t.ref
+  });
+}
+function St(t, i) {
+  const o = w(t.x, i.x), n = w(t.y, i.y), a = w(t.width, i.width), r = w(t.height, i.height);
+  return (l) => ({
+    x: o(l),
+    y: n(l),
+    width: a(l),
+    height: r(l)
+  });
+}
+function Lt(t) {
+  const {
+    initialX: i,
+    currentX: o,
+    initialY: n,
+    currentY: a
+  } = t.placement === "outside" ? Mt(t) : $t(t), r = {
+    x: i,
+    y: n,
+    width: t.width,
+    height: t.height
+  }, l = {
+    x: o,
+    y: a,
+    width: t.width,
+    height: t.height
+  };
+  return se(l, {
+    createInterpolator: St,
+    transformProps: (u) => u,
+    applyProps(u, d) {
+      u.setAttribute("x", d.x.toString()), u.setAttribute("y", d.y.toString()), u.setAttribute("width", d.width.toString()), u.setAttribute("height", d.height.toString());
+    },
+    initialProps: r,
+    skip: t.skipAnimation,
+    ref: t.ref
+  });
+}
+const V = 4;
+function $t(t) {
+  return {
+    initialX: t.layout === "vertical" ? t.x + t.width / 2 : t.xOrigin,
+    initialY: t.layout === "vertical" ? t.yOrigin : t.y + t.height / 2,
+    currentX: t.x + t.width / 2,
+    currentY: t.y + t.height / 2
+  };
+}
+function Mt(t) {
+  let i = 0, o = 0, n = 0, a = 0;
+  return t.layout === "vertical" ? (t.y < t.yOrigin ? (i = t.yOrigin - V, o = t.y - V) : (i = t.yOrigin + V, o = t.y + t.height + V), {
+    initialX: t.x + t.width / 2,
+    currentX: t.x + t.width / 2,
+    initialY: i,
+    currentY: o
+  }) : (t.x < t.xOrigin ? (n = t.xOrigin, a = t.x - V) : (n = t.xOrigin, a = t.x + t.width + V), {
+    initialX: n,
+    currentX: a,
+    initialY: t.y + t.height / 2,
+    currentY: t.y + t.height / 2
+  });
+}
+function At(t) {
+  return ae("MuiBarLabel", t);
+}
+const pe = oe("MuiBarLabel", ["root", "highlighted", "faded", "animate"]), Ct = (t) => {
+  const {
+    classes: i,
+    seriesId: o,
+    isFaded: n,
+    isHighlighted: a,
+    skipAnimation: r
+  } = t, l = {
+    root: ["root", `series-${o}`, a && "highlighted", n && "faded", !r && "animate"]
+  };
+  return re(l, At, i);
+};
+function wt(t) {
+  const {
+    barLabel: i,
+    value: o,
+    dataIndex: n,
+    seriesId: a,
+    height: r,
+    width: l
+  } = t;
+  return i === "value" ? o ? o?.toString() : null : i({
+    seriesId: a,
+    dataIndex: n,
+    value: o
+  }, {
+    bar: {
+      height: r,
+      width: l
+    }
+  });
+}
+const Dt = ["seriesId", "dataIndex", "color", "isFaded", "isHighlighted", "classes", "skipAnimation", "layout", "xOrigin", "yOrigin", "placement", "hidden"], Nt = J("text", {
+  name: "MuiBarLabel",
+  slot: "Root",
+  overridesResolver: (t, i) => [{
+    [`&.${pe.faded}`]: i.faded
+  }, {
+    [`&.${pe.highlighted}`]: i.highlighted
+  }, i.root]
+})(({
+  theme: t
+}) => y({}, t?.typography?.body2, {
+  stroke: "none",
+  fill: (t.vars || t)?.palette?.text?.primary,
+  transitionProperty: "opacity, fill",
+  transitionDuration: `${ce}ms`,
+  transitionTimingFunction: ge,
+  pointerEvents: "none"
+}));
+function qe(t) {
+  const i = he({
+    props: t,
+    name: "MuiBarLabel"
+  }), {
+    isFaded: o,
+    hidden: n
+  } = i, a = N(i, Dt), r = Lt(i), l = Bt(i), u = Et(i), d = o ? 0.3 : 1;
+  return /* @__PURE__ */ b.jsx(Nt, y({
+    textAnchor: l,
+    dominantBaseline: u,
+    opacity: n ? 0 : d
+  }, a, r));
+}
+function Bt({
+  placement: t,
+  layout: i,
+  xOrigin: o,
+  x: n
+}) {
+  return t === "outside" && i === "horizontal" ? n < o ? "end" : "start" : "middle";
+}
+function Et({
+  placement: t,
+  layout: i,
+  yOrigin: o,
+  y: n
+}) {
+  return t === "outside" ? i === "horizontal" ? "central" : n < o ? "auto" : "hanging" : "central";
+}
+process.env.NODE_ENV !== "production" && (qe.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  classes: e.object,
+  dataIndex: e.number.isRequired,
+  /**
+   * Height of the bar this label belongs to.
+   */
+  height: e.number.isRequired,
+  /**
+   * If true, the bar label is hidden.
+   */
+  hidden: e.bool,
+  isFaded: e.bool.isRequired,
+  isHighlighted: e.bool.isRequired,
+  layout: e.oneOf(["horizontal", "vertical"]).isRequired,
+  /**
+   * The placement of the bar label.
+   * It controls whether the label is rendered in the center or outside the bar.
+   * @default 'center'
+   */
+  placement: e.oneOf(["center", "outside"]),
+  seriesId: e.oneOfType([e.number, e.string]).isRequired,
+  skipAnimation: e.bool.isRequired,
+  /**
+   * Width of the bar this label belongs to.
+   */
+  width: e.number.isRequired,
+  /**
+   * Position in the x-axis of the bar this label belongs to.
+   */
+  x: e.number.isRequired,
+  /**
+   * The x-coordinate of the stack this bar label belongs to.
+   */
+  xOrigin: e.number.isRequired,
+  /**
+   * Position in the y-axis of the bar this label belongs to.
+   */
+  y: e.number.isRequired,
+  /**
+   * The y-coordinate of the stack this bar label belongs to.
+   */
+  yOrigin: e.number.isRequired
+});
+const Ft = ["seriesId", "classes", "color", "dataIndex", "barLabel", "slots", "slotProps", "xOrigin", "yOrigin", "x", "y", "width", "height", "value", "skipAnimation", "layout", "barLabelPlacement", "hidden"], zt = ["ownerState"];
+function Pe(t) {
+  const {
+    seriesId: i,
+    classes: o,
+    color: n,
+    dataIndex: a,
+    barLabel: r,
+    slots: l,
+    slotProps: u,
+    xOrigin: d,
+    yOrigin: f,
+    x: s,
+    y: c,
+    width: p,
+    height: O,
+    value: h,
+    skipAnimation: T,
+    layout: g,
+    barLabelPlacement: k,
+    hidden: m
+  } = t, q = N(t, Ft), {
+    isFaded: I,
+    isHighlighted: P
+  } = xe({
+    seriesId: i,
+    dataIndex: a
+  }), S = {
+    seriesId: i,
+    classes: o,
+    color: n,
+    isFaded: I,
+    isHighlighted: P,
+    dataIndex: a,
+    skipAnimation: T,
+    layout: g
+  }, $ = Ct(S), v = l?.barLabel ?? qe, A = ye({
+    elementType: v,
+    externalSlotProps: u?.barLabel,
+    additionalProps: y({}, q, {
+      xOrigin: d,
+      yOrigin: f,
+      x: s,
+      y: c,
+      width: p,
+      height: O,
+      placement: k,
+      className: $.root
+    }),
+    ownerState: S
+  }), {
+    ownerState: D
+  } = A, E = N(A, zt);
+  if (!r)
+    return null;
+  const B = wt({
+    barLabel: r,
+    value: h,
+    dataIndex: a,
+    seriesId: i,
+    height: O,
+    width: p
+  });
+  return B ? /* @__PURE__ */ b.jsx(v, y({}, E, D, {
+    hidden: m,
+    children: B
+  })) : null;
+}
+process.env.NODE_ENV !== "production" && (Pe.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * If provided, the function will be used to format the label of the bar.
+   * It can be set to 'value' to display the current value.
+   * @param {BarItem} item The item to format.
+   * @param {BarLabelContext} context data about the bar.
+   * @returns {string} The formatted label.
+   */
+  barLabel: e.oneOfType([e.oneOf(["value"]), e.func]),
+  classes: e.object,
+  color: e.string.isRequired,
+  dataIndex: e.number.isRequired,
+  /**
+   * The height of the bar.
+   */
+  height: e.number.isRequired,
+  seriesId: e.oneOfType([e.number, e.string]).isRequired,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: e.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: e.object,
+  /**
+   * The value of the data point.
+   */
+  value: e.number,
+  /**
+   * The width of the bar.
+   */
+  width: e.number.isRequired
+});
+const _t = ["processedSeries", "className", "skipAnimation"];
+function Ht(t) {
+  const {
+    processedSeries: i,
+    className: o,
+    skipAnimation: n
+  } = t, a = N(t, _t), {
+    seriesId: r,
+    data: l,
+    layout: u,
+    xOrigin: d,
+    yOrigin: f
+  } = i, s = i.barLabel ?? t.barLabel;
+  return s ? /* @__PURE__ */ b.jsx("g", {
+    className: o,
+    "data-series": r,
+    children: l.map(({
+      x: c,
+      y: p,
+      dataIndex: O,
+      color: h,
+      value: T,
+      width: g,
+      height: k,
+      hidden: m
+    }) => /* @__PURE__ */ b.jsx(Pe, y({
+      seriesId: r,
+      dataIndex: O,
+      value: T,
+      color: h,
+      xOrigin: d,
+      yOrigin: f,
+      x: c,
+      y: p,
+      width: g,
+      height: k,
+      skipAnimation: n ?? !1,
+      layout: u ?? "vertical",
+      hidden: m
+    }, a, {
+      barLabel: s,
+      barLabelPlacement: i.barLabelPlacement || "center"
+    }), O))
+  }, r) : null;
+}
+const W = (t, i) => {
+  const o = `${t}-axis`, n = `${t}Axis`;
+  return i === (t === "x" ? Te : ke) ? `The first \`${n}\`` : `The ${o} with id "${i}"`;
+};
+function Xt(t, i, o, n, a, r, l) {
+  const u = a[n], d = l[r], f = t ? u : d, s = t ? d : u, c = t ? n : r, p = t ? r : n, O = t ? "x" : "y", h = t ? "y" : "x";
+  if (f.scaleType !== "band")
+    throw new Error(`MUI X Charts: ${W(O, c)} should be of type "band" to display the bar series of id "${i}".`);
+  if (f.data === void 0)
+    throw new Error(`MUI X Charts: ${W(O, c)} should have data property.`);
+  if (s.scaleType === "band" || s.scaleType === "point")
+    throw new Error(`MUI X Charts: ${W(h, p)} should be a continuous type to display the bar series of id "${i}".`);
+  process.env.NODE_ENV !== "production" && f.data.length < o && Be([`MUI X Charts: ${W(O, c)} has less data (${f.data.length} values) than the bar series of id "${i}" (${o} values).`, "The axis data should have at least the same length than the series using it."], "error");
+}
+function Gt(t, i, o) {
+  const n = je() ?? {
+    series: {},
+    stackingGroups: []
+  }, a = le().xAxisIds[0], r = ue().yAxisIds[0], l = st();
+  return Yt(t, l, n.stackingGroups, n.series, i, o, a, r);
+}
+function Yt(t, i, o, n, a, r, l, u) {
+  const d = {};
+  return {
+    completedData: o.flatMap(({
+      ids: s
+    }, c) => {
+      const p = t.left, O = t.left + t.width, h = t.top, T = t.top + t.height, g = /* @__PURE__ */ new Map(), k = /* @__PURE__ */ new Map();
+      return s.map((m) => {
+        const q = n[m].xAxisId ?? l, I = n[m].yAxisId ?? u, P = n[m].layout, S = a[q], $ = r[I], v = n[m].layout === "vertical", A = (v ? $.reverse : S.reverse) ?? !1;
+        Xt(v, m, n[m].stackedData.length, q, a, I, r);
+        const D = v ? S : $, E = S.scale, B = $.scale, M = Math.round(E(0) ?? 0), _ = Math.round(B(0) ?? 0), H = ct(n[m], a[q], r[I]), X = [];
+        for (let L = 0; L < D.data.length; L += 1) {
+          const Y = Re({
+            verticalLayout: v,
+            xAxisConfig: S,
+            yAxisConfig: $,
+            series: n[m],
+            dataIndex: L,
+            numberOfGroups: o.length,
+            groupIndex: c
+          });
+          if (Y == null)
+            continue;
+          const G = n[m].stack, x = y({
+            seriesId: m,
+            dataIndex: L,
+            hidden: n[m].hidden
+          }, Y, {
+            color: H(L),
+            value: n[m].data[L],
+            maskId: `${i}_${G || m}_${c}_${L}`
+          });
+          if (x.x > O || x.x + x.width < p || x.y > T || x.y + x.height < h)
+            continue;
+          const F = g.get(L), z = k.get(L), K = (A ? -1 : 1) * Math.sign(x.value ?? 0);
+          K > 0 ? (z && delete z.borderRadiusSide, x.borderRadiusSide = v ? "top" : "right", k.set(L, x)) : K < 0 && (F && delete F.borderRadiusSide, x.borderRadiusSide = v ? "bottom" : "left", g.set(L, x)), d[x.maskId] || (d[x.maskId] = {
+            id: x.maskId,
+            width: 0,
+            height: 0,
+            hasNegative: !1,
+            hasPositive: !1,
+            layout: P,
+            xOrigin: M,
+            yOrigin: _,
+            x: 0,
+            y: 0
+          });
+          const j = d[x.maskId];
+          j.width = P === "vertical" ? x.width : j.width + x.width, j.height = P === "vertical" ? j.height + x.height : x.height, j.x = Math.min(j.x === 0 ? 1 / 0 : j.x, x.x), j.y = Math.min(j.y === 0 ? 1 / 0 : j.y, x.y);
+          const U = x.value ?? 0;
+          j.hasNegative = j.hasNegative || (A ? U > 0 : U < 0), j.hasPositive = j.hasPositive || (A ? U < 0 : U > 0), X.push(x);
+        }
+        return {
+          seriesId: m,
+          barLabel: n[m].barLabel,
+          barLabelPlacement: n[m].barLabelPlacement,
+          data: X,
+          layout: P,
+          xOrigin: M,
+          yOrigin: _
+        };
+      });
+    }),
+    masksData: Object.values(d)
+  };
+}
+function Kt(t) {
+  return ae("MuiBar", t);
+}
+const An = oe("MuiBar", ["root", "series", "seriesLabels"]), fe = (t) => re({
+  root: ["root"],
+  series: ["series"],
+  seriesLabels: ["seriesLabels"]
+}, Kt, t), Ut = ["ownerState", "skipAnimation", "id", "dataIndex", "xOrigin", "yOrigin"];
+function Vt(t) {
+  const {
+    ownerState: i
+  } = t, o = N(t, Ut), n = It(t);
+  return /* @__PURE__ */ b.jsx("rect", y({}, o, {
+    filter: i.isHighlighted ? "brightness(120%)" : void 0,
+    opacity: i.isFaded ? 0.3 : 1,
+    "data-highlighted": i.isHighlighted || void 0,
+    "data-faded": i.isFaded || void 0
+  }, n));
+}
+function Wt(t) {
+  return Q().use(lt, t);
+}
+const Zt = ["id", "dataIndex", "classes", "color", "slots", "slotProps", "style", "onClick", "skipAnimation", "layout", "x", "xOrigin", "y", "yOrigin", "width", "height", "hidden"];
+function Ie(t) {
+  const {
+    id: i,
+    dataIndex: o,
+    classes: n,
+    color: a,
+    slots: r,
+    slotProps: l,
+    style: u,
+    onClick: d,
+    skipAnimation: f,
+    layout: s,
+    x: c,
+    xOrigin: p,
+    y: O,
+    yOrigin: h,
+    width: T,
+    height: g,
+    hidden: k
+  } = t, m = N(t, Zt), q = R.useMemo(() => ({
+    type: "bar",
+    seriesId: i,
+    dataIndex: o
+  }), [i, o]), I = ze(q), {
+    isFaded: P,
+    isHighlighted: S
+  } = xe(q), $ = Wt(R.useMemo(() => ({
+    type: "bar",
+    seriesId: i,
+    dataIndex: o
+  }), [i, o])), v = {
+    id: i,
+    dataIndex: o,
+    classes: n,
+    color: a,
+    isFaded: P,
+    isHighlighted: S,
+    isFocused: $
+  }, A = qt(v), D = r?.bar ?? Vt, E = ye({
+    elementType: D,
+    externalSlotProps: l?.bar,
+    externalForwardedProps: m,
+    additionalProps: y({}, I, {
+      id: i,
+      dataIndex: o,
+      color: a,
+      x: c,
+      xOrigin: p,
+      y: O,
+      yOrigin: h,
+      width: T,
+      height: g,
+      style: u,
+      onClick: d,
+      cursor: d ? "pointer" : "unset",
+      stroke: "none",
+      fill: a,
+      skipAnimation: f,
+      layout: s,
+      hidden: k
+    }),
+    className: A.root,
+    ownerState: v
+  });
+  return /* @__PURE__ */ b.jsx(D, y({}, E));
+}
+process.env.NODE_ENV !== "production" && (Ie.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  classes: e.object,
+  dataIndex: e.number.isRequired,
+  id: e.oneOfType([e.number, e.string]).isRequired,
+  layout: e.oneOf(["horizontal", "vertical"]).isRequired,
+  skipAnimation: e.bool.isRequired,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: e.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: e.object,
+  xOrigin: e.number.isRequired,
+  yOrigin: e.number.isRequired
+});
+function Jt(t, i) {
+  const o = w(t.x, i.x), n = w(t.y, i.y), a = w(t.width, i.width), r = w(t.height, i.height), l = w(t.borderRadius, i.borderRadius);
+  return (u) => ({
+    x: o(u),
+    y: n(u),
+    width: a(u),
+    height: r(u),
+    borderRadius: l(u)
+  });
+}
+function Qt(t) {
+  const i = {
+    x: t.layout === "vertical" ? t.x : t.xOrigin,
+    y: t.layout === "vertical" ? t.yOrigin : t.y,
+    width: t.layout === "vertical" ? t.width : 0,
+    height: t.layout === "vertical" ? 0 : t.height,
+    borderRadius: t.borderRadius
+  };
+  return se({
+    x: t.x,
+    y: t.y,
+    width: t.width,
+    height: t.height,
+    borderRadius: t.borderRadius
+  }, {
+    createInterpolator: Jt,
+    transformProps: (o) => ({
+      d: tn(t.hasNegative, t.hasPositive, t.layout, o.x, o.y, o.width, o.height, t.xOrigin, t.yOrigin, o.borderRadius)
+    }),
+    applyProps(o, {
+      d: n
+    }) {
+      n && o.setAttribute("d", n);
+    },
+    initialProps: i,
+    skip: t.skipAnimation,
+    ref: t.ref
+  });
+}
+function en(t) {
+  const {
+    maskId: i,
+    x: o,
+    y: n,
+    width: a,
+    height: r,
+    skipAnimation: l
+  } = t, {
+    ref: u,
+    d
+  } = Qt({
+    layout: t.layout ?? "vertical",
+    hasNegative: t.hasNegative,
+    hasPositive: t.hasPositive,
+    xOrigin: t.xOrigin,
+    yOrigin: t.yOrigin,
+    x: o,
+    y: n,
+    width: a,
+    height: r,
+    borderRadius: t.borderRadius ?? 0,
+    skipAnimation: l
+  });
+  return !t.borderRadius || t.borderRadius <= 0 ? null : /* @__PURE__ */ b.jsx("clipPath", {
+    id: i,
+    children: /* @__PURE__ */ b.jsx("path", {
+      ref: u,
+      d
+    })
+  });
+}
+function tn(t, i, o, n, a, r, l, u, d, f) {
+  if (o === "vertical") {
+    if (i && t) {
+      const c = Math.min(f, r / 2, l / 2);
+      return `M${n},${a + l / 2} v${-(l / 2 - c)} a${c},${c} 0 0 1 ${c},${-c} h${r - c * 2} a${c},${c} 0 0 1 ${c},${c} v${l - 2 * c} a${c},${c} 0 0 1 ${-c},${c} h${-(r - c * 2)} a${c},${c} 0 0 1 ${-c},${-c} v${-(l / 2 - c)}`;
+    }
+    const s = Math.min(f, r / 2);
+    if (i)
+      return `M${n},${Math.max(d, a + s)} v${Math.min(0, -(d - a - s))} a${s},${s} 0 0 1 ${s},${-s} h${r - s * 2} a${s},${s} 0 0 1 ${s},${s} v${Math.max(0, d - a - s)} Z`;
+    if (t)
+      return `M${n},${Math.min(d, a + l - s)} v${Math.max(0, l - s)} a${s},${s} 0 0 0 ${s},${s} h${r - s * 2} a${s},${s} 0 0 0 ${s},${-s} v${-Math.max(0, l - s)} Z`;
+  }
+  if (o === "horizontal") {
+    if (i && t) {
+      const c = Math.min(f, r / 2, l / 2);
+      return `M${n + r / 2},${a} h${r / 2 - c} a${c},${c} 0 0 1 ${c},${c} v${l - c * 2} a${c},${c} 0 0 1 ${-c},${c} h${-(r - 2 * c)} a${c},${c} 0 0 1 ${-c},${-c} v${-(l - c * 2)} a${c},${c} 0 0 1 ${c},${-c} h${r / 2 - c}`;
+    }
+    const s = Math.min(f, l / 2);
+    if (i)
+      return `M${Math.min(u, n - s)},${a} h${r} a${s},${s} 0 0 1 ${s},${s} v${l - s * 2} a${s},${s} 0 0 1 ${-s},${s} h${-r} Z`;
+    if (t)
+      return `M${Math.max(u, n + r + s)},${a} h${-r} a${s},${s} 0 0 0 ${-s},${s} v${l - s * 2} a${s},${s} 0 0 0 ${s},${s} h${r} Z`;
+  }
+}
+const nn = ["completedData", "masksData", "borderRadius", "onItemClick", "skipAnimation"];
+function on(t) {
+  let {
+    completedData: i,
+    masksData: o,
+    borderRadius: n,
+    onItemClick: a,
+    skipAnimation: r
+  } = t, l = N(t, nn);
+  const u = fe(), d = !n || n <= 0;
+  return /* @__PURE__ */ b.jsxs(R.Fragment, {
+    children: [!d && o.map(({
+      id: f,
+      x: s,
+      y: c,
+      xOrigin: p,
+      yOrigin: O,
+      width: h,
+      height: T,
+      hasPositive: g,
+      hasNegative: k,
+      layout: m
+    }) => /* @__PURE__ */ b.jsx(en, {
+      maskId: f,
+      borderRadius: n,
+      hasNegative: k,
+      hasPositive: g,
+      layout: m,
+      x: s,
+      y: c,
+      xOrigin: p,
+      yOrigin: O,
+      width: h,
+      height: T,
+      skipAnimation: r ?? !1
+    }, f)), i.map(({
+      seriesId: f,
+      layout: s,
+      xOrigin: c,
+      yOrigin: p,
+      data: O
+    }) => /* @__PURE__ */ b.jsx("g", {
+      "data-series": f,
+      className: u.series,
+      children: O.map(({
+        dataIndex: h,
+        color: T,
+        maskId: g,
+        x: k,
+        y: m,
+        width: q,
+        height: I
+      }) => {
+        const P = /* @__PURE__ */ b.jsx(Ie, y({
+          id: f,
+          dataIndex: h,
+          color: T,
+          skipAnimation: r ?? !1,
+          layout: s ?? "vertical",
+          x: k,
+          xOrigin: c,
+          y: m,
+          yOrigin: p,
+          width: q,
+          height: I
+        }, l, {
+          onClick: a && ((S) => {
+            a(S, {
+              type: "bar",
+              seriesId: f,
+              dataIndex: h
+            });
+          })
+        }), h);
+        return d ? P : /* @__PURE__ */ b.jsx("g", {
+          clipPath: `url(#${g})`,
+          children: P
+        }, h);
+      })
+    }, f))]
+  });
+}
+function rn(t, i) {
+  return t.bandwidth() === 0 ? Math.floor((i - Math.min(...t.range()) + t.step() / 2) / t.step()) : Math.floor((i - Math.min(...t.range())) / t.step());
+}
+const Se = kt(et, Qe, Je, function({
+  axis: i,
+  axisIds: o
+}, {
+  axis: n,
+  axisIds: a
+}, r, l) {
+  const {
+    series: u,
+    stackingGroups: d = []
+  } = r?.bar ?? {}, f = o[0], s = a[0];
+  let c;
+  for (let p = 0; p < d.length; p += 1) {
+    const h = d[p].ids;
+    for (const T of h) {
+      const g = (u ?? {})[T], k = g.xAxisId ?? f, m = g.yAxisId ?? s, q = i[k], I = n[m], P = g.layout === "horizontal" ? I : q, S = g.layout === "horizontal" ? q : I, $ = P.scale, v = g.layout === "horizontal" ? l.y : l.x;
+      if (!Ze($))
+        continue;
+      const A = rn($, v), {
+        barWidth: D,
+        offset: E
+      } = ut($.bandwidth(), d.length, P.barGapRatio), B = p * (D + E), M = P.data?.[A];
+      if (M == null)
+        continue;
+      const _ = $(M);
+      if (_ == null)
+        continue;
+      const H = _ + B, X = H + D, L = Math.min(H, X), Y = Math.max(H, X);
+      if (v >= L && v <= Y) {
+        const G = g.layout === "horizontal" ? l.x : l.y, x = g.visibleStackedData[A], F = S.scale(x[0]), z = S.scale(x[1]);
+        if (F == null || z == null)
+          continue;
+        const K = Math.min(F, z), j = Math.max(F, z);
+        G >= K && G <= j && (c = {
+          seriesId: T,
+          dataIndex: A
+        });
+      }
+    }
+  }
+  if (c)
+    return {
+      type: "bar",
+      seriesId: c.seriesId,
+      dataIndex: c.dataIndex
+    };
+});
+function an(t) {
+  const {
+    instance: i
+  } = ee(), o = de(), n = Q();
+  R.useEffect(() => {
+    const a = o.current;
+    if (!a || !t)
+      return;
+    let r = null;
+    const l = function(f) {
+      let s = f;
+      r && Math.abs(f.clientX - r.clientX) <= 1 && Math.abs(f.clientY - r.clientY) <= 1 && (s = {
+        clientX: r.clientX,
+        clientY: r.clientY
+      }), r = null;
+      const c = ve(a, s);
+      if (!i.isPointInside(c.x, c.y))
+        return;
+      const p = Se(n.state, c);
+      p && t(f, {
+        type: "bar",
+        seriesId: p.seriesId,
+        dataIndex: p.dataIndex
+      });
+    }, u = function(f) {
+      r = f;
+    };
+    return a.addEventListener("click", l), a.addEventListener("pointerup", u), () => {
+      a.removeEventListener("click", l), a.removeEventListener("pointerup", u);
+    };
+  }, [i, t, n, o]);
+}
+function ne(t, i, o) {
+  let n = t.get(i);
+  return n ? n.push(o) : (n = [o], t.set(i, n)), n;
+}
+const sn = 1e3;
+function cn(t, i, o, n, a, r, l, u) {
+  const d = Math.min(a, o / 2, n / 2), f = Math.min(r, o / 2, n / 2), s = Math.min(l, o / 2, n / 2), c = Math.min(u, o / 2, n / 2);
+  return `M${t + d},${i}
+   h${o - d - f}
+   a${f},${f} 0 0 1 ${f},${f}
+   v${n - f - s}
+   a${s},${s} 0 0 1 -${s},${s}
+   h-${o - s - c}
+   a${c},${c} 0 0 1 -${c},-${c}
+   v-${n - c - d}
+   a${d},${d} 0 0 1 ${d},-${d}
+   Z`;
+}
+function ie(t, i) {
+  return cn(t.x, t.y, t.width, t.height, t.borderRadiusSide === "left" || t.borderRadiusSide === "top" ? i : 0, t.borderRadiusSide === "right" || t.borderRadiusSide === "top" ? i : 0, t.borderRadiusSide === "right" || t.borderRadiusSide === "bottom" ? i : 0, t.borderRadiusSide === "left" || t.borderRadiusSide === "bottom" ? i : 0);
+}
+function ln(t, i) {
+  const o = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
+  for (let a = 0; a < t.data.length; a += 1) {
+    const r = t.data[a], l = ie(r, i), u = ne(n, r.color, l);
+    u.length >= sn && (ne(o, r.color, u.join("")), n.delete(r.color));
+  }
+  for (const [a, r] of n.entries())
+    r.length > 0 && ne(o, a, r.join(""));
+  return o;
+}
+const un = ["skipAnimation", "layout", "xOrigin", "yOrigin"], dn = ["children", "layout", "xOrigin", "yOrigin"], Le = J("g")({
+  '&[data-faded="true"]': {
+    opacity: 0.3
+  },
+  "& path": {
+    /* The browser must do hit testing to know which element a pointer is interacting with.
+     * With many data points, we create many paths causing significant time to be spent in the hit test phase.
+     * To fix this issue, we disable pointer events for the descendant paths.
+     *
+     * Ideally, users should be able to override this in case they need pointer events to be enabled,
+     * but it can affect performance negatively, especially with many data points. */
+    pointerEvents: "none"
+  }
+});
+function fn(t) {
+  let {
+    skipAnimation: i,
+    layout: o,
+    xOrigin: n,
+    yOrigin: a
+  } = t, r = N(t, un);
+  return i ? /* @__PURE__ */ b.jsx(Le, y({}, r)) : /* @__PURE__ */ b.jsx(bn, y({}, r, {
+    layout: o,
+    xOrigin: n,
+    yOrigin: a
+  }));
+}
+const Z = J("rect")({
+  "@keyframes scaleInX": {
+    from: {
+      transform: "scaleX(0)"
+    },
+    to: {
+      transform: "scaleX(1)"
+    }
+  },
+  "@keyframes scaleInY": {
+    from: {
+      transform: "scaleY(0)"
+    },
+    to: {
+      transform: "scaleY(1)"
+    }
+  },
+  animationDuration: `${ce}ms`,
+  animationFillMode: "forwards",
+  '&[data-orientation="horizontal"]': {
+    animationName: "scaleInX"
+  },
+  '&[data-orientation="vertical"]': {
+    animationName: "scaleInY"
+  }
+});
+function bn(t) {
+  let {
+    children: i,
+    layout: o,
+    xOrigin: n,
+    yOrigin: a
+  } = t, r = N(t, dn);
+  const u = Q().use(tt), d = Oe(), f = [];
+  return o === "horizontal" ? (f.push(/* @__PURE__ */ b.jsx(Z, {
+    "data-orientation": "horizontal",
+    x: u.left,
+    width: n - u.left,
+    y: u.top,
+    height: u.height,
+    style: {
+      transformOrigin: `${n}px ${u.top + u.height / 2}px`
+    }
+  }, "left")), f.push(/* @__PURE__ */ b.jsx(Z, {
+    "data-orientation": "horizontal",
+    x: n,
+    width: u.left + u.width - n,
+    y: u.top,
+    height: u.height,
+    style: {
+      transformOrigin: `${n}px ${u.top + u.height / 2}px`
+    }
+  }, "right"))) : (f.push(/* @__PURE__ */ b.jsx(Z, {
+    "data-orientation": "vertical",
+    x: u.left,
+    width: u.width,
+    y: u.top,
+    height: a - u.top,
+    style: {
+      transformOrigin: `${u.left + u.width / 2}px ${a}px`
+    }
+  }, "top")), f.push(/* @__PURE__ */ b.jsx(Z, {
+    "data-orientation": "vertical",
+    x: u.left,
+    width: u.width,
+    y: a,
+    height: u.top + u.height - a,
+    style: {
+      transformOrigin: `${u.left + u.width / 2}px ${a}px`
+    }
+  }, "bottom"))), /* @__PURE__ */ b.jsxs(R.Fragment, {
+    children: [/* @__PURE__ */ b.jsx("clipPath", {
+      id: d,
+      children: f
+    }), /* @__PURE__ */ b.jsx(Le, y({
+      clipPath: `url(#${d})`
+    }, r, {
+      children: i
+    }))]
+  });
+}
+function mn(t, i, o) {
+  const {
+    instance: n
+  } = ee(), a = de(), r = Q(), l = R.useRef(!1), u = R.useRef(void 0), d = be(() => i?.()), f = be(() => o?.());
+  R.useEffect(() => {
+    const s = a.current;
+    if (!s)
+      return;
+    function c() {
+      l.current = !0;
+    }
+    function p() {
+      const T = u.current;
+      T && (u.current = void 0, n.removeTooltipItem(T), n.clearHighlight(), f());
+    }
+    function O() {
+      l.current = !1, p();
+    }
+    const h = function(g) {
+      const k = ve(s, g);
+      if (!n.isPointInside(k.x, k.y)) {
+        p();
+        return;
+      }
+      const m = t(r.state, k);
+      m ? (n.setLastUpdateSource("pointer"), n.setTooltipItem(m), n.setHighlight(m), d(), u.current = m) : p();
+    };
+    return s.addEventListener("pointerleave", O), s.addEventListener("pointermove", h), s.addEventListener("pointerenter", c), () => {
+      s.removeEventListener("pointerenter", c), s.removeEventListener("pointermove", h), s.removeEventListener("pointerleave", O), l.current && O();
+    };
+  }, [t, n, d, f, r, a]);
+}
+function pn({
+  completedData: t,
+  borderRadius: i = 0,
+  onItemClick: o,
+  skipAnimation: n = !1
+}) {
+  const a = R.useRef(null), r = de();
+  return mn(Se, o ? () => {
+    const d = r.current;
+    d && a.current == null && (a.current = d.style.cursor, d.style.cursor = "pointer");
+  } : void 0, o ? () => {
+    const d = r.current;
+    d && a.current != null && (d.style.cursor = a.current, a.current = null);
+  } : void 0), an(o), /* @__PURE__ */ b.jsx(R.Fragment, {
+    children: t.map((d) => /* @__PURE__ */ b.jsx(hn, {
+      series: d,
+      borderRadius: i,
+      skipAnimation: n
+    }, d.seriesId))
+  });
+}
+const $e = /* @__PURE__ */ R.memo(On);
+process.env.NODE_ENV !== "production" && ($e.displayName = "MemoFadedHighlightedBars");
+function hn({
+  series: t,
+  borderRadius: i,
+  skipAnimation: o
+}) {
+  const n = fe(), {
+    store: a
+  } = ee(), r = a.use(_e, t.seriesId), l = a.use(He, t.seriesId);
+  return /* @__PURE__ */ b.jsxs(R.Fragment, {
+    children: [/* @__PURE__ */ b.jsx(fn, {
+      className: n.series,
+      "data-series": t.seriesId,
+      layout: t.layout,
+      xOrigin: t.xOrigin,
+      yOrigin: t.yOrigin,
+      skipAnimation: o,
+      "data-faded": l || void 0,
+      "data-highlighted": r || void 0,
+      children: /* @__PURE__ */ b.jsx(yn, {
+        processedSeries: t,
+        borderRadius: i
+      })
+    }), /* @__PURE__ */ b.jsx($e, {
+      processedSeries: t,
+      borderRadius: i
+    })]
+  });
+}
+function yn({
+  processedSeries: t,
+  borderRadius: i
+}) {
+  const o = ln(t, i), n = [];
+  let a = 0;
+  for (const [r, l] of o.entries())
+    for (const u of l)
+      n.push(/* @__PURE__ */ b.jsx("path", {
+        fill: r,
+        d: u
+      }, a)), a += 1;
+  return /* @__PURE__ */ b.jsx(R.Fragment, {
+    children: n
+  });
+}
+function On({
+  processedSeries: t,
+  borderRadius: i
+}) {
+  const {
+    store: o
+  } = ee(), n = o.use(Xe, t.seriesId), a = o.use(Ge, t.seriesId), r = n != null && t.data.find((d) => d.dataIndex === n) || null, l = a != null && t.data.find((d) => d.dataIndex === a) || null, u = [];
+  return r != null && u.push(/* @__PURE__ */ b.jsx("path", {
+    fill: r.color,
+    filter: "brightness(120%)",
+    "data-highlighted": !0,
+    d: ie(r, i)
+  }, `highlighted-${t.seriesId}`)), l != null && u.push(/* @__PURE__ */ b.jsx("path", {
+    fill: l.color,
+    d: ie(l, i)
+  }, `unfaded-${l.seriesId}`)), /* @__PURE__ */ b.jsx(R.Fragment, {
+    children: u
+  });
+}
+const gn = ["skipAnimation", "onItemClick", "borderRadius", "barLabel", "renderer"], xn = J("g", {
+  name: "MuiBarPlot",
+  slot: "Root"
+})({
+  [`& .${jt.root}`]: {
+    transitionProperty: "opacity, fill",
+    transitionDuration: `${ce}ms`,
+    transitionTimingFunction: ge
+  }
+});
+function Me(t) {
+  const {
+    skipAnimation: i,
+    onItemClick: o,
+    borderRadius: n,
+    barLabel: a,
+    renderer: r
+  } = t, l = N(t, gn), u = it(), d = me(u || i), f = me(i), {
+    xAxis: s
+  } = le(), {
+    yAxis: c
+  } = ue(), {
+    completedData: p,
+    masksData: O
+  } = Gt(nt(), s, c), h = fe(), T = r === "svg-batch" ? pn : on;
+  return /* @__PURE__ */ b.jsxs(xn, {
+    className: h.root,
+    children: [/* @__PURE__ */ b.jsx(T, y({
+      completedData: p,
+      masksData: O,
+      skipAnimation: r === "svg-batch" ? f : d,
+      onItemClick: (
+        /* `onItemClick` accepts a `MouseEvent` when the renderer is "svg-batch" and a `React.MouseEvent` otherwise,
+         * so we need this cast to prevent TypeScript from complaining. */
+        o
+      ),
+      borderRadius: n
+    }, l)), p.map((g) => /* @__PURE__ */ b.jsx(Ht, y({
+      className: h.seriesLabels,
+      processedSeries: g,
+      skipAnimation: d,
+      barLabel: a
+    }, l), g.seriesId))]
+  });
+}
+process.env.NODE_ENV !== "production" && (Me.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  /**
+   * @deprecated Use `barLabel` in the chart series instead.
+   * If provided, the function will be used to format the label of the bar.
+   * It can be set to 'value' to display the current value.
+   * @param {BarItem} item The item to format.
+   * @param {BarLabelContext} context data about the bar.
+   * @returns {string} The formatted label.
+   */
+  barLabel: e.oneOfType([e.oneOf(["value"]), e.func]),
+  /**
+   * Defines the border radius of the bar element.
+   */
+  borderRadius: e.number,
+  /**
+   * Callback fired when a bar item is clicked.
+   * @param {React.MouseEvent<SVGElement, MouseEvent>} event The event source of the callback.
+   * @param {BarItemIdentifier} barItemIdentifier The bar item identifier.
+   */
+  onItemClick: e.func,
+  /**
+   * The type of renderer to use for the bar plot.
+   * - `svg-single`: Renders every bar in a `<rect />` element.
+   * - `svg-batch`: Batch renders bars in `<path />` elements for better performance with large datasets, at the cost of some limitations.
+   *                Read more: https://mui.com/x/react-charts/bars/#performance
+   *
+   * @default 'svg-single'
+   */
+  renderer: e.oneOf(["svg-batch", "svg-single"]),
+  /**
+   * If `true`, animations are skipped.
+   * @default undefined
+   */
+  skipAnimation: e.bool,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: e.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: e.object
+});
+const Tn = [dt, ft, bt, mt, pt, ht, yt, Ot], kn = ["xAxis", "yAxis", "series", "width", "height", "margin", "colors", "dataset", "sx", "axisHighlight", "grid", "children", "slots", "slotProps", "skipAnimation", "loading", "layout", "onItemClick", "highlightedItem", "onHighlightChange", "borderRadius", "barLabel", "className", "hideLegend", "showToolbar", "brushConfig", "renderer"], Rn = (t) => {
+  const {
+    xAxis: i,
+    yAxis: o,
+    series: n,
+    width: a,
+    height: r,
+    margin: l,
+    colors: u,
+    dataset: d,
+    sx: f,
+    axisHighlight: s,
+    grid: c,
+    children: p,
+    slots: O,
+    slotProps: h,
+    skipAnimation: T,
+    loading: g,
+    layout: k,
+    onItemClick: m,
+    highlightedItem: q,
+    onHighlightChange: I,
+    borderRadius: P,
+    barLabel: S,
+    className: $,
+    brushConfig: v,
+    renderer: A
+  } = t, D = N(t, kn), B = `${Oe()}-clip-path`, M = k === "horizontal" || k === void 0 && n.some((C) => C.layout === "horizontal"), _ = R.useMemo(() => [{
+    id: Te,
+    scaleType: "band",
+    data: Array.from({
+      length: Math.max(...n.map((C) => (C.data ?? d ?? []).length))
+    }, (C, te) => te)
+  }], [d, n]), H = R.useMemo(() => [{
+    id: ke,
+    scaleType: "band",
+    data: Array.from({
+      length: Math.max(...n.map((C) => (C.data ?? d ?? []).length))
+    }, (C, te) => te)
+  }], [d, n]), X = R.useMemo(() => n.map((C) => y({
+    type: "bar"
+  }, C, {
+    layout: M ? "horizontal" : "vertical"
+  })), [M, n]), L = M ? void 0 : _, Y = R.useMemo(() => i ? M ? i : i.map((C) => y({
+    scaleType: "band"
+  }, C)) : L, [L, M, i]), G = M ? H : void 0, x = R.useMemo(() => o ? M ? o.map((C) => y({
+    scaleType: "band"
+  }, C)) : o : G, [G, M, o]), F = y({}, D, {
+    series: X,
+    width: a,
+    height: r,
+    margin: l,
+    colors: u,
+    dataset: d,
+    xAxis: Y,
+    yAxis: x,
+    highlightedItem: q,
+    onHighlightChange: I,
+    disableAxisListener: h?.tooltip?.trigger !== "axis" && s?.x === "none" && s?.y === "none",
+    className: $,
+    skipAnimation: T,
+    brushConfig: v,
+    plugins: Tn
+  }), z = {
+    onItemClick: m,
+    slots: O,
+    slotProps: h,
+    borderRadius: P,
+    renderer: A,
+    barLabel: S
+  }, K = {
+    vertical: c?.vertical,
+    horizontal: c?.horizontal
+  }, j = {
+    clipPath: `url(#${B})`
+  }, U = {
+    id: B
+  }, Ce = {
+    slots: O,
+    slotProps: h,
+    loading: g
+  }, we = {
+    slots: O,
+    slotProps: h
+  }, De = y({}, M ? {
+    y: "band"
+  } : {
+    x: "band"
+  }, s), Ne = {
+    slots: O,
+    slotProps: h
+  };
+  return {
+    chartsWrapperProps: {
+      sx: f,
+      legendPosition: t.slotProps?.legend?.position,
+      legendDirection: t.slotProps?.legend?.direction,
+      hideLegend: t.hideLegend ?? !1
+    },
+    chartContainerProps: F,
+    barPlotProps: z,
+    gridProps: K,
+    clipPathProps: U,
+    clipPathGroupProps: j,
+    overlayProps: Ce,
+    chartsAxisProps: we,
+    axisHighlightProps: De,
+    legendProps: Ne,
+    children: p
+  };
+};
+function vn(t) {
+  const i = Ee(), o = Ye(), n = je(), {
+    xAxis: a,
+    xAxisIds: r
+  } = le(), {
+    yAxis: l,
+    yAxisIds: u
+  } = ue();
+  if (o === null || o.type !== "bar" || !n)
+    return null;
+  const d = n.series[o.seriesId];
+  if (d.data[o.dataIndex] == null)
+    return null;
+  const f = d.xAxisId ?? r[0], s = d.yAxisId ?? u[0], c = a[f], p = l[s], O = n.series[o.seriesId].layout === "vertical", h = n.stackingGroups.findIndex((I) => I.ids.includes(o.seriesId)), T = Re({
+    verticalLayout: O,
+    xAxisConfig: c,
+    yAxisConfig: p,
+    series: d,
+    dataIndex: o.dataIndex,
+    numberOfGroups: n.stackingGroups.length,
+    groupIndex: h
+  });
+  if (T === null)
+    return null;
+  const {
+    x: g,
+    y: k,
+    height: m,
+    width: q
+  } = T;
+  return /* @__PURE__ */ b.jsx("rect", y({
+    fill: "none",
+    stroke: (i.vars ?? i).palette.text.primary,
+    strokeWidth: 2,
+    x: g - 3,
+    y: k - 3,
+    width: q + 6,
+    height: m + 6,
+    rx: 3,
+    ry: 3
+  }, t));
+}
+const Ae = /* @__PURE__ */ R.forwardRef(function(i, o) {
+  const n = he({
+    props: i,
+    name: "MuiBarChart"
+  }), {
+    chartsWrapperProps: a,
+    chartContainerProps: r,
+    barPlotProps: l,
+    gridProps: u,
+    clipPathProps: d,
+    clipPathGroupProps: f,
+    overlayProps: s,
+    chartsAxisProps: c,
+    axisHighlightProps: p,
+    legendProps: O,
+    children: h
+  } = Rn(n), {
+    chartDataProviderProps: T,
+    chartsSurfaceProps: g
+  } = gt(r, o), k = n.slots?.tooltip ?? Ke, m = n.slots?.toolbar;
+  return /* @__PURE__ */ b.jsx(xt, y({}, T, {
+    children: /* @__PURE__ */ b.jsxs(Ue, y({}, a, {
+      children: [n.showToolbar && m ? /* @__PURE__ */ b.jsx(m, y({}, n.slotProps?.toolbar)) : null, !n.hideLegend && /* @__PURE__ */ b.jsx(Ve, y({}, O)), /* @__PURE__ */ b.jsxs(Tt, y({}, g, {
+        children: [/* @__PURE__ */ b.jsx(ot, y({}, u)), /* @__PURE__ */ b.jsxs("g", y({}, f, {
+          children: [/* @__PURE__ */ b.jsx(Me, y({}, l)), /* @__PURE__ */ b.jsx(We, y({}, s)), /* @__PURE__ */ b.jsx(rt, y({}, p)), /* @__PURE__ */ b.jsx(vn, {})]
+        })), /* @__PURE__ */ b.jsx(Rt, y({}, c)), /* @__PURE__ */ b.jsx(at, y({}, d)), h]
+      })), !n.loading && /* @__PURE__ */ b.jsx(k, y({}, n.slotProps?.tooltip))]
+    }))
+  }));
+});
+process.env.NODE_ENV !== "production" && (Ae.displayName = "BarChart");
+process.env.NODE_ENV !== "production" && (Ae.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // | To update them edit the TypeScript types and run "pnpm proptypes"  |
+  // ----------------------------------------------------------------------
+  apiRef: e.shape({
+    current: e.object
+  }),
+  /**
+   * The configuration of axes highlight.
+   * Default is set to 'band' in the bar direction.
+   * Depends on `layout` prop.
+   * @see See {@link https://mui.com/x/react-charts/highlighting/ highlighting docs} for more details.
+   */
+  axisHighlight: e.shape({
+    x: e.oneOf(["band", "line", "none"]),
+    y: e.oneOf(["band", "line", "none"])
+  }),
+  /**
+   * @deprecated Use `barLabel` in the chart series instead.
+   * If provided, the function will be used to format the label of the bar.
+   * It can be set to 'value' to display the current value.
+   * @param {BarItem} item The item to format.
+   * @param {BarLabelContext} context data about the bar.
+   * @returns {string} The formatted label.
+   */
+  barLabel: e.oneOfType([e.oneOf(["value"]), e.func]),
+  /**
+   * Defines the border radius of the bar element.
+   */
+  borderRadius: e.number,
+  /**
+   * Configuration for the brush interaction.
+   */
+  brushConfig: e.shape({
+    enabled: e.bool,
+    preventHighlight: e.bool,
+    preventTooltip: e.bool
+  }),
+  children: e.node,
+  className: e.string,
+  /**
+   * Color palette used to colorize multiple series.
+   * @default rainbowSurgePalette
+   */
+  colors: e.oneOfType([e.arrayOf(e.string), e.func]),
+  /**
+   * An array of objects that can be used to populate series and axes data using their `dataKey` property.
+   */
+  dataset: e.arrayOf(e.object),
+  desc: e.string,
+  /**
+   * If `true`, the charts will not listen to the mouse move event.
+   * It might break interactive features, but will improve performance.
+   * @default false
+   */
+  disableAxisListener: e.bool,
+  enableKeyboardNavigation: e.bool,
+  /**
+   * Option to display a cartesian grid in the background.
+   */
+  grid: e.shape({
+    horizontal: e.bool,
+    vertical: e.bool
+  }),
+  /**
+   * The height of the chart in px. If not defined, it takes the height of the parent element.
+   */
+  height: e.number,
+  /**
+   * List of hidden series and/or items.
+   *
+   * Different chart types use different keys.
+   *
+   * @example
+   * ```ts
+   * [
+   *   {
+   *     type: 'pie',
+   *     seriesId: 'series-1',
+   *     dataIndex: 3,
+   *   },
+   *   {
+   *     type: 'line',
+   *     seriesId: 'series-2',
+   *   }
+   * ]
+   * ```
+   */
+  hiddenItems: e.arrayOf(e.shape({
+    dataIndex: e.number,
+    seriesId: e.oneOfType([e.number, e.string]),
+    type: e.oneOf(["bar"]).isRequired
+  })),
+  /**
+   * If `true`, the legend is not rendered.
+   */
+  hideLegend: e.bool,
+  /**
+   * The controlled axis highlight.
+   * Identified by the axis id, and data index.
+   */
+  highlightedAxis: e.arrayOf(e.shape({
+    axisId: e.oneOfType([e.number, e.string]).isRequired,
+    dataIndex: e.number.isRequired
+  })),
+  /**
+   * The highlighted item.
+   * Used when the highlight is controlled.
+   */
+  highlightedItem: e.shape({
+    dataIndex: e.number,
+    seriesId: e.oneOfType([e.number, e.string]).isRequired
+  }),
+  /**
+   * This prop is used to help implement the accessibility logic.
+   * If you don't provide this prop. It falls back to a randomly generated id.
+   */
+  id: e.string,
+  /**
+   * List of initially hidden series and/or items.
+   * Used for uncontrolled state.
+   *
+   * Different chart types use different keys.
+   *
+   * @example
+   * ```ts
+   * [
+   *   {
+   *     type: 'pie',
+   *     seriesId: 'series-1',
+   *     dataIndex: 3,
+   *   },
+   *   {
+   *     type: 'line',
+   *     seriesId: 'series-2',
+   *   }
+   * ]
+   * ```
+   */
+  initialHiddenItems: e.arrayOf(e.shape({
+    dataIndex: e.number,
+    seriesId: e.oneOfType([e.number, e.string]),
+    type: e.oneOf(["bar"]).isRequired
+  })),
+  /**
+   * The direction of the bar elements.
+   * @default 'vertical'
+   */
+  layout: e.oneOf(["horizontal", "vertical"]),
+  /**
+   * If `true`, a loading overlay is displayed.
+   * @default false
+   */
+  loading: e.bool,
+  /**
+   * Localized text for chart components.
+   */
+  localeText: e.object,
+  /**
+   * The margin between the SVG and the drawing area.
+   * It's used for leaving some space for extra information such as the x- and y-axis or legend.
+   *
+   * Accepts a `number` to be used on all sides or an object with the optional properties: `top`, `bottom`, `left`, and `right`.
+   */
+  margin: e.oneOfType([e.number, e.shape({
+    bottom: e.number,
+    left: e.number,
+    right: e.number,
+    top: e.number
+  })]),
+  /**
+   * The function called for onClick events.
+   * The second argument contains information about all line/bar elements at the current mouse position.
+   * @param {MouseEvent} event The mouse event recorded on the `<svg/>` element.
+   * @param {null | ChartsAxisData} data The data about the clicked axis and items associated with it.
+   */
+  onAxisClick: e.func,
+  /**
+   * Callback fired when any hidden identifiers change.
+   * @param {VisibilityIdentifier[]} hiddenItems The new list of hidden identifiers.
+   */
+  onHiddenItemsChange: e.func,
+  /**
+   * The callback fired when the highlighted item changes.
+   *
+   * @param {HighlightItemData | null} highlightedItem  The newly highlighted item.
+   */
+  onHighlightChange: e.func,
+  /**
+   * The function called when the pointer position corresponds to a new axis data item.
+   * This update can either be caused by a pointer movement, or an axis update.
+   * In case of multiple axes, the function is called if at least one axis is updated.
+   * The argument contains the identifier for all axes with a `data` property.
+   * @param {AxisItemIdentifier[]} axisItems The array of axes item identifiers.
+   */
+  onHighlightedAxisChange: e.func,
+  /**
+   * Callback fired when a bar item is clicked.
+   * @param {React.MouseEvent<SVGElement, MouseEvent>} event The event source of the callback.
+   * @param {BarItemIdentifier} barItemIdentifier The bar item identifier.
+   */
+  onItemClick: e.func,
+  /**
+   * The callback fired when the tooltip item changes.
+   *
+   * @param {SeriesItemIdentifier<TSeries> | null} tooltipItem  The newly highlighted item.
+   */
+  onTooltipItemChange: e.func,
+  /**
+   * The type of renderer to use for the bar plot.
+   * - `svg-single`: Renders every bar in a `<rect />` element.
+   * - `svg-batch`: Batch renders bars in `<path />` elements for better performance with large datasets, at the cost of some limitations.
+   *                Read more: https://mui.com/x/react-charts/bars/#performance
+   *
+   * @default 'svg-single'
+   */
+  renderer: e.oneOf(["svg-batch", "svg-single"]),
+  /**
+   * The series to display in the bar chart.
+   * An array of [[BarSeries]] objects.
+   */
+  series: e.arrayOf(e.object).isRequired,
+  /**
+   * If true, shows the default chart toolbar.
+   * @default false
+   */
+  showToolbar: e.bool,
+  /**
+   * If `true`, animations are skipped.
+   * If unset or `false`, the animations respects the user's `prefers-reduced-motion` setting.
+   */
+  skipAnimation: e.bool,
+  /**
+   * The props used for each component slot.
+   * @default {}
+   */
+  slotProps: e.object,
+  /**
+   * Overridable component slots.
+   * @default {}
+   */
+  slots: e.object,
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  theme: e.oneOf(["dark", "light"]),
+  title: e.string,
+  /**
+   * The tooltip item.
+   * Used when the tooltip is controlled.
+   */
+  tooltipItem: e.shape({
+    dataIndex: e.number.isRequired,
+    seriesId: e.oneOfType([e.number, e.string]).isRequired,
+    type: e.oneOf(["bar"]).isRequired
+  }),
+  /**
+   * The width of the chart in px. If not defined, it takes the width of the parent element.
+   */
+  width: e.number,
+  /**
+   * The configuration of the x-axes.
+   * If not provided, a default axis config is used.
+   * An array of [[AxisConfig]] objects.
+   */
+  xAxis: e.arrayOf(e.oneOfType([e.shape({
+    axis: e.oneOf(["x"]),
+    barGapRatio: e.number,
+    categoryGapRatio: e.number,
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      type: e.oneOf(["ordinal"]).isRequired,
+      unknownColor: e.string,
+      values: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number, e.string]).isRequired)
+    }), e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    groups: e.arrayOf(e.shape({
+      getValue: e.func.isRequired,
+      tickLabelStyle: e.object,
+      tickSize: e.number
+    })),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    offset: e.number,
+    ordinalTimeTicks: e.arrayOf(e.oneOfType([e.oneOf(["biweekly", "days", "hours", "months", "quarterly", "weeks", "years"]), e.shape({
+      format: e.func.isRequired,
+      getTickNumber: e.func.isRequired,
+      isTick: e.func.isRequired
+    })]).isRequired),
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["band"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  }), e.shape({
+    axis: e.oneOf(["x"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      type: e.oneOf(["ordinal"]).isRequired,
+      unknownColor: e.string,
+      values: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number, e.string]).isRequired)
+    }), e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    groups: e.arrayOf(e.shape({
+      getValue: e.func.isRequired,
+      tickLabelStyle: e.object,
+      tickSize: e.number
+    })),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    offset: e.number,
+    ordinalTimeTicks: e.arrayOf(e.oneOfType([e.oneOf(["biweekly", "days", "hours", "months", "quarterly", "weeks", "years"]), e.shape({
+      format: e.func.isRequired,
+      getTickNumber: e.func.isRequired,
+      isTick: e.func.isRequired
+    })]).isRequired),
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["point"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  }), e.shape({
+    axis: e.oneOf(["x"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["log"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  }), e.shape({
+    axis: e.oneOf(["x"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    constant: e.number,
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["symlog"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  }), e.shape({
+    axis: e.oneOf(["x"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["pow"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  }), e.shape({
+    axis: e.oneOf(["x"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["sqrt"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  }), e.shape({
+    axis: e.oneOf(["x"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.oneOfType([e.number, e.shape({
+      valueOf: e.func.isRequired
+    })]),
+    min: e.oneOfType([e.number, e.shape({
+      valueOf: e.func.isRequired
+    })]),
+    offset: e.number,
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["time"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  }), e.shape({
+    axis: e.oneOf(["x"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.oneOfType([e.number, e.shape({
+      valueOf: e.func.isRequired
+    })]),
+    min: e.oneOfType([e.number, e.shape({
+      valueOf: e.func.isRequired
+    })]),
+    offset: e.number,
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["utc"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  }), e.shape({
+    axis: e.oneOf(["x"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    height: e.number,
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["bottom", "none", "top"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["linear"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelMinGap: e.number,
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func
+  })]).isRequired),
+  /**
+   * The configuration of the y-axes.
+   * If not provided, a default axis config is used.
+   * An array of [[AxisConfig]] objects.
+   */
+  yAxis: e.arrayOf(e.oneOfType([e.shape({
+    axis: e.oneOf(["y"]),
+    barGapRatio: e.number,
+    categoryGapRatio: e.number,
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      type: e.oneOf(["ordinal"]).isRequired,
+      unknownColor: e.string,
+      values: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number, e.string]).isRequired)
+    }), e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    groups: e.arrayOf(e.shape({
+      getValue: e.func.isRequired,
+      tickLabelStyle: e.object,
+      tickSize: e.number
+    })),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    offset: e.number,
+    ordinalTimeTicks: e.arrayOf(e.oneOfType([e.oneOf(["biweekly", "days", "hours", "months", "quarterly", "weeks", "years"]), e.shape({
+      format: e.func.isRequired,
+      getTickNumber: e.func.isRequired,
+      isTick: e.func.isRequired
+    })]).isRequired),
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["band"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  }), e.shape({
+    axis: e.oneOf(["y"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      type: e.oneOf(["ordinal"]).isRequired,
+      unknownColor: e.string,
+      values: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number, e.string]).isRequired)
+    }), e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    groups: e.arrayOf(e.shape({
+      getValue: e.func.isRequired,
+      tickLabelStyle: e.object,
+      tickSize: e.number
+    })),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    offset: e.number,
+    ordinalTimeTicks: e.arrayOf(e.oneOfType([e.oneOf(["biweekly", "days", "hours", "months", "quarterly", "weeks", "years"]), e.shape({
+      format: e.func.isRequired,
+      getTickNumber: e.func.isRequired,
+      isTick: e.func.isRequired
+    })]).isRequired),
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["point"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  }), e.shape({
+    axis: e.oneOf(["y"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["log"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  }), e.shape({
+    axis: e.oneOf(["y"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    constant: e.number,
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["symlog"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  }), e.shape({
+    axis: e.oneOf(["y"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["pow"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  }), e.shape({
+    axis: e.oneOf(["y"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["sqrt"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  }), e.shape({
+    axis: e.oneOf(["y"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.oneOfType([e.number, e.shape({
+      valueOf: e.func.isRequired
+    })]),
+    min: e.oneOfType([e.number, e.shape({
+      valueOf: e.func.isRequired
+    })]),
+    offset: e.number,
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["time"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  }), e.shape({
+    axis: e.oneOf(["y"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.oneOfType([e.number, e.shape({
+      valueOf: e.func.isRequired
+    })]),
+    min: e.oneOfType([e.number, e.shape({
+      valueOf: e.func.isRequired
+    })]),
+    offset: e.number,
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["utc"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  }), e.shape({
+    axis: e.oneOf(["y"]),
+    classes: e.object,
+    colorMap: e.oneOfType([e.shape({
+      color: e.oneOfType([e.arrayOf(e.string.isRequired), e.func]).isRequired,
+      max: e.oneOfType([e.instanceOf(Date), e.number]),
+      min: e.oneOfType([e.instanceOf(Date), e.number]),
+      type: e.oneOf(["continuous"]).isRequired
+    }), e.shape({
+      colors: e.arrayOf(e.string).isRequired,
+      thresholds: e.arrayOf(e.oneOfType([e.instanceOf(Date), e.number]).isRequired).isRequired,
+      type: e.oneOf(["piecewise"]).isRequired
+    })]),
+    data: e.array,
+    dataKey: e.string,
+    disableLine: e.bool,
+    disableTicks: e.bool,
+    domainLimit: e.oneOfType([e.oneOf(["nice", "strict"]), e.func]),
+    hideTooltip: e.bool,
+    id: e.oneOfType([e.number, e.string]),
+    ignoreTooltip: e.bool,
+    label: e.string,
+    labelStyle: e.object,
+    max: e.number,
+    min: e.number,
+    offset: e.number,
+    position: e.oneOf(["left", "none", "right"]),
+    reverse: e.bool,
+    scaleType: e.oneOf(["linear"]),
+    slotProps: e.object,
+    slots: e.object,
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+    tickInterval: e.oneOfType([e.oneOf(["auto"]), e.array, e.func]),
+    tickLabelInterval: e.oneOfType([e.oneOf(["auto"]), e.func]),
+    tickLabelPlacement: e.oneOf(["middle", "tick"]),
+    tickLabelStyle: e.object,
+    tickMaxStep: e.number,
+    tickMinStep: e.number,
+    tickNumber: e.number,
+    tickPlacement: e.oneOf(["end", "extremities", "middle", "start"]),
+    tickSize: e.number,
+    tickSpacing: e.number,
+    valueFormatter: e.func,
+    width: e.number
+  })]).isRequired)
+});
+export {
+  Tn as BAR_CHART_PLUGINS,
+  Ae as BarChart,
+  Ie as BarElement,
+  qe as BarLabel,
+  Me as BarPlot,
+  vn as FocusedBar,
+  An as barClasses,
+  jt as barElementClasses,
+  pe as barLabelClasses,
+  vt as getBarElementUtilityClass,
+  At as getBarLabelUtilityClass,
+  Kt as getBarUtilityClass,
+  qt as useUtilityClasses
+};