@hortiview/modulebase 0.0.12333 → 0.0.12550

package/dist/components/ModuleBase.js

@@ -1,12 +1,511 @@
-import "react/jsx-runtime";
-import { M as d } from "../ModuleBase-brrfWM_W.js";
-import "../QueryClientProvider-QWqHaM3I.js";
-import "react";
-import "../chunk-IR6S3I6Y-BmDdD3SP.js";
-import "../constants.js";
-import "../provider/SignalR/SignalRProvider.js";
-import "../stores/BasePropsStore.js";
-import "../stores/EnvironmentStore.js";
+import { jsx as y } from "react/jsx-runtime";
+import { S as R, g as k, n as u, m as q, j as A, a as h, e as H, k as K, l as B, o as j, p as D, q as S, v as L, h as I, w as F, s as U, Q as V } from "../QueryClientProvider-Q_mWQTzQ.js";
+import { Q as W } from "../query-CRIVoEP7.js";
+import { M as X } from "../mutation-X73nm7Df.js";
+import { useState as $, useEffect as b } from "react";
+import { Y as z, h as Y, O as G, aU as J } from "../chunk-IR6S3I6Y-BmDdD3SP.js";
+import { REQUIRED_PROPS as Z } from "../constants.js";
+import { SignalRProvider as x } from "../provider/SignalR/SignalRProvider.js";
+import { useBasePropsStore as M } from "../stores/BasePropsStore.js";
+import { useEnvironmentStore as T } from "../stores/EnvironmentStore.js";
+var ee = class extends R {
+  constructor(e = {}) {
+    super(), this.config = e, this.#e = /* @__PURE__ */ new Map();
+  }
+  #e;
+  build(e, t, s) {
+    const r = t.queryKey, n = t.queryHash ?? k(r, t);
+    let i = this.get(n);
+    return i || (i = new W({
+      client: e,
+      queryKey: r,
+      queryHash: n,
+      options: e.defaultQueryOptions(t),
+      state: s,
+      defaultOptions: e.getQueryDefaults(r)
+    }), this.add(i)), i;
+  }
+  add(e) {
+    this.#e.has(e.queryHash) || (this.#e.set(e.queryHash, e), this.notify({
+      type: "added",
+      query: e
+    }));
+  }
+  remove(e) {
+    const t = this.#e.get(e.queryHash);
+    t && (e.destroy(), t === e && this.#e.delete(e.queryHash), this.notify({ type: "removed", query: e }));
+  }
+  clear() {
+    u.batch(() => {
+      this.getAll().forEach((e) => {
+        this.remove(e);
+      });
+    });
+  }
+  get(e) {
+    return this.#e.get(e);
+  }
+  getAll() {
+    return [...this.#e.values()];
+  }
+  find(e) {
+    const t = { exact: !0, ...e };
+    return this.getAll().find(
+      (s) => q(t, s)
+    );
+  }
+  findAll(e = {}) {
+    const t = this.getAll();
+    return Object.keys(e).length > 0 ? t.filter((s) => q(e, s)) : t;
+  }
+  notify(e) {
+    u.batch(() => {
+      this.listeners.forEach((t) => {
+        t(e);
+      });
+    });
+  }
+  onFocus() {
+    u.batch(() => {
+      this.getAll().forEach((e) => {
+        e.onFocus();
+      });
+    });
+  }
+  onOnline() {
+    u.batch(() => {
+      this.getAll().forEach((e) => {
+        e.onOnline();
+      });
+    });
+  }
+}, te = class extends R {
+  constructor(e = {}) {
+    super(), this.config = e, this.#e = /* @__PURE__ */ new Set(), this.#t = /* @__PURE__ */ new Map(), this.#s = 0;
+  }
+  #e;
+  #t;
+  #s;
+  build(e, t, s) {
+    const r = new X({
+      mutationCache: this,
+      mutationId: ++this.#s,
+      options: e.defaultMutationOptions(t),
+      state: s
+    });
+    return this.add(r), r;
+  }
+  add(e) {
+    this.#e.add(e);
+    const t = O(e);
+    if (typeof t == "string") {
+      const s = this.#t.get(t);
+      s ? s.push(e) : this.#t.set(t, [e]);
+    }
+    this.notify({ type: "added", mutation: e });
+  }
+  remove(e) {
+    if (this.#e.delete(e)) {
+      const t = O(e);
+      if (typeof t == "string") {
+        const s = this.#t.get(t);
+        if (s)
+          if (s.length > 1) {
+            const r = s.indexOf(e);
+            r !== -1 && s.splice(r, 1);
+          } else s[0] === e && this.#t.delete(t);
+      }
+    }
+    this.notify({ type: "removed", mutation: e });
+  }
+  canRun(e) {
+    const t = O(e);
+    if (typeof t == "string") {
+      const r = this.#t.get(t)?.find(
+        (n) => n.state.status === "pending"
+      );
+      return !r || r === e;
+    } else
+      return !0;
+  }
+  runNext(e) {
+    const t = O(e);
+    return typeof t == "string" ? this.#t.get(t)?.find((r) => r !== e && r.state.isPaused)?.continue() ?? Promise.resolve() : Promise.resolve();
+  }
+  clear() {
+    u.batch(() => {
+      this.#e.forEach((e) => {
+        this.notify({ type: "removed", mutation: e });
+      }), this.#e.clear(), this.#t.clear();
+    });
+  }
+  getAll() {
+    return Array.from(this.#e);
+  }
+  find(e) {
+    const t = { exact: !0, ...e };
+    return this.getAll().find(
+      (s) => A(t, s)
+    );
+  }
+  findAll(e = {}) {
+    return this.getAll().filter((t) => A(e, t));
+  }
+  notify(e) {
+    u.batch(() => {
+      this.listeners.forEach((t) => {
+        t(e);
+      });
+    });
+  }
+  resumePausedMutations() {
+    const e = this.getAll().filter((t) => t.state.isPaused);
+    return u.batch(
+      () => Promise.all(
+        e.map((t) => t.continue().catch(h))
+      )
+    );
+  }
+};
+function O(e) {
+  return e.options.scope?.id;
+}
+function C(e) {
+  return {
+    onFetch: (t, s) => {
+      const r = t.options, n = t.fetchOptions?.meta?.fetchMore?.direction, i = t.state.data?.pages || [], f = t.state.data?.pageParams || [];
+      let c = { pages: [], pageParams: [] }, d = 0;
+      const P = async () => {
+        let g = !1;
+        const Q = (o) => {
+          Object.defineProperty(o, "signal", {
+            enumerable: !0,
+            get: () => (t.signal.aborted ? g = !0 : t.signal.addEventListener("abort", () => {
+              g = !0;
+            }), t.signal)
+          });
+        }, a = H(t.options, t.fetchOptions), m = async (o, l, p) => {
+          if (g)
+            return Promise.reject();
+          if (l == null && o.pages.length)
+            return Promise.resolve(o);
+          const v = {
+            client: t.client,
+            queryKey: t.queryKey,
+            pageParam: l,
+            direction: p ? "backward" : "forward",
+            meta: t.options.meta
+          };
+          Q(v);
+          const _ = await a(
+            v
+          ), { maxPages: w } = t.options, E = p ? K : B;
+          return {
+            pages: E(o.pages, _, w),
+            pageParams: E(o.pageParams, l, w)
+          };
+        };
+        if (n && i.length) {
+          const o = n === "backward", l = o ? se : N, p = {
+            pages: i,
+            pageParams: f
+          }, v = l(r, p);
+          c = await m(p, v, o);
+        } else {
+          const o = e ?? i.length;
+          do {
+            const l = d === 0 ? f[0] ?? r.initialPageParam : N(r, c);
+            if (d > 0 && l == null)
+              break;
+            c = await m(c, l), d++;
+          } while (d < o);
+        }
+        return c;
+      };
+      t.options.persister ? t.fetchFn = () => t.options.persister?.(
+        P,
+        {
+          client: t.client,
+          queryKey: t.queryKey,
+          meta: t.options.meta,
+          signal: t.signal
+        },
+        s
+      ) : t.fetchFn = P;
+    }
+  };
+}
+function N(e, { pages: t, pageParams: s }) {
+  const r = t.length - 1;
+  return t.length > 0 ? e.getNextPageParam(
+    t[r],
+    t,
+    s[r],
+    s
+  ) : void 0;
+}
+function se(e, { pages: t, pageParams: s }) {
+  return t.length > 0 ? e.getPreviousPageParam?.(t[0], t, s[0], s) : void 0;
+}
+var re = class {
+  #e;
+  #t;
+  #s;
+  #n;
+  #i;
+  #r;
+  #a;
+  #u;
+  constructor(e = {}) {
+    this.#e = e.queryCache || new ee(), this.#t = e.mutationCache || new te(), this.#s = e.defaultOptions || {}, this.#n = /* @__PURE__ */ new Map(), this.#i = /* @__PURE__ */ new Map(), this.#r = 0;
+  }
+  mount() {
+    this.#r++, this.#r === 1 && (this.#a = j.subscribe(async (e) => {
+      e && (await this.resumePausedMutations(), this.#e.onFocus());
+    }), this.#u = D.subscribe(async (e) => {
+      e && (await this.resumePausedMutations(), this.#e.onOnline());
+    }));
+  }
+  unmount() {
+    this.#r--, this.#r === 0 && (this.#a?.(), this.#a = void 0, this.#u?.(), this.#u = void 0);
+  }
+  isFetching(e) {
+    return this.#e.findAll({ ...e, fetchStatus: "fetching" }).length;
+  }
+  isMutating(e) {
+    return this.#t.findAll({ ...e, status: "pending" }).length;
+  }
+  getQueryData(e) {
+    const t = this.defaultQueryOptions({ queryKey: e });
+    return this.#e.get(t.queryHash)?.state.data;
+  }
+  ensureQueryData(e) {
+    const t = this.defaultQueryOptions(e), s = this.#e.build(this, t), r = s.state.data;
+    return r === void 0 ? this.fetchQuery(e) : (e.revalidateIfStale && s.isStaleByTime(S(t.staleTime, s)) && this.prefetchQuery(t), Promise.resolve(r));
+  }
+  getQueriesData(e) {
+    return this.#e.findAll(e).map(({ queryKey: t, state: s }) => {
+      const r = s.data;
+      return [t, r];
+    });
+  }
+  setQueryData(e, t, s) {
+    const r = this.defaultQueryOptions({ queryKey: e }), i = this.#e.get(
+      r.queryHash
+    )?.state.data, f = L(t, i);
+    if (f !== void 0)
+      return this.#e.build(this, r).setData(f, { ...s, manual: !0 });
+  }
+  setQueriesData(e, t, s) {
+    return u.batch(
+      () => this.#e.findAll(e).map(({ queryKey: r }) => [
+        r,
+        this.setQueryData(r, t, s)
+      ])
+    );
+  }
+  getQueryState(e) {
+    const t = this.defaultQueryOptions({ queryKey: e });
+    return this.#e.get(
+      t.queryHash
+    )?.state;
+  }
+  removeQueries(e) {
+    const t = this.#e;
+    u.batch(() => {
+      t.findAll(e).forEach((s) => {
+        t.remove(s);
+      });
+    });
+  }
+  resetQueries(e, t) {
+    const s = this.#e;
+    return u.batch(() => (s.findAll(e).forEach((r) => {
+      r.reset();
+    }), this.refetchQueries(
+      {
+        type: "active",
+        ...e
+      },
+      t
+    )));
+  }
+  cancelQueries(e, t = {}) {
+    const s = { revert: !0, ...t }, r = u.batch(
+      () => this.#e.findAll(e).map((n) => n.cancel(s))
+    );
+    return Promise.all(r).then(h).catch(h);
+  }
+  invalidateQueries(e, t = {}) {
+    return u.batch(() => (this.#e.findAll(e).forEach((s) => {
+      s.invalidate();
+    }), e?.refetchType === "none" ? Promise.resolve() : this.refetchQueries(
+      {
+        ...e,
+        type: e?.refetchType ?? e?.type ?? "active"
+      },
+      t
+    )));
+  }
+  refetchQueries(e, t = {}) {
+    const s = {
+      ...t,
+      cancelRefetch: t.cancelRefetch ?? !0
+    }, r = u.batch(
+      () => this.#e.findAll(e).filter((n) => !n.isDisabled()).map((n) => {
+        let i = n.fetch(void 0, s);
+        return s.throwOnError || (i = i.catch(h)), n.state.fetchStatus === "paused" ? Promise.resolve() : i;
+      })
+    );
+    return Promise.all(r).then(h);
+  }
+  fetchQuery(e) {
+    const t = this.defaultQueryOptions(e);
+    t.retry === void 0 && (t.retry = !1);
+    const s = this.#e.build(this, t);
+    return s.isStaleByTime(
+      S(t.staleTime, s)
+    ) ? s.fetch(t) : Promise.resolve(s.state.data);
+  }
+  prefetchQuery(e) {
+    return this.fetchQuery(e).then(h).catch(h);
+  }
+  fetchInfiniteQuery(e) {
+    return e.behavior = C(e.pages), this.fetchQuery(e);
+  }
+  prefetchInfiniteQuery(e) {
+    return this.fetchInfiniteQuery(e).then(h).catch(h);
+  }
+  ensureInfiniteQueryData(e) {
+    return e.behavior = C(e.pages), this.ensureQueryData(e);
+  }
+  resumePausedMutations() {
+    return D.isOnline() ? this.#t.resumePausedMutations() : Promise.resolve();
+  }
+  getQueryCache() {
+    return this.#e;
+  }
+  getMutationCache() {
+    return this.#t;
+  }
+  getDefaultOptions() {
+    return this.#s;
+  }
+  setDefaultOptions(e) {
+    this.#s = e;
+  }
+  setQueryDefaults(e, t) {
+    this.#n.set(I(e), {
+      queryKey: e,
+      defaultOptions: t
+    });
+  }
+  getQueryDefaults(e) {
+    const t = [...this.#n.values()], s = {};
+    return t.forEach((r) => {
+      F(e, r.queryKey) && Object.assign(s, r.defaultOptions);
+    }), s;
+  }
+  setMutationDefaults(e, t) {
+    this.#i.set(I(e), {
+      mutationKey: e,
+      defaultOptions: t
+    });
+  }
+  getMutationDefaults(e) {
+    const t = [...this.#i.values()], s = {};
+    return t.forEach((r) => {
+      F(e, r.mutationKey) && Object.assign(s, r.defaultOptions);
+    }), s;
+  }
+  defaultQueryOptions(e) {
+    if (e._defaulted)
+      return e;
+    const t = {
+      ...this.#s.queries,
+      ...this.getQueryDefaults(e.queryKey),
+      ...e,
+      _defaulted: !0
+    };
+    return t.queryHash || (t.queryHash = k(
+      t.queryKey,
+      t
+    )), t.refetchOnReconnect === void 0 && (t.refetchOnReconnect = t.networkMode !== "always"), t.throwOnError === void 0 && (t.throwOnError = !!t.suspense), !t.networkMode && t.persister && (t.networkMode = "offlineFirst"), t.queryFn === U && (t.enabled = !1), t;
+  }
+  defaultMutationOptions(e) {
+    return e?._defaulted ? e : {
+      ...this.#s.mutations,
+      ...e?.mutationKey && this.getMutationDefaults(e.mutationKey),
+      ...e,
+      _defaulted: !0
+    };
+  }
+  clear() {
+    this.#e.clear(), this.#t.clear();
+  }
+};
+const ne = new re({
+  defaultOptions: {
+    mutations: {
+      retry: !1
+    },
+    queries: {
+      refetchOnWindowFocus: !1,
+      gcTime: 1e3 * 60 * 60 * 24,
+      // 24 hours
+      staleTime: 60 * 1e3,
+      // 60 seconds
+      retry: !1
+    }
+  }
+}), ie = () => {
+  const e = M((s) => s.currentNavigationPath), t = J();
+  b(() => {
+    e && t(e, { replace: !0 });
+  }, [e, t]);
+}, ae = () => (ie(), /* @__PURE__ */ y(G, {})), Oe = ({
+  props: e,
+  routes: t,
+  env: s = void 0,
+  useSignalR: r = !1,
+  queryClient: n = ne
+}) => {
+  const i = M((a) => a.setBaseProps), f = M((a) => a.modulePermissionToken), c = T((a) => a.setEnvironment), d = T((a) => a.addEnvironment), [P, g] = $(!1);
+  b(() => {
+    const a = he();
+    if (g(!a), a && c(a), !s) return;
+    const m = s[a?.ENVIRONMENT];
+    m && d(m);
+  }, [d, s, c]), b(() => {
+    g(!ue(e)), i(e);
+  }, [
+    e.currentLanguage,
+    e.currentLanguageId,
+    e.modulePermissionToken,
+    e.organizationId,
+    e.currentNavigationPath,
+    e.sourcePath
+  ]);
+  const Q = z([
+    {
+      path: e.basePath,
+      children: t,
+      element: /* @__PURE__ */ y(ae, {})
+    }
+  ]);
+  return P ? /* @__PURE__ */ y("div", { children: "TODO: Show fancy error" }) : f ? /* @__PURE__ */ y(V, { client: n, children: /* @__PURE__ */ y(x, { enabled: r, children: /* @__PURE__ */ y(Y, { router: Q }) }) }) : /* @__PURE__ */ y("div", { children: "TODO: Show fancy Loadingspinner" });
+}, ue = (e) => Z.every((t) => oe(t, e)), oe = (e, t) => {
+  if (!t[e]) {
+    if (t.throwError)
+      return t.throwError(`Missing required prop: ${e}`, 404), !1;
+    throw new Error(`Missing required prop: ${e}`);
+  }
+  return !0;
+}, he = () => {
+  const e = window.__env__;
+  if (e && (e.API_PREFIX = "/api/v8.0", !!e.COMMON_API && e.MODULE_AUTH_API && e.API_PREFIX && e.ENVIRONMENT))
+    return e;
+};
 export {
-  d as ModuleBase
+  Oe as ModuleBase
 };

package/dist/hooks/useCustom.js

@@ -1,4 +1,4 @@
-import { u as i } from "../useQuery-DtzakC1A.js";
+import { u as i } from "../useQuery-CwwWze9O.js";
 import { useBasePropsStore as n } from "../stores/BasePropsStore.js";
 import { universalSelector as p } from "../types/Requests.js";
 import { fetchFromCustomApi as a } from "../utils/fetches.js";

package/dist/hooks/useCustomMutation.js

@@ -1,112 +1,21 @@
-import * as o from "react";
-import { g as m } from "../ModuleBase-brrfWM_W.js";
-import { S as p, s as l, h as a, n as h, u as d } from "../QueryClientProvider-QWqHaM3I.js";
-import { n as b, s as f } from "../useQuery-DtzakC1A.js";
+import { u } from "../useMutation-3rykrmeD.js";
+import "../components/ModuleBase.js";
+import "react";
 import "../stores/BasePropsStore.js";
 import "../provider/SignalR/SignalRProvider.js";
 import "../omit-B7MWDtHq.js";
 import "../stores/EnvironmentStore.js";
-import { mutateOnCustomApi as O } from "../utils/fetches.js";
+import { mutateOnCustomApi as n } from "../utils/fetches.js";
 import "./useEntity.js";
 import "../api-D9Lmqe6S.js";
-var v = class extends p {
-  #e;
-  #i = void 0;
-  #t;
-  #s;
-  constructor(t, s) {
-    super(), this.#e = t, this.setOptions(s), this.bindMethods(), this.#r();
-  }
-  bindMethods() {
-    this.mutate = this.mutate.bind(this), this.reset = this.reset.bind(this);
-  }
-  setOptions(t) {
-    const s = this.options;
-    this.options = this.#e.defaultMutationOptions(t), l(this.options, s) || this.#e.getMutationCache().notify({
-      type: "observerOptionsUpdated",
-      mutation: this.#t,
-      observer: this
-    }), s?.mutationKey && this.options.mutationKey && a(s.mutationKey) !== a(this.options.mutationKey) ? this.reset() : this.#t?.state.status === "pending" && this.#t.setOptions(this.options);
-  }
-  onUnsubscribe() {
-    this.hasListeners() || this.#t?.removeObserver(this);
-  }
-  onMutationUpdate(t) {
-    this.#r(), this.#o(t);
-  }
-  getCurrentResult() {
-    return this.#i;
-  }
-  reset() {
-    this.#t?.removeObserver(this), this.#t = void 0, this.#r(), this.#o();
-  }
-  mutate(t, s) {
-    return this.#s = s, this.#t?.removeObserver(this), this.#t = this.#e.getMutationCache().build(this.#e, this.options), this.#t.addObserver(this), this.#t.execute(t);
-  }
-  #r() {
-    const t = this.#t?.state ?? m();
-    this.#i = {
-      ...t,
-      isPending: t.status === "pending",
-      isSuccess: t.status === "success",
-      isError: t.status === "error",
-      isIdle: t.status === "idle",
-      mutate: this.mutate,
-      reset: this.reset
-    };
-  }
-  #o(t) {
-    h.batch(() => {
-      if (this.#s && this.hasListeners()) {
-        const s = this.#i.variables, i = this.#i.context;
-        t?.type === "success" ? (this.#s.onSuccess?.(t.data, s, i), this.#s.onSettled?.(t.data, null, s, i)) : t?.type === "error" && (this.#s.onError?.(t.error, s, i), this.#s.onSettled?.(
-          void 0,
-          t.error,
-          s,
-          i
-        ));
-      }
-      this.listeners.forEach((s) => {
-        s(this.#i);
-      });
-    });
-  }
-};
-function y(t, s) {
-  const i = d(), [e] = o.useState(
-    () => new v(
-      i,
-      t
-    )
-  );
-  o.useEffect(() => {
-    e.setOptions(t);
-  }, [e, t]);
-  const r = o.useSyncExternalStore(
-    o.useCallback(
-      (u) => e.subscribe(h.batchCalls(u)),
-      [e]
-    ),
-    () => e.getCurrentResult(),
-    () => e.getCurrentResult()
-  ), n = o.useCallback(
-    (u, c) => {
-      e.mutate(u, c).catch(b);
-    },
-    [e]
-  );
-  if (r.error && f(e.options.throwOnError, [r.error]))
-    throw r.error;
-  return { ...r, mutate: n, mutateAsync: r.mutate };
-}
-const k = ({
+const O = ({
   endpoint: t,
-  method: s,
-  token: i,
-  headers: e
-}) => y({
-  mutationFn: (r, n) => O(n ?? t, r, s, i, e)
+  method: o,
+  token: m,
+  headers: r
+}) => u({
+  mutationFn: (i, p) => n(p ?? t, i, o, m, r)
 });
 export {
-  k as useCustomMutation
+  O as useCustomMutation
 };

package/dist/hooks/useEntity.d.ts

@@ -1,17 +1,11 @@
-import { Block, BlockPlantLayout, Farm, FarmOrgEntity, Field, ModuleEntity, Season } from '../types/ModuleApi';
+import { Block, BlockPlantLayout, Farm, FarmAlertRule, FarmOrganization, FarmOrgEntity, Field, IrrigationStation, ModuleEntity, Season } from '../types/ModuleApi';
 type HortiviewDataAreaGroup = 'FarmOrganization' | 'FarmMember';
 type ModuleDataAreaGroup = 'ModuleDepended';
 type FarmOrganizationEntities = 'farms' | 'fields' | 'zones' | 'irrigation_stations' | 'farm_organizations' | 'alert_rules';
 type FarmMemberEntities = 'farm_members';
 type ModuleDependendEntities = 'Season' | 'BlockPlantLayout' | (string & {});
 type HortiviewDataAreaEntity<T extends HortiviewDataAreaGroup | ModuleDataAreaGroup> = T extends 'FarmOrganization' ? FarmOrganizationEntities : T extends 'FarmMember' ? FarmMemberEntities : T extends 'ModuleDepended' ? ModuleDependendEntities : never;
-type ResultMap<T extends FarmMemberEntities | FarmOrganizationEntities | ModuleDependendEntities> = T extends 'zones' ? Block : T extends 'fields' ? Field : T extends 'farms' ? Farm : T extends 'irrigation_stations' ? {
-    id: string;
-} : T extends 'farm_organizations' ? {
-    id: string;
-} : T extends 'alert_rules' ? {
-    id: string;
-} : T extends 'Season' ? Season : T extends 'BlockPlantLayout' ? BlockPlantLayout : never;
+type ResultMap<T extends FarmMemberEntities | FarmOrganizationEntities | ModuleDependendEntities> = T extends 'zones' ? Block : T extends 'fields' ? Field : T extends 'farms' ? Farm : T extends 'irrigation_stations' ? IrrigationStation : T extends 'farm_organizations' ? FarmOrganization : T extends 'alert_rules' ? FarmAlertRule : T extends 'Season' ? Season : T extends 'BlockPlantLayout' ? BlockPlantLayout : unknown;
 export declare const FarmOrgEntitiesTypeResultMap: Record<FarmOrganizationEntities, string>;
 export declare const FarmMemberEntitiesTypeResultMap: Record<FarmMemberEntities, string>;
 export declare const ModuleDependedEntityTypeResultMap: Record<ModuleDependendEntities, string>;

package/dist/hooks/useEntity.js

@@ -1,4 +1,4 @@
-import { u as l } from "../useQuery-DtzakC1A.js";
+import { u as l } from "../useQuery-CwwWze9O.js";
 import { useMemo as g } from "react";
 import { useBasePropsStore as p } from "../stores/BasePropsStore.js";
 import { universalSelector as y } from "../types/Requests.js";

package/dist/hooks/useOption.js

@@ -1,4 +1,4 @@
-import { u as m } from "../useQuery-DtzakC1A.js";
+import { u as m } from "../useQuery-CwwWze9O.js";
 import { g as u } from "../api-D9Lmqe6S.js";
 import { useBasePropsStore as n } from "../stores/BasePropsStore.js";
 import { universalSelector as s } from "../types/Requests.js";

package/dist/hooks/useServiceBus.d.ts

@@ -0,0 +1,15 @@
+import { UseMutationResult } from '@tanstack/react-query';
+import { AlertServiceBusMessage } from '../types/ServiceBus';
+import { BaseResponse } from '../types/Requests';
+/**
+ *
+ * @param authenticationKey SASToken, that will be provided by the vendor portal of HortiView
+ * @param queue url of the service bus queue
+ * @param topic topic of the service bus, where the message will be sent to
+ * @returns
+ */
+export declare const useServiceBus: ({ authenticationKey, queue, topic, }: {
+    authenticationKey: string;
+    queue: string;
+    topic: string;
+}) => UseMutationResult<BaseResponse<unknown>, Error, AlertServiceBusMessage, unknown>;