@calimero-network/mero-react 1.0.0-beta.1 → 1.1.0

package/dist/index.cjs

@@ -7,6 +7,21 @@ var reactDom = require('react-dom');
 
 // src/context/MeroContext.tsx
 
+// src/types.ts
+var AppMode = /* @__PURE__ */ ((AppMode2) => {
+  AppMode2["SingleContext"] = "single-context";
+  AppMode2["MultiContext"] = "multi-context";
+  AppMode2["Admin"] = "admin";
+  return AppMode2;
+})(AppMode || {});
+var ConnectionType = /* @__PURE__ */ ((ConnectionType2) => {
+  ConnectionType2["RemoteAndLocal"] = "remote-and-local";
+  ConnectionType2["Remote"] = "remote";
+  ConnectionType2["Local"] = "local";
+  ConnectionType2["Custom"] = "custom";
+  return ConnectionType2;
+})(ConnectionType || {});
+
 // src/storage/index.ts
 var STORAGE_KEYS = {
   ACCESS_TOKEN: "mero:access_token",
@@ -14,20 +29,25 @@ var STORAGE_KEYS = {
   EXPIRES_AT: "mero:expires_at",
   NODE_URL: "mero:node_url",
   APPLICATION_ID: "mero:application_id",
-  CONTEXT_ID: "mero:context_id"
+  CONTEXT_ID: "mero:context_id",
+  CONTEXT_IDENTITY: "mero:context_identity"
 };
+var _storageAvailable = null;
 function isLocalStorageAvailable() {
+  if (_storageAvailable !== null) return _storageAvailable;
   try {
     if (typeof window === "undefined" || !window.localStorage) {
+      _storageAvailable = false;
       return false;
     }
     const testKey = "__mero_test__";
     localStorage.setItem(testKey, "test");
     localStorage.removeItem(testKey);
-    return true;
+    _storageAvailable = true;
   } catch {
-    return false;
+    _storageAvailable = false;
   }
+  return _storageAvailable;
 }
 var localStorageTokenStorage = {
   async get() {
@@ -108,46 +128,37 @@ function setContextId(id) {
   if (!isLocalStorageAvailable()) return;
   localStorage.setItem(STORAGE_KEYS.CONTEXT_ID, id);
 }
+function clearContextId() {
+  if (!isLocalStorageAvailable()) return;
+  localStorage.removeItem(STORAGE_KEYS.CONTEXT_ID);
+}
+function getContextIdentity() {
+  if (!isLocalStorageAvailable()) return null;
+  return localStorage.getItem(STORAGE_KEYS.CONTEXT_IDENTITY);
+}
+function setContextIdentity(id) {
+  if (!isLocalStorageAvailable()) return;
+  localStorage.setItem(STORAGE_KEYS.CONTEXT_IDENTITY, id);
+}
+function clearContextIdentity() {
+  if (!isLocalStorageAvailable()) return;
+  localStorage.removeItem(STORAGE_KEYS.CONTEXT_IDENTITY);
+}
 function clearAllStorage() {
   if (!isLocalStorageAvailable()) return;
   Object.values(STORAGE_KEYS).forEach((key) => {
     localStorage.removeItem(key);
   });
 }
-
-// src/types.ts
-var AppMode = /* @__PURE__ */ ((AppMode2) => {
-  AppMode2["SingleContext"] = "single-context";
-  AppMode2["MultiContext"] = "multi-context";
-  AppMode2["Admin"] = "admin";
-  return AppMode2;
-})(AppMode || {});
-var ConnectionType = /* @__PURE__ */ ((ConnectionType2) => {
-  ConnectionType2["RemoteAndLocal"] = "remote-and-local";
-  ConnectionType2["Remote"] = "remote";
-  ConnectionType2["Local"] = "local";
-  ConnectionType2["Custom"] = "custom";
-  return ConnectionType2;
-})(ConnectionType || {});
-var EventStreamMode = /* @__PURE__ */ ((EventStreamMode2) => {
-  EventStreamMode2["WebSocket"] = "websocket";
-  EventStreamMode2["SSE"] = "sse";
-  return EventStreamMode2;
-})(EventStreamMode || {});
-var defaultContextValue = {
-  mero: null,
-  isAuthenticated: false,
-  isOnline: true,
-  nodeUrl: null,
-  applicationId: null,
-  contextId: null,
-  connectToNode: () => {
-  },
-  logout: () => {
-  },
-  isLoading: true
-};
-var MeroContext = react.createContext(defaultContextValue);
+var MeroContext = react.createContext(null);
+var isBrowser = typeof window !== "undefined";
+var _tokenStore = null;
+function getTokenStore() {
+  if (!_tokenStore) {
+    _tokenStore = new meroJs.LocalStorageTokenStore();
+  }
+  return _tokenStore;
+}
 function getPermissionsForMode(mode) {
   switch (mode) {
     case "single-context" /* SingleContext */:
@@ -160,27 +171,20 @@ function getPermissionsForMode(mode) {
       throw new Error(`Unsupported application mode: ${mode}`);
   }
 }
-function redirectToAuthLogin(params) {
-  const authParams = new URLSearchParams();
-  authParams.append("callback-url", params.callbackUrl);
-  authParams.append("permissions", params.permissions.join(","));
-  authParams.append("mode", params.mode);
-  if (params.packageName) {
-    authParams.append("package-name", params.packageName);
-    if (params.packageVersion) {
-      authParams.append("package-version", params.packageVersion);
-    }
-    if (params.registryUrl) {
-      authParams.append("registry-url", params.registryUrl);
-    }
-  } else if (params.applicationId) {
-    authParams.append("application-id", params.applicationId);
-  }
-  if (params.applicationPath) {
-    authParams.append("application-path", params.applicationPath);
+function parseJwtExpiry(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length === 3) {
+      let b64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+      while (b64.length % 4) b64 += "=";
+      const payload = JSON.parse(atob(b64));
+      if (payload.exp && payload.exp > 0) {
+        return payload.exp * 1e3;
+      }
+    }
+  } catch {
   }
-  authParams.append("app-url", params.nodeUrl);
-  window.location.href = `${params.nodeUrl}/auth/login?${authParams.toString()}`;
+  return Date.now() + 36e5;
 }
 function MeroProvider({
   children,
@@ -188,8 +192,6 @@ function MeroProvider({
   packageName,
   packageVersion,
   registryUrl,
-  applicationId: propApplicationId,
-  applicationPath,
   timeoutMs = 3e4
 }) {
   const [mero, setMero] = react.useState(null);
@@ -198,15 +200,23 @@ function MeroProvider({
   const [isLoading, setIsLoading] = react.useState(true);
   const [nodeUrl, setNodeUrlState] = react.useState(() => getNodeUrl());
   const [applicationId, setApplicationIdState] = react.useState(
-    () => getApplicationId() || propApplicationId || null
+    () => getApplicationId() || null
   );
   const [contextId, setContextIdState] = react.useState(() => getContextId());
+  const [contextIdentity, setContextIdentityState] = react.useState(() => getContextIdentity());
   const meroRef = react.useRef(null);
+  const callbackRef = react.useRef(void 0);
+  if (callbackRef.current === void 0 && isBrowser) {
+    callbackRef.current = meroJs.parseAuthCallback(window.location.href);
+  }
   const createMeroInstance = react.useCallback(
     (url) => {
+      if (meroRef.current) {
+        meroRef.current.close();
+      }
       const instance = new meroJs.MeroJs({
         baseUrl: url,
-        tokenStorage: localStorageTokenStorage,
+        tokenStore: getTokenStore(),
         timeoutMs
       });
       meroRef.current = instance;
@@ -216,127 +226,35 @@ function MeroProvider({
   );
   const checkAuth = react.useCallback(async (instance) => {
     try {
-      await instance.admin.contexts.listContexts();
+      await instance.admin.getContexts();
       return true;
     } catch {
       return false;
     }
   }, []);
-  const processAuthCallback = react.useCallback(() => {
-    const url = new URL(window.location.href);
-    const rawHash = url.hash;
-    const hash = rawHash.slice(1);
-    console.log("========== AUTH CALLBACK DEBUG ==========");
-    console.log("Raw URL:", window.location.href);
-    console.log("Raw hash:", rawHash);
-    console.log("Hash (without #):", hash);
-    if (!hash) {
-      console.log("No hash found, skipping auth callback");
-      console.log("==========================================");
-      return false;
-    }
-    const params = new URLSearchParams(hash);
-    console.log("All hash params:");
-    for (const [key, value] of params.entries()) {
-      console.log(`  ${key}: ${value.substring(0, 50)}${value.length > 50 ? "..." : ""}`);
-    }
-    console.log("==========================================");
-    const accessToken = params.get("access_token");
-    const refreshToken = params.get("refresh_token");
-    const appId = params.get("application_id") || params.get("applicationId") || params.get("app_id");
-    const ctxId = params.get("context_id") || params.get("contextId") || params.get("context");
-    const expiresIn = params.get("expires_in");
-    const nodeUrlParam = params.get("node_url") || params.get("nodeUrl") || params.get("node");
-    if (!accessToken || !refreshToken) return false;
-    if (nodeUrlParam) {
-      const decodedNodeUrl = decodeURIComponent(nodeUrlParam);
-      setNodeUrl(decodedNodeUrl);
-      setNodeUrlState(decodedNodeUrl);
-      console.log("[mero-react] SSO: Node URL from hash params:", decodedNodeUrl);
-    }
-    try {
-      const decodedAccess = decodeURIComponent(accessToken);
-      const decodedRefresh = decodeURIComponent(refreshToken);
-      let expiresAt = Date.now() + 36e5;
-      if (expiresIn) {
-        expiresAt = Date.now() + parseInt(expiresIn, 10) * 1e3;
-      } else {
-        try {
-          const parts = decodedAccess.split(".");
-          if (parts.length === 3) {
-            const payload = JSON.parse(atob(parts[1]));
-            if (payload.exp) {
-              expiresAt = payload.exp * 1e3;
-            }
-          }
-        } catch {
-        }
-      }
-      localStorageTokenStorage.set({
-        access_token: decodedAccess,
-        refresh_token: decodedRefresh,
-        expires_at: expiresAt
-      });
-      if (appId) {
-        setApplicationId(appId);
-        setApplicationIdState(appId);
-      }
-      if (ctxId) {
-        setContextId(ctxId);
-        setContextIdState(ctxId);
-      }
-      params.delete("access_token");
-      params.delete("refresh_token");
-      params.delete("application_id");
-      params.delete("applicationId");
-      params.delete("app_id");
-      params.delete("context_id");
-      params.delete("contextId");
-      params.delete("context");
-      params.delete("expires_in");
-      params.delete("node_url");
-      params.delete("nodeUrl");
-      params.delete("node");
-      const newHash = params.toString();
-      url.hash = newHash ? `#${newHash}` : "";
-      window.history.replaceState({}, document.title, url.toString());
-      console.log("[mero-react] Stored contextId:", ctxId, "applicationId:", appId);
-      return true;
-    } catch (e) {
-      console.error("[mero-react] Failed to process auth callback:", e);
-      return false;
-    }
-  }, []);
   const connectToNode = react.useCallback(
     (url) => {
+      if (!isBrowser) return;
       setNodeUrl(url);
       setNodeUrlState(url);
       const callbackUrl = new URL(window.location.href);
-      if (callbackUrl.hash) {
-        const hashParams = new URLSearchParams(callbackUrl.hash.substring(1));
-        hashParams.delete("access_token");
-        hashParams.delete("refresh_token");
-        hashParams.delete("application_id");
-        callbackUrl.hash = hashParams.toString() ? `#${hashParams.toString()}` : "";
-      }
-      const permissions = getPermissionsForMode(mode);
-      redirectToAuthLogin({
-        nodeUrl: url,
+      callbackUrl.hash = "";
+      const loginUrl = meroJs.buildAuthLoginUrl(url, {
         callbackUrl: callbackUrl.toString(),
-        permissions,
+        permissions: getPermissionsForMode(mode),
         mode,
         packageName,
         packageVersion,
-        registryUrl,
-        applicationId: propApplicationId,
-        applicationPath
+        registryUrl
       });
+      window.location.href = loginUrl;
     },
-    [mode, packageName, packageVersion, registryUrl, propApplicationId, applicationPath]
+    [mode, packageName, packageVersion, registryUrl]
   );
-  const logout = react.useCallback(async () => {
+  const logout = react.useCallback(() => {
     if (meroRef.current) {
-      await meroRef.current.clearToken();
+      meroRef.current.clearToken();
+      meroRef.current.close();
     }
     clearAllStorage();
     setMero(null);
@@ -344,56 +262,90 @@ function MeroProvider({
     setNodeUrlState(null);
     setApplicationIdState(null);
     setContextIdState(null);
+    setContextIdentityState(null);
     meroRef.current = null;
   }, []);
   react.useEffect(() => {
+    let active = true;
     const init = async () => {
-      console.log("[mero-react] Init starting...");
-      console.log("[mero-react] Current URL:", window.location.href);
-      console.log("[mero-react] Stored nodeUrl:", getNodeUrl());
-      console.log("[mero-react] Stored contextId:", getContextId());
-      console.log("[mero-react] Stored applicationId:", getApplicationId());
-      const hasCallback = processAuthCallback();
-      console.log("[mero-react] hasCallback:", hasCallback);
-      const savedUrl = getNodeUrl();
+      const callback = callbackRef.current;
+      if (callback) {
+        getTokenStore().setTokens({
+          access_token: callback.accessToken,
+          refresh_token: callback.refreshToken,
+          expires_at: parseJwtExpiry(callback.accessToken)
+        });
+        if (callback.applicationId) {
+          setApplicationId(callback.applicationId);
+          if (active) setApplicationIdState(callback.applicationId);
+        }
+        if (callback.contextId) {
+          setContextId(callback.contextId);
+          if (active) setContextIdState(callback.contextId);
+        }
+        if (callback.contextIdentity) {
+          setContextIdentity(callback.contextIdentity);
+          if (active) setContextIdentityState(callback.contextIdentity);
+        }
+        if (callback.nodeUrl) {
+          setNodeUrl(callback.nodeUrl);
+          if (active) setNodeUrlState(callback.nodeUrl);
+        }
+        if (isBrowser) {
+          window.history.replaceState({}, "", window.location.pathname + window.location.search);
+        }
+        callbackRef.current = null;
+      }
+      const savedUrl = callback?.nodeUrl || getNodeUrl();
       if (!savedUrl) {
-        setIsLoading(false);
+        if (active) setIsLoading(false);
         return;
       }
       const instance = createMeroInstance(savedUrl);
-      await instance.init();
       const authed = await checkAuth(instance);
+      if (!active) return;
       if (authed) {
         setMero(instance);
         setIsAuthenticated(true);
         setIsOnline(true);
-      } else if (hasCallback) {
+      } else if (callback) {
         setMero(instance);
-        setIsAuthenticated(false);
       }
       setIsLoading(false);
     };
-    init();
-  }, [createMeroInstance, checkAuth, processAuthCallback]);
+    init().catch((err) => {
+      console.error("[MeroProvider] Initialization failed:", err);
+      if (active) setIsLoading(false);
+    });
+    return () => {
+      active = false;
+    };
+  }, [createMeroInstance, checkAuth]);
   react.useEffect(() => {
     if (!isAuthenticated || !meroRef.current) return;
-    const interval = setInterval(async () => {
-      const instance = meroRef.current;
-      if (!instance) return;
-      const healthy = await checkAuth(instance);
-      if (!healthy && isOnline) {
-        setIsOnline(false);
-      } else if (healthy && !isOnline) {
-        setIsOnline(true);
+    let active = true;
+    const sse = meroRef.current.events;
+    const onConnect = () => {
+      if (active) setIsOnline(true);
+    };
+    const onError = (err) => {
+      if (!active) return;
+      setIsOnline(false);
+      if (err.message.includes("401")) {
+        logout();
       }
-    }, 5e3);
-    return () => clearInterval(interval);
-  }, [isAuthenticated, isOnline, checkAuth]);
-  react.useEffect(() => {
-    if (propApplicationId && !applicationId) {
-      setApplicationIdState(propApplicationId);
-    }
-  }, [propApplicationId, applicationId]);
+    };
+    sse.on("connect", onConnect);
+    sse.on("error", onError);
+    sse.connect().catch(() => {
+      if (active) setIsOnline(false);
+    });
+    return () => {
+      active = false;
+      sse.off("connect", onConnect);
+      sse.off("error", onError);
+    };
+  }, [isAuthenticated, mero]);
   const contextValue = react.useMemo(
     () => ({
       mero,
@@ -402,17 +354,18 @@ function MeroProvider({
       nodeUrl,
       applicationId,
       contextId,
+      contextIdentity,
       connectToNode,
       logout,
       isLoading
     }),
-    [mero, isAuthenticated, isOnline, nodeUrl, applicationId, contextId, connectToNode, logout, isLoading]
+    [mero, isAuthenticated, isOnline, nodeUrl, applicationId, contextId, contextIdentity, connectToNode, logout, isLoading]
   );
   return /* @__PURE__ */ jsxRuntime.jsx(MeroContext.Provider, { value: contextValue, children });
 }
 function useMero() {
   const context = react.useContext(MeroContext);
-  if (context === void 0) {
+  if (!context) {
     throw new Error("useMero must be used within a MeroProvider");
   }
   return context;
@@ -888,26 +841,1173 @@ function MeroLogo2() {
     }
   );
 }
+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);
+  const [error, setError] = react.useState(null);
+  const mountedRef = react.useRef(true);
+  react.useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const execute = react.useCallback(
+    async (method, params) => {
+      if (!mero || !contextId || !executorId) {
+        if (mountedRef.current) setError(new Error("Not connected"));
+        return null;
+      }
+      if (mountedRef.current) {
+        setLoading(true);
+        setError(null);
+      }
+      try {
+        const result = await mero.rpc.execute({
+          contextId,
+          method,
+          argsJson: params,
+          executorPublicKey: executorId
+        });
+        return result;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        if (mountedRef.current) setError(e);
+        return null;
+      } finally {
+        if (mountedRef.current) setLoading(false);
+      }
+    },
+    [mero, contextId, executorId]
+  );
+  return { execute, loading, error };
+}
+function useSubscription(contextIds, callback) {
+  const { mero } = useMero();
+  const callbackRef = react.useRef(callback);
+  callbackRef.current = callback;
+  const contextIdsKey = JSON.stringify(contextIds);
+  react.useEffect(() => {
+    if (!mero || contextIds.length === 0) return;
+    const sse = mero.events;
+    const handler = (event) => {
+      callbackRef.current(event);
+    };
+    sse.on("event", handler);
+    sse.connect().catch(() => {
+    });
+    sse.subscribe(contextIds).catch(() => {
+    });
+    return () => {
+      sse.off("event", handler);
+    };
+  }, [mero, contextIdsKey]);
+}
+function useContexts(applicationId) {
+  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) return;
+    if (mountedRef.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const response = applicationId ? await mero.admin.getContextsForApplication(applicationId) : await mero.admin.getContexts();
+      const list = mapApplicationContexts(response.contexts ?? []);
+      if (mountedRef.current) {
+        setContexts(list);
+      }
+    } catch (err) {
+      const errorValue = toError(err);
+      if (mountedRef.current) {
+        setError(errorValue);
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [mero, applicationId]);
+  react.useEffect(() => {
+    void refetch();
+  }, [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 useSetDefaultVisibility() {
+  const { mero } = useMero();
+  const { loading, error, run } = useAsyncMutation();
+  const setDefaultVisibility = react.useCallback(
+    async (groupId, request) => {
+      if (!mero) return null;
+      return run(() => mero.admin.setDefaultVisibility(groupId, request));
+    },
+    [mero, run]
+  );
+  return { setDefaultVisibility, 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 };
+}
 
-Object.defineProperty(exports, "MeroJs", {
-  enumerable: true,
-  get: function () { return meroJs.MeroJs; }
-});
 exports.AppMode = AppMode;
 exports.ConnectButton = ConnectButton;
 exports.ConnectionType = ConnectionType;
-exports.EventStreamMode = EventStreamMode;
 exports.LoginModal = LoginModal;
 exports.MeroContext = MeroContext;
 exports.MeroProvider = MeroProvider;
 exports.clearAllStorage = clearAllStorage;
 exports.clearApplicationId = clearApplicationId;
+exports.clearContextId = clearContextId;
+exports.clearContextIdentity = clearContextIdentity;
 exports.clearNodeUrl = clearNodeUrl;
 exports.getApplicationId = getApplicationId;
+exports.getContextId = getContextId;
+exports.getContextIdentity = getContextIdentity;
 exports.getNodeUrl = getNodeUrl;
 exports.localStorageTokenStorage = localStorageTokenStorage;
 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.useSetDefaultVisibility = useSetDefaultVisibility;
+exports.useSetGroupAlias = useSetGroupAlias;
+exports.useSetMemberAlias = useSetMemberAlias;
+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,
+    get: function () { return meroJs[k]; }
+  });
+});
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map