@open-kingdom/shared-frontend-data-access-api-client 0.0.2-10

package/dist/index.js

@@ -0,0 +1,4139 @@
+import { nanoid as $n, formatProdErrorMessage as ye, isPlainObject as Ve, createAction as De, createSelector as Ir, createNextState as Wt, createAsyncThunk as an, createSlice as Se, prepareAutoBatched as Ne, isAnyOf as ze, isFulfilled as be, isRejectedWithValue as Bt, combineReducers as Ar, SHOULD_AUTOBATCH as Ln, isAllOf as Ot, isRejected as Gt, isPending as jn, isAction as Cr, isAsyncThunkAction as cn, createListenerMiddleware as Tr } from "@reduxjs/toolkit";
+import * as he from "react";
+import Kn, { useCallback as ge, useDebugValue as It, useMemo as G, useState as un, useEffect as de, useRef as fe, useLayoutEffect as Dr } from "react";
+var Yt = /* @__PURE__ */ Symbol.for("immer-nothing"), Fe = /* @__PURE__ */ Symbol.for("immer-draftable"), B = /* @__PURE__ */ Symbol.for("immer-state"), Hn = process.env.NODE_ENV !== "production" ? [
+  // All error codes, starting by 0:
+  function(e) {
+    return `The plugin for '${e}' has not been loaded into Immer. To enable the plugin, import and call \`enable${e}()\` when initializing your application.`;
+  },
+  function(e) {
+    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${e}'`;
+  },
+  "This object has been frozen and should not be mutated",
+  function(e) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + e;
+  },
+  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+  "Immer forbids circular references",
+  "The first or second argument to `produce` must be a function",
+  "The third argument to `produce` must be a function or undefined",
+  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
+  "First argument to `finishDraft` must be a draft returned by `createDraft`",
+  function(e) {
+    return `'current' expects a draft, got: ${e}`;
+  },
+  "Object.defineProperty() cannot be used on an Immer draft",
+  "Object.setPrototypeOf() cannot be used on an Immer draft",
+  "Immer only supports deleting array indices",
+  "Immer only supports setting array indices and the 'length' property",
+  function(e) {
+    return `'original' expects a draft, got: ${e}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function W(e, ...t) {
+  if (process.env.NODE_ENV !== "production") {
+    const n = Hn[e], r = pe(n) ? n.apply(null, t) : n;
+    throw new Error(`[Immer] ${r}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${e}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var J = Object, Ee = J.getPrototypeOf, $e = "constructor", Ge = "prototype", qt = "configurable", ft = "enumerable", ut = "writable", Le = "value", Z = (e) => !!e && !!e[B];
+function ne(e) {
+  return e ? Wn(e) || Je(e) || !!e[Fe] || !!e[$e]?.[Fe] || Xe(e) || Ze(e) : !1;
+}
+var Nr = J[Ge][$e].toString(), ln = /* @__PURE__ */ new WeakMap();
+function Wn(e) {
+  if (!e || !Ce(e))
+    return !1;
+  const t = Ee(e);
+  if (t === null || t === J[Ge])
+    return !0;
+  const n = J.hasOwnProperty.call(t, $e) && t[$e];
+  if (n === Object)
+    return !0;
+  if (!pe(n))
+    return !1;
+  let r = ln.get(n);
+  return r === void 0 && (r = Function.toString.call(n), ln.set(n, r)), r === Nr;
+}
+function kr(e) {
+  return Z(e) || W(15, e), e[B].base_;
+}
+function Ye(e, t, n = !0) {
+  Pe(e) === 0 ? (n ? Reflect.ownKeys(e) : J.keys(e)).forEach((i) => {
+    t(i, e[i], e);
+  }) : e.forEach((r, i) => t(i, r, e));
+}
+function Pe(e) {
+  const t = e[B];
+  return t ? t.type_ : Je(e) ? 1 : Xe(e) ? 2 : Ze(e) ? 3 : 0;
+}
+var xe = (e, t, n = Pe(e)) => n === 2 ? e.has(t) : J[Ge].hasOwnProperty.call(e, t), se = (e, t, n = Pe(e)) => (
+  // @ts-ignore
+  n === 2 ? e.get(t) : e[t]
+), dt = (e, t, n, r = Pe(e)) => {
+  r === 2 ? e.set(t, n) : r === 3 ? e.add(n) : e[t] = n;
+};
+function Mr(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+var Je = Array.isArray, Xe = (e) => e instanceof Map, Ze = (e) => e instanceof Set, Ce = (e) => typeof e == "object", pe = (e) => typeof e == "function", At = (e) => typeof e == "boolean";
+function Qr(e) {
+  const t = +e;
+  return Number.isInteger(t) && String(t) === e;
+}
+var qr = (e) => Ce(e) ? e?.[B] : null, ae = (e) => e.copy_ || e.base_, Jt = (e) => e.modified_ ? e.copy_ : e.base_;
+function Ft(e, t) {
+  if (Xe(e))
+    return new Map(e);
+  if (Ze(e))
+    return new Set(e);
+  if (Je(e))
+    return Array[Ge].slice.call(e);
+  const n = Wn(e);
+  if (t === !0 || t === "class_only" && !n) {
+    const r = J.getOwnPropertyDescriptors(e);
+    delete r[B];
+    let i = Reflect.ownKeys(r);
+    for (let u = 0; u < i.length; u++) {
+      const m = i[u], _ = r[m];
+      _[ut] === !1 && (_[ut] = !0, _[qt] = !0), (_.get || _.set) && (r[m] = {
+        [qt]: !0,
+        [ut]: !0,
+        // could live with !!desc.set as well here...
+        [ft]: _[ft],
+        [Le]: e[m]
+      });
+    }
+    return J.create(Ee(e), r);
+  } else {
+    const r = Ee(e);
+    if (r !== null && n)
+      return { ...e };
+    const i = J.create(r);
+    return J.assign(i, e);
+  }
+}
+function Xt(e, t = !1) {
+  return bt(e) || Z(e) || !ne(e) || (Pe(e) > 1 && J.defineProperties(e, {
+    set: rt,
+    add: rt,
+    clear: rt,
+    delete: rt
+  }), J.freeze(e), t && Ye(
+    e,
+    (n, r) => {
+      Xt(r, !0);
+    },
+    !1
+  )), e;
+}
+function Fr() {
+  W(2);
+}
+var rt = {
+  [Le]: Fr
+};
+function bt(e) {
+  return e === null || !Ce(e) ? !0 : J.isFrozen(e);
+}
+var pt = "MapSet", ht = "Patches", fn = "ArrayMethods", yt = {};
+function we(e) {
+  const t = yt[e];
+  return t || W(0, e), t;
+}
+var dn = (e) => !!yt[e];
+function xr(e, t) {
+  yt[e] || (yt[e] = t);
+}
+var je, Bn = () => je, Ur = (e, t) => ({
+  drafts_: [],
+  parent_: e,
+  immer_: t,
+  // Whenever the modified draft contains a draft from another scope, we
+  // need to prevent auto-freezing so the unowned draft can be finalized.
+  canAutoFreeze_: !0,
+  unfinalizedDrafts_: 0,
+  handledSet_: /* @__PURE__ */ new Set(),
+  processedForPatches_: /* @__PURE__ */ new Set(),
+  mapSetPlugin_: dn(pt) ? we(pt) : void 0,
+  arrayMethodsPlugin_: dn(fn) ? we(fn) : void 0
+});
+function pn(e, t) {
+  t && (e.patchPlugin_ = we(ht), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+function xt(e) {
+  Ut(e), e.drafts_.forEach(Vr), e.drafts_ = null;
+}
+function Ut(e) {
+  e === je && (je = e.parent_);
+}
+var hn = (e) => je = Ur(je, e);
+function Vr(e) {
+  const t = e[B];
+  t.type_ === 0 || t.type_ === 1 ? t.revoke_() : t.revoked_ = !0;
+}
+function yn(e, t) {
+  t.unfinalizedDrafts_ = t.drafts_.length;
+  const n = t.drafts_[0];
+  if (e !== void 0 && e !== n) {
+    n[B].modified_ && (xt(t), W(4)), ne(e) && (e = gn(t, e));
+    const { patchPlugin_: i } = t;
+    i && i.generateReplacementPatches_(
+      n[B].base_,
+      e,
+      t
+    );
+  } else
+    e = gn(t, n);
+  return zr(t, e, !0), xt(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), e !== Yt ? e : void 0;
+}
+function gn(e, t) {
+  if (bt(t))
+    return t;
+  const n = t[B];
+  if (!n)
+    return gt(t, e.handledSet_, e);
+  if (!Et(n, e))
+    return t;
+  if (!n.modified_)
+    return n.base_;
+  if (!n.finalized_) {
+    const { callbacks_: r } = n;
+    if (r)
+      for (; r.length > 0; )
+        r.pop()(e);
+    Jn(n, e);
+  }
+  return n.copy_;
+}
+function zr(e, t, n = !1) {
+  !e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && Xt(t, n);
+}
+function Gn(e) {
+  e.finalized_ = !0, e.scope_.unfinalizedDrafts_--;
+}
+var Et = (e, t) => e.scope_ === t, $r = [];
+function Yn(e, t, n, r) {
+  const i = ae(e), u = e.type_;
+  if (r !== void 0 && se(i, r, u) === t) {
+    dt(i, r, n, u);
+    return;
+  }
+  if (!e.draftLocations_) {
+    const _ = e.draftLocations_ = /* @__PURE__ */ new Map();
+    Ye(i, (C, w) => {
+      if (Z(w)) {
+        const T = _.get(w) || [];
+        T.push(C), _.set(w, T);
+      }
+    });
+  }
+  const m = e.draftLocations_.get(t) ?? $r;
+  for (const _ of m)
+    dt(i, _, n, u);
+}
+function Lr(e, t, n) {
+  e.callbacks_.push(function(i) {
+    const u = t;
+    if (!u || !Et(u, i))
+      return;
+    i.mapSetPlugin_?.fixSetContents(u);
+    const m = Jt(u);
+    Yn(e, u.draft_ ?? u, m, n), Jn(u, i);
+  });
+}
+function Jn(e, t) {
+  if (e.modified_ && !e.finalized_ && (e.type_ === 3 || e.type_ === 1 && e.allIndicesReassigned_ || (e.assigned_?.size ?? 0) > 0)) {
+    const { patchPlugin_: r } = t;
+    if (r) {
+      const i = r.getPath(e);
+      i && r.generatePatches_(e, i, t);
+    }
+    Gn(e);
+  }
+}
+function jr(e, t, n) {
+  const { scope_: r } = e;
+  if (Z(n)) {
+    const i = n[B];
+    Et(i, r) && i.callbacks_.push(function() {
+      lt(e);
+      const m = Jt(i);
+      Yn(e, n, m, t);
+    });
+  } else ne(n) && e.callbacks_.push(function() {
+    const u = ae(e);
+    e.type_ === 3 ? u.has(n) && gt(n, r.handledSet_, r) : se(u, t, e.type_) === n && r.drafts_.length > 1 && (e.assigned_.get(t) ?? !1) === !0 && e.copy_ && gt(
+      se(e.copy_, t, e.type_),
+      r.handledSet_,
+      r
+    );
+  });
+}
+function gt(e, t, n) {
+  return !n.immer_.autoFreeze_ && n.unfinalizedDrafts_ < 1 || Z(e) || t.has(e) || !ne(e) || bt(e) || (t.add(e), Ye(e, (r, i) => {
+    if (Z(i)) {
+      const u = i[B];
+      if (Et(u, n)) {
+        const m = Jt(u);
+        dt(e, r, m, e.type_), Gn(u);
+      }
+    } else ne(i) && gt(i, t, n);
+  })), e;
+}
+function Kr(e, t) {
+  const n = Je(e), r = {
+    type_: n ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: t ? t.scope_ : Bn(),
+    // True for both shallow and deep changes.
+    modified_: !1,
+    // Used during finalization.
+    finalized_: !1,
+    // Track which properties have been assigned (true) or deleted (false).
+    // actually instantiated in `prepareCopy()`
+    assigned_: void 0,
+    // The parent draft state.
+    parent_: t,
+    // The base state.
+    base_: e,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: !1,
+    // `callbacks` actually gets assigned in `createProxy`
+    callbacks_: void 0
+  };
+  let i = r, u = mt;
+  n && (i = [r], u = Ke);
+  const { revoke: m, proxy: _ } = Proxy.revocable(i, u);
+  return r.draft_ = _, r.revoke_ = m, [_, r];
+}
+var mt = {
+  get(e, t) {
+    if (t === B)
+      return e;
+    let n = e.scope_.arrayMethodsPlugin_;
+    const r = e.type_ === 1 && typeof t == "string";
+    if (r && n?.isArrayOperationMethod(t))
+      return n.createMethodInterceptor(e, t);
+    const i = ae(e);
+    if (!xe(i, t, e.type_))
+      return Hr(e, i, t);
+    const u = i[t];
+    if (e.finalized_ || !ne(u) || r && e.operationMethod && n?.isMutatingArrayMethod(
+      e.operationMethod
+    ) && Qr(t))
+      return u;
+    if (u === Ct(e.base_, t)) {
+      lt(e);
+      const m = e.type_ === 1 ? +t : t, _ = zt(e.scope_, u, e, m);
+      return e.copy_[m] = _;
+    }
+    return u;
+  },
+  has(e, t) {
+    return t in ae(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(ae(e));
+  },
+  set(e, t, n) {
+    const r = Xn(ae(e), t);
+    if (r?.set)
+      return r.set.call(e.draft_, n), !0;
+    if (!e.modified_) {
+      const i = Ct(ae(e), t), u = i?.[B];
+      if (u && u.base_ === n)
+        return e.copy_[t] = n, e.assigned_.set(t, !1), !0;
+      if (Mr(n, i) && (n !== void 0 || xe(e.base_, t, e.type_)))
+        return !0;
+      lt(e), Vt(e);
+    }
+    return e.copy_[t] === n && // special case: handle new props with value 'undefined'
+    (n !== void 0 || t in e.copy_) || // special case: NaN
+    Number.isNaN(n) && Number.isNaN(e.copy_[t]) || (e.copy_[t] = n, e.assigned_.set(t, !0), jr(e, t, n)), !0;
+  },
+  deleteProperty(e, t) {
+    return lt(e), Ct(e.base_, t) !== void 0 || t in e.base_ ? (e.assigned_.set(t, !1), Vt(e)) : e.assigned_.delete(t), e.copy_ && delete e.copy_[t], !0;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(e, t) {
+    const n = ae(e), r = Reflect.getOwnPropertyDescriptor(n, t);
+    return r && {
+      [ut]: !0,
+      [qt]: e.type_ !== 1 || t !== "length",
+      [ft]: r[ft],
+      [Le]: n[t]
+    };
+  },
+  defineProperty() {
+    W(11);
+  },
+  getPrototypeOf(e) {
+    return Ee(e.base_);
+  },
+  setPrototypeOf() {
+    W(12);
+  }
+}, Ke = {};
+for (let e in mt) {
+  let t = mt[e];
+  Ke[e] = function() {
+    const n = arguments;
+    return n[0] = n[0][0], t.apply(this, n);
+  };
+}
+Ke.deleteProperty = function(e, t) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(t)) && W(13), Ke.set.call(this, e, t, void 0);
+};
+Ke.set = function(e, t, n) {
+  return process.env.NODE_ENV !== "production" && t !== "length" && isNaN(parseInt(t)) && W(14), mt.set.call(this, e[0], t, n, e[0]);
+};
+function Ct(e, t) {
+  const n = e[B];
+  return (n ? ae(n) : e)[t];
+}
+function Hr(e, t, n) {
+  const r = Xn(t, n);
+  return r ? Le in r ? r[Le] : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    r.get?.call(e.draft_)
+  ) : void 0;
+}
+function Xn(e, t) {
+  if (!(t in e))
+    return;
+  let n = Ee(e);
+  for (; n; ) {
+    const r = Object.getOwnPropertyDescriptor(n, t);
+    if (r)
+      return r;
+    n = Ee(n);
+  }
+}
+function Vt(e) {
+  e.modified_ || (e.modified_ = !0, e.parent_ && Vt(e.parent_));
+}
+function lt(e) {
+  e.copy_ || (e.assigned_ = /* @__PURE__ */ new Map(), e.copy_ = Ft(
+    e.base_,
+    e.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var Wr = class {
+  constructor(e) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.useStrictIteration_ = !1, this.produce = (t, n, r) => {
+      if (pe(t) && !pe(n)) {
+        const u = n;
+        n = t;
+        const m = this;
+        return function(C = u, ...w) {
+          return m.produce(C, (T) => n.call(this, T, ...w));
+        };
+      }
+      pe(n) || W(6), r !== void 0 && !pe(r) && W(7);
+      let i;
+      if (ne(t)) {
+        const u = hn(this), m = zt(u, t, void 0);
+        let _ = !0;
+        try {
+          i = n(m), _ = !1;
+        } finally {
+          _ ? xt(u) : Ut(u);
+        }
+        return pn(u, r), yn(i, u);
+      } else if (!t || !Ce(t)) {
+        if (i = n(t), i === void 0 && (i = t), i === Yt && (i = void 0), this.autoFreeze_ && Xt(i, !0), r) {
+          const u = [], m = [];
+          we(ht).generateReplacementPatches_(t, i, {
+            patches_: u,
+            inversePatches_: m
+          }), r(u, m);
+        }
+        return i;
+      } else
+        W(1, t);
+    }, this.produceWithPatches = (t, n) => {
+      if (pe(t))
+        return (m, ..._) => this.produceWithPatches(m, (C) => t(C, ..._));
+      let r, i;
+      return [this.produce(t, n, (m, _) => {
+        r = m, i = _;
+      }), r, i];
+    }, At(e?.autoFreeze) && this.setAutoFreeze(e.autoFreeze), At(e?.useStrictShallowCopy) && this.setUseStrictShallowCopy(e.useStrictShallowCopy), At(e?.useStrictIteration) && this.setUseStrictIteration(e.useStrictIteration);
+  }
+  createDraft(e) {
+    ne(e) || W(8), Z(e) && (e = Zn(e));
+    const t = hn(this), n = zt(t, e, void 0);
+    return n[B].isManual_ = !0, Ut(t), n;
+  }
+  finishDraft(e, t) {
+    const n = e && e[B];
+    (!n || !n.isManual_) && W(9);
+    const { scope_: r } = n;
+    return pn(r, t), yn(void 0, r);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(e) {
+    this.autoFreeze_ = e;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(e) {
+    this.useStrictShallowCopy_ = e;
+  }
+  /**
+   * Pass false to use faster iteration that skips non-enumerable properties
+   * but still handles symbols for compatibility.
+   *
+   * By default, strict iteration is enabled (includes all own properties).
+   */
+  setUseStrictIteration(e) {
+    this.useStrictIteration_ = e;
+  }
+  shouldUseStrictIteration() {
+    return this.useStrictIteration_;
+  }
+  applyPatches(e, t) {
+    let n;
+    for (n = t.length - 1; n >= 0; n--) {
+      const i = t[n];
+      if (i.path.length === 0 && i.op === "replace") {
+        e = i.value;
+        break;
+      }
+    }
+    n > -1 && (t = t.slice(n + 1));
+    const r = we(ht).applyPatches_;
+    return Z(e) ? r(e, t) : this.produce(
+      e,
+      (i) => r(i, t)
+    );
+  }
+};
+function zt(e, t, n, r) {
+  const [i, u] = Xe(t) ? we(pt).proxyMap_(t, n) : Ze(t) ? we(pt).proxySet_(t, n) : Kr(t, n);
+  return (n?.scope_ ?? Bn()).drafts_.push(i), u.callbacks_ = n?.callbacks_ ?? [], u.key_ = r, n && r !== void 0 ? Lr(n, u, r) : u.callbacks_.push(function(C) {
+    C.mapSetPlugin_?.fixSetContents(u);
+    const { patchPlugin_: w } = C;
+    u.modified_ && w && w.generatePatches_(u, [], C);
+  }), i;
+}
+function Zn(e) {
+  return Z(e) || W(10, e), er(e);
+}
+function er(e) {
+  if (!ne(e) || bt(e))
+    return e;
+  const t = e[B];
+  let n, r = !0;
+  if (t) {
+    if (!t.modified_)
+      return t.base_;
+    t.finalized_ = !0, n = Ft(e, t.scope_.immer_.useStrictShallowCopy_), r = t.scope_.immer_.shouldUseStrictIteration();
+  } else
+    n = Ft(e, !0);
+  return Ye(
+    n,
+    (i, u) => {
+      dt(n, i, er(u));
+    },
+    r
+  ), t && (t.finalized_ = !1), n;
+}
+function Br() {
+  process.env.NODE_ENV !== "production" && Hn.push(
+    'Sets cannot have "replace" patches.',
+    function(d) {
+      return "Unsupported patch operation: " + d;
+    },
+    function(d) {
+      return "Cannot apply patch, path doesn't resolve: " + d;
+    },
+    "Patching reserved attributes like __proto__, prototype and constructor is not allowed"
+  );
+  function t(d, v = []) {
+    if (d.key_ !== void 0) {
+      const p = d.parent_.copy_ ?? d.parent_.base_, P = qr(se(p, d.key_)), O = se(p, d.key_);
+      if (O === void 0 || O !== d.draft_ && O !== d.base_ && O !== d.copy_ || P != null && P.base_ !== d.base_)
+        return null;
+      const f = d.parent_.type_ === 3;
+      let g;
+      if (f) {
+        const s = d.parent_;
+        g = Array.from(s.drafts_.keys()).indexOf(d.key_);
+      } else
+        g = d.key_;
+      if (!(f && p.size > g || xe(p, g)))
+        return null;
+      v.push(g);
+    }
+    if (d.parent_)
+      return t(d.parent_, v);
+    v.reverse();
+    try {
+      n(d.copy_, v);
+    } catch {
+      return null;
+    }
+    return v;
+  }
+  function n(d, v) {
+    let p = d;
+    for (let P = 0; P < v.length - 1; P++) {
+      const O = v[P];
+      if (p = se(p, O), !Ce(p) || p === null)
+        throw new Error(`Cannot resolve path at '${v.join("/")}'`);
+    }
+    return p;
+  }
+  const r = "replace", i = "add", u = "remove";
+  function m(d, v, p) {
+    if (d.scope_.processedForPatches_.has(d))
+      return;
+    d.scope_.processedForPatches_.add(d);
+    const { patches_: P, inversePatches_: O } = p;
+    switch (d.type_) {
+      case 0:
+      case 2:
+        return C(
+          d,
+          v,
+          P,
+          O
+        );
+      case 1:
+        return _(
+          d,
+          v,
+          P,
+          O
+        );
+      case 3:
+        return w(
+          d,
+          v,
+          P,
+          O
+        );
+    }
+  }
+  function _(d, v, p, P) {
+    let { base_: O, assigned_: f } = d, g = d.copy_;
+    g.length < O.length && ([O, g] = [g, O], [p, P] = [P, p]);
+    const s = d.allIndicesReassigned_ === !0;
+    for (let a = 0; a < O.length; a++) {
+      const S = g[a], b = O[a];
+      if ((s || f?.get(a.toString())) && S !== b) {
+        const l = S?.[B];
+        if (l && l.modified_)
+          continue;
+        const o = v.concat([a]);
+        p.push({
+          op: r,
+          path: o,
+          // Need to maybe clone it, as it can in fact be the original value
+          // due to the base/copy inversion at the start of this function
+          value: R(S)
+        }), P.push({
+          op: r,
+          path: o,
+          value: R(b)
+        });
+      }
+    }
+    for (let a = O.length; a < g.length; a++) {
+      const S = v.concat([a]);
+      p.push({
+        op: i,
+        path: S,
+        // Need to maybe clone it, as it can in fact be the original value
+        // due to the base/copy inversion at the start of this function
+        value: R(g[a])
+      });
+    }
+    for (let a = g.length - 1; O.length <= a; --a) {
+      const S = v.concat([a]);
+      P.push({
+        op: u,
+        path: S
+      });
+    }
+  }
+  function C(d, v, p, P) {
+    const { base_: O, copy_: f, type_: g } = d;
+    Ye(d.assigned_, (s, a) => {
+      const S = se(O, s, g), b = se(f, s, g), h = a ? xe(O, s) ? r : i : u;
+      if (S === b && h === r)
+        return;
+      const l = v.concat(s);
+      p.push(
+        h === u ? { op: h, path: l } : { op: h, path: l, value: R(b) }
+      ), P.push(
+        h === i ? { op: u, path: l } : h === u ? { op: i, path: l, value: R(S) } : { op: r, path: l, value: R(S) }
+      );
+    });
+  }
+  function w(d, v, p, P) {
+    let { base_: O, copy_: f } = d, g = 0;
+    O.forEach((s) => {
+      if (!f.has(s)) {
+        const a = v.concat([g]);
+        p.push({
+          op: u,
+          path: a,
+          value: s
+        }), P.unshift({
+          op: i,
+          path: a,
+          value: s
+        });
+      }
+      g++;
+    }), g = 0, f.forEach((s) => {
+      if (!O.has(s)) {
+        const a = v.concat([g]);
+        p.push({
+          op: i,
+          path: a,
+          value: s
+        }), P.unshift({
+          op: u,
+          path: a,
+          value: s
+        });
+      }
+      g++;
+    });
+  }
+  function T(d, v, p) {
+    const { patches_: P, inversePatches_: O } = p;
+    P.push({
+      op: r,
+      path: [],
+      value: v === Yt ? void 0 : v
+    }), O.push({
+      op: r,
+      path: [],
+      value: d
+    });
+  }
+  function I(d, v) {
+    return v.forEach((p) => {
+      const { path: P, op: O } = p;
+      let f = d;
+      for (let S = 0; S < P.length - 1; S++) {
+        const b = Pe(f);
+        let h = P[S];
+        typeof h != "string" && typeof h != "number" && (h = "" + h), (b === 0 || b === 1) && (h === "__proto__" || h === $e) && W(19), pe(f) && h === Ge && W(19), f = se(f, h), Ce(f) || W(18, P.join("/"));
+      }
+      const g = Pe(f), s = A(p.value), a = P[P.length - 1];
+      switch (O) {
+        case r:
+          switch (g) {
+            case 2:
+              return f.set(a, s);
+            case 3:
+              W(16);
+            default:
+              return f[a] = s;
+          }
+        case i:
+          switch (g) {
+            case 1:
+              return a === "-" ? f.push(s) : f.splice(a, 0, s);
+            case 2:
+              return f.set(a, s);
+            case 3:
+              return f.add(s);
+            default:
+              return f[a] = s;
+          }
+        case u:
+          switch (g) {
+            case 1:
+              return f.splice(a, 1);
+            case 2:
+              return f.delete(a);
+            case 3:
+              return f.delete(p.value);
+            default:
+              return delete f[a];
+          }
+        default:
+          W(17, O);
+      }
+    }), d;
+  }
+  function A(d) {
+    if (!ne(d))
+      return d;
+    if (Je(d))
+      return d.map(A);
+    if (Xe(d))
+      return new Map(
+        Array.from(d.entries()).map(([p, P]) => [p, A(P)])
+      );
+    if (Ze(d))
+      return new Set(Array.from(d).map(A));
+    const v = Object.create(Ee(d));
+    for (const p in d)
+      v[p] = A(d[p]);
+    return xe(d, Fe) && (v[Fe] = d[Fe]), v;
+  }
+  function R(d) {
+    return Z(d) ? A(d) : d;
+  }
+  xr(ht, {
+    applyPatches_: I,
+    generatePatches_: m,
+    generateReplacementPatches_: T,
+    getPath: t
+  });
+}
+var He = new Wr();
+He.produce;
+var tr = /* @__PURE__ */ He.produceWithPatches.bind(
+  He
+), mn = /* @__PURE__ */ He.applyPatches.bind(He), Gr = class extends Error {
+  /**
+   * The schema issues.
+   */
+  issues;
+  /**
+   * Creates a schema error with useful information.
+   *
+   * @param issues The schema issues.
+   */
+  constructor(e) {
+    super(e[0].message), this.name = "SchemaError", this.issues = e;
+  }
+}, Yr = (e, t, n) => {
+  if (t.length === 1 && t[0] === n) {
+    let r = !1;
+    try {
+      const i = {};
+      e(i) === i && (r = !0);
+    } catch {
+    }
+    if (r) {
+      let i;
+      try {
+        throw new Error();
+      } catch (u) {
+        ({ stack: i } = u);
+      }
+      console.warn(
+        `The result function returned its own inputs without modification. e.g
+\`createSelector([state => state.todos], todos => todos)\`
+This could lead to inefficient memoization and unnecessary re-renders.
+Ensure transformation logic is in the result function, and extraction logic is in the input selectors.`,
+        { stack: i }
+      );
+    }
+  }
+}, Jr = (e, t, n) => {
+  const { memoize: r, memoizeOptions: i } = t, { inputSelectorResults: u, inputSelectorResultsCopy: m } = e, _ = r(() => ({}), ...i);
+  if (!(_.apply(null, u) === _.apply(null, m))) {
+    let w;
+    try {
+      throw new Error();
+    } catch (T) {
+      ({ stack: w } = T);
+    }
+    console.warn(
+      `An input selector returned a different result when passed same arguments.
+This means your output selector will likely run more frequently than intended.
+Avoid returning a new reference inside your input selector, e.g.
+\`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)\``,
+      {
+        arguments: n,
+        firstInputs: u,
+        secondInputs: m,
+        stack: w
+      }
+    );
+  }
+}, Xr = {
+  inputStabilityCheck: "once",
+  identityFunctionCheck: "once"
+};
+function Zr(e, t = `expected a function, instead received ${typeof e}`) {
+  if (typeof e != "function")
+    throw new TypeError(t);
+}
+function ei(e, t = `expected an object, instead received ${typeof e}`) {
+  if (typeof e != "object")
+    throw new TypeError(t);
+}
+function ti(e, t = "expected all items to be functions, instead received the following types: ") {
+  if (!e.every((n) => typeof n == "function")) {
+    const n = e.map(
+      (r) => typeof r == "function" ? `function ${r.name || "unnamed"}()` : typeof r
+    ).join(", ");
+    throw new TypeError(`${t}[${n}]`);
+  }
+}
+var vn = (e) => Array.isArray(e) ? e : [e];
+function ni(e) {
+  const t = Array.isArray(e[0]) ? e[0] : e;
+  return ti(
+    t,
+    "createSelector expects all input-selectors to be functions, but received the following types: "
+  ), t;
+}
+function Sn(e, t) {
+  const n = [], { length: r } = e;
+  for (let i = 0; i < r; i++)
+    n.push(e[i].apply(null, t));
+  return n;
+}
+var ri = (e, t) => {
+  const { identityFunctionCheck: n, inputStabilityCheck: r } = {
+    ...Xr,
+    ...t
+  };
+  return {
+    identityFunctionCheck: {
+      shouldRun: n === "always" || n === "once" && e,
+      run: Yr
+    },
+    inputStabilityCheck: {
+      shouldRun: r === "always" || r === "once" && e,
+      run: Jr
+    }
+  };
+}, ii = class {
+  constructor(e) {
+    this.value = e;
+  }
+  deref() {
+    return this.value;
+  }
+}, oi = typeof WeakRef < "u" ? WeakRef : ii, si = 0, _n = 1;
+function it() {
+  return {
+    s: si,
+    v: void 0,
+    o: null,
+    p: null
+  };
+}
+function vt(e, t = {}) {
+  let n = it();
+  const { resultEqualityCheck: r } = t;
+  let i, u = 0;
+  function m() {
+    let _ = n;
+    const { length: C } = arguments;
+    for (let I = 0, A = C; I < A; I++) {
+      const R = arguments[I];
+      if (typeof R == "function" || typeof R == "object" && R !== null) {
+        let d = _.o;
+        d === null && (_.o = d = /* @__PURE__ */ new WeakMap());
+        const v = d.get(R);
+        v === void 0 ? (_ = it(), d.set(R, _)) : _ = v;
+      } else {
+        let d = _.p;
+        d === null && (_.p = d = /* @__PURE__ */ new Map());
+        const v = d.get(R);
+        v === void 0 ? (_ = it(), d.set(R, _)) : _ = v;
+      }
+    }
+    const w = _;
+    let T;
+    if (_.s === _n)
+      T = _.v;
+    else if (T = e.apply(null, arguments), u++, r) {
+      const I = i?.deref?.() ?? i;
+      I != null && r(I, T) && (T = I, u !== 0 && u--), i = typeof T == "object" && T !== null || typeof T == "function" ? new oi(T) : T;
+    }
+    return w.s = _n, w.v = T, T;
+  }
+  return m.clearCache = () => {
+    n = it(), m.resetResultsCount();
+  }, m.resultsCount = () => u, m.resetResultsCount = () => {
+    u = 0;
+  }, m;
+}
+function ai(e, ...t) {
+  const n = typeof e == "function" ? {
+    memoize: e,
+    memoizeOptions: t
+  } : e, r = (...i) => {
+    let u = 0, m = 0, _, C = {}, w = i.pop();
+    typeof w == "object" && (C = w, w = i.pop()), Zr(
+      w,
+      `createSelector expects an output function after the inputs, but received: [${typeof w}]`
+    );
+    const T = {
+      ...n,
+      ...C
+    }, {
+      memoize: I,
+      memoizeOptions: A = [],
+      argsMemoize: R = vt,
+      argsMemoizeOptions: d = [],
+      devModeChecks: v = {}
+    } = T, p = vn(A), P = vn(d), O = ni(i), f = I(function() {
+      return u++, w.apply(
+        null,
+        arguments
+      );
+    }, ...p);
+    let g = !0;
+    const s = R(function() {
+      m++;
+      const S = Sn(
+        O,
+        arguments
+      );
+      if (_ = f.apply(null, S), process.env.NODE_ENV !== "production") {
+        const { identityFunctionCheck: b, inputStabilityCheck: h } = ri(g, v);
+        if (b.shouldRun && b.run(
+          w,
+          S,
+          _
+        ), h.shouldRun) {
+          const l = Sn(
+            O,
+            arguments
+          );
+          h.run(
+            { inputSelectorResults: S, inputSelectorResultsCopy: l },
+            { memoize: I, memoizeOptions: p },
+            arguments
+          );
+        }
+        g && (g = !1);
+      }
+      return _;
+    }, ...P);
+    return Object.assign(s, {
+      resultFunc: w,
+      memoizedResultFunc: f,
+      dependencies: O,
+      dependencyRecomputations: () => m,
+      resetDependencyRecomputations: () => {
+        m = 0;
+      },
+      lastResult: () => _,
+      recomputations: () => u,
+      resetRecomputations: () => {
+        u = 0;
+      },
+      memoize: I,
+      argsMemoize: R
+    });
+  };
+  return Object.assign(r, {
+    withTypes: () => r
+  }), r;
+}
+var nr = /* @__PURE__ */ ai(vt), ci = Object.assign(
+  (e, t = nr) => {
+    ei(
+      e,
+      `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof e}`
+    );
+    const n = Object.keys(e), r = n.map(
+      (u) => e[u]
+    );
+    return t(
+      r,
+      (...u) => u.reduce((m, _, C) => (m[n[C]] = _, m), {})
+    );
+  },
+  { withTypes: () => ci }
+), rr = /* @__PURE__ */ ((e) => (e.uninitialized = "uninitialized", e.pending = "pending", e.fulfilled = "fulfilled", e.rejected = "rejected", e))(rr || {}), ce = "uninitialized", $t = "pending", Qe = "fulfilled", qe = "rejected";
+function bn(e) {
+  return {
+    status: e,
+    isUninitialized: e === ce,
+    isLoading: e === $t,
+    isSuccess: e === Qe,
+    isError: e === qe
+  };
+}
+var En = Ve;
+function Zt(e, t) {
+  if (e === t || !(En(e) && En(t) || Array.isArray(e) && Array.isArray(t)))
+    return t;
+  const n = Object.keys(t), r = Object.keys(e);
+  let i = n.length === r.length;
+  const u = Array.isArray(t) ? [] : {};
+  for (const m of n)
+    u[m] = Zt(e[m], t[m]), i && (i = e[m] === u[m]);
+  return i ? e : u;
+}
+function Lt(e, t, n) {
+  return e.reduce((r, i, u) => (t(i, u) && r.push(n(i, u)), r), []).flat();
+}
+function ui(e) {
+  return new RegExp("(^|:)//").test(e);
+}
+function li() {
+  return typeof document > "u" ? !0 : document.visibilityState !== "hidden";
+}
+function en(e) {
+  return e != null;
+}
+function Pn(e) {
+  return [...e?.values() ?? []].filter(en);
+}
+function fi() {
+  return typeof navigator > "u" || navigator.onLine === void 0 ? !0 : navigator.onLine;
+}
+var di = (e) => e.replace(/\/$/, ""), pi = (e) => e.replace(/^\//, "");
+function hi(e, t) {
+  if (!e)
+    return t;
+  if (!t)
+    return e;
+  if (ui(t))
+    return t;
+  const n = e.endsWith("/") || !t.startsWith("?") ? "/" : "";
+  return e = di(e), t = pi(t), `${e}${n}${t}`;
+}
+function St(e, t, n) {
+  return e.has(t) ? e.get(t) : e.set(t, n(t)).get(t);
+}
+var jt = () => /* @__PURE__ */ new Map(), yi = (e) => {
+  const t = new AbortController();
+  return setTimeout(() => {
+    const n = "signal timed out", r = "TimeoutError";
+    t.abort(
+      // some environments (React Native, Node) don't have DOMException
+      typeof DOMException < "u" ? new DOMException(n, r) : Object.assign(new Error(n), {
+        name: r
+      })
+    );
+  }, e), t.signal;
+}, gi = (...e) => {
+  for (const n of e) if (n.aborted) return AbortSignal.abort(n.reason);
+  const t = new AbortController();
+  for (const n of e)
+    n.addEventListener("abort", () => t.abort(n.reason), {
+      signal: t.signal,
+      once: !0
+    });
+  return t.signal;
+}, wn = (...e) => fetch(...e), mi = (e) => e.status >= 200 && e.status <= 299, vi = (e) => (
+  /*applicat*/
+  /ion\/(vnd\.api\+)?json/.test(e.get("content-type") || "")
+);
+function Rn(e) {
+  if (!Ve(e))
+    return e;
+  const t = {
+    ...e
+  };
+  for (const [n, r] of Object.entries(t))
+    r === void 0 && delete t[n];
+  return t;
+}
+var Si = (e) => typeof e == "object" && (Ve(e) || Array.isArray(e) || typeof e.toJSON == "function");
+function _i({
+  baseUrl: e,
+  prepareHeaders: t = (I) => I,
+  fetchFn: n = wn,
+  paramsSerializer: r,
+  isJsonContentType: i = vi,
+  jsonContentType: u = "application/json",
+  jsonReplacer: m,
+  timeout: _,
+  responseHandler: C,
+  validateStatus: w,
+  ...T
+} = {}) {
+  return typeof fetch > "u" && n === wn && console.warn("Warning: `fetch` is not available. Please supply a custom `fetchFn` property to use `fetchBaseQuery` on SSR environments."), async (A, R, d) => {
+    const {
+      getState: v,
+      extra: p,
+      endpoint: P,
+      forced: O,
+      type: f
+    } = R;
+    let g, {
+      url: s,
+      headers: a = new Headers(T.headers),
+      params: S = void 0,
+      responseHandler: b = C ?? "json",
+      validateStatus: h = w ?? mi,
+      timeout: l = _,
+      ...o
+    } = typeof A == "string" ? {
+      url: A
+    } : A, c = {
+      ...T,
+      signal: l ? gi(R.signal, yi(l)) : R.signal,
+      ...o
+    };
+    a = new Headers(Rn(a)), c.headers = await t(a, {
+      getState: v,
+      arg: A,
+      extra: p,
+      endpoint: P,
+      forced: O,
+      type: f,
+      extraOptions: d
+    }) || a;
+    const y = Si(c.body);
+    if (c.body != null && !y && typeof c.body != "string" && c.headers.delete("content-type"), !c.headers.has("content-type") && y && c.headers.set("content-type", u), y && i(c.headers) && (c.body = JSON.stringify(c.body, m)), c.headers.has("accept") || (b === "json" ? c.headers.set("accept", "application/json") : b === "text" && c.headers.set("accept", "text/plain, text/html, */*")), S) {
+      const Q = ~s.indexOf("?") ? "&" : "?", F = r ? r(S) : new URLSearchParams(Rn(S));
+      s += Q + F;
+    }
+    s = hi(e, s);
+    const E = new Request(s, c);
+    g = {
+      request: new Request(s, c)
+    };
+    let M;
+    try {
+      M = await n(E);
+    } catch (Q) {
+      return {
+        error: {
+          status: (Q instanceof Error || typeof DOMException < "u" && Q instanceof DOMException) && Q.name === "TimeoutError" ? "TIMEOUT_ERROR" : "FETCH_ERROR",
+          error: String(Q)
+        },
+        meta: g
+      };
+    }
+    const q = M.clone();
+    g.response = q;
+    let k, D = "";
+    try {
+      let Q;
+      if (await Promise.all([
+        I(M, b).then((F) => k = F, (F) => Q = F),
+        // see https://github.com/node-fetch/node-fetch/issues/665#issuecomment-538995182
+        // we *have* to "use up" both streams at the same time or they will stop running in node-fetch scenarios
+        q.text().then((F) => D = F, () => {
+        })
+      ]), Q) throw Q;
+    } catch (Q) {
+      return {
+        error: {
+          status: "PARSING_ERROR",
+          originalStatus: M.status,
+          data: D,
+          error: String(Q)
+        },
+        meta: g
+      };
+    }
+    return h(M, k) ? {
+      data: k,
+      meta: g
+    } : {
+      error: {
+        status: M.status,
+        data: k
+      },
+      meta: g
+    };
+  };
+  async function I(A, R) {
+    if (typeof R == "function")
+      return R(A);
+    if (R === "content-type" && (R = i(A.headers) ? "json" : "text"), R === "json") {
+      const d = await A.text();
+      return d.length ? JSON.parse(d) : null;
+    }
+    return A.text();
+  }
+}
+var On = class {
+  constructor(e, t = void 0) {
+    this.value = e, this.meta = t;
+  }
+}, Pt = "__rtkq/", bi = "online", Ei = "offline", ir = "focused", tn = /* @__PURE__ */ De(`${Pt}${ir}`), or = /* @__PURE__ */ De(`${Pt}un${ir}`), nn = /* @__PURE__ */ De(`${Pt}${bi}`), sr = /* @__PURE__ */ De(`${Pt}${Ei}`), et = "query", ar = "mutation", cr = "infinitequery";
+function wt(e) {
+  return e.type === et;
+}
+function Pi(e) {
+  return e.type === ar;
+}
+function tt(e) {
+  return e.type === cr;
+}
+function _t(e) {
+  return wt(e) || tt(e);
+}
+function rn(e, t, n, r, i, u) {
+  const m = wi(e) ? e(t, n, r, i) : e;
+  return m ? Lt(m, en, (_) => u(ur(_))) : [];
+}
+function wi(e) {
+  return typeof e == "function";
+}
+function ur(e) {
+  return typeof e == "string" ? {
+    type: e
+  } : e;
+}
+function Ri(e, t) {
+  return e.catch(t);
+}
+var Te = (e, t) => e.endpointDefinitions[t], We = /* @__PURE__ */ Symbol("forceQueryFn"), Kt = (e) => typeof e[We] == "function";
+function Oi({
+  serializeQueryArgs: e,
+  queryThunk: t,
+  infiniteQueryThunk: n,
+  mutationThunk: r,
+  api: i,
+  context: u,
+  getInternalState: m
+}) {
+  const _ = (s) => m(s)?.runningQueries, C = (s) => m(s)?.runningMutations, {
+    unsubscribeQueryResult: w,
+    removeMutationResult: T,
+    updateSubscriptionOptions: I
+  } = i.internalActions;
+  return {
+    buildInitiateQuery: O,
+    buildInitiateInfiniteQuery: f,
+    buildInitiateMutation: g,
+    getRunningQueryThunk: A,
+    getRunningMutationThunk: R,
+    getRunningQueriesThunk: d,
+    getRunningMutationsThunk: v
+  };
+  function A(s, a) {
+    return (S) => {
+      const b = Te(u, s), h = e({
+        queryArgs: a,
+        endpointDefinition: b,
+        endpointName: s
+      });
+      return _(S)?.get(h);
+    };
+  }
+  function R(s, a) {
+    return (S) => C(S)?.get(a);
+  }
+  function d() {
+    return (s) => Pn(_(s));
+  }
+  function v() {
+    return (s) => Pn(C(s));
+  }
+  function p(s) {
+    if (process.env.NODE_ENV !== "production") {
+      if (p.triggered) return;
+      const a = s(i.internalActions.internal_getRTKQSubscriptions());
+      if (p.triggered = !0, typeof a != "object" || typeof a?.type == "string")
+        throw new Error(process.env.NODE_ENV === "production" ? ye(34) : `Warning: Middleware for RTK-Query API at reducerPath "${i.reducerPath}" has not been added to the store.
+You must add the middleware for RTK-Query to function correctly!`);
+    }
+  }
+  function P(s, a) {
+    const S = (b, {
+      subscribe: h = !0,
+      forceRefetch: l,
+      subscriptionOptions: o,
+      [We]: c,
+      ...y
+    } = {}) => (E, N) => {
+      const M = e({
+        queryArgs: b,
+        endpointDefinition: a,
+        endpointName: s
+      });
+      let q;
+      const k = {
+        ...y,
+        type: et,
+        subscribe: h,
+        forceRefetch: l,
+        subscriptionOptions: o,
+        endpointName: s,
+        originalArgs: b,
+        queryCacheKey: M,
+        [We]: c
+      };
+      if (wt(a))
+        q = t(k);
+      else {
+        const {
+          direction: $,
+          initialPageParam: U,
+          refetchCachedPages: x
+        } = y;
+        q = n({
+          ...k,
+          // Supply these even if undefined. This helps with a field existence
+          // check over in `buildSlice.ts`
+          direction: $,
+          initialPageParam: U,
+          refetchCachedPages: x
+        });
+      }
+      const D = i.endpoints[s].select(b), Q = E(q), F = D(N());
+      p(E);
+      const {
+        requestId: L,
+        abort: j
+      } = Q, V = F.requestId !== L, K = _(E)?.get(M), H = () => D(N()), z = Object.assign(c ? (
+        // a query has been forced (upsertQueryData)
+        // -> we want to resolve it once data has been written with the data that will be written
+        Q.then(H)
+      ) : V && !K ? (
+        // a query has been skipped due to a condition and we do not have any currently running query
+        // -> we want to resolve it immediately with the current data
+        Promise.resolve(F)
+      ) : (
+        // query just started or one is already in flight
+        // -> wait for the running query, then resolve with data from after that
+        Promise.all([K, Q]).then(H)
+      ), {
+        arg: b,
+        requestId: L,
+        subscriptionOptions: o,
+        queryCacheKey: M,
+        abort: j,
+        async unwrap() {
+          const $ = await z;
+          if ($.isError)
+            throw $.error;
+          return $.data;
+        },
+        refetch: ($) => E(S(b, {
+          subscribe: !1,
+          forceRefetch: !0,
+          ...$
+        })),
+        unsubscribe() {
+          h && E(w({
+            queryCacheKey: M,
+            requestId: L
+          }));
+        },
+        updateSubscriptionOptions($) {
+          z.subscriptionOptions = $, E(I({
+            endpointName: s,
+            requestId: L,
+            queryCacheKey: M,
+            options: $
+          }));
+        }
+      });
+      if (!K && !V && !c) {
+        const $ = _(E);
+        $.set(M, z), z.then(() => {
+          $.delete(M);
+        });
+      }
+      return z;
+    };
+    return S;
+  }
+  function O(s, a) {
+    return P(s, a);
+  }
+  function f(s, a) {
+    return P(s, a);
+  }
+  function g(s) {
+    return (a, {
+      track: S = !0,
+      fixedCacheKey: b
+    } = {}) => (h, l) => {
+      const o = r({
+        type: "mutation",
+        endpointName: s,
+        originalArgs: a,
+        track: S,
+        fixedCacheKey: b
+      }), c = h(o);
+      p(h);
+      const {
+        requestId: y,
+        abort: E,
+        unwrap: N
+      } = c, M = Ri(c.unwrap().then((Q) => ({
+        data: Q
+      })), (Q) => ({
+        error: Q
+      })), q = () => {
+        h(T({
+          requestId: y,
+          fixedCacheKey: b
+        }));
+      }, k = Object.assign(M, {
+        arg: c.arg,
+        requestId: y,
+        abort: E,
+        unwrap: N,
+        reset: q
+      }), D = C(h);
+      return D.set(y, k), k.then(() => {
+        D.delete(y);
+      }), b && (D.set(b, k), k.then(() => {
+        D.get(b) === k && D.delete(b);
+      })), k;
+    };
+  }
+}
+var lr = class extends Gr {
+  constructor(e, t, n, r) {
+    super(e), this.value = t, this.schemaName = n, this._bqMeta = r;
+  }
+}, me = (e, t) => Array.isArray(e) ? e.includes(t) : !!e;
+async function ve(e, t, n, r) {
+  const i = await e["~standard"].validate(t);
+  if (i.issues)
+    throw new lr(i.issues, t, n, r);
+  return i.value;
+}
+function In(e) {
+  return e;
+}
+var ke = (e = {}) => ({
+  ...e,
+  [Ln]: !0
+});
+function Ii({
+  reducerPath: e,
+  baseQuery: t,
+  context: {
+    endpointDefinitions: n
+  },
+  serializeQueryArgs: r,
+  api: i,
+  assertTagType: u,
+  selectors: m,
+  onSchemaFailure: _,
+  catchSchemaFailure: C,
+  skipSchemaValidation: w
+}) {
+  const T = (o, c, y, E) => (N, M) => {
+    const q = n[o], k = r({
+      queryArgs: c,
+      endpointDefinition: q,
+      endpointName: o
+    });
+    if (N(i.internalActions.queryResultPatched({
+      queryCacheKey: k,
+      patches: y
+    })), !E)
+      return;
+    const D = i.endpoints[o].select(c)(
+      // Work around TS 4.1 mismatch
+      M()
+    ), Q = rn(q.providesTags, D.data, void 0, c, {}, u);
+    N(i.internalActions.updateProvidedBy([{
+      queryCacheKey: k,
+      providedTags: Q
+    }]));
+  };
+  function I(o, c, y = 0) {
+    const E = [c, ...o];
+    return y && E.length > y ? E.slice(0, -1) : E;
+  }
+  function A(o, c, y = 0) {
+    const E = [...o, c];
+    return y && E.length > y ? E.slice(1) : E;
+  }
+  const R = (o, c, y, E = !0) => (N, M) => {
+    const k = i.endpoints[o].select(c)(
+      // Work around TS 4.1 mismatch
+      M()
+    ), D = {
+      patches: [],
+      inversePatches: [],
+      undo: () => N(i.util.patchQueryData(o, c, D.inversePatches, E))
+    };
+    if (k.status === ce)
+      return D;
+    let Q;
+    if ("data" in k)
+      if (ne(k.data)) {
+        const [F, L, j] = tr(k.data, y);
+        D.patches.push(...L), D.inversePatches.push(...j), Q = F;
+      } else
+        Q = y(k.data), D.patches.push({
+          op: "replace",
+          path: [],
+          value: Q
+        }), D.inversePatches.push({
+          op: "replace",
+          path: [],
+          value: k.data
+        });
+    return D.patches.length === 0 || N(i.util.patchQueryData(o, c, D.patches, E)), D;
+  }, d = (o, c, y) => (E) => E(i.endpoints[o].initiate(c, {
+    subscribe: !1,
+    forceRefetch: !0,
+    [We]: () => ({
+      data: y
+    })
+  })), v = (o, c) => o.query && o[c] ? o[c] : In, p = async (o, {
+    signal: c,
+    abort: y,
+    rejectWithValue: E,
+    fulfillWithValue: N,
+    dispatch: M,
+    getState: q,
+    extra: k
+  }) => {
+    const D = n[o.endpointName], {
+      metaSchema: Q,
+      skipSchemaValidation: F = w
+    } = D, L = o.type === et;
+    try {
+      let j = In;
+      const V = {
+        signal: c,
+        abort: y,
+        dispatch: M,
+        getState: q,
+        extra: k,
+        endpoint: o.endpointName,
+        type: o.type,
+        forced: L ? P(o, q()) : void 0,
+        queryCacheKey: L ? o.queryCacheKey : void 0
+      }, K = L ? o[We] : void 0;
+      let H;
+      const z = async (U, x, re, Y) => {
+        if (x == null && U.pages.length)
+          return Promise.resolve({
+            data: U
+          });
+        const Oe = {
+          queryArg: o.originalArgs,
+          pageParam: x
+        }, ie = await $(Oe), Ie = Y ? I : A;
+        return {
+          data: {
+            pages: Ie(U.pages, ie.data, re),
+            pageParams: Ie(U.pageParams, x, re)
+          },
+          meta: ie.meta
+        };
+      };
+      async function $(U) {
+        let x;
+        const {
+          extraOptions: re,
+          argSchema: Y,
+          rawResponseSchema: Oe,
+          responseSchema: ie
+        } = D;
+        if (Y && !me(F, "arg") && (U = await ve(
+          Y,
+          U,
+          "argSchema",
+          {}
+          // we don't have a meta yet, so we can't pass it
+        )), K ? x = K() : D.query ? (j = v(D, "transformResponse"), x = await t(D.query(U), V, re)) : x = await D.queryFn(U, V, re, (X) => t(X, V, re)), typeof process < "u" && process.env.NODE_ENV === "development") {
+          const X = D.query ? "`baseQuery`" : "`queryFn`";
+          let ee;
+          if (!x)
+            ee = `${X} did not return anything.`;
+          else if (typeof x != "object")
+            ee = `${X} did not return an object.`;
+          else if (x.error && x.data)
+            ee = `${X} returned an object containing both \`error\` and \`result\`.`;
+          else if (x.error === void 0 && x.data === void 0)
+            ee = `${X} returned an object containing neither a valid \`error\` and \`result\`. At least one of them should not be \`undefined\``;
+          else
+            for (const le of Object.keys(x))
+              if (le !== "error" && le !== "data" && le !== "meta") {
+                ee = `The object returned by ${X} has the unknown property ${le}.`;
+                break;
+              }
+          ee && console.error(`Error encountered handling the endpoint ${o.endpointName}.
+                  ${ee}
+                  It needs to return an object with either the shape \`{ data: <value> }\` or \`{ error: <value> }\` that may contain an optional \`meta\` property.
+                  Object returned was:`, x);
+        }
+        if (x.error) throw new On(x.error, x.meta);
+        let {
+          data: Ie
+        } = x;
+        Oe && !me(F, "rawResponse") && (Ie = await ve(Oe, x.data, "rawResponseSchema", x.meta));
+        let ue = await j(Ie, x.meta, U);
+        return ie && !me(F, "response") && (ue = await ve(ie, ue, "responseSchema", x.meta)), {
+          ...x,
+          data: ue
+        };
+      }
+      if (L && "infiniteQueryOptions" in D) {
+        const {
+          infiniteQueryOptions: U
+        } = D, {
+          maxPages: x = 1 / 0
+        } = U, re = o.refetchCachedPages ?? U.refetchCachedPages ?? !0;
+        let Y;
+        const Oe = {
+          pages: [],
+          pageParams: []
+        }, ie = m.selectQueryEntry(q(), o.queryCacheKey)?.data, ue = /* arg.forceRefetch */ P(o, q()) && !o.direction || !ie ? Oe : ie;
+        if ("direction" in o && o.direction && ue.pages.length) {
+          const X = o.direction === "backward", le = (X ? fr : Ht)(U, ue, o.originalArgs);
+          Y = await z(ue, le, x, X);
+        } else {
+          const {
+            initialPageParam: X = U.initialPageParam
+          } = o, ee = ie?.pageParams ?? [], le = ee[0] ?? X, Rr = ee.length;
+          if (Y = await z(ue, le, x), K && (Y = {
+            data: Y.data.pages[0]
+          }), re)
+            for (let sn = 1; sn < Rr; sn++) {
+              const Or = Ht(U, Y.data, o.originalArgs);
+              Y = await z(Y.data, Or, x);
+            }
+        }
+        H = Y;
+      } else
+        H = await $(o.originalArgs);
+      return Q && !me(F, "meta") && H.meta && (H.meta = await ve(Q, H.meta, "metaSchema", H.meta)), N(H.data, ke({
+        fulfilledTimeStamp: Date.now(),
+        baseQueryMeta: H.meta
+      }));
+    } catch (j) {
+      let V = j;
+      if (V instanceof On) {
+        let K = v(D, "transformErrorResponse");
+        const {
+          rawErrorResponseSchema: H,
+          errorResponseSchema: z
+        } = D;
+        let {
+          value: $,
+          meta: U
+        } = V;
+        try {
+          H && !me(F, "rawErrorResponse") && ($ = await ve(H, $, "rawErrorResponseSchema", U)), Q && !me(F, "meta") && (U = await ve(Q, U, "metaSchema", U));
+          let x = await K($, U, o.originalArgs);
+          return z && !me(F, "errorResponse") && (x = await ve(z, x, "errorResponseSchema", U)), E(x, ke({
+            baseQueryMeta: U
+          }));
+        } catch (x) {
+          V = x;
+        }
+      }
+      try {
+        if (V instanceof lr) {
+          const K = {
+            endpoint: o.endpointName,
+            arg: o.originalArgs,
+            type: o.type,
+            queryCacheKey: L ? o.queryCacheKey : void 0
+          };
+          D.onSchemaFailure?.(V, K), _?.(V, K);
+          const {
+            catchSchemaFailure: H = C
+          } = D;
+          if (H)
+            return E(H(V, K), ke({
+              baseQueryMeta: V._bqMeta
+            }));
+        }
+      } catch (K) {
+        V = K;
+      }
+      throw typeof process < "u" && process.env.NODE_ENV !== "production" ? console.error(`An unhandled error occurred processing a request for the endpoint "${o.endpointName}".
+In the case of an unhandled error, no tags will be "provided" or "invalidated".`, V) : console.error(V), V;
+    }
+  };
+  function P(o, c) {
+    const y = m.selectQueryEntry(c, o.queryCacheKey), E = m.selectConfig(c).refetchOnMountOrArgChange, N = y?.fulfilledTimeStamp, M = o.forceRefetch ?? (o.subscribe && E);
+    return M ? M === !0 || (Number(/* @__PURE__ */ new Date()) - Number(N)) / 1e3 >= M : !1;
+  }
+  const O = () => an(`${e}/executeQuery`, p, {
+    getPendingMeta({
+      arg: c
+    }) {
+      const y = n[c.endpointName];
+      return ke({
+        startedTimeStamp: Date.now(),
+        ...tt(y) ? {
+          direction: c.direction
+        } : {}
+      });
+    },
+    condition(c, {
+      getState: y
+    }) {
+      const E = y(), N = m.selectQueryEntry(E, c.queryCacheKey), M = N?.fulfilledTimeStamp, q = c.originalArgs, k = N?.originalArgs, D = n[c.endpointName], Q = c.direction;
+      return Kt(c) ? !0 : N?.status === "pending" ? !1 : P(c, E) || wt(D) && D?.forceRefetch?.({
+        currentArg: q,
+        previousArg: k,
+        endpointState: N,
+        state: E
+      }) ? !0 : !(M && !Q);
+    },
+    dispatchConditionRejection: !0
+  }), f = O(), g = O(), s = an(`${e}/executeMutation`, p, {
+    getPendingMeta() {
+      return ke({
+        startedTimeStamp: Date.now()
+      });
+    }
+  }), a = (o) => "force" in o, S = (o) => "ifOlderThan" in o, b = (o, c, y = {}) => (E, N) => {
+    const M = a(y) && y.force, q = S(y) && y.ifOlderThan, k = (Q = !0) => {
+      const F = {
+        forceRefetch: Q,
+        subscribe: !1
+      };
+      return i.endpoints[o].initiate(c, F);
+    }, D = i.endpoints[o].select(c)(N());
+    if (M)
+      E(k());
+    else if (q) {
+      const Q = D?.fulfilledTimeStamp;
+      if (!Q) {
+        E(k());
+        return;
+      }
+      (Number(/* @__PURE__ */ new Date()) - Number(new Date(Q))) / 1e3 >= q && E(k());
+    } else
+      E(k(!1));
+  };
+  function h(o) {
+    return (c) => c?.meta?.arg?.endpointName === o;
+  }
+  function l(o, c) {
+    return {
+      matchPending: Ot(jn(o), h(c)),
+      matchFulfilled: Ot(be(o), h(c)),
+      matchRejected: Ot(Gt(o), h(c))
+    };
+  }
+  return {
+    queryThunk: f,
+    mutationThunk: s,
+    infiniteQueryThunk: g,
+    prefetch: b,
+    updateQueryData: R,
+    upsertQueryData: d,
+    patchQueryData: T,
+    buildMatchThunkActions: l
+  };
+}
+function Ht(e, {
+  pages: t,
+  pageParams: n
+}, r) {
+  const i = t.length - 1;
+  return e.getNextPageParam(t[i], t, n[i], n, r);
+}
+function fr(e, {
+  pages: t,
+  pageParams: n
+}, r) {
+  return e.getPreviousPageParam?.(t[0], t, n[0], n, r);
+}
+function dr(e, t, n, r) {
+  return rn(n[e.meta.arg.endpointName][t], be(e) ? e.payload : void 0, Bt(e) ? e.payload : void 0, e.meta.arg.originalArgs, "baseQueryMeta" in e.meta ? e.meta.baseQueryMeta : void 0, r);
+}
+function An(e) {
+  return Z(e) ? Zn(e) : e;
+}
+function ot(e, t, n) {
+  const r = e[t];
+  r && n(r);
+}
+function Be(e) {
+  return ("arg" in e ? e.arg.fixedCacheKey : e.fixedCacheKey) ?? e.requestId;
+}
+function Cn(e, t, n) {
+  const r = e[Be(t)];
+  r && n(r);
+}
+var st = {};
+function Ai({
+  reducerPath: e,
+  queryThunk: t,
+  mutationThunk: n,
+  serializeQueryArgs: r,
+  context: {
+    endpointDefinitions: i,
+    apiUid: u,
+    extractRehydrationInfo: m,
+    hasRehydrationInfo: _
+  },
+  assertTagType: C,
+  config: w
+}) {
+  const T = De(`${e}/resetApiState`);
+  function I(h, l, o, c) {
+    h[l.queryCacheKey] ??= {
+      status: ce,
+      endpointName: l.endpointName
+    }, ot(h, l.queryCacheKey, (y) => {
+      y.status = $t, y.requestId = o && y.requestId ? (
+        // for `upsertQuery` **updates**, keep the current `requestId`
+        y.requestId
+      ) : (
+        // for normal queries or `upsertQuery` **inserts** always update the `requestId`
+        c.requestId
+      ), l.originalArgs !== void 0 && (y.originalArgs = l.originalArgs), y.startedTimeStamp = c.startedTimeStamp;
+      const E = i[c.arg.endpointName];
+      tt(E) && "direction" in l && (y.direction = l.direction);
+    });
+  }
+  function A(h, l, o, c) {
+    ot(h, l.arg.queryCacheKey, (y) => {
+      if (y.requestId !== l.requestId && !c) return;
+      const {
+        merge: E
+      } = i[l.arg.endpointName];
+      if (y.status = Qe, E)
+        if (y.data !== void 0) {
+          const {
+            fulfilledTimeStamp: N,
+            arg: M,
+            baseQueryMeta: q,
+            requestId: k
+          } = l;
+          let D = Wt(y.data, (Q) => E(Q, o, {
+            arg: M.originalArgs,
+            baseQueryMeta: q,
+            fulfilledTimeStamp: N,
+            requestId: k
+          }));
+          y.data = D;
+        } else
+          y.data = o;
+      else
+        y.data = i[l.arg.endpointName].structuralSharing ?? !0 ? Zt(Z(y.data) ? kr(y.data) : y.data, o) : o;
+      delete y.error, y.fulfilledTimeStamp = l.fulfilledTimeStamp;
+    });
+  }
+  const R = Se({
+    name: `${e}/queries`,
+    initialState: st,
+    reducers: {
+      removeQueryResult: {
+        reducer(h, {
+          payload: {
+            queryCacheKey: l
+          }
+        }) {
+          delete h[l];
+        },
+        prepare: Ne()
+      },
+      cacheEntriesUpserted: {
+        reducer(h, l) {
+          for (const o of l.payload) {
+            const {
+              queryDescription: c,
+              value: y
+            } = o;
+            I(h, c, !0, {
+              arg: c,
+              requestId: l.meta.requestId,
+              startedTimeStamp: l.meta.timestamp
+            }), A(
+              h,
+              {
+                arg: c,
+                requestId: l.meta.requestId,
+                fulfilledTimeStamp: l.meta.timestamp,
+                baseQueryMeta: {}
+              },
+              y,
+              // We know we're upserting here
+              !0
+            );
+          }
+        },
+        prepare: (h) => ({
+          payload: h.map((c) => {
+            const {
+              endpointName: y,
+              arg: E,
+              value: N
+            } = c, M = i[y];
+            return {
+              queryDescription: {
+                type: et,
+                endpointName: y,
+                originalArgs: c.arg,
+                queryCacheKey: r({
+                  queryArgs: E,
+                  endpointDefinition: M,
+                  endpointName: y
+                })
+              },
+              value: N
+            };
+          }),
+          meta: {
+            [Ln]: !0,
+            requestId: $n(),
+            timestamp: Date.now()
+          }
+        })
+      },
+      queryResultPatched: {
+        reducer(h, {
+          payload: {
+            queryCacheKey: l,
+            patches: o
+          }
+        }) {
+          ot(h, l, (c) => {
+            c.data = mn(c.data, o.concat());
+          });
+        },
+        prepare: Ne()
+      }
+    },
+    extraReducers(h) {
+      h.addCase(t.pending, (l, {
+        meta: o,
+        meta: {
+          arg: c
+        }
+      }) => {
+        const y = Kt(c);
+        I(l, c, y, o);
+      }).addCase(t.fulfilled, (l, {
+        meta: o,
+        payload: c
+      }) => {
+        const y = Kt(o.arg);
+        A(l, o, c, y);
+      }).addCase(t.rejected, (l, {
+        meta: {
+          condition: o,
+          arg: c,
+          requestId: y
+        },
+        error: E,
+        payload: N
+      }) => {
+        ot(l, c.queryCacheKey, (M) => {
+          if (!o) {
+            if (M.requestId !== y) return;
+            M.status = qe, M.error = N ?? E;
+          }
+        });
+      }).addMatcher(_, (l, o) => {
+        const {
+          queries: c
+        } = m(o);
+        for (const [y, E] of Object.entries(c))
+          // do not rehydrate entries that were currently in flight.
+          (E?.status === Qe || E?.status === qe) && (l[y] = E);
+      });
+    }
+  }), d = Se({
+    name: `${e}/mutations`,
+    initialState: st,
+    reducers: {
+      removeMutationResult: {
+        reducer(h, {
+          payload: l
+        }) {
+          const o = Be(l);
+          o in h && delete h[o];
+        },
+        prepare: Ne()
+      }
+    },
+    extraReducers(h) {
+      h.addCase(n.pending, (l, {
+        meta: o,
+        meta: {
+          requestId: c,
+          arg: y,
+          startedTimeStamp: E
+        }
+      }) => {
+        y.track && (l[Be(o)] = {
+          requestId: c,
+          status: $t,
+          endpointName: y.endpointName,
+          startedTimeStamp: E
+        });
+      }).addCase(n.fulfilled, (l, {
+        payload: o,
+        meta: c
+      }) => {
+        c.arg.track && Cn(l, c, (y) => {
+          y.requestId === c.requestId && (y.status = Qe, y.data = o, y.fulfilledTimeStamp = c.fulfilledTimeStamp);
+        });
+      }).addCase(n.rejected, (l, {
+        payload: o,
+        error: c,
+        meta: y
+      }) => {
+        y.arg.track && Cn(l, y, (E) => {
+          E.requestId === y.requestId && (E.status = qe, E.error = o ?? c);
+        });
+      }).addMatcher(_, (l, o) => {
+        const {
+          mutations: c
+        } = m(o);
+        for (const [y, E] of Object.entries(c))
+          // do not rehydrate entries that were currently in flight.
+          (E?.status === Qe || E?.status === qe) && // only rehydrate endpoints that were persisted using a `fixedCacheKey`
+          y !== E?.requestId && (l[y] = E);
+      });
+    }
+  }), v = {
+    tags: {},
+    keys: {}
+  }, p = Se({
+    name: `${e}/invalidation`,
+    initialState: v,
+    reducers: {
+      updateProvidedBy: {
+        reducer(h, l) {
+          for (const {
+            queryCacheKey: o,
+            providedTags: c
+          } of l.payload) {
+            P(h, o);
+            for (const {
+              type: y,
+              id: E
+            } of c) {
+              const N = (h.tags[y] ??= {})[E || "__internal_without_id"] ??= [];
+              N.includes(o) || N.push(o);
+            }
+            h.keys[o] = c;
+          }
+        },
+        prepare: Ne()
+      }
+    },
+    extraReducers(h) {
+      h.addCase(R.actions.removeQueryResult, (l, {
+        payload: {
+          queryCacheKey: o
+        }
+      }) => {
+        P(l, o);
+      }).addMatcher(_, (l, o) => {
+        const {
+          provided: c
+        } = m(o);
+        for (const [y, E] of Object.entries(c.tags ?? {}))
+          for (const [N, M] of Object.entries(E)) {
+            const q = (l.tags[y] ??= {})[N || "__internal_without_id"] ??= [];
+            for (const k of M)
+              q.includes(k) || q.push(k), l.keys[k] = c.keys[k];
+          }
+      }).addMatcher(ze(be(t), Bt(t)), (l, o) => {
+        O(l, [o]);
+      }).addMatcher(R.actions.cacheEntriesUpserted.match, (l, o) => {
+        const c = o.payload.map(({
+          queryDescription: y,
+          value: E
+        }) => ({
+          type: "UNKNOWN",
+          payload: E,
+          meta: {
+            requestStatus: "fulfilled",
+            requestId: "UNKNOWN",
+            arg: y
+          }
+        }));
+        O(l, c);
+      });
+    }
+  });
+  function P(h, l) {
+    const o = An(h.keys[l] ?? []);
+    for (const c of o) {
+      const y = c.type, E = c.id ?? "__internal_without_id", N = h.tags[y]?.[E];
+      N && (h.tags[y][E] = An(N).filter((M) => M !== l));
+    }
+    delete h.keys[l];
+  }
+  function O(h, l) {
+    const o = l.map((c) => {
+      const y = dr(c, "providesTags", i, C), {
+        queryCacheKey: E
+      } = c.meta.arg;
+      return {
+        queryCacheKey: E,
+        providedTags: y
+      };
+    });
+    p.caseReducers.updateProvidedBy(h, p.actions.updateProvidedBy(o));
+  }
+  const f = Se({
+    name: `${e}/subscriptions`,
+    initialState: st,
+    reducers: {
+      updateSubscriptionOptions(h, l) {
+      },
+      unsubscribeQueryResult(h, l) {
+      },
+      internal_getRTKQSubscriptions() {
+      }
+    }
+  }), g = Se({
+    name: `${e}/internalSubscriptions`,
+    initialState: st,
+    reducers: {
+      subscriptionsUpdated: {
+        reducer(h, l) {
+          return mn(h, l.payload);
+        },
+        prepare: Ne()
+      }
+    }
+  }), s = Se({
+    name: `${e}/config`,
+    initialState: {
+      online: fi(),
+      focused: li(),
+      middlewareRegistered: !1,
+      ...w
+    },
+    reducers: {
+      middlewareRegistered(h, {
+        payload: l
+      }) {
+        h.middlewareRegistered = h.middlewareRegistered === "conflict" || u !== l ? "conflict" : !0;
+      }
+    },
+    extraReducers: (h) => {
+      h.addCase(nn, (l) => {
+        l.online = !0;
+      }).addCase(sr, (l) => {
+        l.online = !1;
+      }).addCase(tn, (l) => {
+        l.focused = !0;
+      }).addCase(or, (l) => {
+        l.focused = !1;
+      }).addMatcher(_, (l) => ({
+        ...l
+      }));
+    }
+  }), a = Ar({
+    queries: R.reducer,
+    mutations: d.reducer,
+    provided: p.reducer,
+    subscriptions: g.reducer,
+    config: s.reducer
+  }), S = (h, l) => a(T.match(l) ? void 0 : h, l), b = {
+    ...s.actions,
+    ...R.actions,
+    ...f.actions,
+    ...g.actions,
+    ...d.actions,
+    ...p.actions,
+    resetApiState: T
+  };
+  return {
+    reducer: S,
+    actions: b
+  };
+}
+var te = /* @__PURE__ */ Symbol.for("RTKQ/skipToken"), pr = {
+  status: ce
+}, Tn = /* @__PURE__ */ Wt(pr, () => {
+}), Dn = /* @__PURE__ */ Wt(pr, () => {
+});
+function Ci({
+  serializeQueryArgs: e,
+  reducerPath: t,
+  createSelector: n
+}) {
+  const r = (f) => Tn, i = (f) => Dn;
+  return {
+    buildQuerySelector: A,
+    buildInfiniteQuerySelector: R,
+    buildMutationSelector: d,
+    selectInvalidatedBy: v,
+    selectCachedArgsForQuery: p,
+    selectApiState: m,
+    selectQueries: _,
+    selectMutations: w,
+    selectQueryEntry: C,
+    selectConfig: T
+  };
+  function u(f) {
+    return {
+      ...f,
+      ...bn(f.status)
+    };
+  }
+  function m(f) {
+    const g = f[t];
+    if (process.env.NODE_ENV !== "production" && !g) {
+      if (m.triggered) return g;
+      m.triggered = !0, console.error(`Error: No data found at \`state.${t}\`. Did you forget to add the reducer to the store?`);
+    }
+    return g;
+  }
+  function _(f) {
+    return m(f)?.queries;
+  }
+  function C(f, g) {
+    return _(f)?.[g];
+  }
+  function w(f) {
+    return m(f)?.mutations;
+  }
+  function T(f) {
+    return m(f)?.config;
+  }
+  function I(f, g, s) {
+    return (a) => {
+      if (a === te)
+        return n(r, s);
+      const S = e({
+        queryArgs: a,
+        endpointDefinition: g,
+        endpointName: f
+      });
+      return n((h) => C(h, S) ?? Tn, s);
+    };
+  }
+  function A(f, g) {
+    return I(f, g, u);
+  }
+  function R(f, g) {
+    const {
+      infiniteQueryOptions: s
+    } = g;
+    function a(S) {
+      const b = {
+        ...S,
+        ...bn(S.status)
+      }, {
+        isLoading: h,
+        isError: l,
+        direction: o
+      } = b, c = o === "forward", y = o === "backward";
+      return {
+        ...b,
+        hasNextPage: P(s, b.data, b.originalArgs),
+        hasPreviousPage: O(s, b.data, b.originalArgs),
+        isFetchingNextPage: h && c,
+        isFetchingPreviousPage: h && y,
+        isFetchNextPageError: l && c,
+        isFetchPreviousPageError: l && y
+      };
+    }
+    return I(f, g, a);
+  }
+  function d() {
+    return (f) => {
+      let g;
+      return typeof f == "object" ? g = Be(f) ?? te : g = f, n(g === te ? i : (S) => m(S)?.mutations?.[g] ?? Dn, u);
+    };
+  }
+  function v(f, g) {
+    const s = f[t], a = /* @__PURE__ */ new Set(), S = Lt(g, en, ur);
+    for (const b of S) {
+      const h = s.provided.tags[b.type];
+      if (!h)
+        continue;
+      let l = (b.id !== void 0 ? (
+        // id given: invalidate all queries that provide this type & id
+        h[b.id]
+      ) : (
+        // no id: invalidate all queries that provide this type
+        Object.values(h).flat()
+      )) ?? [];
+      for (const o of l)
+        a.add(o);
+    }
+    return Array.from(a.values()).flatMap((b) => {
+      const h = s.queries[b];
+      return h ? {
+        queryCacheKey: b,
+        endpointName: h.endpointName,
+        originalArgs: h.originalArgs
+      } : [];
+    });
+  }
+  function p(f, g) {
+    return Lt(Object.values(_(f)), (s) => s?.endpointName === g && s.status !== ce, (s) => s.originalArgs);
+  }
+  function P(f, g, s) {
+    return g ? Ht(f, g, s) != null : !1;
+  }
+  function O(f, g, s) {
+    return !g || !f.getPreviousPageParam ? !1 : fr(f, g, s) != null;
+  }
+}
+var Nn = WeakMap ? /* @__PURE__ */ new WeakMap() : void 0, kn = ({
+  endpointName: e,
+  queryArgs: t
+}) => {
+  let n = "";
+  const r = Nn?.get(t);
+  if (typeof r == "string")
+    n = r;
+  else {
+    const i = JSON.stringify(t, (u, m) => (m = typeof m == "bigint" ? {
+      $bigint: m.toString()
+    } : m, m = Ve(m) ? Object.keys(m).sort().reduce((_, C) => (_[C] = m[C], _), {}) : m, m));
+    Ve(t) && Nn?.set(t, i), n = i;
+  }
+  return `${e}(${n})`;
+};
+function hr(...e) {
+  return function(n) {
+    const r = vt((w) => n.extractRehydrationInfo?.(w, {
+      reducerPath: n.reducerPath ?? "api"
+    })), i = {
+      reducerPath: "api",
+      keepUnusedDataFor: 60,
+      refetchOnMountOrArgChange: !1,
+      refetchOnFocus: !1,
+      refetchOnReconnect: !1,
+      invalidationBehavior: "delayed",
+      ...n,
+      extractRehydrationInfo: r,
+      serializeQueryArgs(w) {
+        let T = kn;
+        if ("serializeQueryArgs" in w.endpointDefinition) {
+          const I = w.endpointDefinition.serializeQueryArgs;
+          T = (A) => {
+            const R = I(A);
+            return typeof R == "string" ? R : kn({
+              ...A,
+              queryArgs: R
+            });
+          };
+        } else n.serializeQueryArgs && (T = n.serializeQueryArgs);
+        return T(w);
+      },
+      tagTypes: [...n.tagTypes || []]
+    }, u = {
+      endpointDefinitions: {},
+      batch(w) {
+        w();
+      },
+      apiUid: $n(),
+      extractRehydrationInfo: r,
+      hasRehydrationInfo: vt((w) => r(w) != null)
+    }, m = {
+      injectEndpoints: C,
+      enhanceEndpoints({
+        addTagTypes: w,
+        endpoints: T
+      }) {
+        if (w)
+          for (const I of w)
+            i.tagTypes.includes(I) || i.tagTypes.push(I);
+        if (T)
+          for (const [I, A] of Object.entries(T))
+            typeof A == "function" ? A(Te(u, I)) : Object.assign(Te(u, I) || {}, A);
+        return m;
+      }
+    }, _ = e.map((w) => w.init(m, i, u));
+    function C(w) {
+      const T = w.endpoints({
+        query: (I) => ({
+          ...I,
+          type: et
+        }),
+        mutation: (I) => ({
+          ...I,
+          type: ar
+        }),
+        infiniteQuery: (I) => ({
+          ...I,
+          type: cr
+        })
+      });
+      for (const [I, A] of Object.entries(T)) {
+        if (w.overrideExisting !== !0 && I in u.endpointDefinitions) {
+          if (w.overrideExisting === "throw")
+            throw new Error(process.env.NODE_ENV === "production" ? ye(39) : `called \`injectEndpoints\` to override already-existing endpointName ${I} without specifying \`overrideExisting: true\``);
+          typeof process < "u" && process.env.NODE_ENV === "development" && console.error(`called \`injectEndpoints\` to override already-existing endpointName ${I} without specifying \`overrideExisting: true\``);
+          continue;
+        }
+        if (typeof process < "u" && process.env.NODE_ENV === "development" && tt(A)) {
+          const {
+            infiniteQueryOptions: R
+          } = A, {
+            maxPages: d,
+            getPreviousPageParam: v
+          } = R;
+          if (typeof d == "number") {
+            if (d < 1)
+              throw new Error(process.env.NODE_ENV === "production" ? ye(40) : `maxPages for endpoint '${I}' must be a number greater than 0`);
+            if (typeof v != "function")
+              throw new Error(process.env.NODE_ENV === "production" ? ye(41) : `getPreviousPageParam for endpoint '${I}' must be a function if maxPages is used`);
+          }
+        }
+        u.endpointDefinitions[I] = A;
+        for (const R of _)
+          R.injectEndpoint(I, A);
+      }
+      return m;
+    }
+    return m.injectEndpoints({
+      endpoints: n.endpoints
+    });
+  };
+}
+function oe(e, ...t) {
+  return Object.assign(e, ...t);
+}
+var Ti = ({
+  api: e,
+  queryThunk: t,
+  internalState: n,
+  mwApi: r
+}) => {
+  const i = `${e.reducerPath}/subscriptions`;
+  let u = null, m = null;
+  const {
+    updateSubscriptionOptions: _,
+    unsubscribeQueryResult: C
+  } = e.internalActions, w = (v, p) => {
+    if (_.match(p)) {
+      const {
+        queryCacheKey: O,
+        requestId: f,
+        options: g
+      } = p.payload, s = v.get(O);
+      return s?.has(f) && s.set(f, g), !0;
+    }
+    if (C.match(p)) {
+      const {
+        queryCacheKey: O,
+        requestId: f
+      } = p.payload, g = v.get(O);
+      return g && g.delete(f), !0;
+    }
+    if (e.internalActions.removeQueryResult.match(p))
+      return v.delete(p.payload.queryCacheKey), !0;
+    if (t.pending.match(p)) {
+      const {
+        meta: {
+          arg: O,
+          requestId: f
+        }
+      } = p, g = St(v, O.queryCacheKey, jt);
+      return O.subscribe && g.set(f, O.subscriptionOptions ?? g.get(f) ?? {}), !0;
+    }
+    let P = !1;
+    if (t.rejected.match(p)) {
+      const {
+        meta: {
+          condition: O,
+          arg: f,
+          requestId: g
+        }
+      } = p;
+      if (O && f.subscribe) {
+        const s = St(v, f.queryCacheKey, jt);
+        s.set(g, f.subscriptionOptions ?? s.get(g) ?? {}), P = !0;
+      }
+    }
+    return P;
+  }, T = () => n.currentSubscriptions, R = {
+    getSubscriptions: T,
+    getSubscriptionCount: (v) => T().get(v)?.size ?? 0,
+    isRequestSubscribed: (v, p) => !!T()?.get(v)?.get(p)
+  };
+  function d(v) {
+    return JSON.parse(JSON.stringify(Object.fromEntries([...v].map(([p, P]) => [p, Object.fromEntries(P)]))));
+  }
+  return (v, p) => {
+    if (u || (u = d(n.currentSubscriptions)), e.util.resetApiState.match(v))
+      return u = {}, n.currentSubscriptions.clear(), m = null, [!0, !1];
+    if (e.internalActions.internal_getRTKQSubscriptions.match(v))
+      return [!1, R];
+    const P = w(n.currentSubscriptions, v);
+    let O = !0;
+    if (process.env.NODE_ENV === "test" && typeof v.type == "string" && v.type === `${e.reducerPath}/getPolling`)
+      return [!1, n.currentPolls];
+    if (P) {
+      m || (m = setTimeout(() => {
+        const s = d(n.currentSubscriptions), [, a] = tr(u, () => s);
+        p.next(e.internalActions.subscriptionsUpdated(a)), u = s, m = null;
+      }, 500));
+      const f = typeof v.type == "string" && !!v.type.startsWith(i), g = t.rejected.match(v) && v.meta.condition && !!v.meta.arg.subscribe;
+      O = !f && !g;
+    }
+    return [O, !1];
+  };
+}, Di = 2147483647 / 1e3 - 1, Ni = ({
+  reducerPath: e,
+  api: t,
+  queryThunk: n,
+  context: r,
+  internalState: i,
+  selectors: {
+    selectQueryEntry: u,
+    selectConfig: m
+  },
+  getRunningQueryThunk: _,
+  mwApi: C
+}) => {
+  const {
+    removeQueryResult: w,
+    unsubscribeQueryResult: T,
+    cacheEntriesUpserted: I
+  } = t.internalActions, A = ze(T.match, n.fulfilled, n.rejected, I.match);
+  function R(f) {
+    const g = i.currentSubscriptions.get(f);
+    return g ? g.size > 0 : !1;
+  }
+  const d = {};
+  function v(f) {
+    for (const g of f.values())
+      g?.abort?.();
+  }
+  const p = (f, g) => {
+    const s = g.getState(), a = m(s);
+    if (A(f)) {
+      let S;
+      if (I.match(f))
+        S = f.payload.map((b) => b.queryDescription.queryCacheKey);
+      else {
+        const {
+          queryCacheKey: b
+        } = T.match(f) ? f.payload : f.meta.arg;
+        S = [b];
+      }
+      P(S, g, a);
+    }
+    if (t.util.resetApiState.match(f)) {
+      for (const [S, b] of Object.entries(d))
+        b && clearTimeout(b), delete d[S];
+      v(i.runningQueries), v(i.runningMutations);
+    }
+    if (r.hasRehydrationInfo(f)) {
+      const {
+        queries: S
+      } = r.extractRehydrationInfo(f);
+      P(Object.keys(S), g, a);
+    }
+  };
+  function P(f, g, s) {
+    const a = g.getState();
+    for (const S of f) {
+      const b = u(a, S);
+      b?.endpointName && O(S, b.endpointName, g, s);
+    }
+  }
+  function O(f, g, s, a) {
+    const b = Te(r, g)?.keepUnusedDataFor ?? a.keepUnusedDataFor;
+    if (b === 1 / 0)
+      return;
+    const h = Math.max(0, Math.min(b, Di));
+    if (!R(f)) {
+      const l = d[f];
+      l && clearTimeout(l), d[f] = setTimeout(() => {
+        if (!R(f)) {
+          const o = u(s.getState(), f);
+          o?.endpointName && s.dispatch(_(o.endpointName, o.originalArgs))?.abort(), s.dispatch(w({
+            queryCacheKey: f
+          }));
+        }
+        delete d[f];
+      }, h * 1e3);
+    }
+  }
+  return p;
+}, Mn = new Error("Promise never resolved before cacheEntryRemoved."), ki = ({
+  api: e,
+  reducerPath: t,
+  context: n,
+  queryThunk: r,
+  mutationThunk: i,
+  internalState: u,
+  selectors: {
+    selectQueryEntry: m,
+    selectApiState: _
+  }
+}) => {
+  const C = cn(r), w = cn(i), T = be(r, i), I = {}, {
+    removeQueryResult: A,
+    removeMutationResult: R,
+    cacheEntriesUpserted: d
+  } = e.internalActions;
+  function v(s, a, S) {
+    const b = I[s];
+    b?.valueResolved && (b.valueResolved({
+      data: a,
+      meta: S
+    }), delete b.valueResolved);
+  }
+  function p(s) {
+    const a = I[s];
+    a && (delete I[s], a.cacheEntryRemoved());
+  }
+  function P(s) {
+    const {
+      arg: a,
+      requestId: S
+    } = s.meta, {
+      endpointName: b,
+      originalArgs: h
+    } = a;
+    return [b, h, S];
+  }
+  const O = (s, a, S) => {
+    const b = f(s);
+    function h(l, o, c, y) {
+      const E = m(S, o), N = m(a.getState(), o);
+      !E && N && g(l, y, o, a, c);
+    }
+    if (r.pending.match(s)) {
+      const [l, o, c] = P(s);
+      h(l, b, c, o);
+    } else if (d.match(s))
+      for (const {
+        queryDescription: l,
+        value: o
+      } of s.payload) {
+        const {
+          endpointName: c,
+          originalArgs: y,
+          queryCacheKey: E
+        } = l;
+        h(c, E, s.meta.requestId, y), v(E, o, {});
+      }
+    else if (i.pending.match(s)) {
+      if (a.getState()[t].mutations[b]) {
+        const [o, c, y] = P(s);
+        g(o, c, b, a, y);
+      }
+    } else if (T(s))
+      v(b, s.payload, s.meta.baseQueryMeta);
+    else if (A.match(s) || R.match(s))
+      p(b);
+    else if (e.util.resetApiState.match(s))
+      for (const l of Object.keys(I))
+        p(l);
+  };
+  function f(s) {
+    return C(s) ? s.meta.arg.queryCacheKey : w(s) ? s.meta.arg.fixedCacheKey ?? s.meta.requestId : A.match(s) ? s.payload.queryCacheKey : R.match(s) ? Be(s.payload) : "";
+  }
+  function g(s, a, S, b, h) {
+    const l = Te(n, s), o = l?.onCacheEntryAdded;
+    if (!o) return;
+    const c = {}, y = new Promise((D) => {
+      c.cacheEntryRemoved = D;
+    }), E = Promise.race([new Promise((D) => {
+      c.valueResolved = D;
+    }), y.then(() => {
+      throw Mn;
+    })]);
+    E.catch(() => {
+    }), I[S] = c;
+    const N = e.endpoints[s].select(_t(l) ? a : S), M = b.dispatch((D, Q, F) => F), q = {
+      ...b,
+      getCacheEntry: () => N(b.getState()),
+      requestId: h,
+      extra: M,
+      updateCachedData: _t(l) ? (D) => b.dispatch(e.util.updateQueryData(s, a, D)) : void 0,
+      cacheDataLoaded: E,
+      cacheEntryRemoved: y
+    }, k = o(a, q);
+    Promise.resolve(k).catch((D) => {
+      if (D !== Mn)
+        throw D;
+    });
+  }
+  return O;
+}, Mi = ({
+  api: e,
+  context: {
+    apiUid: t
+  },
+  reducerPath: n
+}) => (r, i) => {
+  e.util.resetApiState.match(r) && i.dispatch(e.internalActions.middlewareRegistered(t)), typeof process < "u" && process.env.NODE_ENV === "development" && e.internalActions.middlewareRegistered.match(r) && r.payload === t && i.getState()[n]?.config?.middlewareRegistered === "conflict" && console.warn(`There is a mismatch between slice and middleware for the reducerPath "${n}".
+You can only have one api per reducer path, this will lead to crashes in various situations!${n === "api" ? `
+If you have multiple apis, you *have* to specify the reducerPath option when using createApi!` : ""}`);
+}, Qi = ({
+  reducerPath: e,
+  context: t,
+  context: {
+    endpointDefinitions: n
+  },
+  mutationThunk: r,
+  queryThunk: i,
+  api: u,
+  assertTagType: m,
+  refetchQuery: _,
+  internalState: C
+}) => {
+  const {
+    removeQueryResult: w
+  } = u.internalActions, T = ze(be(r), Bt(r)), I = ze(be(i, r), Gt(i, r));
+  let A = [], R = 0;
+  const d = (P, O) => {
+    (i.pending.match(P) || r.pending.match(P)) && R++, I(P) && (R = Math.max(0, R - 1)), T(P) ? p(dr(P, "invalidatesTags", n, m), O) : I(P) ? p([], O) : u.util.invalidateTags.match(P) && p(rn(P.payload, void 0, void 0, void 0, void 0, m), O);
+  };
+  function v() {
+    return R > 0;
+  }
+  function p(P, O) {
+    const f = O.getState(), g = f[e];
+    if (A.push(...P), g.config.invalidationBehavior === "delayed" && v())
+      return;
+    const s = A;
+    if (A = [], s.length === 0) return;
+    const a = u.util.selectInvalidatedBy(f, s);
+    t.batch(() => {
+      const S = Array.from(a.values());
+      for (const {
+        queryCacheKey: b
+      } of S) {
+        const h = g.queries[b], l = St(C.currentSubscriptions, b, jt);
+        h && (l.size === 0 ? O.dispatch(w({
+          queryCacheKey: b
+        })) : h.status !== ce && O.dispatch(_(h)));
+      }
+    });
+  }
+  return d;
+}, qi = ({
+  reducerPath: e,
+  queryThunk: t,
+  api: n,
+  refetchQuery: r,
+  internalState: i
+}) => {
+  const {
+    currentPolls: u,
+    currentSubscriptions: m
+  } = i, _ = /* @__PURE__ */ new Set();
+  let C = null;
+  const w = (p, P) => {
+    (n.internalActions.updateSubscriptionOptions.match(p) || n.internalActions.unsubscribeQueryResult.match(p)) && T(p.payload.queryCacheKey, P), (t.pending.match(p) || t.rejected.match(p) && p.meta.condition) && T(p.meta.arg.queryCacheKey, P), (t.fulfilled.match(p) || t.rejected.match(p) && !p.meta.condition) && I(p.meta.arg, P), n.util.resetApiState.match(p) && (d(), C && (clearTimeout(C), C = null), _.clear());
+  };
+  function T(p, P) {
+    _.add(p), C || (C = setTimeout(() => {
+      for (const O of _)
+        A({
+          queryCacheKey: O
+        }, P);
+      _.clear(), C = null;
+    }, 0));
+  }
+  function I({
+    queryCacheKey: p
+  }, P) {
+    const O = P.getState()[e], f = O.queries[p], g = m.get(p);
+    if (!f || f.status === ce) return;
+    const {
+      lowestPollingInterval: s,
+      skipPollingIfUnfocused: a
+    } = v(g);
+    if (!Number.isFinite(s)) return;
+    const S = u.get(p);
+    S?.timeout && (clearTimeout(S.timeout), S.timeout = void 0);
+    const b = Date.now() + s;
+    u.set(p, {
+      nextPollTimestamp: b,
+      pollingInterval: s,
+      timeout: setTimeout(() => {
+        (O.config.focused || !a) && P.dispatch(r(f)), I({
+          queryCacheKey: p
+        }, P);
+      }, s)
+    });
+  }
+  function A({
+    queryCacheKey: p
+  }, P) {
+    const f = P.getState()[e].queries[p], g = m.get(p);
+    if (!f || f.status === ce)
+      return;
+    const {
+      lowestPollingInterval: s
+    } = v(g);
+    if (process.env.NODE_ENV === "test") {
+      const b = u.pollUpdateCounters ??= {};
+      b[p] ??= 0, b[p]++;
+    }
+    if (!Number.isFinite(s)) {
+      R(p);
+      return;
+    }
+    const a = u.get(p), S = Date.now() + s;
+    (!a || S < a.nextPollTimestamp) && I({
+      queryCacheKey: p
+    }, P);
+  }
+  function R(p) {
+    const P = u.get(p);
+    P?.timeout && clearTimeout(P.timeout), u.delete(p);
+  }
+  function d() {
+    for (const p of u.keys())
+      R(p);
+  }
+  function v(p = /* @__PURE__ */ new Map()) {
+    let P = !1, O = Number.POSITIVE_INFINITY;
+    for (const f of p.values())
+      f.pollingInterval && (O = Math.min(f.pollingInterval, O), P = f.skipPollingIfUnfocused || P);
+    return {
+      lowestPollingInterval: O,
+      skipPollingIfUnfocused: P
+    };
+  }
+  return w;
+}, Fi = ({
+  api: e,
+  context: t,
+  queryThunk: n,
+  mutationThunk: r
+}) => {
+  const i = jn(n, r), u = Gt(n, r), m = be(n, r), _ = {};
+  return (w, T) => {
+    if (i(w)) {
+      const {
+        requestId: I,
+        arg: {
+          endpointName: A,
+          originalArgs: R
+        }
+      } = w.meta, d = Te(t, A), v = d?.onQueryStarted;
+      if (v) {
+        const p = {}, P = new Promise((s, a) => {
+          p.resolve = s, p.reject = a;
+        });
+        P.catch(() => {
+        }), _[I] = p;
+        const O = e.endpoints[A].select(_t(d) ? R : I), f = T.dispatch((s, a, S) => S), g = {
+          ...T,
+          getCacheEntry: () => O(T.getState()),
+          requestId: I,
+          extra: f,
+          updateCachedData: _t(d) ? (s) => T.dispatch(e.util.updateQueryData(A, R, s)) : void 0,
+          queryFulfilled: P
+        };
+        v(R, g);
+      }
+    } else if (m(w)) {
+      const {
+        requestId: I,
+        baseQueryMeta: A
+      } = w.meta;
+      _[I]?.resolve({
+        data: w.payload,
+        meta: A
+      }), delete _[I];
+    } else if (u(w)) {
+      const {
+        requestId: I,
+        rejectedWithValue: A,
+        baseQueryMeta: R
+      } = w.meta;
+      _[I]?.reject({
+        error: w.payload ?? w.error,
+        isUnhandledError: !A,
+        meta: R
+      }), delete _[I];
+    }
+  };
+}, xi = ({
+  reducerPath: e,
+  context: t,
+  api: n,
+  refetchQuery: r,
+  internalState: i
+}) => {
+  const {
+    removeQueryResult: u
+  } = n.internalActions, m = (C, w) => {
+    tn.match(C) && _(w, "refetchOnFocus"), nn.match(C) && _(w, "refetchOnReconnect");
+  };
+  function _(C, w) {
+    const T = C.getState()[e], I = T.queries, A = i.currentSubscriptions;
+    t.batch(() => {
+      for (const R of A.keys()) {
+        const d = I[R], v = A.get(R);
+        if (!v || !d) continue;
+        const p = [...v.values()];
+        (p.some((O) => O[w] === !0) || p.every((O) => O[w] === void 0) && T.config[w]) && (v.size === 0 ? C.dispatch(u({
+          queryCacheKey: R
+        })) : d.status !== ce && C.dispatch(r(d)));
+      }
+    });
+  }
+  return m;
+};
+function Ui(e) {
+  const {
+    reducerPath: t,
+    queryThunk: n,
+    api: r,
+    context: i,
+    getInternalState: u
+  } = e, {
+    apiUid: m
+  } = i, _ = {
+    invalidateTags: De(`${t}/invalidateTags`)
+  }, C = (A) => A.type.startsWith(`${t}/`), w = [Mi, Ni, Qi, qi, ki, Fi];
+  return {
+    middleware: (A) => {
+      let R = !1;
+      const d = u(A.dispatch), v = {
+        ...e,
+        internalState: d,
+        refetchQuery: I,
+        isThisApiSliceAction: C,
+        mwApi: A
+      }, p = w.map((f) => f(v)), P = Ti(v), O = xi(v);
+      return (f) => (g) => {
+        if (!Cr(g))
+          return f(g);
+        R || (R = !0, A.dispatch(r.internalActions.middlewareRegistered(m)));
+        const s = {
+          ...A,
+          next: f
+        }, a = A.getState(), [S, b] = P(g, s, a);
+        let h;
+        if (S ? h = f(g) : h = b, A.getState()[t] && (O(g, s, a), C(g) || i.hasRehydrationInfo(g)))
+          for (const l of p)
+            l(g, s, a);
+        return h;
+      };
+    },
+    actions: _
+  };
+  function I(A) {
+    return e.api.endpoints[A.endpointName].initiate(A.originalArgs, {
+      subscribe: !1,
+      forceRefetch: !0
+    });
+  }
+}
+var Qn = /* @__PURE__ */ Symbol(), yr = ({
+  createSelector: e = Ir
+} = {}) => ({
+  name: Qn,
+  init(t, {
+    baseQuery: n,
+    tagTypes: r,
+    reducerPath: i,
+    serializeQueryArgs: u,
+    keepUnusedDataFor: m,
+    refetchOnMountOrArgChange: _,
+    refetchOnFocus: C,
+    refetchOnReconnect: w,
+    invalidationBehavior: T,
+    onSchemaFailure: I,
+    catchSchemaFailure: A,
+    skipSchemaValidation: R
+  }, d) {
+    Br();
+    const v = (z) => (typeof process < "u" && process.env.NODE_ENV === "development" && (r.includes(z.type) || console.error(`Tag type '${z.type}' was used, but not specified in \`tagTypes\`!`)), z);
+    Object.assign(t, {
+      reducerPath: i,
+      endpoints: {},
+      internalActions: {
+        onOnline: nn,
+        onOffline: sr,
+        onFocus: tn,
+        onFocusLost: or
+      },
+      util: {}
+    });
+    const p = Ci({
+      serializeQueryArgs: u,
+      reducerPath: i,
+      createSelector: e
+    }), {
+      selectInvalidatedBy: P,
+      selectCachedArgsForQuery: O,
+      buildQuerySelector: f,
+      buildInfiniteQuerySelector: g,
+      buildMutationSelector: s
+    } = p;
+    oe(t.util, {
+      selectInvalidatedBy: P,
+      selectCachedArgsForQuery: O
+    });
+    const {
+      queryThunk: a,
+      infiniteQueryThunk: S,
+      mutationThunk: b,
+      patchQueryData: h,
+      updateQueryData: l,
+      upsertQueryData: o,
+      prefetch: c,
+      buildMatchThunkActions: y
+    } = Ii({
+      baseQuery: n,
+      reducerPath: i,
+      context: d,
+      api: t,
+      serializeQueryArgs: u,
+      assertTagType: v,
+      selectors: p,
+      onSchemaFailure: I,
+      catchSchemaFailure: A,
+      skipSchemaValidation: R
+    }), {
+      reducer: E,
+      actions: N
+    } = Ai({
+      context: d,
+      queryThunk: a,
+      mutationThunk: b,
+      serializeQueryArgs: u,
+      reducerPath: i,
+      assertTagType: v,
+      config: {
+        refetchOnFocus: C,
+        refetchOnReconnect: w,
+        refetchOnMountOrArgChange: _,
+        keepUnusedDataFor: m,
+        reducerPath: i,
+        invalidationBehavior: T
+      }
+    });
+    oe(t.util, {
+      patchQueryData: h,
+      updateQueryData: l,
+      upsertQueryData: o,
+      prefetch: c,
+      resetApiState: N.resetApiState,
+      upsertQueryEntries: N.cacheEntriesUpserted
+    }), oe(t.internalActions, N);
+    const M = /* @__PURE__ */ new WeakMap(), q = (z) => St(M, z, () => ({
+      currentSubscriptions: /* @__PURE__ */ new Map(),
+      currentPolls: /* @__PURE__ */ new Map(),
+      runningQueries: /* @__PURE__ */ new Map(),
+      runningMutations: /* @__PURE__ */ new Map()
+    })), {
+      buildInitiateQuery: k,
+      buildInitiateInfiniteQuery: D,
+      buildInitiateMutation: Q,
+      getRunningMutationThunk: F,
+      getRunningMutationsThunk: L,
+      getRunningQueriesThunk: j,
+      getRunningQueryThunk: V
+    } = Oi({
+      queryThunk: a,
+      mutationThunk: b,
+      infiniteQueryThunk: S,
+      api: t,
+      serializeQueryArgs: u,
+      context: d,
+      getInternalState: q
+    });
+    oe(t.util, {
+      getRunningMutationThunk: F,
+      getRunningMutationsThunk: L,
+      getRunningQueryThunk: V,
+      getRunningQueriesThunk: j
+    });
+    const {
+      middleware: K,
+      actions: H
+    } = Ui({
+      reducerPath: i,
+      context: d,
+      queryThunk: a,
+      mutationThunk: b,
+      infiniteQueryThunk: S,
+      api: t,
+      assertTagType: v,
+      selectors: p,
+      getRunningQueryThunk: V,
+      getInternalState: q
+    });
+    return oe(t.util, H), oe(t, {
+      reducer: E,
+      middleware: K
+    }), {
+      name: Qn,
+      injectEndpoint(z, $) {
+        const U = t, x = U.endpoints[z] ??= {};
+        wt($) && oe(x, {
+          name: z,
+          select: f(z, $),
+          initiate: k(z, $)
+        }, y(a, z)), Pi($) && oe(x, {
+          name: z,
+          select: s(),
+          initiate: Q(z)
+        }, y(b, z)), tt($) && oe(x, {
+          name: z,
+          select: g(z, $),
+          initiate: D(z, $)
+        }, y(a, z));
+      }
+    };
+  }
+});
+yr();
+var at = { exports: {} }, Tt = {};
+var qn;
+function Vi() {
+  if (qn) return Tt;
+  qn = 1;
+  var e = Kn;
+  function t(C, w) {
+    return C === w && (C !== 0 || 1 / C === 1 / w) || C !== C && w !== w;
+  }
+  var n = typeof Object.is == "function" ? Object.is : t, r = e.useSyncExternalStore, i = e.useRef, u = e.useEffect, m = e.useMemo, _ = e.useDebugValue;
+  return Tt.useSyncExternalStoreWithSelector = function(C, w, T, I, A) {
+    var R = i(null);
+    if (R.current === null) {
+      var d = { hasValue: !1, value: null };
+      R.current = d;
+    } else d = R.current;
+    R = m(
+      function() {
+        function p(s) {
+          if (!P) {
+            if (P = !0, O = s, s = I(s), A !== void 0 && d.hasValue) {
+              var a = d.value;
+              if (A(a, s))
+                return f = a;
+            }
+            return f = s;
+          }
+          if (a = f, n(O, s)) return a;
+          var S = I(s);
+          return A !== void 0 && A(a, S) ? (O = s, a) : (O = s, f = S);
+        }
+        var P = !1, O, f, g = T === void 0 ? null : T;
+        return [
+          function() {
+            return p(w());
+          },
+          g === null ? void 0 : function() {
+            return p(g());
+          }
+        ];
+      },
+      [w, T, I, A]
+    );
+    var v = r(C, R[0], R[1]);
+    return u(
+      function() {
+        d.hasValue = !0, d.value = v;
+      },
+      [v]
+    ), _(v), v;
+  }, Tt;
+}
+var Dt = {};
+var Fn;
+function zi() {
+  return Fn || (Fn = 1, process.env.NODE_ENV !== "production" && (function() {
+    function e(C, w) {
+      return C === w && (C !== 0 || 1 / C === 1 / w) || C !== C && w !== w;
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var t = Kn, n = typeof Object.is == "function" ? Object.is : e, r = t.useSyncExternalStore, i = t.useRef, u = t.useEffect, m = t.useMemo, _ = t.useDebugValue;
+    Dt.useSyncExternalStoreWithSelector = function(C, w, T, I, A) {
+      var R = i(null);
+      if (R.current === null) {
+        var d = { hasValue: !1, value: null };
+        R.current = d;
+      } else d = R.current;
+      R = m(
+        function() {
+          function p(s) {
+            if (!P) {
+              if (P = !0, O = s, s = I(s), A !== void 0 && d.hasValue) {
+                var a = d.value;
+                if (A(a, s))
+                  return f = a;
+              }
+              return f = s;
+            }
+            if (a = f, n(O, s))
+              return a;
+            var S = I(s);
+            return A !== void 0 && A(a, S) ? (O = s, a) : (O = s, f = S);
+          }
+          var P = !1, O, f, g = T === void 0 ? null : T;
+          return [
+            function() {
+              return p(w());
+            },
+            g === null ? void 0 : function() {
+              return p(g());
+            }
+          ];
+        },
+        [w, T, I, A]
+      );
+      var v = r(C, R[0], R[1]);
+      return u(
+        function() {
+          d.hasValue = !0, d.value = v;
+        },
+        [v]
+      ), _(v), v;
+    }, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), Dt;
+}
+var xn;
+function $i() {
+  return xn || (xn = 1, process.env.NODE_ENV === "production" ? at.exports = Vi() : at.exports = zi()), at.exports;
+}
+var Li = $i();
+function ji(e) {
+  e();
+}
+function Un(e, t) {
+  return e === t ? e !== 0 || t !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+function Ue(e, t) {
+  if (Un(e, t)) return !0;
+  if (typeof e != "object" || e === null || typeof t != "object" || t === null)
+    return !1;
+  const n = Object.keys(e), r = Object.keys(t);
+  if (n.length !== r.length) return !1;
+  for (let i = 0; i < n.length; i++)
+    if (!Object.prototype.hasOwnProperty.call(t, n[i]) || !Un(e[n[i]], t[n[i]]))
+      return !1;
+  return !0;
+}
+var Ki = /* @__PURE__ */ Symbol.for("react-redux-context"), Hi = typeof globalThis < "u" ? globalThis : (
+  /* fall back to a per-module scope (pre-8.1 behaviour) if `globalThis` is not available */
+  {}
+);
+function Wi() {
+  if (!he.createContext) return {};
+  const e = Hi[Ki] ??= /* @__PURE__ */ new Map();
+  let t = e.get(he.createContext);
+  return t || (t = he.createContext(
+    null
+  ), process.env.NODE_ENV !== "production" && (t.displayName = "ReactRedux"), e.set(he.createContext, t)), t;
+}
+var Re = /* @__PURE__ */ Wi();
+function on(e = Re) {
+  return function() {
+    const n = he.useContext(e);
+    if (process.env.NODE_ENV !== "production" && !n)
+      throw new Error(
+        "could not find react-redux context value; please ensure the component is wrapped in a <Provider>"
+      );
+    return n;
+  };
+}
+var gr = /* @__PURE__ */ on();
+function mr(e = Re) {
+  const t = e === Re ? gr : (
+    // @ts-ignore
+    on(e)
+  ), n = () => {
+    const { store: r } = t();
+    return r;
+  };
+  return Object.assign(n, {
+    withTypes: () => n
+  }), n;
+}
+var vr = /* @__PURE__ */ mr();
+function Bi(e = Re) {
+  const t = e === Re ? vr : mr(e), n = () => t().dispatch;
+  return Object.assign(n, {
+    withTypes: () => n
+  }), n;
+}
+var Gi = /* @__PURE__ */ Bi(), Yi = (e, t) => e === t;
+function Ji(e = Re) {
+  const t = e === Re ? gr : on(e), n = (r, i = {}) => {
+    const { equalityFn: u = Yi } = typeof i == "function" ? { equalityFn: i } : i;
+    if (process.env.NODE_ENV !== "production") {
+      if (!r)
+        throw new Error("You must pass a selector to useSelector");
+      if (typeof r != "function")
+        throw new Error("You must pass a function as a selector to useSelector");
+      if (typeof u != "function")
+        throw new Error(
+          "You must pass a function as an equality function to useSelector"
+        );
+    }
+    const m = t(), { store: _, subscription: C, getServerState: w } = m, T = he.useRef(!0), I = he.useCallback(
+      {
+        [r.name](R) {
+          const d = r(R);
+          if (process.env.NODE_ENV !== "production") {
+            const { devModeChecks: v = {} } = typeof i == "function" ? {} : i, { identityFunctionCheck: p, stabilityCheck: P } = m, {
+              identityFunctionCheck: O,
+              stabilityCheck: f
+            } = {
+              stabilityCheck: P,
+              identityFunctionCheck: p,
+              ...v
+            };
+            if (f === "always" || f === "once" && T.current) {
+              const g = r(R);
+              if (!u(d, g)) {
+                let s;
+                try {
+                  throw new Error();
+                } catch (a) {
+                  ({ stack: s } = a);
+                }
+                console.warn(
+                  "Selector " + (r.name || "unknown") + ` returned a different result when called with the same parameters. This can lead to unnecessary rerenders.
+Selectors that return a new reference (such as an object or an array) should be memoized: https://redux.js.org/usage/deriving-data-selectors#optimizing-selectors-with-memoization`,
+                  {
+                    state: R,
+                    selected: d,
+                    selected2: g,
+                    stack: s
+                  }
+                );
+              }
+            }
+            if ((O === "always" || O === "once" && T.current) && d === R) {
+              let g;
+              try {
+                throw new Error();
+              } catch (s) {
+                ({ stack: g } = s);
+              }
+              console.warn(
+                "Selector " + (r.name || "unknown") + ` returned the root state when called. This can lead to unnecessary rerenders.
+Selectors that return the entire state are almost certainly a mistake, as they will cause a rerender whenever *anything* in state changes.`,
+                { stack: g }
+              );
+            }
+            T.current && (T.current = !1);
+          }
+          return d;
+        }
+      }[r.name],
+      [r]
+    ), A = Li.useSyncExternalStoreWithSelector(
+      C.addNestedSub,
+      _.getState,
+      w || _.getState,
+      I,
+      u
+    );
+    return he.useDebugValue(A), A;
+  };
+  return Object.assign(n, {
+    withTypes: () => n
+  }), n;
+}
+var Xi = /* @__PURE__ */ Ji(), Zi = ji;
+function ct(e) {
+  return e.replace(e[0], e[0].toUpperCase());
+}
+function eo(e) {
+  let t = 0;
+  for (const n in e)
+    t++;
+  return t;
+}
+var to = "query", no = "mutation", ro = "infinitequery";
+function io(e) {
+  return e.type === to;
+}
+function oo(e) {
+  return e.type === no;
+}
+function Sr(e) {
+  return e.type === ro;
+}
+function Me(e, ...t) {
+  return Object.assign(e, ...t);
+}
+var Nt = /* @__PURE__ */ Symbol();
+function kt(e) {
+  const t = fe(e), n = G(() => Zt(t.current, e), [e]);
+  return de(() => {
+    t.current !== n && (t.current = n);
+  }, [n]), n;
+}
+function Ae(e) {
+  const t = fe(e);
+  return de(() => {
+    Ue(t.current, e) || (t.current = e);
+  }, [e]), Ue(t.current, e) ? t.current : e;
+}
+var so = () => typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u", ao = /* @__PURE__ */ so(), co = () => typeof navigator < "u" && navigator.product === "ReactNative", uo = /* @__PURE__ */ co(), lo = () => ao || uo ? Dr : de, fo = /* @__PURE__ */ lo(), Vn = (e) => e.isUninitialized ? {
+  ...e,
+  isUninitialized: !1,
+  isFetching: !0,
+  isLoading: e.data === void 0,
+  // This is the one place where we still have to use `QueryStatus` as an enum,
+  // since it's the only reference in the React package and not in the core.
+  status: rr.pending
+} : e;
+function Mt(e, ...t) {
+  const n = {};
+  return t.forEach((r) => {
+    n[r] = e[r];
+  }), n;
+}
+var Qt = ["data", "status", "isLoading", "isSuccess", "isError", "error"];
+function po({
+  api: e,
+  moduleOptions: {
+    batch: t,
+    hooks: {
+      useDispatch: n,
+      useSelector: r,
+      useStore: i
+    },
+    unstable__sideEffectsInRender: u,
+    createSelector: m
+  },
+  serializeQueryArgs: _,
+  context: C
+}) {
+  const w = u ? (a) => a() : de, T = (a) => a.current?.unsubscribe?.(), I = C.endpointDefinitions;
+  return {
+    buildQueryHooks: f,
+    buildInfiniteQueryHooks: g,
+    buildMutationHook: s,
+    usePrefetch: d
+  };
+  function A(a, S, b) {
+    if (S?.endpointName && a.isUninitialized) {
+      const {
+        endpointName: E
+      } = S, N = I[E];
+      b !== te && _({
+        queryArgs: S.originalArgs,
+        endpointDefinition: N,
+        endpointName: E
+      }) === _({
+        queryArgs: b,
+        endpointDefinition: N,
+        endpointName: E
+      }) && (S = void 0);
+    }
+    let h = a.isSuccess ? a.data : S?.data;
+    h === void 0 && (h = a.data);
+    const l = h !== void 0, o = a.isLoading, c = (!S || S.isLoading || S.isUninitialized) && !l && o, y = a.isSuccess || l && (o && !S?.isError || a.isUninitialized);
+    return {
+      ...a,
+      data: h,
+      currentData: a.data,
+      isFetching: o,
+      isLoading: c,
+      isSuccess: y
+    };
+  }
+  function R(a, S, b) {
+    if (S?.endpointName && a.isUninitialized) {
+      const {
+        endpointName: E
+      } = S, N = I[E];
+      b !== te && _({
+        queryArgs: S.originalArgs,
+        endpointDefinition: N,
+        endpointName: E
+      }) === _({
+        queryArgs: b,
+        endpointDefinition: N,
+        endpointName: E
+      }) && (S = void 0);
+    }
+    let h = a.isSuccess ? a.data : S?.data;
+    h === void 0 && (h = a.data);
+    const l = h !== void 0, o = a.isLoading, c = (!S || S.isLoading || S.isUninitialized) && !l && o, y = a.isSuccess || o && l;
+    return {
+      ...a,
+      data: h,
+      currentData: a.data,
+      isFetching: o,
+      isLoading: c,
+      isSuccess: y
+    };
+  }
+  function d(a, S) {
+    const b = n(), h = Ae(S);
+    return ge((l, o) => b(e.util.prefetch(a, l, {
+      ...h,
+      ...o
+    })), [a, b, h]);
+  }
+  function v(a, S, {
+    refetchOnReconnect: b,
+    refetchOnFocus: h,
+    refetchOnMountOrArgChange: l,
+    skip: o = !1,
+    pollingInterval: c = 0,
+    skipPollingIfUnfocused: y = !1,
+    ...E
+  } = {}) {
+    const {
+      initiate: N
+    } = e.endpoints[a], M = n(), q = fe(void 0);
+    if (!q.current) {
+      const U = M(e.internalActions.internal_getRTKQSubscriptions());
+      if (process.env.NODE_ENV !== "production" && (typeof U != "object" || typeof U?.type == "string"))
+        throw new Error(process.env.NODE_ENV === "production" ? ye(37) : `Warning: Middleware for RTK-Query API at reducerPath "${e.reducerPath}" has not been added to the store.
+    You must add the middleware for RTK-Query to function correctly!`);
+      q.current = U;
+    }
+    const k = kt(o ? te : S), D = Ae({
+      refetchOnReconnect: b,
+      refetchOnFocus: h,
+      pollingInterval: c,
+      skipPollingIfUnfocused: y
+    }), Q = E.initialPageParam, F = Ae(Q), L = E.refetchCachedPages, j = Ae(L), V = fe(void 0);
+    let {
+      queryCacheKey: K,
+      requestId: H
+    } = V.current || {}, z = !1;
+    K && H && (z = q.current.isRequestSubscribed(K, H));
+    const $ = !z && V.current !== void 0;
+    return w(() => {
+      $ && (V.current = void 0);
+    }, [$]), w(() => {
+      const U = V.current;
+      if (typeof process < "u" && process.env.NODE_ENV === "removeMeOnCompilation" && console.log($), k === te) {
+        U?.unsubscribe(), V.current = void 0;
+        return;
+      }
+      const x = V.current?.subscriptionOptions;
+      if (!U || U.arg !== k) {
+        U?.unsubscribe();
+        const re = M(N(k, {
+          subscriptionOptions: D,
+          forceRefetch: l,
+          ...Sr(I[a]) ? {
+            initialPageParam: F,
+            refetchCachedPages: j
+          } : {}
+        }));
+        V.current = re;
+      } else D !== x && U.updateSubscriptionOptions(D);
+    }, [M, N, l, k, D, $, F, j, a]), [V, M, N, D];
+  }
+  function p(a, S) {
+    return (h, {
+      skip: l = !1,
+      selectFromResult: o
+    } = {}) => {
+      const {
+        select: c
+      } = e.endpoints[a], y = kt(l ? te : h), E = fe(void 0), N = G(() => (
+        // Normally ts-ignores are bad and should be avoided, but we're
+        // already casting this selector to be `Selector<any>` anyway,
+        // so the inconsistencies don't matter here
+        // @ts-ignore
+        m([
+          // @ts-ignore
+          c(y),
+          (Q, F) => F,
+          (Q) => y
+        ], S, {
+          memoizeOptions: {
+            resultEqualityCheck: Ue
+          }
+        })
+      ), [c, y]), M = G(() => o ? m([N], o, {
+        devModeChecks: {
+          identityFunctionCheck: "never"
+        }
+      }) : N, [N, o]), q = r((Q) => M(Q, E.current), Ue), k = i(), D = N(k.getState(), E.current);
+      return fo(() => {
+        E.current = D;
+      }, [D]), q;
+    };
+  }
+  function P(a) {
+    de(() => () => {
+      T(a), a.current = void 0;
+    }, [a]);
+  }
+  function O(a) {
+    if (!a.current) throw new Error(process.env.NODE_ENV === "production" ? ye(38) : "Cannot refetch a query that has not been started yet.");
+    return a.current.refetch();
+  }
+  function f(a) {
+    const S = (l, o = {}) => {
+      const [c] = v(a, l, o);
+      return P(c), G(() => ({
+        /**
+         * A method to manually refetch data for the query
+         */
+        refetch: () => O(c)
+      }), [c]);
+    }, b = ({
+      refetchOnReconnect: l,
+      refetchOnFocus: o,
+      pollingInterval: c = 0,
+      skipPollingIfUnfocused: y = !1
+    } = {}) => {
+      const {
+        initiate: E
+      } = e.endpoints[a], N = n(), [M, q] = un(Nt), k = fe(void 0), D = Ae({
+        refetchOnReconnect: l,
+        refetchOnFocus: o,
+        pollingInterval: c,
+        skipPollingIfUnfocused: y
+      });
+      w(() => {
+        const j = k.current?.subscriptionOptions;
+        D !== j && k.current?.updateSubscriptionOptions(D);
+      }, [D]);
+      const Q = fe(D);
+      w(() => {
+        Q.current = D;
+      }, [D]);
+      const F = ge(function(j, V = !1) {
+        let K;
+        return t(() => {
+          T(k), k.current = K = N(E(j, {
+            subscriptionOptions: Q.current,
+            forceRefetch: !V
+          })), q(j);
+        }), K;
+      }, [N, E]), L = ge(() => {
+        k.current?.queryCacheKey && N(e.internalActions.removeQueryResult({
+          queryCacheKey: k.current?.queryCacheKey
+        }));
+      }, [N]);
+      return de(() => () => {
+        T(k);
+      }, []), de(() => {
+        M !== Nt && !k.current && F(M, !0);
+      }, [M, F]), G(() => [F, M, {
+        reset: L
+      }], [F, M, L]);
+    }, h = p(a, A);
+    return {
+      useQueryState: h,
+      useQuerySubscription: S,
+      useLazyQuerySubscription: b,
+      useLazyQuery(l) {
+        const [o, c, {
+          reset: y
+        }] = b(l), E = h(c, {
+          ...l,
+          skip: c === Nt
+        }), N = G(() => ({
+          lastArg: c
+        }), [c]);
+        return G(() => [o, {
+          ...E,
+          reset: y
+        }, N], [o, E, y, N]);
+      },
+      useQuery(l, o) {
+        const c = S(l, o), y = h(l, {
+          selectFromResult: l === te || o?.skip ? void 0 : Vn,
+          ...o
+        }), E = Mt(y, ...Qt);
+        return It(E), G(() => ({
+          ...y,
+          ...c
+        }), [y, c]);
+      }
+    };
+  }
+  function g(a) {
+    const S = (h, l = {}) => {
+      const [o, c, y, E] = v(a, h, l), N = fe(E);
+      w(() => {
+        N.current = E;
+      }, [E]);
+      const M = l.refetchCachedPages, q = Ae(M), k = ge(function(F, L) {
+        let j;
+        return t(() => {
+          T(o), o.current = j = c(y(F, {
+            subscriptionOptions: N.current,
+            direction: L
+          }));
+        }), j;
+      }, [o, c, y]);
+      P(o);
+      const D = kt(l.skip ? te : h), Q = ge((F) => {
+        if (!o.current) throw new Error(process.env.NODE_ENV === "production" ? ye(38) : "Cannot refetch a query that has not been started yet.");
+        const L = {
+          refetchCachedPages: F?.refetchCachedPages ?? q
+        };
+        return o.current.refetch(L);
+      }, [o, q]);
+      return G(() => ({
+        trigger: k,
+        /**
+         * A method to manually refetch data for the query
+         */
+        refetch: Q,
+        fetchNextPage: () => k(D, "forward"),
+        fetchPreviousPage: () => k(D, "backward")
+      }), [Q, k, D]);
+    }, b = p(a, R);
+    return {
+      useInfiniteQueryState: b,
+      useInfiniteQuerySubscription: S,
+      useInfiniteQuery(h, l) {
+        const {
+          refetch: o,
+          fetchNextPage: c,
+          fetchPreviousPage: y
+        } = S(h, l), E = b(h, {
+          selectFromResult: h === te || l?.skip ? void 0 : Vn,
+          ...l
+        }), N = Mt(E, ...Qt, "hasNextPage", "hasPreviousPage");
+        return It(N), G(() => ({
+          ...E,
+          fetchNextPage: c,
+          fetchPreviousPage: y,
+          refetch: o
+        }), [E, c, y, o]);
+      }
+    };
+  }
+  function s(a) {
+    return ({
+      selectFromResult: S,
+      fixedCacheKey: b
+    } = {}) => {
+      const {
+        select: h,
+        initiate: l
+      } = e.endpoints[a], o = n(), [c, y] = un();
+      de(() => () => {
+        c?.arg.fixedCacheKey || c?.reset();
+      }, [c]);
+      const E = ge(function(j) {
+        const V = o(l(j, {
+          fixedCacheKey: b
+        }));
+        return y(V), V;
+      }, [o, l, b]), {
+        requestId: N
+      } = c || {}, M = G(() => h({
+        fixedCacheKey: b,
+        requestId: c?.requestId
+      }), [b, c, h]), q = G(() => S ? m([M], S) : M, [S, M]), k = r(q, Ue), D = b == null ? c?.arg.originalArgs : void 0, Q = ge(() => {
+        t(() => {
+          c && y(void 0), b && o(e.internalActions.removeMutationResult({
+            requestId: N,
+            fixedCacheKey: b
+          }));
+        });
+      }, [o, b, c, N]), F = Mt(k, ...Qt, "endpointName");
+      It(F);
+      const L = G(() => ({
+        ...k,
+        originalArgs: D,
+        reset: Q
+      }), [k, D, Q]);
+      return G(() => [E, L], [E, L]);
+    };
+  }
+}
+var ho = /* @__PURE__ */ Symbol(), yo = ({
+  batch: e = Zi,
+  hooks: t = {
+    useDispatch: Gi,
+    useSelector: Xi,
+    useStore: vr
+  },
+  createSelector: n = nr,
+  unstable__sideEffectsInRender: r = !1,
+  ...i
+} = {}) => {
+  if (process.env.NODE_ENV !== "production") {
+    const u = ["useDispatch", "useSelector", "useStore"];
+    let m = !1;
+    for (const _ of u)
+      if (eo(i) > 0 && (i[_] && (m || (console.warn("As of RTK 2.0, the hooks now need to be specified as one object, provided under a `hooks` key:\n`reactHooksModule({ hooks: { useDispatch, useSelector, useStore } })`"), m = !0)), t[_] = i[_]), typeof t[_] != "function")
+        throw new Error(process.env.NODE_ENV === "production" ? ye(36) : `When using custom hooks for context, all ${u.length} hooks need to be provided: ${u.join(", ")}.
+Hook ${_} was either not provided or not a function.`);
+  }
+  return {
+    name: ho,
+    init(u, {
+      serializeQueryArgs: m
+    }, _) {
+      const C = u, {
+        buildQueryHooks: w,
+        buildInfiniteQueryHooks: T,
+        buildMutationHook: I,
+        usePrefetch: A
+      } = po({
+        api: u,
+        moduleOptions: {
+          batch: e,
+          hooks: t,
+          unstable__sideEffectsInRender: r,
+          createSelector: n
+        },
+        serializeQueryArgs: m,
+        context: _
+      });
+      return Me(C, {
+        usePrefetch: A
+      }), Me(_, {
+        batch: e
+      }), {
+        injectEndpoint(R, d) {
+          if (io(d)) {
+            const {
+              useQuery: v,
+              useLazyQuery: p,
+              useLazyQuerySubscription: P,
+              useQueryState: O,
+              useQuerySubscription: f
+            } = w(R);
+            Me(C.endpoints[R], {
+              useQuery: v,
+              useLazyQuery: p,
+              useLazyQuerySubscription: P,
+              useQueryState: O,
+              useQuerySubscription: f
+            }), u[`use${ct(R)}Query`] = v, u[`useLazy${ct(R)}Query`] = p;
+          }
+          if (oo(d)) {
+            const v = I(R);
+            Me(C.endpoints[R], {
+              useMutation: v
+            }), u[`use${ct(R)}Mutation`] = v;
+          } else if (Sr(d)) {
+            const {
+              useInfiniteQuery: v,
+              useInfiniteQuerySubscription: p,
+              useInfiniteQueryState: P
+            } = T(R);
+            Me(C.endpoints[R], {
+              useInfiniteQuery: v,
+              useInfiniteQuerySubscription: p,
+              useInfiniteQueryState: P
+            }), u[`use${ct(R)}InfiniteQuery`] = v;
+          }
+        }
+      };
+    }
+  };
+}, go = /* @__PURE__ */ hr(yr(), yo());
+const nt = "auth";
+let _r = null;
+function mo() {
+  return _r;
+}
+function Do(e) {
+  _r = e;
+}
+const vo = {
+  token: null
+}, br = Se({
+  name: nt,
+  initialState: vo,
+  reducers: {
+    setToken: (e, t) => {
+      e.token = t.payload;
+    },
+    logout: (e) => {
+      e.token = null;
+    }
+  }
+}), { setToken: Er, logout: zn } = br.actions, No = br.reducer, ko = (e) => e[nt].token, Mo = (e) => !!e[nt].token, So = "api", Rt = go({
+  reducerPath: So,
+  baseQuery: _i({
+    baseUrl: process.env.VITE_API_BASE_URL || "",
+    prepareHeaders: (e, { getState: t }) => {
+      const r = t()[nt], i = r ? r.token : void 0, u = mo();
+      return i && (u ? u.prepareHeaders(e, i) : e.set("Authorization", `Bearer ${i}`)), e;
+    }
+  }),
+  endpoints: () => ({})
+}), Qo = Rt.reducer, qo = Rt.middleware, Pr = [
+  "Authentication",
+  "Email",
+  "Invitations",
+  "Users"
+], wr = Rt.enhanceEndpoints({
+  addTagTypes: Pr
+}).injectEndpoints({
+  endpoints: (e) => ({
+    authControllerLogin: e.mutation({
+      query: (t) => ({
+        url: "/api/auth/login",
+        method: "POST",
+        body: t.loginDto
+      }),
+      invalidatesTags: ["Authentication"]
+    }),
+    authControllerGetProfile: e.query({
+      query: () => ({ url: "/api/profile" }),
+      providesTags: ["Authentication"]
+    }),
+    emailControllerSendEmail: e.mutation({
+      query: (t) => ({
+        url: "/api/email/send",
+        method: "POST",
+        body: t.sendEmailDto
+      }),
+      invalidatesTags: ["Email"]
+    }),
+    invitationsControllerInvite: e.mutation({
+      query: (t) => ({
+        url: "/api/invitations/invite",
+        method: "POST",
+        body: t.inviteUserDto
+      }),
+      invalidatesTags: ["Invitations"]
+    }),
+    invitationsControllerValidate: e.query({
+      query: (t) => ({
+        url: `/api/invitations/validate/${t.token}`
+      }),
+      providesTags: ["Invitations"]
+    }),
+    invitationsControllerAccept: e.mutation({
+      query: (t) => ({
+        url: "/api/invitations/accept",
+        method: "POST",
+        body: t.acceptInvitationDto
+      }),
+      invalidatesTags: ["Invitations"]
+    }),
+    usersControllerFindAll: e.query({
+      query: () => ({ url: "/api/users" }),
+      providesTags: ["Users"]
+    }),
+    usersControllerFindOne: e.query({
+      query: (t) => ({ url: `/api/users/${t.id}` }),
+      providesTags: ["Users"]
+    }),
+    usersControllerDelete: e.mutation({
+      query: (t) => ({
+        url: `/api/users/${t.id}`,
+        method: "DELETE"
+      }),
+      invalidatesTags: ["Users"]
+    })
+  }),
+  overrideExisting: !1
+}), {
+  useAuthControllerLoginMutation: _o,
+  useAuthControllerGetProfileQuery: bo,
+  useEmailControllerSendEmailMutation: Eo,
+  useInvitationsControllerInviteMutation: Po,
+  useInvitationsControllerValidateQuery: wo,
+  useInvitationsControllerAcceptMutation: Ro,
+  useUsersControllerFindAllQuery: Oo,
+  useUsersControllerFindOneQuery: Io,
+  useUsersControllerDeleteMutation: Ao
+} = wr, Fo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  addTagTypes: Pr,
+  api: wr,
+  useAuthControllerGetProfileQuery: bo,
+  useAuthControllerLoginMutation: _o,
+  useEmailControllerSendEmailMutation: Eo,
+  useInvitationsControllerAcceptMutation: Ro,
+  useInvitationsControllerInviteMutation: Po,
+  useInvitationsControllerValidateQuery: wo,
+  useUsersControllerDeleteMutation: Ao,
+  useUsersControllerFindAllQuery: Oo,
+  useUsersControllerFindOneQuery: Io
+}, Symbol.toStringTag, { value: "Module" }));
+function xo(e) {
+  return {
+    prepareHeaders(t, n) {
+      const r = e.formatValue ? e.formatValue(n) : n;
+      t.set(e.headerName, r);
+    }
+  };
+}
+let _e = {};
+function Uo(e) {
+  _e = e;
+}
+function Vo() {
+  const e = Tr();
+  return e.startListening({
+    actionCreator: zn,
+    effect: (t, n) => {
+      n.dispatch(Rt.util.resetApiState()), _e.onLogout && _e.onLogout();
+    }
+  }), e.startListening({
+    matcher: ze(Er, zn),
+    effect: (t, n) => {
+      if (!_e.persistence) return;
+      const r = n.getState();
+      _e.persistence.setToken(r[nt].token);
+    }
+  }), e.middleware;
+}
+function zo() {
+  let e = !1;
+  return (t) => (n) => (r) => {
+    if (!e && _e.persistence) {
+      e = !0;
+      const i = _e.persistence.getToken();
+      i && t.dispatch(Er(i));
+    }
+    return n(r);
+  };
+}
+function $o(e, t = "token") {
+  return {
+    getToken: () => {
+      try {
+        return e.getItem(t);
+      } catch {
+        return null;
+      }
+    },
+    setToken: (n) => {
+      try {
+        n ? e.setItem(t, n) : e.removeItem(t);
+      } catch {
+      }
+    }
+  };
+}
+export {
+  So as ApiKey,
+  nt as AuthKey,
+  Pr as addTagTypes,
+  wr as api,
+  qo as apiMiddleware,
+  Qo as apiReducer,
+  No as authReducer,
+  br as authSlice,
+  Rt as baseApi,
+  Uo as configureAuth,
+  zo as createAuthHydrationMiddleware,
+  Vo as createAuthListenerMiddleware,
+  xo as createCustomHeaderAdapter,
+  Fo as demoScaffoldBackend,
+  mo as getAuthAdapter,
+  zn as logout,
+  Mo as selectIsAuthenticated,
+  ko as selectToken,
+  Do as setAuthAdapter,
+  Er as setToken,
+  $o as storagePersistence,
+  bo as useAuthControllerGetProfileQuery,
+  _o as useAuthControllerLoginMutation,
+  Eo as useEmailControllerSendEmailMutation,
+  Ro as useInvitationsControllerAcceptMutation,
+  Po as useInvitationsControllerInviteMutation,
+  wo as useInvitationsControllerValidateQuery,
+  Ao as useUsersControllerDeleteMutation,
+  Oo as useUsersControllerFindAllQuery,
+  Io as useUsersControllerFindOneQuery
+};