@calimero-network/mero-react 1.0.2 → 2.0.1

package/dist/index.cjs

@@ -3,6 +3,7 @@
 var react = require('react');
 var meroJs = require('@calimero-network/mero-js');
 var jsxRuntime = require('react/jsx-runtime');
+var reactDom = require('react-dom');
 
 // src/context/MeroContext.tsx
 
@@ -369,6 +370,544 @@ function useMero() {
   }
   return context;
 }
+function isValidUrl(urlString) {
+  if (!urlString || urlString.trim() === "") {
+    return false;
+  }
+  try {
+    const urlToTest = urlString.startsWith("http://") || urlString.startsWith("https://") ? urlString : `https://${urlString}`;
+    const url = new URL(urlToTest);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      return false;
+    }
+    if (!url.hostname) {
+      return false;
+    }
+    const hostname = url.hostname;
+    if (hostname === "localhost") {
+      return true;
+    }
+    const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
+    if (ipv4Regex.test(hostname)) {
+      const octets = hostname.split(".").map(Number);
+      return octets.every((octet) => octet >= 0 && octet <= 255);
+    }
+    const domainRegex = /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+    return domainRegex.test(hostname);
+  } catch {
+    return false;
+  }
+}
+var styles = {
+  overlay: {
+    position: "fixed",
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    backgroundColor: "rgba(0, 0, 0, 0.75)",
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    zIndex: 1e4,
+    padding: "1rem"
+  },
+  content: {
+    backgroundColor: "#1f2937",
+    borderRadius: "12px",
+    padding: "2rem",
+    maxWidth: "400px",
+    width: "100%",
+    position: "relative",
+    border: "1px solid #374151",
+    boxShadow: "0 25px 50px -12px rgba(0, 0, 0, 0.5)"
+  },
+  closeButton: {
+    position: "absolute",
+    top: "1rem",
+    right: "1rem",
+    background: "none",
+    border: "none",
+    fontSize: "1.5rem",
+    color: "#9ca3af",
+    cursor: "pointer",
+    padding: "0.25rem",
+    lineHeight: 1
+  },
+  header: {
+    display: "flex",
+    flexDirection: "column",
+    alignItems: "center",
+    gap: "0.75rem",
+    marginBottom: "1.5rem"
+  },
+  title: {
+    fontSize: "1.25rem",
+    fontWeight: 600,
+    color: "#f3f4f6",
+    margin: 0
+  },
+  info: {
+    color: "#9ca3af",
+    textAlign: "center",
+    marginBottom: "1.5rem",
+    fontSize: "0.875rem"
+  },
+  error: {
+    color: "#ef4444",
+    backgroundColor: "rgba(239, 68, 68, 0.1)",
+    border: "1px solid rgba(239, 68, 68, 0.3)",
+    borderRadius: "6px",
+    padding: "0.75rem",
+    marginBottom: "1rem",
+    fontSize: "0.875rem",
+    textAlign: "center"
+  },
+  radioGroup: {
+    display: "flex",
+    gap: "1rem",
+    marginBottom: "1rem",
+    justifyContent: "center"
+  },
+  radioLabel: {
+    display: "flex",
+    alignItems: "center",
+    gap: "0.5rem",
+    color: "#e5e7eb",
+    cursor: "pointer",
+    padding: "0.5rem 1rem",
+    borderRadius: "6px",
+    border: "1px solid #374151",
+    backgroundColor: "#111827",
+    transition: "all 0.2s"
+  },
+  radioLabelActive: {
+    borderColor: "#3b82f6",
+    backgroundColor: "rgba(59, 130, 246, 0.1)"
+  },
+  input: {
+    width: "100%",
+    padding: "0.75rem 1rem",
+    borderRadius: "6px",
+    border: "1px solid #374151",
+    backgroundColor: "#111827",
+    color: "#f3f4f6",
+    fontSize: "0.875rem",
+    outline: "none",
+    marginBottom: "1rem",
+    boxSizing: "border-box"
+  },
+  localInfo: {
+    color: "#9ca3af",
+    fontSize: "0.875rem",
+    textAlign: "center",
+    padding: "0.75rem",
+    backgroundColor: "#111827",
+    borderRadius: "6px",
+    marginBottom: "1rem"
+  },
+  buttonGroup: {
+    display: "flex",
+    justifyContent: "center"
+  },
+  button: {
+    padding: "0.75rem 2rem",
+    borderRadius: "6px",
+    border: "none",
+    fontSize: "0.875rem",
+    fontWeight: 600,
+    cursor: "pointer",
+    backgroundColor: "#3b82f6",
+    color: "white",
+    transition: "all 0.2s"
+  },
+  buttonDisabled: {
+    opacity: 0.5,
+    cursor: "not-allowed"
+  },
+  loading: {
+    display: "flex",
+    flexDirection: "column",
+    alignItems: "center",
+    gap: "1rem",
+    padding: "2rem",
+    color: "#9ca3af"
+  },
+  spinner: {
+    width: "2rem",
+    height: "2rem",
+    border: "3px solid #374151",
+    borderTopColor: "#3b82f6",
+    borderRadius: "50%",
+    animation: "spin 1s linear infinite"
+  }
+};
+function LoginModal({
+  onConnect,
+  onClose,
+  connectionType,
+  isOpen
+}) {
+  const [nodeType, setNodeType] = react.useState("local");
+  const [nodeUrl, setNodeUrl2] = react.useState("");
+  const [isValid, setIsValid] = react.useState(true);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const shouldShowLocal = connectionType === "remote-and-local" /* RemoteAndLocal */ || connectionType === "local" /* Local */;
+  const shouldShowRemote = connectionType === "remote-and-local" /* RemoteAndLocal */ || connectionType === "remote" /* Remote */;
+  const shouldShowRadioGroup = shouldShowLocal && shouldShowRemote;
+  react.useEffect(() => {
+    const savedUrl = localStorage.getItem("mero:node_url");
+    if (savedUrl) {
+      setNodeUrl2(savedUrl);
+    }
+  }, []);
+  react.useEffect(() => {
+    if (connectionType === "local" /* Local */) {
+      setNodeType("local");
+    } else if (connectionType === "remote" /* Remote */) {
+      setNodeType("remote");
+    }
+  }, [connectionType]);
+  react.useEffect(() => {
+    if (nodeType === "remote") {
+      setIsValid(isValidUrl(nodeUrl));
+    } else {
+      setIsValid(true);
+    }
+  }, [nodeUrl, nodeType]);
+  const handleConnect = react.useCallback(async () => {
+    if (!isValid) return;
+    setLoading(true);
+    setError(null);
+    const baseUrl = nodeType === "local" ? "http://node1.127.0.0.1.nip.io" : nodeUrl;
+    try {
+      const response = await fetch(
+        new URL("admin-api/is-authed", baseUrl).toString()
+      );
+      if (response.ok || response.status === 401) {
+        setLoading(false);
+        const normalizedUrl = baseUrl.replace(/\/+$/, "");
+        onConnect(normalizedUrl);
+      } else {
+        throw new Error(`Connection failed: ${response.statusText}`);
+      }
+    } catch (err) {
+      console.error("Connection failed:", err);
+      setError("Failed to connect. Please check the URL and try again.");
+      setLoading(false);
+    }
+  }, [isValid, nodeType, nodeUrl, onConnect]);
+  if (!isOpen) {
+    return null;
+  }
+  const modalContent = /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("style", { children: `
+        @keyframes spin {
+          to { transform: rotate(360deg); }
+        }
+      ` }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { style: styles.overlay, onClick: onClose, children: /* @__PURE__ */ jsxRuntime.jsxs("div", { style: styles.content, onClick: (e) => e.stopPropagation(), children: [
+      /* @__PURE__ */ jsxRuntime.jsx("button", { style: styles.closeButton, onClick: onClose, children: "\xD7" }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { style: styles.header, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(MeroLogo, {}),
+        /* @__PURE__ */ jsxRuntime.jsx("h1", { style: styles.title, children: "Connect to Calimero" })
+      ] }),
+      loading ? /* @__PURE__ */ jsxRuntime.jsxs("div", { style: styles.loading, children: [
+        /* @__PURE__ */ jsxRuntime.jsx("p", { children: "Connecting to node..." }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { style: styles.spinner })
+      ] }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx("p", { style: styles.info, children: shouldShowRadioGroup ? "Select your Calimero node type to continue." : connectionType === "local" /* Local */ ? "Connect to your local Calimero node." : "Enter your remote Calimero node URL." }),
+        error && /* @__PURE__ */ jsxRuntime.jsx("p", { style: styles.error, children: error }),
+        shouldShowRadioGroup && /* @__PURE__ */ jsxRuntime.jsxs("div", { style: styles.radioGroup, children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "label",
+            {
+              style: {
+                ...styles.radioLabel,
+                ...nodeType === "local" ? styles.radioLabelActive : {}
+              },
+              onClick: () => setNodeType("local"),
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  "input",
+                  {
+                    type: "radio",
+                    value: "local",
+                    checked: nodeType === "local",
+                    onChange: () => setNodeType("local"),
+                    style: { display: "none" }
+                  }
+                ),
+                "\u{1F3E0} Local"
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs(
+            "label",
+            {
+              style: {
+                ...styles.radioLabel,
+                ...nodeType === "remote" ? styles.radioLabelActive : {}
+              },
+              onClick: () => setNodeType("remote"),
+              children: [
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  "input",
+                  {
+                    type: "radio",
+                    value: "remote",
+                    checked: nodeType === "remote",
+                    onChange: () => setNodeType("remote"),
+                    style: { display: "none" }
+                  }
+                ),
+                "\u{1F310} Remote"
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { children: shouldShowRemote && nodeType === "remote" ? /* @__PURE__ */ jsxRuntime.jsx(
+          "input",
+          {
+            type: "text",
+            value: nodeUrl,
+            onChange: (e) => setNodeUrl2(e.target.value),
+            placeholder: "https://your-node-url.calimero.network",
+            style: styles.input,
+            onKeyDown: (e) => {
+              if (e.key === "Enter" && isValid) {
+                handleConnect();
+              }
+            }
+          }
+        ) : shouldShowLocal ? /* @__PURE__ */ jsxRuntime.jsxs("p", { style: styles.localInfo, children: [
+          "Using default local node: ",
+          /* @__PURE__ */ jsxRuntime.jsx("br", {}),
+          /* @__PURE__ */ jsxRuntime.jsx("code", { style: { color: "#60a5fa" }, children: "http://node1.127.0.0.1.nip.io" })
+        ] }) : null }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { style: styles.buttonGroup, children: /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            onClick: handleConnect,
+            disabled: !isValid || loading,
+            style: {
+              ...styles.button,
+              ...!isValid || loading ? styles.buttonDisabled : {}
+            },
+            children: "Connect"
+          }
+        ) })
+      ] })
+    ] }) })
+  ] });
+  return reactDom.createPortal(modalContent, document.body);
+}
+function MeroLogo() {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      width: "40",
+      height: "40",
+      viewBox: "0 0 24 24",
+      fill: "#3b82f6",
+      xmlns: "http://www.w3.org/2000/svg",
+      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm-1-13h2v6h-2zm0 8h2v2h-2z" })
+    }
+  );
+}
+function ConnectButton({
+  connectionType = "remote-and-local" /* RemoteAndLocal */,
+  className,
+  style
+}) {
+  const { isAuthenticated, connectToNode, logout, nodeUrl, isOnline } = useMero();
+  const [isDropdownOpen, setIsDropdownOpen] = react.useState(false);
+  const [isModalOpen, setIsModalOpen] = react.useState(false);
+  const dropdownRef = react.useRef(null);
+  react.useEffect(() => {
+    const handleClickOutside = (event) => {
+      if (dropdownRef.current && !dropdownRef.current.contains(event.target)) {
+        setIsDropdownOpen(false);
+      }
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => document.removeEventListener("mousedown", handleClickOutside);
+  }, []);
+  const dashboardUrl = react.useMemo(() => {
+    if (!isAuthenticated || !nodeUrl) return "#";
+    return new URL("admin-dashboard/", nodeUrl).toString();
+  }, [isAuthenticated, nodeUrl]);
+  const handleConnect = () => {
+    if (typeof connectionType === "object" && connectionType.type === "custom" /* Custom */) {
+      connectToNode(connectionType.url);
+      return;
+    }
+    setIsModalOpen(true);
+  };
+  const handleModalConnect = (url) => {
+    setIsModalOpen(false);
+    connectToNode(url);
+  };
+  if (isAuthenticated && !isOnline) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        className: `mero-connect-button mero-reconnecting ${className || ""}`,
+        style,
+        disabled: true,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(MeroLogo2, {}),
+          "Reconnecting..."
+        ]
+      }
+    );
+  }
+  if (isAuthenticated) {
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { ref: dropdownRef, className: "mero-connect-container", style: { position: "relative", display: "inline-block" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          className: `mero-connect-button mero-connected ${className || ""}`,
+          style,
+          onClick: () => setIsDropdownOpen((prev) => !prev),
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(MeroLogo2, {}),
+            "Connected"
+          ]
+        }
+      ),
+      isDropdownOpen && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mero-dropdown", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "mero-dropdown-info", title: nodeUrl || "", children: nodeUrl }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "a",
+          {
+            href: dashboardUrl,
+            target: "_blank",
+            rel: "noopener noreferrer",
+            className: "mero-dropdown-item",
+            children: "Dashboard"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            className: "mero-dropdown-item",
+            onClick: () => {
+              setIsDropdownOpen(false);
+              logout();
+            },
+            children: "Log out"
+          }
+        )
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        className: `mero-connect-button ${className || ""}`,
+        style,
+        onClick: handleConnect,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(MeroLogo2, {}),
+          "Connect"
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      LoginModal,
+      {
+        isOpen: isModalOpen,
+        onConnect: handleModalConnect,
+        onClose: () => setIsModalOpen(false),
+        connectionType: typeof connectionType === "object" ? "remote-and-local" /* RemoteAndLocal */ : connectionType
+      }
+    )
+  ] });
+}
+function MeroLogo2() {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      className: "mero-logo",
+      width: "24",
+      height: "24",
+      viewBox: "0 0 24 24",
+      fill: "currentColor",
+      xmlns: "http://www.w3.org/2000/svg",
+      children: /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm-1-13h2v6h-2zm0 8h2v2h-2z" })
+    }
+  );
+}
+function toError(err) {
+  return err instanceof Error ? err : new Error(String(err));
+}
+function mapApplicationContexts(contexts) {
+  return contexts.map((context) => ({
+    contextId: context.id,
+    applicationId: context.applicationId
+  }));
+}
+function useMountedRef() {
+  const mountedRef = react.useRef(true);
+  react.useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  return mountedRef;
+}
+function useAsyncMutation() {
+  const mountedRef = useMountedRef();
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const run = react.useCallback(
+    async (action) => {
+      if (mountedRef.current) {
+        setLoading(true);
+        setError(null);
+      }
+      try {
+        return await action();
+      } catch (err) {
+        const errorValue = toError(err);
+        if (mountedRef.current) {
+          setError(errorValue);
+        }
+        return null;
+      } finally {
+        if (mountedRef.current) {
+          setLoading(false);
+        }
+      }
+    },
+    [mountedRef]
+  );
+  return { loading, error, run, setError };
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function extractAliasContextId(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  if ("value" in value && typeof value.value === "string") {
+    return value.value;
+  }
+  if ("contextId" in value && typeof value.contextId === "string") {
+    return value.contextId;
+  }
+  return null;
+}
 function useExecute(contextId, executorId) {
   const { mero } = useMero();
   const [loading, setLoading] = react.useState(false);
@@ -436,13 +975,7 @@ function useContexts(applicationId) {
   const [contexts, setContexts] = react.useState([]);
   const [loading, setLoading] = react.useState(false);
   const [error, setError] = react.useState(null);
-  const mountedRef = react.useRef(true);
-  react.useEffect(() => {
-    mountedRef.current = true;
-    return () => {
-      mountedRef.current = false;
-    };
-  }, []);
+  const mountedRef = useMountedRef();
   const refetch = react.useCallback(async () => {
     if (!mero) return;
     if (mountedRef.current) {
@@ -450,17 +983,20 @@ function useContexts(applicationId) {
       setError(null);
     }
     try {
-      const response = await mero.admin.getContexts();
-      let list = (response.contexts ?? []).map((c) => ({ contextId: c.id, applicationId: c.applicationId }));
-      if (applicationId) {
-        list = list.filter((c) => c.applicationId === applicationId);
+      const response = applicationId ? await mero.admin.getContextsForApplication(applicationId) : await mero.admin.getContexts();
+      const list = mapApplicationContexts(response.contexts ?? []);
+      if (mountedRef.current) {
+        setContexts(list);
       }
-      if (mountedRef.current) setContexts(list);
     } catch (err) {
-      const e = err instanceof Error ? err : new Error(String(err));
-      if (mountedRef.current) setError(e);
+      const errorValue = toError(err);
+      if (mountedRef.current) {
+        setError(errorValue);
+      }
     } finally {
-      if (mountedRef.current) setLoading(false);
+      if (mountedRef.current) {
+        setLoading(false);
+      }
     }
   }, [mero, applicationId]);
   react.useEffect(() => {
@@ -468,9 +1004,944 @@ function useContexts(applicationId) {
   }, [refetch]);
   return { contexts, loading, error, refetch };
 }
+function useApplicationContexts(applicationId) {
+  return useContexts(applicationId);
+}
+function useGroupMembers(groupId) {
+  const { mero } = useMero();
+  const [members, setMembers] = react.useState([]);
+  const [selfIdentity, setSelfIdentity] = react.useState(null);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const mountedRef = useMountedRef();
+  const refetch = react.useCallback(async () => {
+    if (!mero || !groupId) {
+      if (mountedRef.current) {
+        setMembers([]);
+        setSelfIdentity(null);
+        setError(null);
+        setLoading(false);
+      }
+      return;
+    }
+    if (mountedRef.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const response = await mero.admin.listGroupMembers(groupId);
+      if (mountedRef.current) {
+        setMembers(response.data ?? []);
+        setSelfIdentity(response.selfIdentity ?? null);
+      }
+    } catch (err) {
+      const errorValue = toError(err);
+      if (mountedRef.current) {
+        setError(errorValue);
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [groupId, mero, mountedRef]);
+  react.useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  return { members, selfIdentity, loading, error, refetch };
+}
+function useGroupContexts(groupId) {
+  const { mero } = useMero();
+  const [contexts, setContexts] = react.useState([]);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const mountedRef = useMountedRef();
+  const refetch = react.useCallback(async () => {
+    if (!mero || !groupId) {
+      if (mountedRef.current) {
+        setContexts([]);
+        setError(null);
+        setLoading(false);
+      }
+      return;
+    }
+    if (mountedRef.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const nextContexts = await mero.admin.listGroupContexts(groupId);
+      if (mountedRef.current) {
+        setContexts(nextContexts);
+      }
+    } catch (err) {
+      const errorValue = toError(err);
+      if (mountedRef.current) {
+        setError(errorValue);
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [groupId, mero, mountedRef]);
+  react.useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  return { contexts, loading, error, refetch };
+}
+function useGroupInvitations() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const createInvitation = react.useCallback(
+    async (groupId, request) => {
+      if (!mero) {
+        return null;
+      }
+      return run(() => mero.admin.createGroupInvitation(groupId, request));
+    },
+    [mero, run]
+  );
+  return { createInvitation, loading, error };
+}
+function useJoinGroup() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const joinGroup = react.useCallback(
+    async (request) => {
+      if (!mero) {
+        return null;
+      }
+      return run(() => mero.admin.joinGroup(request));
+    },
+    [mero, run]
+  );
+  return { joinGroup, loading, error };
+}
+function useGroupCapabilities(groupId, memberId) {
+  const { mero } = useMero();
+  const [capabilities, setCapabilitiesState] = react.useState(null);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const mountedRef = useMountedRef();
+  const refetch = react.useCallback(async () => {
+    if (!mero || !groupId || !memberId) {
+      if (mountedRef.current) {
+        setCapabilitiesState(null);
+        setError(null);
+        setLoading(false);
+      }
+      return null;
+    }
+    if (mountedRef.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const response = await mero.admin.getMemberCapabilities(groupId, memberId);
+      if (mountedRef.current) {
+        setCapabilitiesState(response.capabilities);
+      }
+      return response.capabilities;
+    } catch (err) {
+      const errorValue = toError(err);
+      if (mountedRef.current) {
+        setError(errorValue);
+      }
+      return null;
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [groupId, memberId, mero, mountedRef]);
+  react.useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  const setCapabilities = react.useCallback(
+    async (nextCapabilities) => {
+      if (!mero || !groupId || !memberId) {
+        return null;
+      }
+      if (mountedRef.current) {
+        setLoading(true);
+        setError(null);
+      }
+      try {
+        await mero.admin.setMemberCapabilities(groupId, memberId, { capabilities: nextCapabilities });
+        if (mountedRef.current) {
+          setCapabilitiesState(nextCapabilities);
+        }
+        return nextCapabilities;
+      } catch (err) {
+        const errorValue = toError(err);
+        if (mountedRef.current) {
+          setError(errorValue);
+        }
+        return null;
+      } finally {
+        if (mountedRef.current) {
+          setLoading(false);
+        }
+      }
+    },
+    [groupId, memberId, mero, mountedRef]
+  );
+  return { capabilities, loading, error, refetch, setCapabilities };
+}
+function useContextDiscovery(options) {
+  const { mero } = useMero();
+  const [context, setContext] = react.useState(null);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const mountedRef = useMountedRef();
+  const knownContextIdsKey = JSON.stringify(options.knownContextIds ?? []);
+  const discover = react.useCallback(async () => {
+    if (!mero) {
+      const notConnectedError = new Error("Not connected");
+      if (mountedRef.current) {
+        setError(notConnectedError);
+      }
+      return null;
+    }
+    const knownContextIds = new Set(options.knownContextIds ?? []);
+    const pollIntervalMs = options.pollIntervalMs ?? 1e3;
+    const timeoutMs = options.timeoutMs ?? 3e4;
+    const deadline = Date.now() + timeoutMs;
+    if (mountedRef.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      while (Date.now() <= deadline) {
+        if (options.targetAlias) {
+          const aliasMatch = extractAliasContextId(
+            await mero.admin.lookupContextAlias(options.targetAlias)
+          );
+          if (aliasMatch && !knownContextIds.has(aliasMatch)) {
+            const discoveredFromAlias = {
+              contextId: aliasMatch,
+              applicationId: options.applicationId
+            };
+            if (mountedRef.current) {
+              setContext(discoveredFromAlias);
+            }
+            return discoveredFromAlias;
+          }
+        }
+        const response = await mero.admin.getContextsForApplication(options.applicationId);
+        const contexts = mapApplicationContexts(response.contexts ?? []);
+        const discovered = contexts.find(
+          (applicationContext) => !knownContextIds.has(applicationContext.contextId)
+        );
+        if (discovered) {
+          if (mountedRef.current) {
+            setContext(discovered);
+          }
+          return discovered;
+        }
+        if (Date.now() + pollIntervalMs > deadline) {
+          break;
+        }
+        await sleep(pollIntervalMs);
+      }
+      const timeoutError = new Error(
+        `Timed out discovering a context for application ${options.applicationId}`
+      );
+      if (mountedRef.current) {
+        setContext(null);
+        setError(timeoutError);
+      }
+      return null;
+    } catch (err) {
+      const errorValue = toError(err);
+      if (mountedRef.current) {
+        setContext(null);
+        setError(errorValue);
+      }
+      return null;
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [
+    knownContextIdsKey,
+    mero,
+    mountedRef,
+    options.applicationId,
+    options.knownContextIds,
+    options.pollIntervalMs,
+    options.targetAlias,
+    options.timeoutMs
+  ]);
+  const reset = react.useCallback(() => {
+    if (mountedRef.current) {
+      setContext(null);
+      setError(null);
+      setLoading(false);
+    }
+  }, [mountedRef]);
+  return { context, loading, error, discover, reset };
+}
+function useCreateContext() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const createContext2 = react.useCallback(
+    async (request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.createContext(request));
+    },
+    [mero, run]
+  );
+  return { createContext: createContext2, loading, error };
+}
+function useDeleteContext() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const deleteContext = react.useCallback(
+    async (contextId) => {
+      if (!mero) return null;
+      return run(() => mero.admin.deleteContext(contextId));
+    },
+    [mero, run]
+  );
+  return { deleteContext, loading, error };
+}
+function useJoinContext() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const joinContext = react.useCallback(
+    async (contextId) => {
+      if (!mero) return null;
+      return run(() => mero.admin.joinContext(contextId));
+    },
+    [mero, run]
+  );
+  return { joinContext, loading, error };
+}
+function useContextGroup(contextId) {
+  const { mero } = useMero();
+  const [groupId, setGroupId] = react.useState(null);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const mountedRef = useMountedRef();
+  const refetch = react.useCallback(async () => {
+    if (!mero || !contextId) {
+      if (mountedRef.current) {
+        setGroupId(null);
+        setError(null);
+        setLoading(false);
+      }
+      return;
+    }
+    if (mountedRef.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const result = await mero.admin.getContextGroup(contextId);
+      if (mountedRef.current) {
+        setGroupId(result);
+      }
+    } catch (err) {
+      const errorValue = toError(err);
+      if (mountedRef.current) {
+        setError(errorValue);
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [contextId, mero, mountedRef]);
+  react.useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  return { groupId, loading, error, refetch };
+}
+function useGroupInfo(groupId) {
+  const { mero } = useMero();
+  const [groupInfo, setGroupInfo] = react.useState(null);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const mountedRef = useMountedRef();
+  const refetch = react.useCallback(async () => {
+    if (!mero || !groupId) {
+      if (mountedRef.current) {
+        setGroupInfo(null);
+        setError(null);
+        setLoading(false);
+      }
+      return;
+    }
+    if (mountedRef.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const result = await mero.admin.getGroupInfo(groupId);
+      if (mountedRef.current) {
+        setGroupInfo(result);
+      }
+    } catch (err) {
+      const errorValue = toError(err);
+      if (mountedRef.current) {
+        setError(errorValue);
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [groupId, mero, mountedRef]);
+  react.useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  return { groupInfo, loading, error, refetch };
+}
+function useDeleteGroup() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const deleteGroup = react.useCallback(
+    async (groupId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.deleteGroup(groupId, request));
+    },
+    [mero, run]
+  );
+  return { deleteGroup, loading, error };
+}
+function useSyncGroup() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const syncGroup = react.useCallback(
+    async (groupId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.syncGroup(groupId, request));
+    },
+    [mero, run]
+  );
+  return { syncGroup, loading, error };
+}
+function useAddGroupMembers() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const addGroupMembers = react.useCallback(
+    async (groupId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.addGroupMembers(groupId, request));
+    },
+    [mero, run]
+  );
+  return { addGroupMembers, loading, error };
+}
+function useRemoveGroupMembers() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const removeGroupMembers = react.useCallback(
+    async (groupId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.removeGroupMembers(groupId, request));
+    },
+    [mero, run]
+  );
+  return { removeGroupMembers, loading, error };
+}
+function useNamespaces() {
+  const { mero } = useMero();
+  const [namespaces, setNamespaces] = react.useState([]);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const mountedRef = useMountedRef();
+  const refetch = react.useCallback(async () => {
+    if (!mero) return;
+    if (mountedRef.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const result = await mero.admin.listNamespaces();
+      if (mountedRef.current) {
+        setNamespaces(result);
+      }
+    } catch (err) {
+      const errorValue = toError(err);
+      if (mountedRef.current) {
+        setError(errorValue);
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [mero, mountedRef]);
+  react.useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  return { namespaces, loading, error, refetch };
+}
+function useNamespace(namespaceId) {
+  const { mero } = useMero();
+  const [namespace, setNamespace] = react.useState(null);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const mountedRef = useMountedRef();
+  const refetch = react.useCallback(async () => {
+    if (!mero || !namespaceId) {
+      if (mountedRef.current) {
+        setNamespace(null);
+        setError(null);
+        setLoading(false);
+      }
+      return;
+    }
+    if (mountedRef.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const result = await mero.admin.getNamespace(namespaceId);
+      if (mountedRef.current) {
+        setNamespace(result);
+      }
+    } catch (err) {
+      const errorValue = toError(err);
+      if (mountedRef.current) {
+        setError(errorValue);
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [namespaceId, mero, mountedRef]);
+  react.useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  return { namespace, loading, error, refetch };
+}
+function useNamespaceIdentity(namespaceId) {
+  const { mero } = useMero();
+  const [identity, setIdentity] = react.useState(null);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const mountedRef = useMountedRef();
+  const refetch = react.useCallback(async () => {
+    if (!mero || !namespaceId) {
+      if (mountedRef.current) {
+        setIdentity(null);
+        setError(null);
+        setLoading(false);
+      }
+      return;
+    }
+    if (mountedRef.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const result = await mero.admin.getNamespaceIdentity(namespaceId);
+      if (mountedRef.current) {
+        setIdentity(result);
+      }
+    } catch (err) {
+      const errorValue = toError(err);
+      if (mountedRef.current) {
+        setError(errorValue);
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [namespaceId, mero, mountedRef]);
+  react.useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  return { identity, loading, error, refetch };
+}
+function useNamespacesForApplication(applicationId) {
+  const { mero } = useMero();
+  const [namespaces, setNamespaces] = react.useState([]);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const mountedRef = useMountedRef();
+  const refetch = react.useCallback(async () => {
+    if (!mero || !applicationId) {
+      if (mountedRef.current) {
+        setNamespaces([]);
+        setError(null);
+        setLoading(false);
+      }
+      return;
+    }
+    if (mountedRef.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const result = await mero.admin.listNamespacesForApplication(applicationId);
+      if (mountedRef.current) {
+        setNamespaces(result);
+      }
+    } catch (err) {
+      const errorValue = toError(err);
+      if (mountedRef.current) {
+        setError(errorValue);
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [applicationId, mero, mountedRef]);
+  react.useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  return { namespaces, loading, error, refetch };
+}
+function useCreateNamespace() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const createNamespace = react.useCallback(
+    async (request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.createNamespace(request));
+    },
+    [mero, run]
+  );
+  return { createNamespace, loading, error };
+}
+function useDeleteNamespace() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const deleteNamespace = react.useCallback(
+    async (namespaceId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.deleteNamespace(namespaceId, request));
+    },
+    [mero, run]
+  );
+  return { deleteNamespace, loading, error };
+}
+function useCreateNamespaceInvitation() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const createNamespaceInvitation = react.useCallback(
+    async (namespaceId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.createNamespaceInvitation(namespaceId, request));
+    },
+    [mero, run]
+  );
+  return { createNamespaceInvitation, loading, error };
+}
+function useJoinNamespace() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const joinNamespace = react.useCallback(
+    async (namespaceId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.joinNamespace(namespaceId, request));
+    },
+    [mero, run]
+  );
+  return { joinNamespace, loading, error };
+}
+function useCreateGroupInNamespace() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const createGroupInNamespace = react.useCallback(
+    async (namespaceId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.createGroupInNamespace(namespaceId, request));
+    },
+    [mero, run]
+  );
+  return { createGroupInNamespace, loading, error };
+}
+function useNamespaceGroups(namespaceId) {
+  const { mero } = useMero();
+  const [groups, setGroups] = react.useState([]);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const mountedRef = useMountedRef();
+  const refetch = react.useCallback(async () => {
+    if (!mero || !namespaceId) {
+      if (mountedRef.current) {
+        setGroups([]);
+        setError(null);
+        setLoading(false);
+      }
+      return;
+    }
+    if (mountedRef.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const result = await mero.admin.listNamespaceGroups(namespaceId);
+      if (mountedRef.current) {
+        setGroups(result);
+      }
+    } catch (err) {
+      const errorValue = toError(err);
+      if (mountedRef.current) {
+        setError(errorValue);
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [namespaceId, mero, mountedRef]);
+  react.useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  return { groups, loading, error, refetch };
+}
+function useUpdateMemberRole() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const updateMemberRole = react.useCallback(
+    async (groupId, identity, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.updateMemberRole(groupId, identity, request));
+    },
+    [mero, run]
+  );
+  return { updateMemberRole, loading, error };
+}
+function useSetDefaultCapabilities() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const setDefaultCapabilities = react.useCallback(
+    async (groupId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.setDefaultCapabilities(groupId, request));
+    },
+    [mero, run]
+  );
+  return { setDefaultCapabilities, loading, error };
+}
+function useSetSubgroupVisibility() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const setSubgroupVisibility = react.useCallback(
+    async (groupId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.setSubgroupVisibility(groupId, request));
+    },
+    [mero, run]
+  );
+  return { setSubgroupVisibility, loading, error };
+}
+function useSetTeeAdmissionPolicy() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const setTeeAdmissionPolicy = react.useCallback(
+    async (groupId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.setTeeAdmissionPolicy(groupId, request));
+    },
+    [mero, run]
+  );
+  return { setTeeAdmissionPolicy, loading, error };
+}
+function useUpdateGroupSettings() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const updateGroupSettings = react.useCallback(
+    async (groupId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.updateGroupSettings(groupId, request));
+    },
+    [mero, run]
+  );
+  return { updateGroupSettings, loading, error };
+}
+function useSetGroupAlias() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const setGroupAlias = react.useCallback(
+    async (groupId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.setGroupAlias(groupId, request));
+    },
+    [mero, run]
+  );
+  return { setGroupAlias, loading, error };
+}
+function useSetMemberAlias() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const setMemberAlias = react.useCallback(
+    async (groupId, identity, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.setMemberAlias(groupId, identity, request));
+    },
+    [mero, run]
+  );
+  return { setMemberAlias, loading, error };
+}
+function useRegisterGroupSigningKey() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const registerGroupSigningKey = react.useCallback(
+    async (groupId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.registerGroupSigningKey(groupId, request));
+    },
+    [mero, run]
+  );
+  return { registerGroupSigningKey, loading, error };
+}
+function useUpgradeGroup() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const upgradeGroup = react.useCallback(
+    async (groupId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.upgradeGroup(groupId, request));
+    },
+    [mero, run]
+  );
+  return { upgradeGroup, loading, error };
+}
+function useGroupUpgradeStatus(groupId) {
+  const { mero } = useMero();
+  const [upgradeStatus, setUpgradeStatus] = react.useState(null);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const mountedRef = useMountedRef();
+  const refetch = react.useCallback(async () => {
+    if (!mero || !groupId) {
+      if (mountedRef.current) {
+        setUpgradeStatus(null);
+        setError(null);
+        setLoading(false);
+      }
+      return;
+    }
+    if (mountedRef.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const result = await mero.admin.getGroupUpgradeStatus(groupId);
+      if (mountedRef.current) {
+        setUpgradeStatus(result);
+      }
+    } catch (err) {
+      const errorValue = toError(err);
+      if (mountedRef.current) {
+        setError(errorValue);
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [groupId, mero, mountedRef]);
+  react.useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  return { upgradeStatus, loading, error, refetch };
+}
+function useRetryGroupUpgrade() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const retryGroupUpgrade = react.useCallback(
+    async (groupId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.retryGroupUpgrade(groupId, request));
+    },
+    [mero, run]
+  );
+  return { retryGroupUpgrade, loading, error };
+}
+function useNestGroup() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const nestGroup = react.useCallback(
+    async (parentGroupId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.nestGroup(parentGroupId, request));
+    },
+    [mero, run]
+  );
+  return { nestGroup, loading, error };
+}
+function useUnnestGroup() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const unnestGroup = react.useCallback(
+    async (parentGroupId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.unnestGroup(parentGroupId, request));
+    },
+    [mero, run]
+  );
+  return { unnestGroup, loading, error };
+}
+function useSubgroups(groupId) {
+  const { mero } = useMero();
+  const [subgroups, setSubgroups] = react.useState([]);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const mountedRef = useMountedRef();
+  const refetch = react.useCallback(async () => {
+    if (!mero || !groupId) {
+      if (mountedRef.current) {
+        setSubgroups([]);
+        setError(null);
+        setLoading(false);
+      }
+      return;
+    }
+    if (mountedRef.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const result = await mero.admin.listSubgroups(groupId);
+      if (mountedRef.current) {
+        setSubgroups(result);
+      }
+    } catch (err) {
+      const errorValue = toError(err);
+      if (mountedRef.current) {
+        setError(errorValue);
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [groupId, mero, mountedRef]);
+  react.useEffect(() => {
+    void refetch();
+  }, [refetch]);
+  return { subgroups, loading, error, refetch };
+}
+function useDetachContextFromGroup() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const detachContextFromGroup = react.useCallback(
+    async (groupId, contextId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.detachContextFromGroup(groupId, contextId, request));
+    },
+    [mero, run]
+  );
+  return { detachContextFromGroup, loading, error };
+}
 
 exports.AppMode = AppMode;
+exports.ConnectButton = ConnectButton;
 exports.ConnectionType = ConnectionType;
+exports.LoginModal = LoginModal;
 exports.MeroContext = MeroContext;
 exports.MeroProvider = MeroProvider;
 exports.clearAllStorage = clearAllStorage;
@@ -487,10 +1958,51 @@ exports.setApplicationId = setApplicationId;
 exports.setContextId = setContextId;
 exports.setContextIdentity = setContextIdentity;
 exports.setNodeUrl = setNodeUrl;
+exports.useAddGroupMembers = useAddGroupMembers;
+exports.useApplicationContexts = useApplicationContexts;
+exports.useContextDiscovery = useContextDiscovery;
+exports.useContextGroup = useContextGroup;
 exports.useContexts = useContexts;
+exports.useCreateContext = useCreateContext;
+exports.useCreateGroupInNamespace = useCreateGroupInNamespace;
+exports.useCreateNamespace = useCreateNamespace;
+exports.useCreateNamespaceInvitation = useCreateNamespaceInvitation;
+exports.useDeleteContext = useDeleteContext;
+exports.useDeleteGroup = useDeleteGroup;
+exports.useDeleteNamespace = useDeleteNamespace;
+exports.useDetachContextFromGroup = useDetachContextFromGroup;
 exports.useExecute = useExecute;
+exports.useGroupCapabilities = useGroupCapabilities;
+exports.useGroupContexts = useGroupContexts;
+exports.useGroupInfo = useGroupInfo;
+exports.useGroupInvitations = useGroupInvitations;
+exports.useGroupMembers = useGroupMembers;
+exports.useGroupUpgradeStatus = useGroupUpgradeStatus;
+exports.useJoinContext = useJoinContext;
+exports.useJoinGroup = useJoinGroup;
+exports.useJoinNamespace = useJoinNamespace;
 exports.useMero = useMero;
+exports.useNamespace = useNamespace;
+exports.useNamespaceGroups = useNamespaceGroups;
+exports.useNamespaceIdentity = useNamespaceIdentity;
+exports.useNamespaces = useNamespaces;
+exports.useNamespacesForApplication = useNamespacesForApplication;
+exports.useNestGroup = useNestGroup;
+exports.useRegisterGroupSigningKey = useRegisterGroupSigningKey;
+exports.useRemoveGroupMembers = useRemoveGroupMembers;
+exports.useRetryGroupUpgrade = useRetryGroupUpgrade;
+exports.useSetDefaultCapabilities = useSetDefaultCapabilities;
+exports.useSetGroupAlias = useSetGroupAlias;
+exports.useSetMemberAlias = useSetMemberAlias;
+exports.useSetSubgroupVisibility = useSetSubgroupVisibility;
+exports.useSetTeeAdmissionPolicy = useSetTeeAdmissionPolicy;
+exports.useSubgroups = useSubgroups;
 exports.useSubscription = useSubscription;
+exports.useSyncGroup = useSyncGroup;
+exports.useUnnestGroup = useUnnestGroup;
+exports.useUpdateGroupSettings = useUpdateGroupSettings;
+exports.useUpdateMemberRole = useUpdateMemberRole;
+exports.useUpgradeGroup = useUpgradeGroup;
 Object.keys(meroJs).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,