@ynput/ayon-frontend-shared 0.3.30 → 0.3.32

package/dist/shared/src/api/queries/overview/updateOverview.es.js

@@ -1,3 +1,6 @@
+import { foldersQueries as w } from "../folders/getFolders.es.js";
+import "../folders/getFolderDeleteInfo.es.js";
+import { detailsPanelQueries as E } from "../entities/getEntityPanel.es.js";
 import "../../base/client.es.js";
 import "../../generated/graphql.es.js";
 import "../../generated/graphqlLinks.es.js";
@@ -20,7 +23,7 @@ import "../../generated/inbox.es.js";
 import "../../generated/links.es.js";
 import "../../generated/market.es.js";
 import "../../generated/onboarding.es.js";
-import { api as D } from "../../generated/operations.es.js";
+import { api as H } from "../../generated/operations.es.js";
 import "../../generated/products.es.js";
 import "../../generated/projectDashboard.es.js";
 import "../../generated/projects.es.js";
@@ -38,253 +41,219 @@ import "../../generated/workfiles.es.js";
 import "../../generated/ynputCloud.es.js";
 import "../../generated/grouping.es.js";
 import "../../generated/views.es.js";
-import "../actions/getActions.es.js";
-import "../activities/getActivities.es.js";
-import "../activities/updateActivities.es.js";
-import "../activities/updateReaction.es.js";
-import "../activities/getMentions.es.js";
-import "../activities/getCategories.es.js";
-import "../addons/getAddons.es.js";
-import "../addons/updateAddons.es.js";
-import "../attributes/getAttributes.es.js";
-import "../attributes/updateAttributes.es.js";
-import "../authentication/getAuthentication.es.js";
-import "../cloud/cloud.es.js";
-import "../config/getConfig.es.js";
-import "../config/updateConfig.es.js";
-import "../entities/getEntity.es.js";
-import { detailsPanelQueries as E } from "../entities/getEntityPanel.es.js";
-import "../entities/updateEntity.es.js";
-import { patchDetailsPanelEntity as _ } from "../entities/patchDetailsPanel.es.js";
-import F from "../entityLists/getLists.es.js";
 import "../entityLists/updateLists.es.js";
-import "../entityLists/getListsAttributes.es.js";
-import "../entityLists/updateListsAttributes.es.js";
-import "../entityLists/listFolders.es.js";
-import { foldersQueries as A } from "../folders/getFolders.es.js";
-import "../folders/getFolderDeleteInfo.es.js";
-import "../grouping/getGrouping.es.js";
-import "../links/updateLinks.es.js";
-import "../links/getLinks.es.js";
-import "../links/getEntityLinks.es.js";
 import T from "./getOverview.es.js";
-import { patchVersions as q } from "./patchVersions.es.js";
-import { patchProducts as H } from "./patchProducts.es.js";
-import "../permissions/getPermissions.es.js";
-import "../products/createProduct.es.js";
-import "../products/getFolderProducts.es.js";
-import "../project/getProject.es.js";
-import "../project/updateProject.es.js";
-import "../projectFolders/projectFolders.es.js";
-import "../review/getReview.es.js";
-import "../review/updateReview.es.js";
-import "../share/share.es.js";
-import "../system/getSystem.es.js";
-import "../tasks/getTasks.es.js";
-import "../tasks/updateTasks.es.js";
-import "../teams/getTeams.es.js";
-import "../userDashboard/getUserDashboard.es.js";
-import "../users/getUsers.es.js";
-import "../users/updateUsers.es.js";
-import "../users/guests.es.js";
-import "../versions/updateVersions.es.js";
-import "../versions/getVersionsProducts.es.js";
-import "../views/getViews.es.js";
-import "../views/updateViews.es.js";
-import "../watchers/getWatchers.es.js";
-import "../uris/getUris.es.js";
-import { getUpdatedEntityIds as B } from "./filterRefetchUtils.es.js";
-import { refetchTasksForCacheEntry as M, refetchOverviewTasksForCacheEntry as U } from "./refetchFilteredEntities.es.js";
-const w = (t, e) => {
-  if (Object.keys(e).forEach((s) => {
-    s === "attrib" || s === "links" || s === "deleteLinks" || (t[s] = e[s]);
-  }), e.attrib && (t.attrib = {
-    ...t.attrib,
-    ...e.attrib
-  }), e.links) {
-    const s = t.links || [], a = e.links || [];
-    t.links || (t.links = []), t.links = [...s], a.forEach((r) => {
-      const p = t.links.findIndex((n) => n.id === r.id);
-      p !== -1 ? t.links[p] = { ...t.links[p], ...r } : t.links.push(r);
+import "../entities/getEntity.es.js";
+import { patchVersions as U } from "./patchVersions.es.js";
+import { patchProducts as $ } from "./patchProducts.es.js";
+import "../links/getEntityLinks.es.js";
+import "../entities/updateEntity.es.js";
+import { patchDetailsPanelEntity as z } from "../entities/patchDetailsPanel.es.js";
+import { getUpdatedEntityIds as S } from "./filterRefetchUtils.es.js";
+import { refetchTasksForCacheEntry as G, refetchOverviewTasksForCacheEntry as V } from "./refetchFilteredEntities.es.js";
+import B from "../entityLists/getLists.es.js";
+const A = (e, t) => {
+  if (Object.keys(t).forEach((r) => {
+    r === "attrib" || r === "links" || r === "deleteLinks" || (e[r] = t[r]);
+  }), t.attrib && (e.attrib = {
+    ...e.attrib,
+    ...t.attrib
+  }), t.links) {
+    const r = e.links || [], o = t.links || [];
+    e.links || (e.links = []), e.links = [...r], o.forEach((i) => {
+      const d = e.links.findIndex((a) => a.id === i.id);
+      d !== -1 ? e.links[d] = { ...e.links[d], ...i } : e.links.push(i);
     });
   }
-  if (e.deleteLinks) {
-    const s = e.deleteLinks || [];
-    t.links || (t.links = []), s.forEach((a) => {
-      t.links = t.links.filter((r) => r.id !== a);
+  if (t.deleteLinks) {
+    const r = t.deleteLinks || [];
+    e.links || (e.links = []), r.forEach((o) => {
+      e.links = e.links.filter((i) => i.id !== o);
     });
   }
-}, N = (t) => [
+}, x = (e) => [
   { type: "overviewTask", id: "LIST" },
-  ...t.map((e) => ({ type: "overviewTask", id: e.entityId })),
+  ...e.map((t) => ({ type: "overviewTask", id: t.entityId })),
   // we also add the projectName so that tasks that do not exist in the cache can still invalidate
-  ...t.filter((e) => e.data?.projectName).map((e) => ({
+  ...e.filter((t) => t.data?.projectName).map((t) => ({
     type: "overviewTask",
-    id: e.data?.projectName
+    id: t.data?.projectName
   }))
-], z = (t) => [
-  ...t.map((e) => ({ type: "folder", id: e.entityId })),
+], W = (e) => [
+  ...e.map((t) => ({ type: "folder", id: t.entityId })),
   // we also add the projectName so that tasks that do not exist in the cache can still invalidate
-  ...t.filter((e) => e.data?.projectName).map((e) => ({
+  ...e.filter((t) => t.data?.projectName).map((t) => ({
     type: "folder",
-    id: e.data?.projectName
+    id: t.data?.projectName
   }))
-], G = (t, e, s) => ({
-  entityId: t,
-  entityType: e,
+], J = (e, t, r) => ({
+  entityId: e,
+  entityType: t,
   type: "update",
-  data: { deleteLinks: s }
-}), De = (t, e) => t.map(
-  (s) => G(s.entityId, s.entityType, e)
-), _e = (t, {
-  state: e,
-  dispatch: s
-}, a) => {
-  const r = t.reduce((p, n) => (p[n.entityType] || (p[n.entityType] = []), p[n.entityType].push(n), p), {});
-  r.task && L(r.task, { state: e, dispatch: s }, a), r.folder && O(r.folder, { state: e, dispatch: s }, a);
-}, L = (t, {
-  state: e,
-  dispatch: s
-}, a) => {
-  const r = N(t), p = T.util.selectInvalidatedBy(e, r);
-  for (const n of p)
-    if (n.endpointName === "getTasksListInfinite") {
-      const l = s(
-        T.util.updateQueryData("getTasksListInfinite", n.originalArgs, (o) => {
-          for (const i of t)
-            if (i.type === "create" && i.data)
-              o.pages[0].tasks.push(i.data);
+  data: { deleteLinks: r }
+}), Zt = (e, t) => e.map(
+  (r) => J(r.entityId, r.entityType, t)
+), te = (e, {
+  state: t,
+  dispatch: r
+}, o) => {
+  const i = e.reduce((d, a) => (d[a.entityType] || (d[a.entityType] = []), d[a.entityType].push(a), d), {});
+  i.task && L(i.task, { state: t, dispatch: r }, o), i.folder && P(i.folder, { state: t, dispatch: r }, o);
+}, L = (e, {
+  state: t,
+  dispatch: r
+}, o) => {
+  const i = x(e), d = T.util.selectInvalidatedBy(t, i);
+  for (const a of d)
+    if (a.endpointName === "getTasksListInfinite") {
+      const p = r(
+        T.util.updateQueryData("getTasksListInfinite", a.originalArgs, (n) => {
+          for (const s of e)
+            if (s.type === "create" && s.data)
+              n.pages[0].tasks.push(s.data);
             else
-              for (const d of o.pages) {
-                const c = d.tasks.find((y) => y.id === i.entityId);
-                c && w(c, i.data);
+              for (const l of n.pages) {
+                const f = l.tasks.find((m) => m.id === s.entityId);
+                f && A(f, s.data);
               }
         })
       );
-      a?.push(l);
+      o?.push(p);
     } else {
-      const l = s(
+      const p = r(
         T.util.updateQueryData(
-          n.endpointName,
-          n.originalArgs,
-          (o) => {
-            for (const i of t)
-              if (i.type === "create" && i.data && n.originalArgs.parentIds?.includes(i.data.folderId)) {
-                const d = (c) => {
-                  c.push(i.data);
+          a.endpointName,
+          a.originalArgs,
+          (n) => {
+            for (const s of e)
+              if (s.type === "create" && s.data && a.originalArgs.parentIds?.includes(s.data.folderId)) {
+                const l = (f) => {
+                  f.push(s.data);
                 };
-                if (Array.isArray(o))
-                  d(o);
-                else if (o.tasks && Array.isArray(o.tasks)) {
-                  const c = o.tasks;
-                  d(c);
+                if (Array.isArray(n))
+                  l(n);
+                else if (n.tasks && Array.isArray(n.tasks)) {
+                  const f = n.tasks;
+                  l(f);
                 }
               } else {
-                const d = (c) => {
-                  const y = c.find((I) => I.id === i.entityId);
-                  y && w(y, i.data);
+                const l = (f) => {
+                  const m = f.find((I) => I.id === s.entityId);
+                  m && A(m, s.data);
                 };
-                if (Array.isArray(o))
-                  d(o);
-                else if (o.tasks && Array.isArray(o.tasks)) {
-                  const c = o.tasks;
-                  d(c);
+                if (Array.isArray(n))
+                  l(n);
+                else if (n.tasks && Array.isArray(n.tasks)) {
+                  const f = n.tasks;
+                  l(f);
                 }
               }
           }
         )
       );
-      a?.push(l);
+      o?.push(p);
     }
-}, V = (t, {
-  dispatch: e
+}, K = (e, {
+  dispatch: t
 }) => {
-  t.length && e(T.util.invalidateTags(N(t)));
-}, O = (t, {
-  state: e,
-  dispatch: s
-}, a) => {
-  const r = A.util.selectInvalidatedBy(e, z(t)).filter((p) => p.endpointName === "getFolderList");
-  for (const p of r) {
-    const n = s(
-      A.util.updateQueryData(
-        p.endpointName,
-        p.originalArgs,
-        (l) => {
-          const o = /* @__PURE__ */ new Map();
-          l.folders.forEach((i) => {
-            o.set(i.id, i);
+  e.length && t(T.util.invalidateTags(x(e)));
+}, O = /* @__PURE__ */ new Map(), b = (e, t, r) => {
+  const o = `${t}:${r.join()}`, i = O.get(o);
+  i && clearTimeout(i), O.set(
+    o,
+    setTimeout(() => {
+      O.delete(o), e(
+        T.util.invalidateTags(
+          r.map((d) => ({ type: d, id: t }))
+        )
+      );
+    }, 500)
+  );
+}, P = (e, {
+  state: t,
+  dispatch: r
+}, o) => {
+  const i = w.util.selectInvalidatedBy(t, W(e)).filter((d) => d.endpointName === "getFolderList");
+  for (const d of i) {
+    const a = r(
+      w.util.updateQueryData(
+        d.endpointName,
+        d.originalArgs,
+        (p) => {
+          const n = /* @__PURE__ */ new Map();
+          p.folders.forEach((s) => {
+            n.set(s.id, s);
           });
-          for (const i of t)
-            if (i.type === "create" && i.data)
-              l.folders.push(i.data);
+          for (const s of e)
+            if (s.type === "create" && s.data)
+              p.folders.push(s.data);
             else {
-              const d = o.get(i.entityId);
-              d && w(d, i.data);
+              const l = n.get(s.entityId);
+              l && A(l, s.data);
             }
         }
       )
     );
-    a?.push(n);
+    o?.push(a);
   }
-}, W = (t, {
-  state: e,
-  dispatch: s
-}, a) => {
-  const r = t.map((n) => ({ type: "entityListItem", id: n.entityId })), p = F.util.selectInvalidatedBy(e, r);
-  for (const n of p)
-    if (n.endpointName === "getListItemsInfinite") {
-      const l = s(
-        F.util.updateQueryData(
+}, X = (e, {
+  state: t,
+  dispatch: r
+}, o) => {
+  const i = e.map((a) => ({ type: "entityListItem", id: a.entityId })), d = B.util.selectInvalidatedBy(t, i);
+  for (const a of d)
+    if (a.endpointName === "getListItemsInfinite") {
+      const p = r(
+        B.util.updateQueryData(
           "getListItemsInfinite",
-          n.originalArgs,
-          (o) => {
-            for (const i of t)
-              if (i.type === "update" && i.data)
-                for (const d of o.pages) {
-                  const c = d.items.find((y) => y.entityId === i.entityId);
-                  c && w(c, i.data);
+          a.originalArgs,
+          (n) => {
+            for (const s of e)
+              if (s.type === "update" && s.data)
+                for (const l of n.pages) {
+                  const f = l.items.find((m) => m.entityId === s.entityId);
+                  f && A(f, s.data);
                 }
           }
         )
       );
-      a?.push(l);
+      o?.push(p);
     }
-}, b = (t) => t.reduce(
-  (e, s) => (e[s.type].push(s), e),
+}, Q = (e) => e.reduce(
+  (t, r) => (t[r.type].push(r), t),
   {
     create: [],
     update: [],
     delete: []
   }
-), C = D.enhanceEndpoints({
+), R = H.enhanceEndpoints({
   endpoints: {
     operations: {}
   }
-}), J = C.injectEndpoints({
-  endpoints: (t) => ({
-    updateOverviewEntities: t.mutation({
-      async queryFn(e, { dispatch: s }) {
+}), Y = R.injectEndpoints({
+  endpoints: (e) => ({
+    updateOverviewEntities: e.mutation({
+      async queryFn(t, { dispatch: r }) {
         try {
-          const a = await s(C.endpoints.operations.initiate(e));
-          if (a.error)
-            return { error: a.error };
-          const r = a.data, p = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
-          for (const l of r?.operations || [])
-            l.success === !1 && l.detail && (p.has(l.detail) || p.add(l.detail), n.has(l.errorCode) || n.add(l.errorCode));
-          return p.size > 0 ? { error: {
+          const o = await r(R.endpoints.operations.initiate(t));
+          if (o.error)
+            return { error: o.error };
+          const i = o.data, d = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set();
+          for (const p of i?.operations || [])
+            p.success === !1 && p.detail && (d.has(p.detail) || d.add(p.detail), a.has(p.errorCode) || a.add(p.errorCode));
+          return d.size > 0 ? { error: {
             status: "FETCH_ERROR",
-            error: Array.from(p).join(", "),
-            errorCodes: Array.from(n)
-          } } : { data: r };
-        } catch (a) {
-          return console.error(a), { error: { status: "FETCH_ERROR", error: a.message } };
+            error: Array.from(d).join(", "),
+            errorCodes: Array.from(a)
+          } } : { data: i };
+        } catch (o) {
+          return console.error(o), { error: { status: "FETCH_ERROR", error: o.message } };
         }
       },
-      async onQueryStarted({ operationsRequestModel: e, patchOperations: s = [], projectName: a }, { dispatch: r, queryFulfilled: p, getState: n }) {
-        if (!e.operations?.length) return;
-        const { operations: l } = e, o = l.reduce(
-          (m, f) => (m[f.entityType].push(f), m),
+      async onQueryStarted({ operationsRequestModel: t, patchOperations: r = [], projectName: o }, { dispatch: i, queryFulfilled: d, getState: a }) {
+        if (!t.operations?.length) return;
+        const { operations: p } = t, n = p.reduce(
+          (c, u) => (c[u.entityType].push(u), c),
           {
             task: [],
             folder: [],
@@ -293,105 +262,108 @@ const w = (t, e) => {
             representation: [],
             workfile: []
           }
-        ), i = n(), d = [];
-        if (o.task?.length) {
-          const { delete: m, update: f } = b(o.task), u = f.filter(
-            (g) => !s.some((h) => h.entityId === g.entityId)
+        ), s = a(), l = [];
+        if (n.task?.length) {
+          const { delete: c, update: u } = Q(n.task), g = u.filter(
+            (k) => !r.some((y) => y.entityId === k.entityId)
           );
-          L(u, { state: i, dispatch: r }, d), V([...m], {
-            dispatch: r
+          L(g, { state: s, dispatch: i }, l), K([...c], {
+            dispatch: i
           });
         }
-        if (o.folder?.length) {
-          const { delete: m, update: f } = b(o.folder), u = f.filter(
-            (g) => !s.some((h) => h.entityId === g.entityId)
+        if (n.folder?.length) {
+          const { delete: c, update: u } = Q(n.folder), g = u.filter(
+            (k) => !r.some((y) => y.entityId === k.entityId)
           );
-          O(u, { state: i, dispatch: r }, d), m.length && r(A.util.invalidateTags([{ type: "folder", id: "LIST" }]));
+          P(g, { state: s, dispatch: i }, l), c.length && i(w.util.invalidateTags([{ type: "folder", id: "LIST" }]));
         }
-        const c = s.filter((m) => m.entityType === "task"), y = s.filter((m) => m.entityType === "folder");
-        c.length && L(c, { state: i, dispatch: r }, d), y.length && O(y, { state: i, dispatch: r }, d), W([...l, ...s], { state: i, dispatch: r }, d), o.version?.length && q(o.version, { state: i, dispatch: r }, d), o.product?.length && H(o.product, { state: i, dispatch: r }, d);
-        const I = l.map((m) => ({
-          id: m.entityId,
-          type: m.entityType
-        })), P = I.map((m) => ({
+        const f = r.filter((c) => c.entityType === "task"), m = r.filter((c) => c.entityType === "folder");
+        f.length && L(f, { state: s, dispatch: i }, l), m.length && P(m, { state: s, dispatch: i }, l), X([...p, ...r], { state: s, dispatch: i }, l), n.version?.length && U(n.version, { state: s, dispatch: i }, l), n.product?.length && $(n.product, { state: s, dispatch: i }, l);
+        const I = p.map((c) => ({
+          id: c.entityId,
+          type: c.entityType
+        })), C = I.map((c) => ({
           type: "entities",
-          id: m.id
-        })), Q = () => r(E.util.invalidateTags(P)), j = E.util.selectInvalidatedBy(
-          i,
+          id: c.id
+        })), j = () => i(E.util.invalidateTags(C)), D = E.util.selectInvalidatedBy(
+          s,
           I
-        ), x = E.util.selectInvalidatedBy(
-          i,
-          P
+        ), N = E.util.selectInvalidatedBy(
+          s,
+          C
         );
-        for (const m of x) {
-          if (m.endpointName !== "getEntitiesDetailsPanel") continue;
-          const f = r(
+        for (const c of N) {
+          if (c.endpointName !== "getEntitiesDetailsPanel") continue;
+          const u = i(
             E.util.updateQueryData(
-              m.endpointName,
-              m.originalArgs,
-              (u) => {
-                for (const g of u)
-                  _(l, g);
+              c.endpointName,
+              c.originalArgs,
+              (g) => {
+                for (const k of g)
+                  z(p, k);
               }
             )
           );
-          d.push(f);
+          l.push(u);
         }
         try {
-          await p;
-          const m = o.task || [], f = o.folder || [];
-          if (m.length === 0 && f.length === 0)
+          await d;
+          const c = n.task || [], u = n.folder || [], g = n.version || [], k = n.product || [];
+          if (o && ((c.length || u.length) && b(i, o, ["folderColumnStats", "taskColumnStats"]), (g.length || k.length) && b(i, o, [
+            "productColumnStats",
+            "versionColumnStats"
+          ])), c.length === 0 && u.length === 0)
             return;
-          const u = B(m), g = B(f), h = u.map((k) => ({ type: "overviewTask", id: k })), R = T.util.selectInvalidatedBy(i, h).filter((k) => k.endpointName === "getTasksListInfinite");
-          if (u.length > 0 && a) {
-            for (const v of R)
-              await M({
-                dispatch: r,
-                projectName: a,
-                updatedTaskIds: u,
+          const y = S(c), _ = S(u), F = y.map((h) => ({ type: "overviewTask", id: h })), q = T.util.selectInvalidatedBy(s, F).filter((h) => h.endpointName === "getTasksListInfinite");
+          if (y.length > 0 && o) {
+            for (const v of q)
+              await G({
+                dispatch: i,
+                projectName: o,
+                updatedTaskIds: y,
                 cacheEntry: v
               });
-            const k = T.util.selectInvalidatedBy(i, h).filter((v) => v.endpointName === "getOverviewTasksByFolders");
-            for (const v of k)
-              await U({
-                dispatch: r,
-                projectName: a,
-                updatedTaskIds: u,
+            const h = T.util.selectInvalidatedBy(s, F).filter((v) => v.endpointName === "getOverviewTasksByFolders");
+            for (const v of h)
+              await V({
+                dispatch: i,
+                projectName: o,
+                updatedTaskIds: y,
                 cacheEntry: v
               });
           }
-          const S = (o.folder || []).some(
-            (k) => k.type === "delete"
+          const M = (n.folder || []).some(
+            (h) => h.type === "delete"
           );
-          g.length > 0 && a && !S && r(A.util.invalidateTags([{ type: "folder", id: "LIST" }]));
+          _.length > 0 && o && !M && i(w.util.invalidateTags([{ type: "folder", id: "LIST" }]));
         } catch {
-          for (const f of d)
-            f.undo();
-          j.length && Q();
+          for (const u of l)
+            u.undo();
+          D.length && j();
         }
       },
-      invalidatesTags: (e, s, { operationsRequestModel: a, projectName: r }) => {
-        const p = [{ type: "kanban", id: "project-" + r }], n = [], l = [], o = [];
-        let i = !1;
-        return a.operations?.forEach((d) => {
-          const { entityId: c } = d;
-          c ? (n.push({ type: "progress", id: c }), l.push({ type: "entityListItem", id: c })) : n.push({ type: "progress", id: "LIST" }), d.data?.attrib && (i = !0);
-        }), i && o.push({ type: "tasksFolder", id: r }), [
+      invalidatesTags: (t, r, { operationsRequestModel: o, projectName: i }) => {
+        const d = [{ type: "kanban", id: "project-" + i }], a = [], p = [], n = [];
+        let s = !1;
+        return o.operations?.forEach((l) => {
+          const { entityId: f } = l;
+          f ? (a.push({ type: "progress", id: f }), p.push({ type: "entityListItem", id: f })) : a.push({ type: "progress", id: "LIST" }), l.data?.attrib && (s = !0);
+        }), s && n.push({ type: "tasksFolder", id: i }), [
+          ...d,
+          ...a,
           ...p,
-          ...n,
-          ...l,
-          ...o
+          ...n
         ];
       }
     })
   })
-}), { useUpdateOverviewEntitiesMutation: qe } = J;
+}), { useUpdateOverviewEntitiesMutation: ee } = Y;
 export {
-  G as createLinkDeletionPatch,
-  De as deleteLinksFromEntities,
-  _e as patchOverviewEntities,
-  O as patchOverviewFolders,
+  J as createLinkDeletionPatch,
+  Zt as deleteLinksFromEntities,
+  te as patchOverviewEntities,
+  P as patchOverviewFolders,
   L as patchOverviewTasks,
-  qe as useUpdateOverviewEntitiesMutation
+  ee as useUpdateOverviewEntitiesMutation
 };
 //# sourceMappingURL=updateOverview.es.js.map