@singi-labs/sifa-sdk 0.7.1 → 0.7.3

package/dist/query/index.cjs

@@ -75,6 +75,34 @@ async function apiFetchOrNull(config, path, options = {}) {
     throw e;
   }
 }
+function extractWriteError(data, status) {
+  const body = data ?? {};
+  return {
+    error: body.message ?? `Request failed (${status})`,
+    ...body.pdsHost ? { pdsHost: body.pdsHost } : {}
+  };
+}
+async function apiWrite(config, path, method, options = {}) {
+  try {
+    const data = await apiFetch(config, path, {
+      method,
+      credentials: "include",
+      ...options
+    });
+    return { success: true, ...data ?? {} };
+  } catch (e) {
+    if (e instanceof ApiError) {
+      return { success: false, ...extractWriteError(e.body, e.status) };
+    }
+    return { success: false, error: "Network error" };
+  }
+}
+function apiWriteCreate(config, path, body, options = {}) {
+  return apiWrite(config, path, "POST", {
+    body,
+    ...options
+  });
+}
 var SifaConfigContext = react.createContext(null);
 function SifaProvider({ config, children }) {
   return /* @__PURE__ */ jsxRuntime.jsx(SifaConfigContext.Provider, { value: config, children });
@@ -111,15 +139,303 @@ async function fetchAtFundLink(config, did, options = {}) {
   }
 }
 
+// src/query/fetchers/profile-mutations.ts
+function updateProfileSelf(config, data, options = {}) {
+  return apiWrite(config, "/api/profile/self", "PUT", { body: data, ...options });
+}
+function updateProfileOverride(config, data, options = {}) {
+  return apiWrite(config, "/api/profile/override", "PUT", { body: data, ...options });
+}
+function refreshPds(config, options = {}) {
+  return apiWrite(
+    config,
+    "/api/profile/refresh-pds",
+    "POST",
+    options
+  );
+}
+async function uploadAvatar(config, file, options = {}) {
+  const fetchFn = config.fetch ?? globalThis.fetch;
+  const url = `${config.baseUrl}/api/profile/avatar`;
+  const formData = new FormData();
+  formData.append("file", file);
+  try {
+    const res = await fetchFn(url, {
+      method: "POST",
+      credentials: options.credentials ?? "include",
+      body: formData,
+      signal: options.signal ?? AbortSignal.timeout(options.timeoutMs ?? 3e4),
+      headers: options.headers
+    });
+    if (!res.ok) {
+      const errBody = await res.json().catch(() => ({}));
+      const msg = errBody.message ?? `Request failed (${res.status})`;
+      const pdsHost = errBody.pdsHost;
+      return { success: false, error: msg, ...pdsHost ? { pdsHost } : {} };
+    }
+    const data = await res.json();
+    return { success: true, url: data.url };
+  } catch {
+    return { success: false, error: "Network error" };
+  }
+}
+function deleteAvatarOverride(config, options = {}) {
+  return apiWrite(config, "/api/profile/avatar", "DELETE", options);
+}
+
 // src/query/fetchers/positions.ts
 function createPosition(config, data, options = {}) {
-  return apiFetch(config, "/api/positions", {
-    method: "POST",
+  return apiWriteCreate(config, "/api/profile/position", data, options);
+}
+function updatePosition(config, rkey, data, options = {}) {
+  return apiWrite(config, `/api/profile/position/${encodeURIComponent(rkey)}`, "PUT", {
+    body: data,
+    ...options
+  });
+}
+function deletePosition(config, rkey, options = {}) {
+  return apiWrite(config, `/api/profile/position/${encodeURIComponent(rkey)}`, "DELETE", options);
+}
+function setPositionPrimary(config, rkey, options = {}) {
+  return apiWrite(
+    config,
+    `/api/profile/position/${encodeURIComponent(rkey)}/primary`,
+    "PUT",
+    options
+  );
+}
+function unsetPositionPrimary(config, rkey, options = {}) {
+  return apiWrite(
+    config,
+    `/api/profile/position/${encodeURIComponent(rkey)}/primary`,
+    "DELETE",
+    options
+  );
+}
+function buildPositionPayload(position, skills) {
+  return {
+    company: position.company,
+    title: position.title,
+    description: position.description,
+    startedAt: position.startedAt,
+    endedAt: position.endedAt,
+    location: position.location ?? void 0,
+    skills
+  };
+}
+function linkSkillToPosition(config, position, skillRef, options = {}) {
+  const currentSkills = position.skills ?? [];
+  if (currentSkills.some((s) => s.uri === skillRef.uri)) {
+    return Promise.resolve({ success: true });
+  }
+  return updatePosition(
+    config,
+    position.rkey,
+    buildPositionPayload(position, [...currentSkills, skillRef]),
+    options
+  );
+}
+function unlinkSkillFromPosition(config, position, skillRef, options = {}) {
+  const remaining = (position.skills ?? []).filter((s) => s.uri !== skillRef.uri);
+  return updatePosition(config, position.rkey, buildPositionPayload(position, remaining), options);
+}
+
+// src/query/fetchers/education.ts
+function createEducation(config, data, options = {}) {
+  return apiWriteCreate(config, "/api/profile/education", data, options);
+}
+function updateEducation(config, rkey, data, options = {}) {
+  return apiWrite(config, `/api/profile/education/${encodeURIComponent(rkey)}`, "PUT", {
+    body: data,
+    ...options
+  });
+}
+function deleteEducation(config, rkey, options = {}) {
+  return apiWrite(config, `/api/profile/education/${encodeURIComponent(rkey)}`, "DELETE", options);
+}
+
+// src/query/fetchers/skills.ts
+function createSkill(config, data, options = {}) {
+  return apiWriteCreate(config, "/api/profile/skill", data, options);
+}
+function updateSkill(config, rkey, data, options = {}) {
+  return apiWrite(config, `/api/profile/skill/${encodeURIComponent(rkey)}`, "PUT", {
+    body: data,
+    ...options
+  });
+}
+function deleteSkill(config, rkey, options = {}) {
+  return apiWrite(config, `/api/profile/skill/${encodeURIComponent(rkey)}`, "DELETE", options);
+}
+
+// src/query/fetchers/records.ts
+function createRecord(config, collection, data, options = {}) {
+  return apiWriteCreate(
+    config,
+    `/api/profile/records/${encodeURIComponent(collection)}`,
+    data,
+    options
+  );
+}
+function updateRecord(config, collection, rkey, data, options = {}) {
+  const path = `/api/profile/records/${encodeURIComponent(collection)}/${encodeURIComponent(rkey)}`;
+  return apiWrite(config, path, "PUT", { body: data, ...options });
+}
+function deleteRecord(config, collection, rkey, options = {}) {
+  const path = `/api/profile/records/${encodeURIComponent(collection)}/${encodeURIComponent(rkey)}`;
+  return apiWrite(config, path, "DELETE", options);
+}
+
+// src/query/fetchers/profile-locations.ts
+function createProfileLocation(config, data, options = {}) {
+  return apiWriteCreate(config, "/api/profile/location", data, options);
+}
+function updateProfileLocation(config, rkey, data, options = {}) {
+  return apiWrite(config, `/api/profile/location/${encodeURIComponent(rkey)}`, "PUT", {
+    body: data,
+    ...options
+  });
+}
+function deleteProfileLocation(config, rkey, options = {}) {
+  return apiWrite(config, `/api/profile/location/${encodeURIComponent(rkey)}`, "DELETE", options);
+}
+
+// src/query/fetchers/external-accounts.ts
+async function fetchExternalAccounts(config, handleOrDid, options = {}) {
+  const path = `/api/profile/${encodeURIComponent(handleOrDid)}/external-accounts`;
+  try {
+    const data = await apiFetch(config, path, {
+      credentials: "include",
+      ...options
+    });
+    return data.accounts ?? [];
+  } catch {
+    return [];
+  }
+}
+function createExternalAccount(config, data, options = {}) {
+  return apiWrite(
+    config,
+    "/api/profile/external-accounts",
+    "POST",
+    { body: data, ...options }
+  );
+}
+function updateExternalAccount(config, rkey, data, options = {}) {
+  return apiWrite(config, `/api/profile/external-accounts/${encodeURIComponent(rkey)}`, "PUT", {
     body: data,
-    credentials: "include",
     ...options
   });
 }
+function deleteExternalAccount(config, rkey, options = {}) {
+  return apiWrite(
+    config,
+    `/api/profile/external-accounts/${encodeURIComponent(rkey)}`,
+    "DELETE",
+    options
+  );
+}
+function setExternalAccountPrimary(config, rkey, options = {}) {
+  return apiWrite(
+    config,
+    `/api/profile/external-accounts/${encodeURIComponent(rkey)}/primary`,
+    "PUT",
+    options
+  );
+}
+function unsetExternalAccountPrimary(config, rkey, options = {}) {
+  return apiWrite(
+    config,
+    `/api/profile/external-accounts/${encodeURIComponent(rkey)}/primary`,
+    "DELETE",
+    options
+  );
+}
+function verifyExternalAccount(config, rkey, options = {}) {
+  return apiWrite(
+    config,
+    `/api/profile/external-accounts/${encodeURIComponent(rkey)}/verify`,
+    "POST",
+    { body: {}, ...options }
+  );
+}
+
+// src/query/fetchers/endorsements.ts
+function createEndorsement(config, data, options = {}) {
+  return apiWriteCreate(config, "/api/endorsements", data, options);
+}
+
+// src/query/fetchers/keytrace-claims.ts
+function hideKeytraceClaim(config, rkey, options = {}) {
+  return apiWrite(
+    config,
+    `/api/profile/keytrace-claims/${encodeURIComponent(rkey)}/hide`,
+    "POST",
+    options
+  );
+}
+function unhideKeytraceClaim(config, rkey, options = {}) {
+  return apiWrite(
+    config,
+    `/api/profile/keytrace-claims/${encodeURIComponent(rkey)}/hide`,
+    "DELETE",
+    options
+  );
+}
+
+// src/query/fetchers/publications.ts
+function hideOrcidPublication(config, putCode, options = {}) {
+  return apiWrite(config, `/api/profile/orcid-publications/${putCode}/hide`, "POST", options);
+}
+function unhideOrcidPublication(config, putCode, options = {}) {
+  return apiWrite(config, `/api/profile/orcid-publications/${putCode}/hide`, "DELETE", options);
+}
+function hideStandardPublication(config, uri, options = {}) {
+  return apiWrite(
+    config,
+    `/api/profile/standard-publications/${encodeURIComponent(uri)}/hide`,
+    "POST",
+    options
+  );
+}
+function unhideStandardPublication(config, uri, options = {}) {
+  return apiWrite(
+    config,
+    `/api/profile/standard-publications/${encodeURIComponent(uri)}/hide`,
+    "DELETE",
+    options
+  );
+}
+function bulkHideStandardPublications(config, uris, options = {}) {
+  return apiWrite(config, "/api/profile/standard-publications/bulk-hide", "POST", {
+    body: { uris },
+    ...options
+  });
+}
+function bulkUnhideStandardPublications(config, uris, options = {}) {
+  return apiWrite(config, "/api/profile/standard-publications/bulk-hide", "DELETE", {
+    body: { uris },
+    ...options
+  });
+}
+function hideSifaPublication(config, rkey, options = {}) {
+  return apiWrite(config, `/api/profile/publications/${rkey}/hide`, "POST", options);
+}
+function unhideSifaPublication(config, rkey, options = {}) {
+  return apiWrite(config, `/api/profile/publications/${rkey}/hide`, "DELETE", options);
+}
+async function refreshOrcidPublications(config, options = {}) {
+  const result = await apiWrite(
+    config,
+    "/api/profile/orcid-publications/refresh",
+    "POST",
+    { body: {}, ...options }
+  );
+  if (result.success && result.error) {
+    return { success: false, error: result.error };
+  }
+  return result;
+}
 
 // src/query/fetchers/stats.ts
 async function fetchStats(config, options = {}) {
@@ -197,6 +513,19 @@ async function fetchSearchFilters(config, options = {}) {
     return EMPTY_FILTERS;
   }
 }
+async function searchSkills(config, query, limit = 10, options = {}) {
+  if (!query.trim()) return [];
+  const path = `/api/skills/search?q=${encodeURIComponent(query)}&limit=${limit}`;
+  try {
+    const data = await apiFetch(config, path, {
+      cache: "no-store",
+      ...options
+    });
+    return data.skills ?? [];
+  } catch {
+    return [];
+  }
+}
 
 // src/query/fetchers/discovery.ts
 async function fetchSimilarProfiles(config, did, opts = {}) {
@@ -412,6 +741,79 @@ async function checkAppAccount(config, appId, options = {}) {
     return null;
   }
 }
+async function createReaction(config, targetUri, appId, targetCid, options = {}) {
+  const fetchFn = config.fetch ?? globalThis.fetch;
+  const url = `${config.baseUrl}/api/reactions`;
+  try {
+    const res = await fetchFn(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...options.headers ?? {} },
+      credentials: options.credentials ?? "include",
+      body: JSON.stringify({ targetUri, appId, targetCid }),
+      signal: options.signal ?? AbortSignal.timeout(options.timeoutMs ?? 1e4)
+    });
+    if (!res.ok) {
+      if (res.status === 403) {
+        try {
+          const body = await res.json();
+          if (body.error === "ScopeInsufficient") {
+            return {
+              ok: false,
+              error: { type: "scope_insufficient", requiredScope: body.requiredScope }
+            };
+          }
+        } catch {
+        }
+      }
+      return { ok: false, error: { type: "error" } };
+    }
+    const data = await res.json();
+    return { ok: true, data };
+  } catch {
+    return { ok: false, error: { type: "error" } };
+  }
+}
+function deleteReaction(config, targetUri, appId, options = {}) {
+  return apiWrite(config, "/api/reactions", "DELETE", {
+    body: { targetUri, appId },
+    ...options
+  });
+}
+
+// src/query/fetchers/quoted-posts.ts
+var QUOTED_POSTS_BATCH_MAX = 20;
+async function resolveQuotedPosts(config, uris, options = {}) {
+  if (uris.length === 0) return {};
+  const unique = [...new Set(uris)];
+  const batches = [];
+  for (let i = 0; i < unique.length; i += QUOTED_POSTS_BATCH_MAX) {
+    batches.push(unique.slice(i, i + QUOTED_POSTS_BATCH_MAX));
+  }
+  const headers = { ...options.headers ?? {} };
+  if (options.cookieHeader) headers.cookie = options.cookieHeader;
+  const results = {};
+  await Promise.all(
+    batches.map(async (batch) => {
+      try {
+        const data = await apiFetch(
+          config,
+          "/api/quoted-posts/resolve",
+          {
+            method: "POST",
+            body: { uris: batch },
+            credentials: "include",
+            timeoutMs: 8e3,
+            ...options,
+            headers
+          }
+        );
+        Object.assign(results, data);
+      } catch {
+      }
+    })
+  );
+  return results;
+}
 
 // src/query/fetchers/roadmap.ts
 async function fetchRoadmapVotes(config, options = {}) {
@@ -438,6 +840,26 @@ async function fetchMyRoadmapVotes(config, options = {}) {
     return [];
   }
 }
+function castRoadmapVote(config, key, options = {}) {
+  return apiWrite(config, `/api/roadmap/votes/${encodeURIComponent(key)}`, "POST", options);
+}
+function retractRoadmapVote(config, key, options = {}) {
+  return apiWrite(config, `/api/roadmap/votes/${encodeURIComponent(key)}`, "DELETE", options);
+}
+
+// src/query/fetchers/destructive.ts
+function resetProfile(config, deletePdsData, options = {}) {
+  return apiWrite(config, "/api/profile/reset", "DELETE", {
+    body: { deletePdsData },
+    ...options
+  });
+}
+function deleteAccount(config, deletePdsData, options = {}) {
+  return apiWrite(config, "/api/profile/account", "DELETE", {
+    body: { deletePdsData },
+    ...options
+  });
+}
 
 // src/query/keys.ts
 var sifaQueryKeys = {
@@ -445,7 +867,8 @@ var sifaQueryKeys = {
   profile: {
     all: () => ["sifa", "profile"],
     byHandle: (handleOrDid) => ["sifa", "profile", handleOrDid],
-    atFundLink: (did) => ["sifa", "profile", "at-fund-link", did]
+    atFundLink: (did) => ["sifa", "profile", "at-fund-link", did],
+    externalAccounts: (handleOrDid) => ["sifa", "profile", "external-accounts", handleOrDid]
   },
   position: {
     all: () => ["sifa", "position"],
@@ -455,6 +878,7 @@ var sifaQueryKeys = {
     all: () => ["sifa", "search"],
     profiles: (filters) => ["sifa", "search", "profiles", filters],
     skills: (query) => ["sifa", "search", "skills", query],
+    canonicalSkills: (query, limit) => ["sifa", "search", "canonical-skills", query, limit],
     filters: () => ["sifa", "search", "filters"]
   },
   discovery: {
@@ -522,105 +946,681 @@ function useAtFundLink(did, options) {
     ...options
   });
 }
-function useCreatePosition(ownerDid, options) {
+async function invalidateProfile(queryClient, ownerHandleOrDid) {
+  await queryClient.invalidateQueries({
+    queryKey: sifaQueryKeys.profile.byHandle(ownerHandleOrDid)
+  });
+}
+function useUpdateProfileSelf(ownerHandleOrDid, options) {
   const config = useSifaConfig();
   const queryClient = reactQuery.useQueryClient();
   return reactQuery.useMutation({
-    mutationFn: (data) => createPosition(config, data),
+    mutationFn: (data) => updateProfileSelf(config, data),
     onSuccess: async (result, variables, onMutateResult, context) => {
       if (result.success) {
-        await queryClient.invalidateQueries({ queryKey: sifaQueryKeys.profile.byHandle(ownerDid) });
-        await queryClient.invalidateQueries({ queryKey: sifaQueryKeys.position.byOwner(ownerDid) });
+        await invalidateProfile(queryClient, ownerHandleOrDid);
       }
       await options?.onSuccess?.(result, variables, onMutateResult, context);
     },
     ...options
   });
 }
-function useStats(options) {
+function useUpdateProfileOverride(ownerHandleOrDid, options) {
   const config = useSifaConfig();
-  return reactQuery.useQuery({
-    queryKey: sifaQueryKeys.stats.homepage(),
-    queryFn: () => fetchStats(config),
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (data) => updateProfileOverride(config, data),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
     ...options
   });
 }
-function useAppsRegistry(options) {
+function useRefreshPds(ownerHandleOrDid, options) {
   const config = useSifaConfig();
-  return reactQuery.useQuery({
-    queryKey: sifaQueryKeys.apps.registry(),
-    queryFn: () => fetchAppsRegistry(config),
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: () => refreshPds(config),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
     ...options
   });
 }
-function useHiddenApps(options) {
+function useUploadAvatar(ownerHandleOrDid, options) {
   const config = useSifaConfig();
-  return reactQuery.useQuery({
-    queryKey: sifaQueryKeys.apps.hidden(),
-    queryFn: () => fetchHiddenApps(config),
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (file) => uploadAvatar(config, file),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
     ...options
   });
 }
-function useSearchProfiles(filters, options) {
+function useDeleteAvatarOverride(ownerHandleOrDid, options) {
   const config = useSifaConfig();
-  return reactQuery.useQuery({
-    queryKey: sifaQueryKeys.search.profiles(filters),
-    queryFn: () => fetchSearchProfiles(config, filters),
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: () => deleteAvatarOverride(config),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
     ...options
   });
 }
-function useSkillSuggestions(query, options) {
+function useCreatePosition(ownerDid, options) {
   const config = useSifaConfig();
-  return reactQuery.useQuery({
-    queryKey: sifaQueryKeys.search.skills(query),
-    queryFn: () => fetchSkillSuggestions(config, query),
-    enabled: query.trim().length > 0 && (options?.enabled ?? true),
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (data) => createPosition(config, data),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await queryClient.invalidateQueries({ queryKey: sifaQueryKeys.profile.byHandle(ownerDid) });
+        await queryClient.invalidateQueries({ queryKey: sifaQueryKeys.position.byOwner(ownerDid) });
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
     ...options
   });
 }
-function useSearchFilters(options) {
-  const config = useSifaConfig();
-  return reactQuery.useQuery({
-    queryKey: sifaQueryKeys.search.filters(),
-    queryFn: () => fetchSearchFilters(config),
-    ...options
+async function invalidatePositionCaches(queryClient, ownerHandleOrDid) {
+  await queryClient.invalidateQueries({
+    queryKey: sifaQueryKeys.profile.byHandle(ownerHandleOrDid)
   });
-}
-function useSimilarProfiles(did, opts = {}, options) {
-  const config = useSifaConfig();
-  const limit = opts.limit ?? 5;
-  return reactQuery.useQuery({
-    queryKey: sifaQueryKeys.discovery.similar(did ?? "", limit),
-    queryFn: () => fetchSimilarProfiles(config, did ?? "", { limit }),
-    enabled: Boolean(did) && (options?.enabled ?? true),
-    ...options
+  await queryClient.invalidateQueries({
+    queryKey: sifaQueryKeys.position.byOwner(ownerHandleOrDid)
   });
 }
-function useSuggestions(opts = {}, options) {
+function useUpdatePosition(ownerHandleOrDid, options) {
   const config = useSifaConfig();
-  return reactQuery.useQuery({
-    queryKey: sifaQueryKeys.discovery.suggestions(opts),
-    queryFn: () => fetchSuggestions(config, opts),
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ rkey, data }) => updatePosition(config, rkey, data),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidatePositionCaches(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
     ...options
   });
 }
-function useSuggestionCount(since, options) {
+function useDeletePosition(ownerHandleOrDid, options) {
   const config = useSifaConfig();
-  return reactQuery.useQuery({
-    queryKey: sifaQueryKeys.discovery.suggestionCount(since),
-    queryFn: () => fetchSuggestionCount(config, since),
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (rkey) => deletePosition(config, rkey),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidatePositionCaches(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
     ...options
   });
 }
-function useFeaturedProfile(options) {
+function useSetPositionPrimary(ownerHandleOrDid, options) {
   const config = useSifaConfig();
-  return reactQuery.useQuery({
-    queryKey: sifaQueryKeys.discovery.featured(),
-    queryFn: () => fetchFeaturedProfile(config),
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (rkey) => setPositionPrimary(config, rkey),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidatePositionCaches(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
     ...options
   });
 }
-function useFollowing(opts = {}, options) {
+function useUnsetPositionPrimary(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (rkey) => unsetPositionPrimary(config, rkey),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidatePositionCaches(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useLinkSkillToPosition(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ position, skillRef }) => linkSkillToPosition(config, position, skillRef),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidatePositionCaches(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useUnlinkSkillFromPosition(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ position, skillRef }) => unlinkSkillFromPosition(config, position, skillRef),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidatePositionCaches(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+async function invalidateProfile2(queryClient, ownerHandleOrDid) {
+  await queryClient.invalidateQueries({
+    queryKey: sifaQueryKeys.profile.byHandle(ownerHandleOrDid)
+  });
+}
+function useCreateEducation(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (data) => createEducation(config, data),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile2(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useUpdateEducation(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ rkey, data }) => updateEducation(config, rkey, data),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile2(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useDeleteEducation(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (rkey) => deleteEducation(config, rkey),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile2(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+async function invalidateProfile3(queryClient, ownerHandleOrDid) {
+  await queryClient.invalidateQueries({
+    queryKey: sifaQueryKeys.profile.byHandle(ownerHandleOrDid)
+  });
+}
+function useCreateSkill(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (data) => createSkill(config, data),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile3(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useUpdateSkill(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ rkey, data }) => updateSkill(config, rkey, data),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile3(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useDeleteSkill(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (rkey) => deleteSkill(config, rkey),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile3(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+async function invalidateProfile4(queryClient, ownerHandleOrDid) {
+  await queryClient.invalidateQueries({
+    queryKey: sifaQueryKeys.profile.byHandle(ownerHandleOrDid)
+  });
+}
+function useCreateRecord(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ collection, data }) => createRecord(config, collection, data),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile4(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useUpdateRecord(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ collection, rkey, data }) => updateRecord(config, collection, rkey, data),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile4(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useDeleteRecord(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ collection, rkey }) => deleteRecord(config, collection, rkey),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile4(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+async function invalidateProfile5(queryClient, ownerHandleOrDid) {
+  await queryClient.invalidateQueries({
+    queryKey: sifaQueryKeys.profile.byHandle(ownerHandleOrDid)
+  });
+}
+function useCreateProfileLocation(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (data) => createProfileLocation(config, data),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile5(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useUpdateProfileLocation(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ rkey, data }) => updateProfileLocation(config, rkey, data),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile5(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useDeleteProfileLocation(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (rkey) => deleteProfileLocation(config, rkey),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile5(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+async function invalidateProfileAndExternalAccounts(queryClient, ownerHandleOrDid) {
+  await queryClient.invalidateQueries({
+    queryKey: sifaQueryKeys.profile.byHandle(ownerHandleOrDid)
+  });
+  await queryClient.invalidateQueries({
+    queryKey: sifaQueryKeys.profile.externalAccounts(ownerHandleOrDid)
+  });
+}
+function useExternalAccounts(handleOrDid, options) {
+  const config = useSifaConfig();
+  return reactQuery.useQuery({
+    queryKey: sifaQueryKeys.profile.externalAccounts(handleOrDid ?? ""),
+    queryFn: () => fetchExternalAccounts(config, handleOrDid ?? ""),
+    enabled: Boolean(handleOrDid) && (options?.enabled ?? true),
+    ...options
+  });
+}
+function useCreateExternalAccount(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (data) => createExternalAccount(config, data),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfileAndExternalAccounts(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useUpdateExternalAccount(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ rkey, data }) => updateExternalAccount(config, rkey, data),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfileAndExternalAccounts(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useDeleteExternalAccount(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (rkey) => deleteExternalAccount(config, rkey),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfileAndExternalAccounts(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useSetExternalAccountPrimary(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (rkey) => setExternalAccountPrimary(config, rkey),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfileAndExternalAccounts(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useUnsetExternalAccountPrimary(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (rkey) => unsetExternalAccountPrimary(config, rkey),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfileAndExternalAccounts(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useVerifyExternalAccount(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (rkey) => verifyExternalAccount(config, rkey),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfileAndExternalAccounts(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useCreateEndorsement(endorsedHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (data) => createEndorsement(config, data),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success && endorsedHandleOrDid) {
+        await queryClient.invalidateQueries({
+          queryKey: sifaQueryKeys.profile.byHandle(endorsedHandleOrDid)
+        });
+        await queryClient.invalidateQueries({
+          queryKey: sifaQueryKeys.endorsement.count(endorsedHandleOrDid)
+        });
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+async function invalidateProfile6(queryClient, ownerHandleOrDid) {
+  await queryClient.invalidateQueries({
+    queryKey: sifaQueryKeys.profile.byHandle(ownerHandleOrDid)
+  });
+}
+function useHideKeytraceClaim(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (rkey) => hideKeytraceClaim(config, rkey),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile6(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useUnhideKeytraceClaim(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (rkey) => unhideKeytraceClaim(config, rkey),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile6(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+async function invalidateProfile7(queryClient, ownerHandleOrDid) {
+  await queryClient.invalidateQueries({
+    queryKey: sifaQueryKeys.profile.byHandle(ownerHandleOrDid)
+  });
+}
+function makeWriteHook(fetcher) {
+  return function useHook(ownerHandleOrDid, options) {
+    const config = useSifaConfig();
+    const queryClient = reactQuery.useQueryClient();
+    return reactQuery.useMutation({
+      mutationFn: (v) => fetcher(config, v),
+      onSuccess: async (result, variables, onMutateResult, context) => {
+        if (result.success) {
+          await invalidateProfile7(queryClient, ownerHandleOrDid);
+        }
+        await options?.onSuccess?.(result, variables, onMutateResult, context);
+      },
+      ...options
+    });
+  };
+}
+var useHideOrcidPublication = makeWriteHook(
+  (config, putCode) => hideOrcidPublication(config, putCode)
+);
+var useUnhideOrcidPublication = makeWriteHook(
+  (config, putCode) => unhideOrcidPublication(config, putCode)
+);
+var useHideStandardPublication = makeWriteHook(
+  (config, uri) => hideStandardPublication(config, uri)
+);
+var useUnhideStandardPublication = makeWriteHook(
+  (config, uri) => unhideStandardPublication(config, uri)
+);
+var useBulkHideStandardPublications = makeWriteHook(
+  (config, uris) => bulkHideStandardPublications(config, uris)
+);
+var useBulkUnhideStandardPublications = makeWriteHook(
+  (config, uris) => bulkUnhideStandardPublications(config, uris)
+);
+var useHideSifaPublication = makeWriteHook(
+  (config, rkey) => hideSifaPublication(config, rkey)
+);
+var useUnhideSifaPublication = makeWriteHook(
+  (config, rkey) => unhideSifaPublication(config, rkey)
+);
+function useRefreshOrcidPublications(ownerHandleOrDid, options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: () => refreshOrcidPublications(config),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateProfile7(queryClient, ownerHandleOrDid);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useStats(options) {
+  const config = useSifaConfig();
+  return reactQuery.useQuery({
+    queryKey: sifaQueryKeys.stats.homepage(),
+    queryFn: () => fetchStats(config),
+    ...options
+  });
+}
+function useAppsRegistry(options) {
+  const config = useSifaConfig();
+  return reactQuery.useQuery({
+    queryKey: sifaQueryKeys.apps.registry(),
+    queryFn: () => fetchAppsRegistry(config),
+    ...options
+  });
+}
+function useHiddenApps(options) {
+  const config = useSifaConfig();
+  return reactQuery.useQuery({
+    queryKey: sifaQueryKeys.apps.hidden(),
+    queryFn: () => fetchHiddenApps(config),
+    ...options
+  });
+}
+function useSearchProfiles(filters, options) {
+  const config = useSifaConfig();
+  return reactQuery.useQuery({
+    queryKey: sifaQueryKeys.search.profiles(filters),
+    queryFn: () => fetchSearchProfiles(config, filters),
+    ...options
+  });
+}
+function useSkillSuggestions(query, options) {
+  const config = useSifaConfig();
+  return reactQuery.useQuery({
+    queryKey: sifaQueryKeys.search.skills(query),
+    queryFn: () => fetchSkillSuggestions(config, query),
+    enabled: query.trim().length > 0 && (options?.enabled ?? true),
+    ...options
+  });
+}
+function useCanonicalSkillSearch(query, limit = 10, options) {
+  const config = useSifaConfig();
+  return reactQuery.useQuery({
+    queryKey: sifaQueryKeys.search.canonicalSkills(query, limit),
+    queryFn: () => searchSkills(config, query, limit),
+    enabled: query.trim().length > 0 && (options?.enabled ?? true),
+    ...options
+  });
+}
+function useSearchFilters(options) {
+  const config = useSifaConfig();
+  return reactQuery.useQuery({
+    queryKey: sifaQueryKeys.search.filters(),
+    queryFn: () => fetchSearchFilters(config),
+    ...options
+  });
+}
+function useSimilarProfiles(did, opts = {}, options) {
+  const config = useSifaConfig();
+  const limit = opts.limit ?? 5;
+  return reactQuery.useQuery({
+    queryKey: sifaQueryKeys.discovery.similar(did ?? "", limit),
+    queryFn: () => fetchSimilarProfiles(config, did ?? "", { limit }),
+    enabled: Boolean(did) && (options?.enabled ?? true),
+    ...options
+  });
+}
+function useSuggestions(opts = {}, options) {
+  const config = useSifaConfig();
+  return reactQuery.useQuery({
+    queryKey: sifaQueryKeys.discovery.suggestions(opts),
+    queryFn: () => fetchSuggestions(config, opts),
+    ...options
+  });
+}
+function useSuggestionCount(since, options) {
+  const config = useSifaConfig();
+  return reactQuery.useQuery({
+    queryKey: sifaQueryKeys.discovery.suggestionCount(since),
+    queryFn: () => fetchSuggestionCount(config, since),
+    ...options
+  });
+}
+function useFeaturedProfile(options) {
+  const config = useSifaConfig();
+  return reactQuery.useQuery({
+    queryKey: sifaQueryKeys.discovery.featured(),
+    queryFn: () => fetchFeaturedProfile(config),
+    ...options
+  });
+}
+function useFollowing(opts = {}, options) {
   const config = useSifaConfig();
   return reactQuery.useQuery({
     queryKey: sifaQueryKeys.follow.following(opts),
@@ -690,6 +1690,34 @@ function useAppAccountCheck(appId, options) {
     ...options
   });
 }
+function useCreateReaction(options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ targetUri, appId, targetCid }) => createReaction(config, targetUri, appId, targetCid),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.ok) {
+        await queryClient.invalidateQueries({ queryKey: sifaQueryKeys.reactions.all() });
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useDeleteReaction(options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: ({ targetUri, appId }) => deleteReaction(config, targetUri, appId),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await queryClient.invalidateQueries({ queryKey: sifaQueryKeys.reactions.all() });
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
 function useRoadmapVotes(options) {
   const config = useSifaConfig();
   return reactQuery.useQuery({
@@ -706,18 +1734,100 @@ function useMyRoadmapVotes(options) {
     ...options
   });
 }
+async function invalidateRoadmap(queryClient) {
+  await queryClient.invalidateQueries({ queryKey: sifaQueryKeys.roadmap.all() });
+}
+function useCastRoadmapVote(options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (key) => castRoadmapVote(config, key),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateRoadmap(queryClient);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useRetractRoadmapVote(options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (key) => retractRoadmapVote(config, key),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await invalidateRoadmap(queryClient);
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useResetProfile(options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (deletePdsData) => resetProfile(config, deletePdsData),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        await queryClient.invalidateQueries({ queryKey: sifaQueryKeys.all() });
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
+function useDeleteAccount(options) {
+  const config = useSifaConfig();
+  const queryClient = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: (deletePdsData) => deleteAccount(config, deletePdsData),
+    onSuccess: async (result, variables, onMutateResult, context) => {
+      if (result.success) {
+        queryClient.clear();
+      }
+      await options?.onSuccess?.(result, variables, onMutateResult, context);
+    },
+    ...options
+  });
+}
 
 exports.ApiError = ApiError;
+exports.QUOTED_POSTS_BATCH_MAX = QUOTED_POSTS_BATCH_MAX;
 exports.SifaProvider = SifaProvider;
 exports.apiFetch = apiFetch;
 exports.apiFetchOrNull = apiFetchOrNull;
+exports.apiWrite = apiWrite;
+exports.apiWriteCreate = apiWriteCreate;
+exports.bulkHideStandardPublications = bulkHideStandardPublications;
+exports.bulkUnhideStandardPublications = bulkUnhideStandardPublications;
+exports.castRoadmapVote = castRoadmapVote;
 exports.checkAppAccount = checkAppAccount;
+exports.createEducation = createEducation;
+exports.createEndorsement = createEndorsement;
+exports.createExternalAccount = createExternalAccount;
 exports.createPosition = createPosition;
+exports.createProfileLocation = createProfileLocation;
+exports.createReaction = createReaction;
+exports.createRecord = createRecord;
+exports.createSkill = createSkill;
+exports.deleteAccount = deleteAccount;
+exports.deleteAvatarOverride = deleteAvatarOverride;
+exports.deleteEducation = deleteEducation;
+exports.deleteExternalAccount = deleteExternalAccount;
+exports.deletePosition = deletePosition;
+exports.deleteProfileLocation = deleteProfileLocation;
+exports.deleteReaction = deleteReaction;
+exports.deleteRecord = deleteRecord;
+exports.deleteSkill = deleteSkill;
 exports.fetchActivityFeed = fetchActivityFeed;
 exports.fetchActivityTeaser = fetchActivityTeaser;
 exports.fetchAppsRegistry = fetchAppsRegistry;
 exports.fetchAtFundLink = fetchAtFundLink;
 exports.fetchEndorsementCount = fetchEndorsementCount;
+exports.fetchExternalAccounts = fetchExternalAccounts;
 exports.fetchFeaturedProfile = fetchFeaturedProfile;
 exports.fetchFollowing = fetchFollowing;
 exports.fetchHeatmapData = fetchHeatmapData;
@@ -734,30 +1844,109 @@ exports.fetchSkillSuggestions = fetchSkillSuggestions;
 exports.fetchStats = fetchStats;
 exports.fetchSuggestionCount = fetchSuggestionCount;
 exports.fetchSuggestions = fetchSuggestions;
+exports.hideKeytraceClaim = hideKeytraceClaim;
+exports.hideOrcidPublication = hideOrcidPublication;
+exports.hideSifaPublication = hideSifaPublication;
+exports.hideStandardPublication = hideStandardPublication;
+exports.linkSkillToPosition = linkSkillToPosition;
+exports.refreshOrcidPublications = refreshOrcidPublications;
+exports.refreshPds = refreshPds;
+exports.resetProfile = resetProfile;
+exports.resolveQuotedPosts = resolveQuotedPosts;
+exports.retractRoadmapVote = retractRoadmapVote;
+exports.searchSkills = searchSkills;
+exports.setExternalAccountPrimary = setExternalAccountPrimary;
+exports.setPositionPrimary = setPositionPrimary;
 exports.sifaQueryKeys = sifaQueryKeys;
+exports.unhideKeytraceClaim = unhideKeytraceClaim;
+exports.unhideOrcidPublication = unhideOrcidPublication;
+exports.unhideSifaPublication = unhideSifaPublication;
+exports.unhideStandardPublication = unhideStandardPublication;
+exports.unlinkSkillFromPosition = unlinkSkillFromPosition;
+exports.unsetExternalAccountPrimary = unsetExternalAccountPrimary;
+exports.unsetPositionPrimary = unsetPositionPrimary;
+exports.updateEducation = updateEducation;
+exports.updateExternalAccount = updateExternalAccount;
+exports.updatePosition = updatePosition;
+exports.updateProfileLocation = updateProfileLocation;
+exports.updateProfileOverride = updateProfileOverride;
+exports.updateProfileSelf = updateProfileSelf;
+exports.updateRecord = updateRecord;
+exports.updateSkill = updateSkill;
+exports.uploadAvatar = uploadAvatar;
 exports.useActivityFeed = useActivityFeed;
 exports.useActivityTeaser = useActivityTeaser;
 exports.useAppAccountCheck = useAppAccountCheck;
 exports.useAppsRegistry = useAppsRegistry;
 exports.useAtFundLink = useAtFundLink;
+exports.useBulkHideStandardPublications = useBulkHideStandardPublications;
+exports.useBulkUnhideStandardPublications = useBulkUnhideStandardPublications;
+exports.useCanonicalSkillSearch = useCanonicalSkillSearch;
+exports.useCastRoadmapVote = useCastRoadmapVote;
+exports.useCreateEducation = useCreateEducation;
+exports.useCreateEndorsement = useCreateEndorsement;
+exports.useCreateExternalAccount = useCreateExternalAccount;
 exports.useCreatePosition = useCreatePosition;
+exports.useCreateProfileLocation = useCreateProfileLocation;
+exports.useCreateReaction = useCreateReaction;
+exports.useCreateRecord = useCreateRecord;
+exports.useCreateSkill = useCreateSkill;
+exports.useDeleteAccount = useDeleteAccount;
+exports.useDeleteAvatarOverride = useDeleteAvatarOverride;
+exports.useDeleteEducation = useDeleteEducation;
+exports.useDeleteExternalAccount = useDeleteExternalAccount;
+exports.useDeletePosition = useDeletePosition;
+exports.useDeleteProfileLocation = useDeleteProfileLocation;
+exports.useDeleteReaction = useDeleteReaction;
+exports.useDeleteRecord = useDeleteRecord;
+exports.useDeleteSkill = useDeleteSkill;
 exports.useEndorsementCount = useEndorsementCount;
+exports.useExternalAccounts = useExternalAccounts;
 exports.useFeaturedProfile = useFeaturedProfile;
 exports.useFollowing = useFollowing;
 exports.useHeatmapData = useHeatmapData;
 exports.useHiddenApps = useHiddenApps;
+exports.useHideKeytraceClaim = useHideKeytraceClaim;
+exports.useHideOrcidPublication = useHideOrcidPublication;
+exports.useHideSifaPublication = useHideSifaPublication;
+exports.useHideStandardPublication = useHideStandardPublication;
+exports.useLinkSkillToPosition = useLinkSkillToPosition;
 exports.useMyRoadmapVotes = useMyRoadmapVotes;
 exports.useNetworkStreamCount = useNetworkStreamCount;
 exports.useProfile = useProfile;
 exports.useReactionStatus = useReactionStatus;
+exports.useRefreshOrcidPublications = useRefreshOrcidPublications;
+exports.useRefreshPds = useRefreshPds;
+exports.useResetProfile = useResetProfile;
+exports.useRetractRoadmapVote = useRetractRoadmapVote;
 exports.useRoadmapVotes = useRoadmapVotes;
 exports.useSearchFilters = useSearchFilters;
 exports.useSearchProfiles = useSearchProfiles;
+exports.useSetExternalAccountPrimary = useSetExternalAccountPrimary;
+exports.useSetPositionPrimary = useSetPositionPrimary;
 exports.useSifaConfig = useSifaConfig;
 exports.useSimilarProfiles = useSimilarProfiles;
 exports.useSkillSuggestions = useSkillSuggestions;
 exports.useStats = useStats;
 exports.useSuggestionCount = useSuggestionCount;
 exports.useSuggestions = useSuggestions;
+exports.useUnhideKeytraceClaim = useUnhideKeytraceClaim;
+exports.useUnhideOrcidPublication = useUnhideOrcidPublication;
+exports.useUnhideSifaPublication = useUnhideSifaPublication;
+exports.useUnhideStandardPublication = useUnhideStandardPublication;
+exports.useUnlinkSkillFromPosition = useUnlinkSkillFromPosition;
+exports.useUnsetExternalAccountPrimary = useUnsetExternalAccountPrimary;
+exports.useUnsetPositionPrimary = useUnsetPositionPrimary;
+exports.useUpdateEducation = useUpdateEducation;
+exports.useUpdateExternalAccount = useUpdateExternalAccount;
+exports.useUpdatePosition = useUpdatePosition;
+exports.useUpdateProfileLocation = useUpdateProfileLocation;
+exports.useUpdateProfileOverride = useUpdateProfileOverride;
+exports.useUpdateProfileSelf = useUpdateProfileSelf;
+exports.useUpdateRecord = useUpdateRecord;
+exports.useUpdateSkill = useUpdateSkill;
+exports.useUploadAvatar = useUploadAvatar;
+exports.useVerifyExternalAccount = useVerifyExternalAccount;
+exports.verifyExternalAccount = verifyExternalAccount;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map