@ynput/ayon-frontend-shared 0.3.40 → 0.3.42

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

@@ -42,9 +42,62 @@ import "lodash";
 import "react-toastify";
 import "uuid";
 import { subscribeToThumbnailUpdates as E } from "../../../util/thumbnailWebsocket.es.js";
-import F from "../../../util/pubsub.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 { mergeFieldStats as N, normalizeFieldStats as x } from "../columnStats/columnStats.es.js";
 import { hasNewTargetFields as G } from "../columnStats/metricTargets.es.js";
+import "../config/getConfig.es.js";
+import "../config/updateConfig.es.js";
+import "../entities/getEntity.es.js";
+import "../entities/getEntityPanel.es.js";
+import "./updateOverview.es.js";
+import "../versions/getVersionsProducts.es.js";
+import "../links/getEntityLinks.es.js";
+import "../entities/updateEntity.es.js";
+import "../entityLists/getLists.es.js";
+import "../entityLists/updateLists.es.js";
+import "../entityLists/getListsAttributes.es.js";
+import "../entityLists/listItemsColumnStats.es.js";
+import "../entityLists/updateListsAttributes.es.js";
+import "../entityLists/listFolders.es.js";
+import "../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 "../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 "../views/getViews.es.js";
+import "../views/updateViews.es.js";
+import "../watchers/getWatchers.es.js";
+import "../uris/getUris.es.js";
+import F from "../../../util/pubsub.es.js";
 const q = (s) => {
   try {
     return JSON.parse(s);
@@ -54,26 +107,26 @@ const q = (s) => {
 }, L = (s) => {
   if (!s.project)
     return [];
-  const e = [];
-  for (const { node: t } of s.project.tasks.edges)
-    e.push({
-      ...t,
-      folderId: t.folderId || "root",
-      attrib: q(t.allAttrib),
-      entityId: t.id,
+  const t = [];
+  for (const { node: e } of s.project.tasks.edges)
+    t.push({
+      ...e,
+      folderId: e.folderId || "root",
+      attrib: q(e.allAttrib),
+      entityId: e.id,
       entityType: "task",
       links: []
     });
-  return e;
-}, R = (s = [], e, t) => {
-  const o = s?.map((l) => ({ type: "overviewTask", id: l.id })) || [], a = t ? (Array.isArray(t) ? t : [t]).map((l) => ({
+  return t;
+}, R = (s = [], t, e) => {
+  const o = s?.map((d) => ({ type: "overviewTask", id: d.id })) || [], i = e ? (Array.isArray(e) ? e : [e]).map((d) => ({
     type: "overviewTask",
-    id: l
+    id: d
   })) : [];
   return [
     ...o,
-    ...a,
-    { type: "overviewTask", id: e },
+    ...i,
+    { type: "overviewTask", id: t },
     { type: "overviewTask", id: "LIST" }
   ];
 }, P = O.enhanceEndpoints({
@@ -83,30 +136,30 @@ const q = (s) => {
     // It is only used by getOverviewTasksByFolders in this file
     GetTasksByParent: {
       transformResponse: L,
-      providesTags: (s, e, { parentIds: t, projectName: o }) => R(s, o, t)
+      providesTags: (s, t, { parentIds: e, projectName: o }) => R(s, o, e)
     },
     GetTasksList: {
       transformResponse: (s) => ({
         tasks: L(s),
         pageInfo: s.project.tasks.pageInfo
       }),
-      providesTags: (s, e, { projectName: t }) => R(s?.tasks || [], t)
+      providesTags: (s, t, { projectName: e }) => R(s?.tasks || [], e)
     },
     // footer stats: `targets` excluded from cache key + responses merged,
     // so column toggles reuse cache and only added targets refetch
     GetFolderColumnStats: {
       transformResponse: (s) => x(s?.project?.folders?.fieldStats ?? []),
-      serializeQueryArgs: ({ queryArgs: { targets: s, ...e } }) => e,
-      merge: (s, e) => N(e, s),
-      forceRefetch: ({ currentArg: s, previousArg: e }) => G(s, e),
-      providesTags: (s, e, { projectName: t }) => [{ type: "folderColumnStats", id: t }]
+      serializeQueryArgs: ({ queryArgs: { targets: s, ...t } }) => t,
+      merge: (s, t) => N(t, s),
+      forceRefetch: ({ currentArg: s, previousArg: t }) => G(s, t),
+      providesTags: (s, t, { projectName: e }) => [{ type: "folderColumnStats", id: e }]
     },
     GetTaskColumnStats: {
       transformResponse: (s) => x(s?.project?.tasks?.fieldStats ?? []),
-      serializeQueryArgs: ({ queryArgs: { targets: s, ...e } }) => e,
-      merge: (s, e) => N(e, s),
-      forceRefetch: ({ currentArg: s, previousArg: e }) => G(s, e),
-      providesTags: (s, e, { projectName: t }) => [{ type: "taskColumnStats", id: t }]
+      serializeQueryArgs: ({ queryArgs: { targets: s, ...t } }) => t,
+      merge: (s, t) => N(t, s),
+      forceRefetch: ({ currentArg: s, previousArg: t }) => G(s, t),
+      providesTags: (s, t, { projectName: e }) => [{ type: "taskColumnStats", id: e }]
     }
   }
 }), Q = H.enhanceEndpoints({
@@ -121,20 +174,20 @@ const q = (s) => {
     // When new folders are expanded, the new tasks are fetched and we use the cache for the rest
     // This also solves the pagination issue of getting all tasks in one query, splitting it up in multiple queries to avoid pagination limits
     getOverviewTasksByFolders: s.query({
-      async queryFn({ projectName: e, parentIds: t, filter: o, folderFilter: a, search: l, showComments: I }, { dispatch: g, forced: w }) {
+      async queryFn({ projectName: t, parentIds: e, filter: o, folderFilter: i, search: d, showComments: I }, { dispatch: g, forced: w }) {
         try {
           const y = [];
-          for (let u = 0; u < t.length; u += 20) {
-            const C = t.slice(u, u + 20), i = (await Promise.all(
+          for (let m = 0; m < e.length; m += 20) {
+            const C = e.slice(m, m + 20), a = (await Promise.all(
               C.map(
                 async (r) => g(
                   P.endpoints.GetTasksByParent.initiate(
                     {
-                      projectName: e,
+                      projectName: t,
                       parentIds: [r],
                       filter: o,
-                      folderFilter: a,
-                      search: l,
+                      folderFilter: i,
+                      search: d,
                       showComments: !!I
                     },
                     { forceRefetch: w }
@@ -142,7 +195,7 @@ const q = (s) => {
                 )
               )
             )).filter((r) => !!r.data).flatMap((r) => r.data);
-            y.push(...i);
+            y.push(...a);
           }
           return { data: y };
         } catch (v) {
@@ -150,132 +203,132 @@ const q = (s) => {
         }
       },
       // keep one cache per project
-      serializeQueryArgs: ({ queryArgs: { parentIds: e, ...t } }) => ({
-        ...t
+      serializeQueryArgs: ({ queryArgs: { parentIds: t, ...e } }) => ({
+        ...e
       }),
       // Refetch when the page arg changes
-      forceRefetch({ currentArg: e, previousArg: t }) {
-        return JSON.stringify(e) !== JSON.stringify(t);
+      forceRefetch({ currentArg: t, previousArg: e }) {
+        return JSON.stringify(t) !== JSON.stringify(e);
       },
-      providesTags: (e, t, { parentIds: o, projectName: a }) => R(e, a, o),
-      async onCacheEntryAdded({ projectName: e, parentIds: t, filter: o, search: a, showComments: l }, { cacheDataLoaded: I, cacheEntryRemoved: g, updateCachedData: w, dispatch: v }) {
+      providesTags: (t, e, { parentIds: o, projectName: i }) => R(t, i, o),
+      async onCacheEntryAdded({ projectName: t, parentIds: e, filter: o, search: i, showComments: d }, { cacheDataLoaded: I, cacheEntryRemoved: g, updateCachedData: w, dispatch: v }) {
         let y;
-        const u = /* @__PURE__ */ new Set(), C = 100, b = 500;
-        let i = !1;
+        const m = /* @__PURE__ */ new Set(), C = 100, b = 500;
+        let a = !1;
         const r = () => {
-          i || (i = !0, setTimeout(h, b));
+          a || (a = !0, setTimeout(h, b));
         }, h = async () => {
-          if (i = !1, !u.size) return;
-          const c = Array.from(u).slice(0, C);
-          c.forEach((n) => u.delete(n));
+          if (a = !1, !m.size) return;
+          const p = Array.from(m).slice(0, C);
+          p.forEach((n) => m.delete(n));
           try {
-            const p = (await v(
+            const u = (await v(
               P.endpoints.GetTasksList.initiate(
                 {
-                  projectName: e,
-                  taskIds: c,
-                  showComments: !!l
+                  projectName: t,
+                  taskIds: p,
+                  showComments: !!d
                 },
                 { forceRefetch: !0 }
               )
-            ).unwrap()).tasks || [], f = new Map(p.map((d) => [d.id, d]));
-            w((d) => {
-              for (const k of p) {
-                const A = d.findIndex((T) => T.id === k.id);
-                A > -1 ? d[A] = k : d.push(k);
+            ).unwrap()).tasks || [], l = new Map(u.map((c) => [c.id, c]));
+            w((c) => {
+              for (const k of u) {
+                const A = c.findIndex((T) => T.id === k.id);
+                A > -1 ? c[A] = k : c.push(k);
               }
-              for (const k of c)
-                if (!f.has(k)) {
-                  const A = d.findIndex((T) => T.id === k);
-                  A > -1 && d.splice(A, 1);
+              for (const k of p)
+                if (!l.has(k)) {
+                  const A = c.findIndex((T) => T.id === k);
+                  A > -1 && c.splice(A, 1);
                 }
             });
           } catch (n) {
             console.error("Realtime overview batch update failed", n);
           } finally {
-            u.size && r();
+            m.size && r();
           }
         };
-        let m;
+        let f;
         try {
-          await I, m = E(
+          await I, f = E(
             (n) => {
-              w((p) => {
-                n.forEach((f) => {
-                  if (f.summary.entityType === "task" && f.summary.thumbnailHash) {
-                    const d = p.findIndex((k) => k.id === f.summary.entityId);
-                    d > -1 && (p[d].thumbnailHash = f.summary.thumbnailHash);
+              w((u) => {
+                n.forEach((l) => {
+                  if (l.summary.entityType === "task" && l.summary.thumbnailHash) {
+                    const c = u.findIndex((k) => k.id === l.summary.entityId);
+                    c > -1 && (u[c].thumbnailHash = l.summary.thumbnailHash);
                   }
                 });
               });
             },
             ["task"]
           );
-          const c = async (n, p) => {
-            const f = p?.summary?.entityId, d = p?.summary?.parentId;
-            !f || !d || t.includes(d) && (u.add(f), r());
+          const p = async (n, u) => {
+            const l = u?.summary?.entityId, c = u?.summary?.parentId;
+            !l || !c || e.includes(c) && (m.add(l), r());
           };
-          y = F.subscribe("entity.task", c);
+          y = F.subscribe("entity.task", p);
         } catch {
         }
-        await g, y && F.unsubscribe(y), m && m();
+        await g, y && F.unsubscribe(y), f && f();
       }
     }),
     // searchFolders is a post so it's a bit annoying to consume
     // we wrap it in a queryFn to make it easier to consume as a query hook
     getSearchFolders: s.query({
-      async queryFn({ projectName: e, folderSearchRequest: t }, { dispatch: o }) {
+      async queryFn({ projectName: t, folderSearchRequest: e }, { dispatch: o }) {
         try {
           return { data: (await o(
             Q.endpoints.searchFolders.initiate({
-              projectName: e,
-              folderSearchRequest: t
+              projectName: t,
+              folderSearchRequest: e
             })
           )).data?.folderIds || [] };
-        } catch (a) {
-          return console.error(a), { error: { status: "FETCH_ERROR", error: a.message } };
+        } catch (i) {
+          return console.error(i), { error: { status: "FETCH_ERROR", error: i.message } };
         }
       },
-      providesTags: (e, t, { projectName: o }) => [{ type: "tasksFolder", id: o }]
+      providesTags: (t, e, { projectName: o }) => [{ type: "tasksFolder", id: o }]
     }),
     // Add new infinite query endpoint for tasks list
     getTasksListInfinite: s.infiniteQuery({
       infiniteQueryOptions: {
         initialPageParam: { cursor: "", desc: !1 },
         // Calculate the next page param based on current page response and params
-        getNextPageParam: (e, t, o, a) => {
-          const l = e.pageInfo;
-          if (!(!(o.desc ? l.hasPreviousPage : l.hasNextPage) || !l.endCursor))
+        getNextPageParam: (t, e, o, i) => {
+          const d = t.pageInfo;
+          if (!(!(o.desc ? d.hasPreviousPage : d.hasNextPage) || !d.endCursor))
             return {
-              cursor: l.endCursor,
+              cursor: d.endCursor,
               desc: o.desc
             };
         }
       },
-      queryFn: async ({ queryArg: e, pageParam: t }, o) => {
+      queryFn: async ({ queryArg: t, pageParam: e }, o) => {
         try {
           const {
-            projectName: a,
-            filter: l,
+            projectName: i,
+            filter: d,
             folderFilter: I,
             search: g,
             folderIds: w,
             taskIds: v,
             sortBy: y,
-            desc: u,
+            desc: m,
             showComments: C
-          } = e, { cursor: b } = t, i = {
-            projectName: a,
-            filter: l,
+          } = t, { cursor: b } = e, a = {
+            projectName: i,
+            filter: d,
             folderFilter: I,
             search: g,
             folderIds: w,
             taskIds: v,
             showComments: !!C
           };
-          y ? (i.sortBy = y, u ? (i.before = b || void 0, i.last = S) : (i.after = b || void 0, i.first = S)) : (i.after = b || void 0, i.first = S);
+          y ? (a.sortBy = y, m ? (a.before = b || void 0, a.last = S) : (a.after = b || void 0, a.first = S)) : (a.after = b || void 0, a.first = S);
           const r = await o.dispatch(
-            P.endpoints.GetTasksList.initiate(i, { forceRefetch: !0 })
+            P.endpoints.GetTasksList.initiate(a, { forceRefetch: !0 })
           );
           if (r.error) throw r.error;
           const h = {
@@ -290,44 +343,44 @@ const q = (s) => {
           return {
             data: r.data || h
           };
-        } catch (a) {
-          return console.error("Error in getTasksListInfinite queryFn:", a), { error: { status: "FETCH_ERROR", error: a.message } };
+        } catch (i) {
+          return console.error("Error in getTasksListInfinite queryFn:", i), { error: { status: "FETCH_ERROR", error: i.message } };
         }
       },
-      providesTags: (e, t, { projectName: o }) => R(e?.pages.flatMap((a) => a.tasks) || [], o),
-      async onCacheEntryAdded(e, { cacheDataLoaded: t, cacheEntryRemoved: o, updateCachedData: a, dispatch: l }) {
+      providesTags: (t, e, { projectName: o }) => R(t?.pages.flatMap((i) => i.tasks) || [], o),
+      async onCacheEntryAdded(t, { cacheDataLoaded: e, cacheEntryRemoved: o, updateCachedData: i, dispatch: d }) {
         let I;
         const g = /* @__PURE__ */ new Set(), w = 100, v = 500;
         let y = !1;
-        const u = () => {
+        const m = () => {
           y || (y = !0, setTimeout(C, v));
         }, C = async () => {
           if (y = !1, !g.size) return;
-          const i = Array.from(g).slice(0, w);
-          i.forEach((r) => g.delete(r));
+          const a = Array.from(g).slice(0, w);
+          a.forEach((r) => g.delete(r));
           try {
-            const h = (await l(
+            const h = (await d(
               P.endpoints.GetTasksList.initiate(
                 {
-                  projectName: e.projectName,
-                  taskIds: i,
-                  folderIds: e.folderIds,
-                  showComments: !!e.showComments
+                  projectName: t.projectName,
+                  taskIds: a,
+                  folderIds: t.folderIds,
+                  showComments: !!t.showComments
                 },
                 { forceRefetch: !0 }
               )
-            ).unwrap()).tasks || [], m = new Map(h.map((c) => [c.id, c]));
-            a((c) => {
+            ).unwrap()).tasks || [], f = new Map(h.map((p) => [p.id, p]));
+            i((p) => {
               for (const n of h) {
-                let p = !1;
-                for (const f of c.pages) {
-                  const d = f.tasks.findIndex((k) => k.id === n.id);
-                  if (d !== -1) {
-                    f.tasks[d] = n, p = !0;
+                let u = !1;
+                for (const l of p.pages) {
+                  const c = l.tasks.findIndex((k) => k.id === n.id);
+                  if (c !== -1) {
+                    l.tasks[c] = n, u = !0;
                     break;
                   }
                 }
-                p || (c.pages.length ? c.pages[0].tasks.unshift(n) : c.pages.push({
+                u || (p.pages.length ? p.pages[0].tasks.unshift(n) : p.pages.push({
                   tasks: [n],
                   pageInfo: {
                     startCursor: null,
@@ -337,12 +390,12 @@ const q = (s) => {
                   }
                 }));
               }
-              for (const n of i)
-                if (!m.has(n))
-                  for (const p of c.pages) {
-                    const f = p.tasks.findIndex((d) => d.id === n);
-                    if (f !== -1) {
-                      p.tasks.splice(f, 1);
+              for (const n of a)
+                if (!f.has(n))
+                  for (const u of p.pages) {
+                    const l = u.tasks.findIndex((c) => c.id === n);
+                    if (l !== -1) {
+                      u.tasks.splice(l, 1);
                       break;
                     }
                   }
@@ -350,20 +403,20 @@ const q = (s) => {
           } catch (r) {
             console.error("Realtime infinite tasks batch update failed", r);
           } finally {
-            g.size && u();
+            g.size && m();
           }
         };
         let b;
         try {
-          await t, b = E(
+          await e, b = E(
             (r) => {
-              a((h) => {
-                r.forEach((m) => {
-                  if (m.summary.entityType === "task" && m.summary.thumbnailHash)
-                    for (const c of h.pages) {
-                      const n = c.tasks.findIndex((p) => p.id === m.summary.entityId);
+              i((h) => {
+                r.forEach((f) => {
+                  if (f.summary.entityType === "task" && f.summary.thumbnailHash)
+                    for (const p of h.pages) {
+                      const n = p.tasks.findIndex((u) => u.id === f.summary.entityId);
                       if (n > -1) {
-                        c.tasks[n].thumbnailHash = m.summary.thumbnailHash;
+                        p.tasks[n].thumbnailHash = f.summary.thumbnailHash;
                         break;
                       }
                     }
@@ -372,11 +425,11 @@ const q = (s) => {
             },
             ["task"]
           );
-          const i = async (r, h) => {
-            const m = h?.summary?.entityId;
-            m && (g.add(m), u());
+          const a = async (r, h) => {
+            const f = h?.summary?.entityId;
+            f && (g.add(f), m());
           };
-          I = F.subscribe("entity.task", i);
+          I = F.subscribe("entity.task", a);
         } catch {
         }
         await o, I && F.unsubscribe(I), b && b();
@@ -384,99 +437,99 @@ const q = (s) => {
     }),
     getGroupedTasksList: s.query({
       queryFn: async ({
-        projectName: e,
-        groups: t,
+        projectName: t,
+        groups: e,
         search: o,
-        folderFilter: a,
-        folderIds: l,
+        folderFilter: i,
+        folderIds: d,
         desc: I,
         sortBy: g,
         groupCount: w,
         showComments: v
       }, y) => {
         try {
-          let u = [];
+          let m = [];
           const C = /* @__PURE__ */ new Set(["folderType"]);
-          for (const r of t) {
+          for (const r of e) {
             const h = w || r.count || 500;
-            let m = r.filter, c = a;
+            let f = r.filter, p = i;
             if (r.filter)
               try {
-                const f = JSON.parse(r.filter), d = f.conditions || [], k = d.filter((T) => !C.has(T.key)), A = d.filter((T) => C.has(T.key));
+                const l = JSON.parse(r.filter), c = l.conditions || [], k = c.filter((T) => !C.has(T.key)), A = c.filter((T) => C.has(T.key));
                 if (A.length > 0) {
-                  m = k.length ? JSON.stringify({ ...f, conditions: k }) : void 0;
-                  const T = a ? JSON.parse(a) : null, _ = [...T && Array.isArray(T.conditions) ? T.conditions : [], ...A];
-                  c = JSON.stringify(
+                  f = k.length ? JSON.stringify({ ...l, conditions: k }) : void 0;
+                  const T = i ? JSON.parse(i) : null, _ = [...T && Array.isArray(T.conditions) ? T.conditions : [], ...A];
+                  p = JSON.stringify(
                     T ? { ...T, conditions: _ } : { conditions: _ }
                   );
                 }
               } catch {
               }
             const n = {
-              projectName: e,
-              filter: m,
-              folderFilter: c,
+              projectName: t,
+              filter: f,
+              folderFilter: p,
               search: o,
-              folderIds: l,
+              folderIds: d,
               sortBy: g,
               showComments: !!v,
               // @ts-expect-error - we know group does not exist on query variables but we need it for later
               group: r.value
             };
             I ? n.last = h : n.first = h;
-            const p = y.dispatch(
+            const u = y.dispatch(
               P.endpoints.GetTasksList.initiate(n, { forceRefetch: !0 })
             );
-            u.push(p);
+            m.push(u);
           }
-          const b = await Promise.all(u), i = [];
+          const b = await Promise.all(m), a = [];
           for (const r of b) {
             if (r.error) throw r.error;
-            const h = r.originalArgs?.group, m = r.data?.pageInfo?.hasNextPage || r.data?.pageInfo?.hasPreviousPage || !1, c = r.data?.tasks.map((n, p, f) => ({
+            const h = r.originalArgs?.group, f = r.data?.pageInfo?.hasNextPage || r.data?.pageInfo?.hasPreviousPage || !1, p = r.data?.tasks.map((n, u, l) => ({
               ...n,
               groups: [
                 {
                   value: h,
-                  hasNextPage: p === f.length - 1 && m ? h : void 0
+                  hasNextPage: u === l.length - 1 && f ? h : void 0
                   // Only add hasNextPage to the last task in the group
                 }
               ]
             })) || [];
-            i.push(...c);
+            a.push(...p);
           }
           return {
             data: {
-              tasks: i
+              tasks: a
             }
           };
-        } catch (u) {
-          return console.error("Error in getGroupedTasksList queryFn:", u), { error: { status: "FETCH_ERROR", error: u.message } };
+        } catch (m) {
+          return console.error("Error in getGroupedTasksList queryFn:", m), { error: { status: "FETCH_ERROR", error: m.message } };
         }
       },
-      providesTags: (e, t, { projectName: o }) => R(e?.tasks, o)
+      providesTags: (t, e, { projectName: o }) => R(t?.tasks, o)
     })
   })
 }), {
-  useGetOverviewTasksByFoldersQuery: Le,
-  useGetSearchFoldersQuery: Oe,
-  useGetTasksListQuery: He,
-  useGetTasksListInfiniteInfiniteQuery: qe,
-  useLazyGetTasksByParentQuery: Qe,
-  useGetGroupedTasksListQuery: Be,
-  useGetFolderColumnStatsQuery: je,
-  useGetTaskColumnStatsQuery: ze
+  useGetOverviewTasksByFoldersQuery: Ge,
+  useGetSearchFoldersQuery: Le,
+  useGetTasksListQuery: Oe,
+  useGetTasksListInfiniteInfiniteQuery: He,
+  useLazyGetTasksByParentQuery: qe,
+  useGetGroupedTasksListQuery: Qe,
+  useGetFolderColumnStatsQuery: Be,
+  useGetTaskColumnStatsQuery: je
 } = B;
 export {
   S as TASKS_INFINITE_QUERY_COUNT,
   B as default,
   q as parseAllAttribs,
-  je as useGetFolderColumnStatsQuery,
-  Be as useGetGroupedTasksListQuery,
-  Le as useGetOverviewTasksByFoldersQuery,
-  Oe as useGetSearchFoldersQuery,
-  ze as useGetTaskColumnStatsQuery,
-  qe as useGetTasksListInfiniteInfiniteQuery,
-  He as useGetTasksListQuery,
-  Qe as useLazyGetTasksByParentQuery
+  Be as useGetFolderColumnStatsQuery,
+  Qe as useGetGroupedTasksListQuery,
+  Ge as useGetOverviewTasksByFoldersQuery,
+  Le as useGetSearchFoldersQuery,
+  je as useGetTaskColumnStatsQuery,
+  He as useGetTasksListInfiniteInfiniteQuery,
+  Oe as useGetTasksListQuery,
+  qe as useLazyGetTasksByParentQuery
 };
 //# sourceMappingURL=getOverview.es.js.map