@ynput/ayon-frontend-shared 0.3.30 → 0.3.32

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

@@ -1,5 +1,5 @@
 import "../../base/client.es.js";
-import { api as C } from "../../generated/graphql.es.js";
+import { api as L } from "../../generated/graphql.es.js";
 import "../../generated/graphqlLinks.es.js";
 import "../../generated/access.es.js";
 import "../../generated/actions.es.js";
@@ -15,7 +15,7 @@ import "../../generated/desktop.es.js";
 import "../../generated/entityLists.es.js";
 import "../../generated/events.es.js";
 import "../../generated/files.es.js";
-import { api as x } from "../../generated/folders.es.js";
+import { api as O } from "../../generated/folders.es.js";
 import "../../generated/inbox.es.js";
 import "../../generated/links.es.js";
 import "../../generated/market.es.js";
@@ -41,199 +41,231 @@ import "../../generated/views.es.js";
 import "lodash";
 import "react-toastify";
 import "uuid";
-import E from "../../../util/pubsub.es.js";
-const S = (l) => {
+import { subscribeToThumbnailUpdates as E } from "../../../util/thumbnailWebsocket.es.js";
+import S from "../../../util/pubsub.es.js";
+import { mergeFieldStats as C, normalizeFieldStats as N } from "../columnStats/columnStats.es.js";
+import { hasNewTargetFields as x } from "../columnStats/metricTargets.es.js";
+const H = (s) => {
   try {
-    return JSON.parse(l);
+    return JSON.parse(s);
   } catch {
     return {};
   }
-}, _ = (l) => {
-  if (!l.project)
+}, G = (s) => {
+  if (!s.project)
     return [];
-  const t = [];
-  for (const { node: e } of l.project.tasks.edges)
-    t.push({
-      ...e,
-      folderId: e.folderId || "root",
-      attrib: S(e.allAttrib),
-      entityId: e.id,
+  const e = [];
+  for (const { node: t } of s.project.tasks.edges)
+    e.push({
+      ...t,
+      folderId: t.folderId || "root",
+      attrib: H(t.allAttrib),
+      entityId: t.id,
       entityType: "task",
       links: []
     });
-  return t;
-}, b = (l = [], t, e) => {
-  const r = l?.map((c) => ({ type: "overviewTask", id: c.id })) || [], o = e ? (Array.isArray(e) ? e : [e]).map((c) => ({
+  return e;
+}, F = (s = [], e, t) => {
+  const o = s?.map((f) => ({ type: "overviewTask", id: f.id })) || [], a = t ? (Array.isArray(t) ? t : [t]).map((f) => ({
     type: "overviewTask",
-    id: c
+    id: f
   })) : [];
   return [
-    ...r,
     ...o,
-    { type: "overviewTask", id: t },
+    ...a,
+    { type: "overviewTask", id: e },
     { type: "overviewTask", id: "LIST" }
   ];
-}, w = C.enhanceEndpoints({
+}, R = L.enhanceEndpoints({
   endpoints: {
     // This gets tasks for all parent folders provided
     // But in this case it will only ever receive one parent folder from the getOverviewTasksByFolders query
     // It is only used by getOverviewTasksByFolders in this file
     GetTasksByParent: {
-      transformResponse: _,
-      providesTags: (l, t, { parentIds: e, projectName: r }) => b(l, r, e)
+      transformResponse: G,
+      providesTags: (s, e, { parentIds: t, projectName: o }) => F(s, o, t)
     },
     GetTasksList: {
-      transformResponse: (l) => ({
-        tasks: _(l),
-        pageInfo: l.project.tasks.pageInfo
+      transformResponse: (s) => ({
+        tasks: G(s),
+        pageInfo: s.project.tasks.pageInfo
       }),
-      providesTags: (l, t, { projectName: e }) => b(l?.tasks || [], e)
+      providesTags: (s, e, { projectName: t }) => F(s?.tasks || [], t)
+    },
+    // footer stats: `targets` excluded from cache key + responses merged,
+    // so column toggles reuse cache and only added targets refetch
+    GetFolderColumnStats: {
+      transformResponse: (s) => N(s?.project?.folders?.fieldStats ?? []),
+      serializeQueryArgs: ({ queryArgs: { targets: s, ...e } }) => e,
+      merge: (s, e) => C(e, s),
+      forceRefetch: ({ currentArg: s, previousArg: e }) => x(s, e),
+      providesTags: (s, e, { projectName: t }) => [{ type: "folderColumnStats", id: t }]
+    },
+    GetTaskColumnStats: {
+      transformResponse: (s) => N(s?.project?.tasks?.fieldStats ?? []),
+      serializeQueryArgs: ({ queryArgs: { targets: s, ...e } }) => e,
+      merge: (s, e) => C(e, s),
+      forceRefetch: ({ currentArg: s, previousArg: e }) => x(s, e),
+      providesTags: (s, e, { projectName: t }) => [{ type: "taskColumnStats", id: t }]
     }
   }
-}), G = x.enhanceEndpoints({
+}), q = O.enhanceEndpoints({
   endpoints: {
     searchFolders: {}
   }
-}), F = 100, L = w.injectEndpoints({
-  endpoints: (l) => ({
+}), _ = 100, Q = R.injectEndpoints({
+  endpoints: (s) => ({
     // Each project has one cache for all the tasks of the expanded folders
     // Changing the expanded folders will trigger a refetch but not a new cache
     // Each expanded folder has it's own query that is looped over here
     // 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: l.query({
-      async queryFn({ projectName: t, parentIds: e, filter: r, folderFilter: o, search: c }, { dispatch: k, forced: f }) {
+    getOverviewTasksByFolders: s.query({
+      async queryFn({ projectName: e, parentIds: t, filter: o, folderFilter: a, search: f }, { dispatch: I, forced: h }) {
         try {
-          const g = [];
-          for (let i = 0; i < e.length; i += 20) {
-            const I = e.slice(i, i + 20), a = (await Promise.all(
-              I.map(
-                async (s) => k(
-                  w.endpoints.GetTasksByParent.initiate(
+          const k = [];
+          for (let n = 0; n < t.length; n += 20) {
+            const v = t.slice(n, n + 20), l = (await Promise.all(
+              v.map(
+                async (r) => I(
+                  R.endpoints.GetTasksByParent.initiate(
                     {
-                      projectName: t,
-                      parentIds: [s],
-                      filter: r,
-                      folderFilter: o,
-                      search: c
+                      projectName: e,
+                      parentIds: [r],
+                      filter: o,
+                      folderFilter: a,
+                      search: f
                     },
-                    { forceRefetch: f }
+                    { forceRefetch: h }
                   )
                 )
               )
-            )).filter((s) => !!s.data).flatMap((s) => s.data);
-            g.push(...a);
+            )).filter((r) => !!r.data).flatMap((r) => r.data);
+            k.push(...l);
           }
-          return { data: g };
-        } catch (T) {
-          return console.error(T), { error: { status: "FETCH_ERROR", error: T.message } };
+          return { data: k };
+        } catch (b) {
+          return console.error(b), { error: { status: "FETCH_ERROR", error: b.message } };
         }
       },
       // keep one cache per project
-      serializeQueryArgs: ({ queryArgs: { parentIds: t, ...e } }) => ({
-        ...e
+      serializeQueryArgs: ({ queryArgs: { parentIds: e, ...t } }) => ({
+        ...t
       }),
       // Refetch when the page arg changes
-      forceRefetch({ currentArg: t, previousArg: e }) {
-        return JSON.stringify(t) !== JSON.stringify(e);
+      forceRefetch({ currentArg: e, previousArg: t }) {
+        return JSON.stringify(e) !== JSON.stringify(t);
       },
-      providesTags: (t, e, { parentIds: r, projectName: o }) => b(t, o, r),
-      async onCacheEntryAdded({ projectName: t, parentIds: e, filter: r, search: o }, { cacheDataLoaded: c, cacheEntryRemoved: k, updateCachedData: f, dispatch: T }) {
-        let g;
-        const i = /* @__PURE__ */ new Set(), I = 100, v = 500;
-        let a = !1;
-        const s = () => {
-          a || (a = !0, setTimeout(y, v));
-        }, y = async () => {
-          if (a = !1, !i.size) return;
-          const u = Array.from(i).slice(0, I);
-          u.forEach((d) => i.delete(d));
+      providesTags: (e, t, { parentIds: o, projectName: a }) => F(e, a, o),
+      async onCacheEntryAdded({ projectName: e, parentIds: t, filter: o, search: a }, { cacheDataLoaded: f, cacheEntryRemoved: I, updateCachedData: h, dispatch: b }) {
+        let k;
+        const n = /* @__PURE__ */ new Set(), v = 100, A = 500;
+        let l = !1;
+        const r = () => {
+          l || (l = !0, setTimeout(m, A));
+        }, m = async () => {
+          if (l = !1, !n.size) return;
+          const p = Array.from(n).slice(0, v);
+          p.forEach((i) => n.delete(i));
           try {
-            const p = (await T(
-              w.endpoints.GetTasksList.initiate(
+            const c = (await b(
+              R.endpoints.GetTasksList.initiate(
                 {
-                  projectName: t,
-                  taskIds: u
+                  projectName: e,
+                  taskIds: p
                 },
                 { forceRefetch: !0 }
               )
-            ).unwrap()).tasks || [], m = new Map(p.map((n) => [n.id, n]));
-            f((n) => {
-              for (const h of p) {
-                const P = n.findIndex((R) => R.id === h.id);
-                P > -1 ? n[P] = h : n.push(h);
+            ).unwrap()).tasks || [], u = new Map(c.map((d) => [d.id, d]));
+            h((d) => {
+              for (const y of c) {
+                const P = d.findIndex((T) => T.id === y.id);
+                P > -1 ? d[P] = y : d.push(y);
               }
-              for (const h of u)
-                if (!m.has(h)) {
-                  const P = n.findIndex((R) => R.id === h);
-                  P > -1 && n.splice(P, 1);
+              for (const y of p)
+                if (!u.has(y)) {
+                  const P = d.findIndex((T) => T.id === y);
+                  P > -1 && d.splice(P, 1);
                 }
             });
-          } catch (d) {
-            console.error("Realtime overview batch update failed", d);
+          } catch (i) {
+            console.error("Realtime overview batch update failed", i);
           } finally {
-            i.size && s();
+            n.size && r();
           }
         };
+        let g;
         try {
-          await c;
-          const u = async (d, p) => {
-            const m = p?.summary?.entityId, n = p?.summary?.parentId;
-            !m || !n || e.includes(n) && (i.add(m), s());
+          await f, g = E(
+            (i) => {
+              h((c) => {
+                i.forEach((u) => {
+                  if (u.summary.entityType === "task" && u.summary.thumbnailHash) {
+                    const d = c.findIndex((y) => y.id === u.summary.entityId);
+                    d > -1 && (c[d].thumbnailHash = u.summary.thumbnailHash);
+                  }
+                });
+              });
+            },
+            ["task"]
+          );
+          const p = async (i, c) => {
+            const u = c?.summary?.entityId, d = c?.summary?.parentId;
+            !u || !d || t.includes(d) && (n.add(u), r());
           };
-          g = E.subscribe("entity.task", u);
+          k = S.subscribe("entity.task", p);
         } catch {
         }
-        await k, g && E.unsubscribe(g);
+        await I, k && S.unsubscribe(k), g && g();
       }
     }),
     // 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: l.query({
-      async queryFn({ projectName: t, folderSearchRequest: e }, { dispatch: r }) {
+    getSearchFolders: s.query({
+      async queryFn({ projectName: e, folderSearchRequest: t }, { dispatch: o }) {
         try {
-          return { data: (await r(
-            G.endpoints.searchFolders.initiate({
-              projectName: t,
-              folderSearchRequest: e
+          return { data: (await o(
+            q.endpoints.searchFolders.initiate({
+              projectName: e,
+              folderSearchRequest: t
             })
           )).data?.folderIds || [] };
-        } catch (o) {
-          return console.error(o), { error: { status: "FETCH_ERROR", error: o.message } };
+        } catch (a) {
+          return console.error(a), { error: { status: "FETCH_ERROR", error: a.message } };
         }
       },
-      providesTags: (t, e, { projectName: r }) => [{ type: "tasksFolder", id: r }]
+      providesTags: (e, t, { projectName: o }) => [{ type: "tasksFolder", id: o }]
     }),
     // Add new infinite query endpoint for tasks list
-    getTasksListInfinite: l.infiniteQuery({
+    getTasksListInfinite: s.infiniteQuery({
       infiniteQueryOptions: {
         initialPageParam: { cursor: "", desc: !1 },
         // Calculate the next page param based on current page response and params
-        getNextPageParam: (t, e, r, o) => {
-          const c = t.pageInfo;
-          if (!(!(r.desc ? c.hasPreviousPage : c.hasNextPage) || !c.endCursor))
+        getNextPageParam: (e, t, o, a) => {
+          const f = e.pageInfo;
+          if (!(!(o.desc ? f.hasPreviousPage : f.hasNextPage) || !f.endCursor))
             return {
-              cursor: c.endCursor,
-              desc: r.desc
+              cursor: f.endCursor,
+              desc: o.desc
             };
         }
       },
-      queryFn: async ({ queryArg: t, pageParam: e }, r) => {
+      queryFn: async ({ queryArg: e, pageParam: t }, o) => {
         try {
-          const { projectName: o, filter: c, folderFilter: k, search: f, folderIds: T, taskIds: g, sortBy: i, desc: I } = t, { cursor: v } = e, a = {
-            projectName: o,
-            filter: c,
-            folderFilter: k,
-            search: f,
-            folderIds: T,
-            taskIds: g
+          const { projectName: a, filter: f, folderFilter: I, search: h, folderIds: b, taskIds: k, sortBy: n, desc: v } = e, { cursor: A } = t, l = {
+            projectName: a,
+            filter: f,
+            folderFilter: I,
+            search: h,
+            folderIds: b,
+            taskIds: k
           };
-          i ? (a.sortBy = i, I ? (a.before = v || void 0, a.last = F) : (a.after = v || void 0, a.first = F)) : (a.after = v || void 0, a.first = F);
-          const s = await r.dispatch(
-            w.endpoints.GetTasksList.initiate(a, { forceRefetch: !0 })
+          n ? (l.sortBy = n, v ? (l.before = A || void 0, l.last = _) : (l.after = A || void 0, l.first = _)) : (l.after = A || void 0, l.first = _);
+          const r = await o.dispatch(
+            R.endpoints.GetTasksList.initiate(l, { forceRefetch: !0 })
           );
-          if (s.error) throw s.error;
-          const y = {
+          if (r.error) throw r.error;
+          const m = {
             tasks: [],
             pageInfo: {
               hasNextPage: !1,
@@ -243,46 +275,46 @@ const S = (l) => {
             }
           };
           return {
-            data: s.data || y
+            data: r.data || m
           };
-        } catch (o) {
-          return console.error("Error in getTasksListInfinite queryFn:", o), { error: { status: "FETCH_ERROR", error: o.message } };
+        } catch (a) {
+          return console.error("Error in getTasksListInfinite queryFn:", a), { error: { status: "FETCH_ERROR", error: a.message } };
         }
       },
-      providesTags: (t, e, { projectName: r }) => b(t?.pages.flatMap((o) => o.tasks) || [], r),
-      async onCacheEntryAdded(t, { cacheDataLoaded: e, cacheEntryRemoved: r, updateCachedData: o, dispatch: c }) {
-        let k;
-        const f = /* @__PURE__ */ new Set(), T = 100, g = 500;
-        let i = !1;
-        const I = () => {
-          i || (i = !0, setTimeout(v, g));
-        }, v = async () => {
-          if (i = !1, !f.size) return;
-          const a = Array.from(f).slice(0, T);
-          a.forEach((s) => f.delete(s));
+      providesTags: (e, t, { projectName: o }) => F(e?.pages.flatMap((a) => a.tasks) || [], o),
+      async onCacheEntryAdded(e, { cacheDataLoaded: t, cacheEntryRemoved: o, updateCachedData: a, dispatch: f }) {
+        let I;
+        const h = /* @__PURE__ */ new Set(), b = 100, k = 500;
+        let n = !1;
+        const v = () => {
+          n || (n = !0, setTimeout(A, k));
+        }, A = async () => {
+          if (n = !1, !h.size) return;
+          const r = Array.from(h).slice(0, b);
+          r.forEach((m) => h.delete(m));
           try {
-            const y = (await c(
-              w.endpoints.GetTasksList.initiate(
+            const g = (await f(
+              R.endpoints.GetTasksList.initiate(
                 {
-                  projectName: t.projectName,
-                  taskIds: a,
-                  folderIds: t.folderIds
+                  projectName: e.projectName,
+                  taskIds: r,
+                  folderIds: e.folderIds
                 },
                 { forceRefetch: !0 }
               )
-            ).unwrap()).tasks || [], u = new Map(y.map((d) => [d.id, d]));
-            o((d) => {
-              for (const p of y) {
-                let m = !1;
-                for (const n of d.pages) {
-                  const h = n.tasks.findIndex((P) => P.id === p.id);
-                  if (h !== -1) {
-                    n.tasks[h] = p, m = !0;
+            ).unwrap()).tasks || [], p = new Map(g.map((i) => [i.id, i]));
+            a((i) => {
+              for (const c of g) {
+                let u = !1;
+                for (const d of i.pages) {
+                  const y = d.tasks.findIndex((P) => P.id === c.id);
+                  if (y !== -1) {
+                    d.tasks[y] = c, u = !0;
                     break;
                   }
                 }
-                m || (d.pages.length ? d.pages[0].tasks.unshift(p) : d.pages.push({
-                  tasks: [p],
+                u || (i.pages.length ? i.pages[0].tasks.unshift(c) : i.pages.push({
+                  tasks: [c],
                   pageInfo: {
                     startCursor: null,
                     endCursor: null,
@@ -291,118 +323,135 @@ const S = (l) => {
                   }
                 }));
               }
-              for (const p of a)
-                if (!u.has(p))
-                  for (const m of d.pages) {
-                    const n = m.tasks.findIndex((h) => h.id === p);
-                    if (n !== -1) {
-                      m.tasks.splice(n, 1);
+              for (const c of r)
+                if (!p.has(c))
+                  for (const u of i.pages) {
+                    const d = u.tasks.findIndex((y) => y.id === c);
+                    if (d !== -1) {
+                      u.tasks.splice(d, 1);
                       break;
                     }
                   }
             });
-          } catch (s) {
-            console.error("Realtime infinite tasks batch update failed", s);
+          } catch (m) {
+            console.error("Realtime infinite tasks batch update failed", m);
           } finally {
-            f.size && I();
+            h.size && v();
           }
         };
+        let l;
         try {
-          await e;
-          const a = async (s, y) => {
-            const u = y?.summary?.entityId;
-            u && (f.add(u), I());
+          await t, l = E(
+            (m) => {
+              a((g) => {
+                m.forEach((p) => {
+                  if (p.summary.entityType === "task" && p.summary.thumbnailHash)
+                    for (const i of g.pages) {
+                      const c = i.tasks.findIndex((u) => u.id === p.summary.entityId);
+                      if (c > -1) {
+                        i.tasks[c].thumbnailHash = p.summary.thumbnailHash;
+                        break;
+                      }
+                    }
+                });
+              });
+            },
+            ["task"]
+          );
+          const r = async (m, g) => {
+            const p = g?.summary?.entityId;
+            p && (h.add(p), v());
           };
-          k = E.subscribe("entity.task", a);
+          I = S.subscribe("entity.task", r);
         } catch {
         }
-        await r, k && E.unsubscribe(k);
+        await o, I && S.unsubscribe(I), l && l();
       }
     }),
-    getGroupedTasksList: l.query({
-      queryFn: async ({ projectName: t, groups: e, search: r, folderFilter: o, folderIds: c, desc: k, sortBy: f, groupCount: T }, g) => {
+    getGroupedTasksList: s.query({
+      queryFn: async ({ projectName: e, groups: t, search: o, folderFilter: a, folderIds: f, desc: I, sortBy: h, groupCount: b }, k) => {
         try {
-          let i = [];
-          const I = /* @__PURE__ */ new Set(["folderType"]);
-          for (const s of e) {
-            const y = T || s.count || 500;
-            let u = s.filter, d = o;
-            if (s.filter)
+          let n = [];
+          const v = /* @__PURE__ */ new Set(["folderType"]);
+          for (const r of t) {
+            const m = b || r.count || 500;
+            let g = r.filter, p = a;
+            if (r.filter)
               try {
-                const n = JSON.parse(s.filter), h = n.conditions || [], P = h.filter(
-                  (A) => !I.has(A.key)
-                ), R = h.filter(
-                  (A) => I.has(A.key)
-                );
-                if (R.length > 0) {
-                  u = P.length ? JSON.stringify({ ...n, conditions: P }) : void 0;
-                  const A = o ? JSON.parse(o) : null, N = [...A && Array.isArray(A.conditions) ? A.conditions : [], ...R];
-                  d = JSON.stringify(
-                    A ? { ...A, conditions: N } : { conditions: N }
+                const u = JSON.parse(r.filter), d = u.conditions || [], y = d.filter((T) => !v.has(T.key)), P = d.filter((T) => v.has(T.key));
+                if (P.length > 0) {
+                  g = y.length ? JSON.stringify({ ...u, conditions: y }) : void 0;
+                  const T = a ? JSON.parse(a) : null, w = [...T && Array.isArray(T.conditions) ? T.conditions : [], ...P];
+                  p = JSON.stringify(
+                    T ? { ...T, conditions: w } : { conditions: w }
                   );
                 }
               } catch {
               }
-            const p = {
-              projectName: t,
-              filter: u,
-              folderFilter: d,
-              search: r,
-              folderIds: c,
-              sortBy: f,
+            const i = {
+              projectName: e,
+              filter: g,
+              folderFilter: p,
+              search: o,
+              folderIds: f,
+              sortBy: h,
               // @ts-expect-error - we know group does not exist on query variables but we need it for later
-              group: s.value
+              group: r.value
             };
-            k ? p.last = y : p.first = y;
-            const m = g.dispatch(
-              w.endpoints.GetTasksList.initiate(p, { forceRefetch: !0 })
+            I ? i.last = m : i.first = m;
+            const c = k.dispatch(
+              R.endpoints.GetTasksList.initiate(i, { forceRefetch: !0 })
             );
-            i.push(m);
+            n.push(c);
           }
-          const v = await Promise.all(i), a = [];
-          for (const s of v) {
-            if (s.error) throw s.error;
-            const y = s.originalArgs?.group, u = s.data?.pageInfo?.hasNextPage || s.data?.pageInfo?.hasPreviousPage || !1, d = s.data?.tasks.map((p, m, n) => ({
-              ...p,
+          const A = await Promise.all(n), l = [];
+          for (const r of A) {
+            if (r.error) throw r.error;
+            const m = r.originalArgs?.group, g = r.data?.pageInfo?.hasNextPage || r.data?.pageInfo?.hasPreviousPage || !1, p = r.data?.tasks.map((i, c, u) => ({
+              ...i,
               groups: [
                 {
-                  value: y,
-                  hasNextPage: m === n.length - 1 && u ? y : void 0
+                  value: m,
+                  hasNextPage: c === u.length - 1 && g ? m : void 0
                   // Only add hasNextPage to the last task in the group
                 }
               ]
             })) || [];
-            a.push(...d);
+            l.push(...p);
           }
           return {
             data: {
-              tasks: a
+              tasks: l
             }
           };
-        } catch (i) {
-          return console.error("Error in getGroupedTasksList queryFn:", i), { error: { status: "FETCH_ERROR", error: i.message } };
+        } catch (n) {
+          return console.error("Error in getGroupedTasksList queryFn:", n), { error: { status: "FETCH_ERROR", error: n.message } };
         }
       },
-      providesTags: (t, e, { projectName: r }) => b(t?.tasks, r)
+      providesTags: (e, t, { projectName: o }) => F(e?.tasks, o)
     })
   })
 }), {
-  useGetOverviewTasksByFoldersQuery: Ee,
-  useGetSearchFoldersQuery: Fe,
-  useGetTasksListQuery: Ne,
-  useGetTasksListInfiniteInfiniteQuery: _e,
-  useLazyGetTasksByParentQuery: Ce,
-  useGetGroupedTasksListQuery: xe
-} = L;
+  useGetOverviewTasksByFoldersQuery: Ge,
+  useGetSearchFoldersQuery: Le,
+  useGetTasksListQuery: Oe,
+  useGetTasksListInfiniteInfiniteQuery: He,
+  useLazyGetTasksByParentQuery: qe,
+  useGetGroupedTasksListQuery: Qe,
+  useGetFolderColumnStatsQuery: Be,
+  useGetTaskColumnStatsQuery: je
+} = Q;
 export {
-  F as TASKS_INFINITE_QUERY_COUNT,
-  L as default,
-  S as parseAllAttribs,
-  xe as useGetGroupedTasksListQuery,
-  Ee as useGetOverviewTasksByFoldersQuery,
-  Fe as useGetSearchFoldersQuery,
-  _e as useGetTasksListInfiniteInfiniteQuery,
-  Ne as useGetTasksListQuery,
-  Ce as useLazyGetTasksByParentQuery
+  _ as TASKS_INFINITE_QUERY_COUNT,
+  Q as default,
+  H as parseAllAttribs,
+  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