@sublay/js 5.0.0 → 7.0.0

package/dist/index.mjs

@@ -6,150 +6,1859 @@ var __export = (target, all) => {
 
 // src/core/client.ts
 import axios from "axios";
+var BASE_URL = "https://api.sublay.io/v7";
 var SublayHttpClient = class {
-  instance;
-  constructor({ projectId }) {
-    this.instance = axios.create({
-      baseURL: `https://api.sublay.io/api/v5/${projectId}`
+  projectInstance;
+  baseURL;
+  hostManaged;
+  getToken;
+  onAuthChange;
+  accessToken;
+  refreshToken;
+  /** Shared so concurrent 403s trigger a single refresh (mutex). */
+  refreshPromise = null;
+  constructor({
+    projectId,
+    initialTokens,
+    getToken,
+    onAuthChange
+  }) {
+    this.baseURL = `${BASE_URL}/${projectId}`;
+    this.getToken = getToken;
+    this.onAuthChange = onAuthChange;
+    this.hostManaged = Boolean(getToken);
+    this.accessToken = initialTokens?.accessToken ?? null;
+    this.refreshToken = initialTokens?.refreshToken ?? null;
+    this.projectInstance = axios.create({
+      baseURL: this.baseURL,
+      headers: { "Content-Type": "application/json" }
     });
+    this.projectInstance.interceptors.request.use(async (config) => {
+      if (config.headers.Authorization) return config;
+      const token = this.hostManaged ? await this.getToken?.() : this.accessToken;
+      if (token) config.headers.Authorization = `Bearer ${token}`;
+      return config;
+    });
+    this.projectInstance.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        const prevRequest = error?.config;
+        const status = error?.response?.status;
+        if (status !== 403 || !prevRequest || prevRequest._retry) {
+          return Promise.reject(error);
+        }
+        prevRequest._retry = true;
+        let newToken = null;
+        if (this.hostManaged) {
+          const fresh = await this.getToken?.();
+          if (fresh && `Bearer ${fresh}` !== prevRequest.headers?.Authorization) {
+            newToken = fresh;
+          }
+        } else {
+          newToken = await this.refreshAccessToken();
+        }
+        if (!newToken) return Promise.reject(error);
+        prevRequest.headers.Authorization = `Bearer ${newToken}`;
+        return this.projectInstance(prevRequest);
+      }
+    );
+  }
+  /**
+   * The SDK's own in-memory access token (SDK-managed mode). Distinct from the
+   * `init({ getToken })` host hook, which supplies a token in host-managed mode.
+   */
+  getAccessToken() {
+    return this.accessToken;
+  }
+  getRefreshToken() {
+    return this.refreshToken;
+  }
+  /**
+   * The `Authorization` header value (`Bearer <token>`) for the active auth
+   * mode, or `undefined` if there is no token. Host-managed mode reads the
+   * `getToken` hook; SDK-managed mode reads the in-memory access token. Use this
+   * for requests that bypass `projectInstance` (e.g. the SSE `askContent`
+   * stream, which needs `fetch` rather than axios).
+   */
+  async getAuthHeader() {
+    const token = this.hostManaged ? await this.getToken?.() : this.accessToken;
+    return token ? `Bearer ${token}` : void 0;
+  }
+  /** Store a full token pair (SDK-managed mode only; no-op when host-managed). */
+  setTokens(tokens) {
+    if (this.hostManaged) return;
+    this.accessToken = tokens.accessToken;
+    this.refreshToken = tokens.refreshToken;
+    this.onAuthChange?.({
+      accessToken: this.accessToken,
+      refreshToken: this.refreshToken
+    });
+  }
+  /** Update just the access token, e.g. after a refresh (no-op when host-managed). */
+  setAccessToken(accessToken) {
+    if (this.hostManaged) return;
+    this.accessToken = accessToken;
+    if (this.refreshToken) {
+      this.onAuthChange?.({ accessToken, refreshToken: this.refreshToken });
+    }
+  }
+  /** Clear tokens and notify with null (SDK-managed mode only). */
+  clearTokens() {
+    if (this.hostManaged) return;
+    this.accessToken = null;
+    this.refreshToken = null;
+    this.onAuthChange?.(null);
+  }
+  /**
+   * Refresh the access token using the in-memory refresh token. A single shared
+   * promise (mutex) means concurrent 403s trigger only one network refresh. The
+   * call goes through a bare axios (not `projectInstance`) so it never re-enters
+   * the response interceptor. Returns the new access token, or null on failure.
+   */
+  async refreshAccessToken() {
+    if (!this.refreshToken) return null;
+    if (!this.refreshPromise) {
+      const refreshToken = this.refreshToken;
+      this.refreshPromise = axios.post(
+        `${this.baseURL}/auth/request-new-access-token`,
+        { refreshToken }
+      ).then((res) => {
+        const { accessToken, refreshToken: rotated } = res.data;
+        if (rotated) this.setTokens({ accessToken, refreshToken: rotated });
+        else this.setAccessToken(accessToken);
+        return accessToken;
+      }).catch(() => null).finally(() => {
+        this.refreshPromise = null;
+      });
+    }
+    return this.refreshPromise;
   }
 };
 
+// src/modules/auth/index.ts
+var auth_exports = {};
+__export(auth_exports, {
+  changePassword: () => changePassword,
+  requestNewAccessToken: () => requestNewAccessToken,
+  requestPasswordReset: () => requestPasswordReset,
+  resetPassword: () => resetPassword,
+  sendVerificationEmail: () => sendVerificationEmail,
+  signIn: () => signIn,
+  signOut: () => signOut,
+  signUp: () => signUp,
+  verifyEmail: () => verifyEmail,
+  verifyExternalUser: () => verifyExternalUser
+});
+
+// src/modules/auth/signUp.ts
+async function signUp(client, data) {
+  const response = await client.projectInstance.post(
+    "/auth/sign-up",
+    data
+  );
+  client.setTokens({
+    accessToken: response.data.accessToken,
+    refreshToken: response.data.refreshToken
+  });
+  return response.data;
+}
+
+// src/modules/auth/signIn.ts
+async function signIn(client, data) {
+  const response = await client.projectInstance.post(
+    "/auth/sign-in",
+    data
+  );
+  client.setTokens({
+    accessToken: response.data.accessToken,
+    refreshToken: response.data.refreshToken
+  });
+  return response.data;
+}
+
+// src/modules/auth/signOut.ts
+async function signOut(client, data) {
+  const refreshToken = data?.refreshToken ?? client.getRefreshToken();
+  await client.projectInstance.post(
+    "/auth/sign-out",
+    refreshToken ? { refreshToken } : {}
+  );
+  client.clearTokens();
+}
+
+// src/modules/auth/requestNewAccessToken.ts
+async function requestNewAccessToken(client, data) {
+  const refreshToken = data?.refreshToken ?? client.getRefreshToken();
+  if (!refreshToken) {
+    throw new Error(
+      "requestNewAccessToken: no refresh token available (none stored and none provided)."
+    );
+  }
+  const response = await client.projectInstance.post(
+    "/auth/request-new-access-token",
+    { refreshToken }
+  );
+  const { accessToken, refreshToken: rotated } = response.data;
+  if (rotated) client.setTokens({ accessToken, refreshToken: rotated });
+  else client.setAccessToken(accessToken);
+  return response.data;
+}
+
+// src/modules/auth/verifyExternalUser.ts
+async function verifyExternalUser(client, data) {
+  const response = await client.projectInstance.post(
+    "/auth/verify-external-user",
+    data
+  );
+  client.setTokens({
+    accessToken: response.data.accessToken,
+    refreshToken: response.data.refreshToken
+  });
+  return response.data;
+}
+
+// src/modules/auth/requestPasswordReset.ts
+async function requestPasswordReset(client, data) {
+  await client.projectInstance.post("/auth/request-password-reset", data);
+}
+
+// src/modules/auth/resetPassword.ts
+async function resetPassword(client, data) {
+  await client.projectInstance.post("/auth/reset-password", data);
+}
+
+// src/modules/auth/changePassword.ts
+async function changePassword(client, data) {
+  const response = await client.projectInstance.post(
+    "/auth/change-password",
+    data
+  );
+  return response.data;
+}
+
+// src/modules/auth/verifyEmail.ts
+async function verifyEmail(client, data) {
+  await client.projectInstance.post("/auth/verify-email", data);
+}
+
+// src/modules/auth/sendVerificationEmail.ts
+async function sendVerificationEmail(client, data) {
+  const response = await client.projectInstance.post(
+    "/auth/send-verification-email",
+    data ?? {}
+  );
+  return response.data;
+}
+
 // src/modules/users/index.ts
 var users_exports = {};
 __export(users_exports, {
+  checkUsernameAvailability: () => checkUsernameAvailability,
+  createFollow: () => createFollow,
+  deleteFollow: () => deleteFollow,
+  fetchConnectionStatus: () => fetchConnectionStatus,
+  fetchConnectionsByUserId: () => fetchConnectionsByUserId,
+  fetchConnectionsCountByUserId: () => fetchConnectionsCountByUserId,
+  fetchFollowStatus: () => fetchFollowStatus,
+  fetchFollowersByUserId: () => fetchFollowersByUserId,
+  fetchFollowersCountByUserId: () => fetchFollowersCountByUserId,
+  fetchFollowingByUserId: () => fetchFollowingByUserId,
+  fetchFollowingCountByUserId: () => fetchFollowingCountByUserId,
   fetchUserByForeignId: () => fetchUserByForeignId,
-  fetchUserById: () => fetchUserById
+  fetchUserById: () => fetchUserById,
+  fetchUserByUsername: () => fetchUserByUsername,
+  fetchUserSuggestions: () => fetchUserSuggestions,
+  removeConnectionByUserId: () => removeConnectionByUserId,
+  requestConnection: () => requestConnection,
+  updateUser: () => updateUser
 });
 
 // src/modules/users/fetchUserById.ts
 async function fetchUserById(client, data) {
-  const path = `/users/${data.userId}`;
-  const response = await client.instance.get(path);
+  const { userId, ...params } = data;
+  const response = await client.projectInstance.get(`/users/${userId}`, {
+    params
+  });
   return response.data;
 }
 
 // src/modules/users/fetchUserByForeignId.ts
 async function fetchUserByForeignId(client, data) {
-  const path = `/users/by-foreign-id`;
-  const params = {
-    foreignId: data.foreignId,
-    name: data.name,
-    username: data.username,
-    avatar: data.avatar,
-    bio: data.bio,
-    // birthdate: data.birthdate,
-    // location: data.location,
-    metadata: data.metadata ? JSON.stringify(data.metadata) : void 0,
-    secureMetadata: data.secureMetadata ? JSON.stringify(data.secureMetadata) : void 0
-  };
-  const response = await client.instance.get(path, {
-    params
-  });
+  const response = await client.projectInstance.get(
+    "/users/by-foreign-id",
+    { params: data }
+  );
+  return response.data;
+}
+
+// src/modules/users/fetchUserByUsername.ts
+async function fetchUserByUsername(client, data) {
+  const response = await client.projectInstance.get(
+    "/users/by-username",
+    { params: data }
+  );
+  return response.data;
+}
+
+// src/modules/users/fetchUserSuggestions.ts
+async function fetchUserSuggestions(client, data) {
+  const response = await client.projectInstance.get(
+    "/users/suggestions",
+    { params: data }
+  );
+  return response.data;
+}
+
+// src/modules/users/checkUsernameAvailability.ts
+async function checkUsernameAvailability(client, data) {
+  const response = await client.projectInstance.get(
+    "/users/check-username",
+    { params: data }
+  );
+  return response.data;
+}
+
+// src/core/multipart.ts
+function appendField(form, key, value) {
+  if (value === void 0) return;
+  form.append(
+    key,
+    typeof value === "object" ? JSON.stringify(value) : String(value)
+  );
+}
+function appendFields(form, fields) {
+  for (const [key, value] of Object.entries(fields)) {
+    appendField(form, key, value);
+  }
+}
+function appendFile(form, field, file, opts) {
+  const name = opts?.filename ?? (file instanceof File && file.name ? file.name : void 0) ?? opts?.fallback ?? "upload";
+  form.append(field, file, name);
+}
+
+// src/modules/users/updateUser.ts
+async function updateUser(client, data) {
+  const { userId, avatarFile, bannerFile, ...body } = data;
+  const path = `/users/${userId}`;
+  if (avatarFile || bannerFile) {
+    const formData = new FormData();
+    if (avatarFile) {
+      appendFile(formData, "avatarFile", avatarFile.file, { fallback: "avatar" });
+      appendField(formData, "avatarFile.options", avatarFile.options);
+    }
+    if (bannerFile) {
+      appendFile(formData, "bannerFile", bannerFile.file, { fallback: "banner" });
+      appendField(formData, "bannerFile.options", bannerFile.options);
+    }
+    appendFields(formData, body);
+    const response2 = await client.projectInstance.patch(
+      path,
+      formData
+    );
+    return response2.data;
+  }
+  const response = await client.projectInstance.patch(path, body);
+  return response.data;
+}
+
+// src/modules/users/fetchFollowersByUserId.ts
+async function fetchFollowersByUserId(client, data) {
+  const { userId, ...params } = data;
+  const response = await client.projectInstance.get(`/users/${userId}/followers`, { params });
+  return response.data;
+}
+
+// src/modules/users/fetchFollowersCountByUserId.ts
+async function fetchFollowersCountByUserId(client, data) {
+  const { userId } = data;
+  const response = await client.projectInstance.get(
+    `/users/${userId}/followers-count`
+  );
+  return response.data;
+}
+
+// src/modules/users/fetchFollowingByUserId.ts
+async function fetchFollowingByUserId(client, data) {
+  const { userId, ...params } = data;
+  const response = await client.projectInstance.get(`/users/${userId}/following`, { params });
+  return response.data;
+}
+
+// src/modules/users/fetchFollowingCountByUserId.ts
+async function fetchFollowingCountByUserId(client, data) {
+  const { userId } = data;
+  const response = await client.projectInstance.get(
+    `/users/${userId}/following-count`
+  );
+  return response.data;
+}
+
+// src/modules/users/fetchConnectionsByUserId.ts
+async function fetchConnectionsByUserId(client, data) {
+  const { userId, ...params } = data;
+  const response = await client.projectInstance.get(`/users/${userId}/connections`, { params });
+  return response.data;
+}
+
+// src/modules/users/fetchConnectionsCountByUserId.ts
+async function fetchConnectionsCountByUserId(client, data) {
+  const { userId } = data;
+  const response = await client.projectInstance.get(
+    `/users/${userId}/connections-count`
+  );
+  return response.data;
+}
+
+// src/modules/users/createFollow.ts
+async function createFollow(client, data) {
+  const { userId } = data;
+  const response = await client.projectInstance.post(
+    `/users/${userId}/follow`,
+    {}
+  );
+  return response.data;
+}
+
+// src/modules/users/deleteFollow.ts
+async function deleteFollow(client, data) {
+  const { userId } = data;
+  await client.projectInstance.delete(`/users/${userId}/follow`);
+}
+
+// src/modules/users/fetchFollowStatus.ts
+async function fetchFollowStatus(client, data) {
+  const { userId } = data;
+  const response = await client.projectInstance.get(
+    `/users/${userId}/follow`
+  );
+  return response.data;
+}
+
+// src/modules/users/requestConnection.ts
+async function requestConnection(client, data) {
+  const { userId, ...body } = data;
+  const response = await client.projectInstance.post(
+    `/users/${userId}/connection`,
+    body
+  );
+  return response.data;
+}
+
+// src/modules/users/fetchConnectionStatus.ts
+async function fetchConnectionStatus(client, data) {
+  const { userId } = data;
+  const response = await client.projectInstance.get(
+    `/users/${userId}/connection`
+  );
+  return response.data;
+}
+
+// src/modules/users/removeConnectionByUserId.ts
+async function removeConnectionByUserId(client, data) {
+  const { userId } = data;
+  const response = await client.projectInstance.delete(
+    `/users/${userId}/connection`
+  );
   return response.data;
 }
 
 // src/modules/entities/index.ts
 var entities_exports = {};
 __export(entities_exports, {
+  addReaction: () => addReaction,
   createEntity: () => createEntity,
   deleteEntity: () => deleteEntity,
+  fetchDrafts: () => fetchDrafts,
   fetchEntity: () => fetchEntity,
   fetchEntityByForeignId: () => fetchEntityByForeignId,
   fetchEntityByShortId: () => fetchEntityByShortId,
   fetchManyEntities: () => fetchManyEntities,
+  fetchReactions: () => fetchReactions,
+  fetchTopComment: () => fetchTopComment,
+  getUserReaction: () => getUserReaction,
+  isEntitySaved: () => isEntitySaved,
+  publishDraft: () => publishDraft,
+  removeReaction: () => removeReaction,
   updateEntity: () => updateEntity
 });
 
 // src/modules/entities/createEntity.ts
 async function createEntity(client, data) {
   const path = `/entities`;
-  const response = await client.instance.post(path, data);
+  const response = await client.projectInstance.post(path, data);
   return response.data;
 }
 
 // src/modules/entities/fetchEntity.ts
 async function fetchEntity(client, data) {
-  const path = `/entities/${data.entityId}`;
-  const response = await client.instance.get(path);
+  const { entityId, ...params } = data;
+  const response = await client.projectInstance.get(
+    `/entities/${entityId}`,
+    { params }
+  );
   return response.data;
 }
 
 // src/modules/entities/fetchEntityByForeignId.ts
 async function fetchEntityByForeignId(client, data) {
   const path = `/entities/by-foreign-id`;
-  const response = await client.instance.get(path, { params: data });
+  const response = await client.projectInstance.get(path, {
+    params: data
+  });
   return response.data;
 }
 
 // src/modules/entities/fetchEntityByShortId.ts
 async function fetchEntityByShortId(client, data) {
   const path = `/entities/by-short-id`;
-  const response = await client.instance.get(path, { params: data });
+  const response = await client.projectInstance.get(path, {
+    params: data
+  });
   return response.data;
 }
 
 // src/modules/entities/fetchManyEntities.ts
 async function fetchManyEntities(client, data) {
   const path = `/entities`;
-  const response = await client.instance.get(path, {
-    params: data
-  });
+  const response = await client.projectInstance.get(
+    path,
+    {
+      params: data
+    }
+  );
   return response.data;
 }
 
 // src/modules/entities/updateEntity.ts
 async function updateEntity(client, data) {
   const { entityId, ...restOfProps } = data;
-  const path = `/entities/${data.entityId}`;
-  const response = await client.instance.patch(path, restOfProps);
+  const path = `/entities/${entityId}`;
+  const response = await client.projectInstance.patch(
+    path,
+    restOfProps
+  );
   return response.data;
 }
 
 // src/modules/entities/deleteEntity.ts
 async function deleteEntity(client, data) {
   const path = `/entities/${data.entityId}`;
-  const response = await client.instance.delete(path);
+  const response = await client.projectInstance.delete(path);
+  return response.data;
+}
+
+// src/modules/entities/fetchDrafts.ts
+async function fetchDrafts(client, data) {
+  const response = await client.projectInstance.get(
+    "/entities/drafts",
+    { params: data }
+  );
+  return response.data;
+}
+
+// src/modules/entities/publishDraft.ts
+async function publishDraft(client, data) {
+  const { entityId } = data;
+  const response = await client.projectInstance.patch(
+    `/entities/${entityId}/publish`
+  );
+  return response.data;
+}
+
+// src/modules/entities/fetchTopComment.ts
+async function fetchTopComment(client, data) {
+  const { entityId } = data;
+  const response = await client.projectInstance.get(
+    `/entities/${entityId}/top-comment`
+  );
+  return response.data;
+}
+
+// src/modules/entities/addReaction.ts
+async function addReaction(client, data) {
+  const { entityId, reactionType } = data;
+  const response = await client.projectInstance.post(
+    `/entities/${entityId}/reactions`,
+    { reactionType }
+  );
+  return response.data;
+}
+
+// src/modules/entities/removeReaction.ts
+async function removeReaction(client, data) {
+  const { entityId } = data;
+  const response = await client.projectInstance.delete(
+    `/entities/${entityId}/reactions`
+  );
+  return response.data;
+}
+
+// src/modules/entities/fetchReactions.ts
+async function fetchReactions(client, data) {
+  const { entityId, ...params } = data;
+  const response = await client.projectInstance.get(
+    `/entities/${entityId}/reactions`,
+    { params }
+  );
+  return response.data;
+}
+
+// src/modules/entities/getUserReaction.ts
+async function getUserReaction(client, data) {
+  const { entityId } = data;
+  const response = await client.projectInstance.get(
+    `/entities/${entityId}/reactions/me`
+  );
+  return response.data;
+}
+
+// src/modules/entities/isEntitySaved.ts
+async function isEntitySaved(client, data) {
+  const response = await client.projectInstance.get(
+    "/entities/is-entity-saved",
+    { params: data }
+  );
   return response.data;
 }
 
 // src/modules/comments/index.ts
 var comments_exports = {};
 __export(comments_exports, {
+  addReaction: () => addReaction2,
+  createComment: () => createComment,
+  deleteComment: () => deleteComment,
   fetchComment: () => fetchComment,
-  fetchCommentByForeignId: () => fetchCommentByForeignId
+  fetchCommentByForeignId: () => fetchCommentByForeignId,
+  fetchManyComments: () => fetchManyComments,
+  fetchReactions: () => fetchReactions2,
+  getUserReaction: () => getUserReaction2,
+  removeReaction: () => removeReaction2,
+  updateComment: () => updateComment
 });
 
+// src/modules/comments/createComment.ts
+async function createComment(client, data) {
+  const response = await client.projectInstance.post(
+    "/comments",
+    data
+  );
+  return response.data;
+}
+
 // src/modules/comments/fetchComment.ts
 async function fetchComment(client, data) {
-  const path = `/comments/${data.commentId}`;
-  const response = await client.instance.get(path);
+  const { commentId, ...params } = data;
+  const response = await client.projectInstance.get(
+    `/comments/${commentId}`,
+    { params }
+  );
   return response.data;
 }
 
 // src/modules/comments/fetchCommentByForeignId.ts
 async function fetchCommentByForeignId(client, data) {
   const path = `/comments/by-foreign-id`;
-  const response = await client.instance.get(path, { params: data });
+  const response = await client.projectInstance.get(path, {
+    params: data
+  });
+  return response.data;
+}
+
+// src/modules/comments/updateComment.ts
+async function updateComment(client, data) {
+  const { commentId, ...restOfProps } = data;
+  const path = `/comments/${commentId}`;
+  const response = await client.projectInstance.patch(
+    path,
+    restOfProps
+  );
+  return response.data;
+}
+
+// src/modules/comments/deleteComment.ts
+async function deleteComment(client, data) {
+  const path = `/comments/${data.commentId}`;
+  const response = await client.projectInstance.delete(path);
+  return response.data;
+}
+
+// src/modules/comments/fetchManyComments.ts
+async function fetchManyComments(client, data) {
+  const response = await client.projectInstance.get(
+    "/comments",
+    { params: data }
+  );
+  return response.data;
+}
+
+// src/modules/comments/addReaction.ts
+async function addReaction2(client, data) {
+  const { commentId, reactionType } = data;
+  const response = await client.projectInstance.post(
+    `/comments/${commentId}/reactions`,
+    { reactionType }
+  );
+  return response.data;
+}
+
+// src/modules/comments/removeReaction.ts
+async function removeReaction2(client, data) {
+  const { commentId } = data;
+  const response = await client.projectInstance.delete(
+    `/comments/${commentId}/reactions`
+  );
+  return response.data;
+}
+
+// src/modules/comments/fetchReactions.ts
+async function fetchReactions2(client, data) {
+  const { commentId, ...params } = data;
+  const response = await client.projectInstance.get(
+    `/comments/${commentId}/reactions`,
+    { params }
+  );
+  return response.data;
+}
+
+// src/modules/comments/getUserReaction.ts
+async function getUserReaction2(client, data) {
+  const { commentId } = data;
+  const response = await client.projectInstance.get(
+    `/comments/${commentId}/reactions/me`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/index.ts
+var spaces_exports = {};
+__export(spaces_exports, {
+  approveMembership: () => approveMembership,
+  banMember: () => banMember,
+  checkMyMembership: () => checkMyMembership,
+  checkSlugAvailability: () => checkSlugAvailability,
+  createRule: () => createRule,
+  createSpace: () => createSpace,
+  declineMembership: () => declineMembership,
+  deleteRule: () => deleteRule,
+  deleteSpace: () => deleteSpace,
+  fetchChildSpaces: () => fetchChildSpaces,
+  fetchDigestConfig: () => fetchDigestConfig,
+  fetchManyRules: () => fetchManyRules,
+  fetchManySpaces: () => fetchManySpaces,
+  fetchRule: () => fetchRule,
+  fetchSpace: () => fetchSpace,
+  fetchSpaceBreadcrumb: () => fetchSpaceBreadcrumb,
+  fetchSpaceByShortId: () => fetchSpaceByShortId,
+  fetchSpaceBySlug: () => fetchSpaceBySlug,
+  fetchSpaceMembers: () => fetchSpaceMembers,
+  fetchSpaceTeam: () => fetchSpaceTeam,
+  fetchUserSpaces: () => fetchUserSpaces,
+  getSpaceConversation: () => getSpaceConversation,
+  handleCommentReport: () => handleCommentReport,
+  handleEntityReport: () => handleEntityReport,
+  handleSpaceChatReport: () => handleSpaceChatReport,
+  joinSpace: () => joinSpace,
+  leaveSpace: () => leaveSpace,
+  moderateSpaceChatMessage: () => moderateSpaceChatMessage,
+  moderateSpaceComment: () => moderateSpaceComment,
+  moderateSpaceEntity: () => moderateSpaceEntity,
+  reorderRules: () => reorderRules,
+  unbanMember: () => unbanMember,
+  updateDigestConfig: () => updateDigestConfig,
+  updateMemberRole: () => updateMemberRole,
+  updateRule: () => updateRule,
+  updateSpace: () => updateSpace
+});
+
+// src/modules/spaces/createSpace.ts
+async function createSpace(client, data) {
+  const response = await client.projectInstance.post("/spaces", data);
+  return response.data;
+}
+
+// src/modules/spaces/fetchManySpaces.ts
+async function fetchManySpaces(client, data) {
+  const response = await client.projectInstance.get(
+    "/spaces",
+    { params: data }
+  );
+  return response.data;
+}
+
+// src/modules/spaces/fetchSpace.ts
+async function fetchSpace(client, data) {
+  const { spaceId } = data;
+  const response = await client.projectInstance.get(
+    `/spaces/${spaceId}`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/fetchSpaceByShortId.ts
+async function fetchSpaceByShortId(client, data) {
+  const response = await client.projectInstance.get(
+    "/spaces/by-short-id",
+    { params: data }
+  );
+  return response.data;
+}
+
+// src/modules/spaces/fetchSpaceBySlug.ts
+async function fetchSpaceBySlug(client, data) {
+  const response = await client.projectInstance.get(
+    "/spaces/by-slug",
+    { params: data }
+  );
+  return response.data;
+}
+
+// src/modules/spaces/fetchUserSpaces.ts
+async function fetchUserSpaces(client, data) {
+  const response = await client.projectInstance.get(
+    "/spaces/user-spaces",
+    { params: data }
+  );
+  return response.data;
+}
+
+// src/modules/spaces/checkSlugAvailability.ts
+async function checkSlugAvailability(client, data) {
+  const response = await client.projectInstance.get(
+    "/spaces/check-slug",
+    { params: data }
+  );
+  return response.data;
+}
+
+// src/modules/spaces/updateSpace.ts
+async function updateSpace(client, data) {
+  const { spaceId, ...body } = data;
+  const response = await client.projectInstance.patch(
+    `/spaces/${spaceId}`,
+    body
+  );
+  return response.data;
+}
+
+// src/modules/spaces/deleteSpace.ts
+async function deleteSpace(client, data) {
+  const { spaceId } = data;
+  const response = await client.projectInstance.delete(
+    `/spaces/${spaceId}`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/fetchChildSpaces.ts
+async function fetchChildSpaces(client, data) {
+  const { spaceId, ...params } = data;
+  const response = await client.projectInstance.get(
+    `/spaces/${spaceId}/children`,
+    { params }
+  );
+  return response.data;
+}
+
+// src/modules/spaces/fetchSpaceBreadcrumb.ts
+async function fetchSpaceBreadcrumb(client, data) {
+  const { spaceId } = data;
+  const response = await client.projectInstance.get(
+    `/spaces/${spaceId}/breadcrumb`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/joinSpace.ts
+async function joinSpace(client, data) {
+  const { spaceId } = data;
+  const response = await client.projectInstance.post(
+    `/spaces/${spaceId}/join`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/leaveSpace.ts
+async function leaveSpace(client, data) {
+  const { spaceId } = data;
+  const response = await client.projectInstance.delete(
+    `/spaces/${spaceId}/leave`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/checkMyMembership.ts
+async function checkMyMembership(client, data) {
+  const { spaceId } = data;
+  const response = await client.projectInstance.get(
+    `/spaces/${spaceId}/membership/me`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/fetchSpaceMembers.ts
+async function fetchSpaceMembers(client, data) {
+  const { spaceId, ...params } = data;
+  const response = await client.projectInstance.get(
+    `/spaces/${spaceId}/members`,
+    { params }
+  );
+  return response.data;
+}
+
+// src/modules/spaces/fetchSpaceTeam.ts
+async function fetchSpaceTeam(client, data) {
+  const { spaceId } = data;
+  const response = await client.projectInstance.get(
+    `/spaces/${spaceId}/team`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/updateMemberRole.ts
+async function updateMemberRole(client, data) {
+  const { spaceId, memberId, role } = data;
+  const response = await client.projectInstance.patch(
+    `/spaces/${spaceId}/members/${memberId}/role`,
+    { role }
+  );
+  return response.data;
+}
+
+// src/modules/spaces/approveMembership.ts
+async function approveMembership(client, data) {
+  const { spaceId, memberId } = data;
+  const response = await client.projectInstance.patch(
+    `/spaces/${spaceId}/members/${memberId}/approve`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/declineMembership.ts
+async function declineMembership(client, data) {
+  const { spaceId, memberId } = data;
+  const response = await client.projectInstance.patch(
+    `/spaces/${spaceId}/members/${memberId}/decline`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/banMember.ts
+async function banMember(client, data) {
+  const { spaceId, memberId } = data;
+  const response = await client.projectInstance.patch(
+    `/spaces/${spaceId}/members/${memberId}/ban`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/unbanMember.ts
+async function unbanMember(client, data) {
+  const { spaceId, memberId } = data;
+  const response = await client.projectInstance.patch(
+    `/spaces/${spaceId}/members/${memberId}/unban`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/fetchManyRules.ts
+async function fetchManyRules(client, data) {
+  const { spaceId } = data;
+  const response = await client.projectInstance.get(
+    `/spaces/${spaceId}/rules`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/fetchRule.ts
+async function fetchRule(client, data) {
+  const { spaceId, ruleId } = data;
+  const response = await client.projectInstance.get(
+    `/spaces/${spaceId}/rules/${ruleId}`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/createRule.ts
+async function createRule(client, data) {
+  const { spaceId, ...body } = data;
+  const response = await client.projectInstance.post(
+    `/spaces/${spaceId}/rules`,
+    body
+  );
+  return response.data;
+}
+
+// src/modules/spaces/updateRule.ts
+async function updateRule(client, data) {
+  const { spaceId, ruleId, ...body } = data;
+  const response = await client.projectInstance.patch(
+    `/spaces/${spaceId}/rules/${ruleId}`,
+    body
+  );
+  return response.data;
+}
+
+// src/modules/spaces/deleteRule.ts
+async function deleteRule(client, data) {
+  const { spaceId, ruleId } = data;
+  const response = await client.projectInstance.delete(
+    `/spaces/${spaceId}/rules/${ruleId}`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/reorderRules.ts
+async function reorderRules(client, data) {
+  const { spaceId, ruleIds } = data;
+  const response = await client.projectInstance.patch(
+    `/spaces/${spaceId}/rules/reorder`,
+    { ruleIds }
+  );
+  return response.data;
+}
+
+// src/modules/spaces/handleEntityReport.ts
+async function handleEntityReport(client, data) {
+  const { spaceId, reportId, ...body } = data;
+  const response = await client.projectInstance.patch(
+    `/spaces/${spaceId}/reports/entity/${reportId}`,
+    body
+  );
+  return response.data;
+}
+
+// src/modules/spaces/handleCommentReport.ts
+async function handleCommentReport(client, data) {
+  const { spaceId, reportId, ...body } = data;
+  const response = await client.projectInstance.patch(
+    `/spaces/${spaceId}/reports/comment/${reportId}`,
+    body
+  );
+  return response.data;
+}
+
+// src/modules/spaces/moderateSpaceEntity.ts
+async function moderateSpaceEntity(client, data) {
+  const { spaceId, entityId, ...body } = data;
+  const response = await client.projectInstance.patch(
+    `/spaces/${spaceId}/entities/${entityId}/moderation`,
+    body
+  );
+  return response.data;
+}
+
+// src/modules/spaces/moderateSpaceComment.ts
+async function moderateSpaceComment(client, data) {
+  const { spaceId, commentId, ...body } = data;
+  const response = await client.projectInstance.patch(
+    `/spaces/${spaceId}/comments/${commentId}/moderation`,
+    body
+  );
+  return response.data;
+}
+
+// src/modules/spaces/fetchDigestConfig.ts
+async function fetchDigestConfig(client, data) {
+  const { spaceId } = data;
+  const response = await client.projectInstance.get(
+    `/spaces/${spaceId}/digest-config`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/updateDigestConfig.ts
+async function updateDigestConfig(client, data) {
+  const { spaceId, ...body } = data;
+  const response = await client.projectInstance.patch(
+    `/spaces/${spaceId}/digest-config`,
+    body
+  );
+  return response.data;
+}
+
+// src/modules/spaces/getSpaceConversation.ts
+async function getSpaceConversation(client, data) {
+  const { spaceId } = data;
+  const response = await client.projectInstance.get(
+    `/spaces/${spaceId}/conversation`
+  );
+  return response.data;
+}
+
+// src/modules/spaces/moderateSpaceChatMessage.ts
+async function moderateSpaceChatMessage(client, data) {
+  const { spaceId, messageId, ...body } = data;
+  const response = await client.projectInstance.patch(
+    `/spaces/${spaceId}/chat/messages/${messageId}/moderation`,
+    body
+  );
+  return response.data;
+}
+
+// src/modules/spaces/handleSpaceChatReport.ts
+async function handleSpaceChatReport(client, data) {
+  const { spaceId, reportId, ...body } = data;
+  const response = await client.projectInstance.patch(
+    `/spaces/${spaceId}/chat/reports/${reportId}`,
+    body
+  );
+  return response.data;
+}
+
+// src/modules/collections/index.ts
+var collections_exports = {};
+__export(collections_exports, {
+  addEntityToCollection: () => addEntityToCollection,
+  createNewCollection: () => createNewCollection,
+  deleteCollection: () => deleteCollection,
+  fetchCollectionEntities: () => fetchCollectionEntities,
+  fetchRootCollection: () => fetchRootCollection,
+  fetchSubCollections: () => fetchSubCollections,
+  removeEntityFromCollection: () => removeEntityFromCollection,
+  updateCollection: () => updateCollection
+});
+
+// src/modules/collections/fetchRootCollection.ts
+async function fetchRootCollection(client) {
+  const response = await client.projectInstance.get(
+    "/collections/root"
+  );
+  return response.data;
+}
+
+// src/modules/collections/fetchSubCollections.ts
+async function fetchSubCollections(client, data) {
+  const { collectionId } = data;
+  const response = await client.projectInstance.get(
+    `/collections/${collectionId}/sub-collections`
+  );
+  return response.data;
+}
+
+// src/modules/collections/createNewCollection.ts
+async function createNewCollection(client, data) {
+  const { collectionId, ...body } = data;
+  const response = await client.projectInstance.post(
+    `/collections/${collectionId}/sub-collections`,
+    body
+  );
+  return response.data;
+}
+
+// src/modules/collections/fetchCollectionEntities.ts
+async function fetchCollectionEntities(client, data) {
+  const { collectionId, ...params } = data;
+  const response = await client.projectInstance.get(
+    `/collections/${collectionId}/entities`,
+    { params }
+  );
+  return response.data;
+}
+
+// src/modules/collections/addEntityToCollection.ts
+async function addEntityToCollection(client, data) {
+  const { collectionId, ...body } = data;
+  const response = await client.projectInstance.post(
+    `/collections/${collectionId}/entities`,
+    body
+  );
+  return response.data;
+}
+
+// src/modules/collections/removeEntityFromCollection.ts
+async function removeEntityFromCollection(client, data) {
+  const { collectionId, entityId } = data;
+  const response = await client.projectInstance.delete(
+    `/collections/${collectionId}/entities/${entityId}`
+  );
+  return response.data;
+}
+
+// src/modules/collections/updateCollection.ts
+async function updateCollection(client, data) {
+  const { collectionId, ...body } = data;
+  const response = await client.projectInstance.patch(
+    `/collections/${collectionId}`,
+    body
+  );
+  return response.data;
+}
+
+// src/modules/collections/deleteCollection.ts
+async function deleteCollection(client, data) {
+  const { collectionId } = data;
+  await client.projectInstance.delete(`/collections/${collectionId}`);
+}
+
+// src/modules/follows/index.ts
+var follows_exports = {};
+__export(follows_exports, {
+  deleteFollow: () => deleteFollow2,
+  fetchFollowers: () => fetchFollowers,
+  fetchFollowersCount: () => fetchFollowersCount,
+  fetchFollowing: () => fetchFollowing,
+  fetchFollowingCount: () => fetchFollowingCount
+});
+
+// src/modules/follows/fetchFollowing.ts
+async function fetchFollowing(client, data) {
+  const response = await client.projectInstance.get("/follows/following", { params: data });
+  return response.data;
+}
+
+// src/modules/follows/fetchFollowers.ts
+async function fetchFollowers(client, data) {
+  const response = await client.projectInstance.get("/follows/followers", { params: data });
+  return response.data;
+}
+
+// src/modules/follows/fetchFollowingCount.ts
+async function fetchFollowingCount(client) {
+  const response = await client.projectInstance.get(
+    "/follows/following-count"
+  );
+  return response.data;
+}
+
+// src/modules/follows/fetchFollowersCount.ts
+async function fetchFollowersCount(client) {
+  const response = await client.projectInstance.get(
+    "/follows/followers-count"
+  );
+  return response.data;
+}
+
+// src/modules/follows/deleteFollow.ts
+async function deleteFollow2(client, data) {
+  const { followId } = data;
+  await client.projectInstance.delete(`/follows/${followId}`);
+}
+
+// src/modules/connections/index.ts
+var connections_exports = {};
+__export(connections_exports, {
+  acceptConnection: () => acceptConnection,
+  declineConnection: () => declineConnection,
+  fetchConnections: () => fetchConnections,
+  fetchConnectionsCount: () => fetchConnectionsCount,
+  fetchReceivedPendingConnections: () => fetchReceivedPendingConnections,
+  fetchSentPendingConnections: () => fetchSentPendingConnections,
+  removeConnection: () => removeConnection
+});
+
+// src/modules/connections/fetchConnections.ts
+async function fetchConnections(client, data) {
+  const response = await client.projectInstance.get("/connections", { params: data });
+  return response.data;
+}
+
+// src/modules/connections/fetchConnectionsCount.ts
+async function fetchConnectionsCount(client) {
+  const response = await client.projectInstance.get(
+    "/connections/count"
+  );
+  return response.data;
+}
+
+// src/modules/connections/fetchSentPendingConnections.ts
+async function fetchSentPendingConnections(client, data) {
+  const response = await client.projectInstance.get(
+    "/connections/pending/sent",
+    { params: data }
+  );
+  return response.data;
+}
+
+// src/modules/connections/fetchReceivedPendingConnections.ts
+async function fetchReceivedPendingConnections(client, data) {
+  const response = await client.projectInstance.get(
+    "/connections/pending/received",
+    { params: data }
+  );
+  return response.data;
+}
+
+// src/modules/connections/acceptConnection.ts
+async function acceptConnection(client, data) {
+  const { connectionId } = data;
+  const response = await client.projectInstance.patch(
+    `/connections/${connectionId}/accept`,
+    {}
+  );
+  return response.data;
+}
+
+// src/modules/connections/declineConnection.ts
+async function declineConnection(client, data) {
+  const { connectionId } = data;
+  const response = await client.projectInstance.patch(
+    `/connections/${connectionId}/decline`,
+    {}
+  );
+  return response.data;
+}
+
+// src/modules/connections/removeConnection.ts
+async function removeConnection(client, data) {
+  const { connectionId } = data;
+  await client.projectInstance.delete(`/connections/${connectionId}`);
+}
+
+// src/modules/app-notifications/index.ts
+var app_notifications_exports = {};
+__export(app_notifications_exports, {
+  countUnreadNotifications: () => countUnreadNotifications,
+  fetchNotifications: () => fetchNotifications,
+  markAllNotificationsAsRead: () => markAllNotificationsAsRead,
+  markNotificationAsRead: () => markNotificationAsRead
+});
+
+// src/modules/app-notifications/fetchNotifications.ts
+async function fetchNotifications(client, data) {
+  const response = await client.projectInstance.get("/app-notifications", { params: data });
+  return response.data;
+}
+
+// src/modules/app-notifications/countUnreadNotifications.ts
+async function countUnreadNotifications(client) {
+  const response = await client.projectInstance.get(
+    "/app-notifications/count"
+  );
+  return response.data;
+}
+
+// src/modules/app-notifications/markNotificationAsRead.ts
+async function markNotificationAsRead(client, data) {
+  const { notificationId } = data;
+  await client.projectInstance.patch(
+    `/app-notifications/${notificationId}/mark-as-read`
+  );
+}
+
+// src/modules/app-notifications/markAllNotificationsAsRead.ts
+async function markAllNotificationsAsRead(client) {
+  const response = await client.projectInstance.patch(
+    "/app-notifications/mark-all-as-read"
+  );
+  return response.data;
+}
+
+// src/modules/reports/index.ts
+var reports_exports = {};
+__export(reports_exports, {
+  createReport: () => createReport,
+  fetchModeratedReports: () => fetchModeratedReports
+});
+
+// src/modules/reports/createReport.ts
+async function createReport(client, data) {
+  const response = await client.projectInstance.post(
+    "/reports",
+    data
+  );
+  return response.data;
+}
+
+// src/modules/reports/fetchModeratedReports.ts
+async function fetchModeratedReports(client, data) {
+  const response = await client.projectInstance.get(
+    "/reports/moderated",
+    { params: data }
+  );
+  return response.data;
+}
+
+// src/modules/search/index.ts
+var search_exports = {};
+__export(search_exports, {
+  askContent: () => askContent,
+  searchContent: () => searchContent,
+  searchSpaces: () => searchSpaces,
+  searchUsers: () => searchUsers
+});
+
+// src/modules/search/searchContent.ts
+async function searchContent(client, data) {
+  const response = await client.projectInstance.post(
+    "/search/content",
+    data
+  );
+  return response.data;
+}
+
+// src/modules/search/searchUsers.ts
+async function searchUsers(client, data) {
+  const response = await client.projectInstance.post(
+    "/search/users",
+    data
+  );
+  return response.data;
+}
+
+// src/modules/search/searchSpaces.ts
+async function searchSpaces(client, data) {
+  const response = await client.projectInstance.post(
+    "/search/spaces",
+    data
+  );
+  return response.data;
+}
+
+// src/modules/search/askContent.ts
+function parseSseBlock(block) {
+  let event = "message";
+  let data = "";
+  for (const line of block.split("\n")) {
+    if (line.startsWith("event:")) event = line.slice(6).trim();
+    else if (line.startsWith("data:")) data += line.slice(5).trim();
+  }
+  if (!event) return null;
+  let payload = void 0;
+  if (data) {
+    try {
+      payload = JSON.parse(data);
+    } catch {
+      payload = void 0;
+    }
+  }
+  switch (event) {
+    case "token":
+      return { type: "token", content: payload?.content ?? "" };
+    case "sources":
+      return {
+        type: "sources",
+        sources: Array.isArray(payload) ? payload : []
+      };
+    case "done":
+      return { type: "done" };
+    case "error":
+      return { type: "error", error: payload?.error ?? "Unknown error" };
+    default:
+      return null;
+  }
+}
+async function* askContent(client, data) {
+  const { signal, ...body } = data;
+  const baseURL = client.projectInstance.defaults.baseURL ?? "";
+  const authHeader = await client.getAuthHeader();
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (authHeader) headers.Authorization = authHeader;
+  const response = await fetch(`${baseURL}/search/ask`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal
+  });
+  if (!response.ok || !response.body) {
+    let message = `Request failed with status ${response.status}`;
+    try {
+      const json = await response.json();
+      message = json?.error ?? message;
+    } catch {
+    }
+    yield { type: "error", error: message };
+    return;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let boundary;
+      while ((boundary = buffer.indexOf("\n\n")) !== -1) {
+        const rawBlock = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        const event = parseSseBlock(rawBlock);
+        if (event) yield event;
+      }
+    }
+    const tail = buffer.trim();
+    if (tail) {
+      const event = parseSseBlock(tail);
+      if (event) yield event;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/modules/storage/index.ts
+var storage_exports = {};
+__export(storage_exports, {
+  deleteFile: () => deleteFile,
+  getFile: () => getFile,
+  uploadFile: () => uploadFile,
+  uploadImage: () => uploadImage
+});
+
+// src/modules/storage/uploadImage.ts
+async function uploadImage(client, data) {
+  const { file, filename, imageOptions, ...rest } = data;
+  const formData = new FormData();
+  appendFile(formData, "file", file, { filename });
+  appendFields(formData, { ...imageOptions, ...rest });
+  const response = await client.projectInstance.post(
+    "/storage/images",
+    formData
+  );
+  return response.data;
+}
+
+// src/modules/storage/uploadFile.ts
+async function uploadFile(client, data) {
+  const { file, filename, ...fields } = data;
+  const formData = new FormData();
+  appendFile(formData, "file", file, { filename });
+  appendFields(formData, fields);
+  const response = await client.projectInstance.post(
+    "/storage",
+    formData
+  );
+  return response.data;
+}
+
+// src/modules/storage/getFile.ts
+async function getFile(client, data) {
+  const { fileId } = data;
+  const response = await client.projectInstance.get(
+    `/storage/${fileId}`
+  );
+  return response.data;
+}
+
+// src/modules/storage/deleteFile.ts
+async function deleteFile(client, data) {
+  const { fileId } = data;
+  await client.projectInstance.delete(`/storage/${fileId}`);
+}
+
+// src/modules/oauth/index.ts
+var oauth_exports = {};
+__export(oauth_exports, {
+  authorize: () => authorize,
+  linkIdentity: () => linkIdentity,
+  listIdentities: () => listIdentities,
+  unlinkIdentity: () => unlinkIdentity
+});
+
+// src/modules/oauth/authorize.ts
+async function authorize(client, data) {
+  const response = await client.projectInstance.post(
+    "/oauth/authorize",
+    data
+  );
+  return response.data;
+}
+
+// src/modules/oauth/linkIdentity.ts
+async function linkIdentity(client, data) {
+  const response = await client.projectInstance.post(
+    "/oauth/link",
+    data
+  );
+  return response.data;
+}
+
+// src/modules/oauth/listIdentities.ts
+async function listIdentities(client) {
+  const response = await client.projectInstance.get(
+    "/oauth/identities"
+  );
+  return response.data;
+}
+
+// src/modules/oauth/unlinkIdentity.ts
+async function unlinkIdentity(client, data) {
+  const { identityId } = data;
+  const response = await client.projectInstance.delete(
+    `/oauth/identities/${identityId}`
+  );
+  return response.data;
+}
+
+// src/modules/chat/index.ts
+var chat_exports = {};
+__export(chat_exports, {
+  addMember: () => addMember,
+  changeMemberRole: () => changeMemberRole,
+  createDirectConversation: () => createDirectConversation,
+  createGroupConversation: () => createGroupConversation,
+  deleteConversation: () => deleteConversation,
+  deleteMessage: () => deleteMessage,
+  editMessage: () => editMessage,
+  getConversation: () => getConversation,
+  getMessage: () => getMessage,
+  getUnreadCount: () => getUnreadCount,
+  leaveConversation: () => leaveConversation,
+  listConversations: () => listConversations,
+  listMembers: () => listMembers,
+  listMessages: () => listMessages,
+  listReactions: () => listReactions,
+  markAsRead: () => markAsRead,
+  removeMember: () => removeMember,
+  reportMessage: () => reportMessage,
+  sendMessage: () => sendMessage,
+  toggleReaction: () => toggleReaction,
+  updateConversation: () => updateConversation
+});
+
+// src/modules/chat/listConversations.ts
+async function listConversations(client, data) {
+  const response = await client.projectInstance.get(
+    "/chat/conversations",
+    { params: data }
+  );
+  return response.data;
+}
+
+// src/modules/chat/createGroupConversation.ts
+async function createGroupConversation(client, data) {
+  const response = await client.projectInstance.post(
+    "/chat/conversations",
+    { type: "group", ...data }
+  );
+  return response.data;
+}
+
+// src/modules/chat/createDirectConversation.ts
+async function createDirectConversation(client, data) {
+  const response = await client.projectInstance.post(
+    "/chat/conversations/direct",
+    data
+  );
+  return response.data;
+}
+
+// src/modules/chat/getConversation.ts
+async function getConversation(client, data) {
+  const { conversationId } = data;
+  const response = await client.projectInstance.get(
+    `/chat/conversations/${conversationId}`
+  );
+  return response.data;
+}
+
+// src/modules/chat/updateConversation.ts
+async function updateConversation(client, data) {
+  const { conversationId, ...body } = data;
+  const response = await client.projectInstance.patch(
+    `/chat/conversations/${conversationId}`,
+    body
+  );
+  return response.data;
+}
+
+// src/modules/chat/deleteConversation.ts
+async function deleteConversation(client, data) {
+  const { conversationId } = data;
+  const response = await client.projectInstance.delete(
+    `/chat/conversations/${conversationId}`
+  );
+  return response.data;
+}
+
+// src/modules/chat/getUnreadCount.ts
+async function getUnreadCount(client) {
+  const response = await client.projectInstance.get(
+    "/chat/conversations/unread-count"
+  );
+  return response.data;
+}
+
+// src/modules/chat/listMembers.ts
+async function listMembers(client, data) {
+  const { conversationId, ...params } = data;
+  const response = await client.projectInstance.get(`/chat/conversations/${conversationId}/members`, { params });
+  return response.data;
+}
+
+// src/modules/chat/addMember.ts
+async function addMember(client, data) {
+  const { conversationId, userId } = data;
+  const response = await client.projectInstance.post(
+    `/chat/conversations/${conversationId}/members`,
+    { userId }
+  );
+  return response.data;
+}
+
+// src/modules/chat/removeMember.ts
+async function removeMember(client, data) {
+  const { conversationId, userId } = data;
+  const response = await client.projectInstance.delete(
+    `/chat/conversations/${conversationId}/members/${userId}`
+  );
+  return response.data;
+}
+
+// src/modules/chat/leaveConversation.ts
+async function leaveConversation(client, data) {
+  const { conversationId } = data;
+  const response = await client.projectInstance.delete(
+    `/chat/conversations/${conversationId}/leave`
+  );
+  return response.data;
+}
+
+// src/modules/chat/changeMemberRole.ts
+async function changeMemberRole(client, data) {
+  const { conversationId, userId, role } = data;
+  const response = await client.projectInstance.patch(
+    `/chat/conversations/${conversationId}/members/${userId}/role`,
+    { role }
+  );
+  return response.data;
+}
+
+// src/modules/chat/listMessages.ts
+async function listMessages(client, data) {
+  const { conversationId, ...params } = data;
+  const response = await client.projectInstance.get(
+    `/chat/conversations/${conversationId}/messages`,
+    { params }
+  );
+  return response.data;
+}
+
+// src/modules/chat/sendMessage.ts
+async function sendMessage(client, data) {
+  const { conversationId, files, ...body } = data;
+  const path = `/chat/conversations/${conversationId}/messages`;
+  if (files && files.length > 0) {
+    const formData = new FormData();
+    for (const file of files) {
+      appendFile(formData, "files", file, { fallback: "attachment" });
+    }
+    appendFields(formData, body);
+    const response2 = await client.projectInstance.post(
+      path,
+      formData
+    );
+    return response2.data;
+  }
+  const response = await client.projectInstance.post(path, body);
+  return response.data;
+}
+
+// src/modules/chat/getMessage.ts
+async function getMessage(client, data) {
+  const { conversationId, messageId } = data;
+  const response = await client.projectInstance.get(
+    `/chat/conversations/${conversationId}/messages/${messageId}`
+  );
+  return response.data;
+}
+
+// src/modules/chat/editMessage.ts
+async function editMessage(client, data) {
+  const { conversationId, messageId, ...body } = data;
+  const response = await client.projectInstance.patch(
+    `/chat/conversations/${conversationId}/messages/${messageId}`,
+    body
+  );
+  return response.data;
+}
+
+// src/modules/chat/deleteMessage.ts
+async function deleteMessage(client, data) {
+  const { conversationId, messageId } = data;
+  const response = await client.projectInstance.delete(
+    `/chat/conversations/${conversationId}/messages/${messageId}`
+  );
+  return response.data;
+}
+
+// src/modules/chat/toggleReaction.ts
+async function toggleReaction(client, data) {
+  const { conversationId, messageId, emoji } = data;
+  const response = await client.projectInstance.post(
+    `/chat/conversations/${conversationId}/messages/${messageId}/reactions`,
+    { emoji }
+  );
+  return response.data;
+}
+
+// src/modules/chat/listReactions.ts
+async function listReactions(client, data) {
+  const { conversationId, messageId, ...params } = data;
+  const response = await client.projectInstance.get(
+    `/chat/conversations/${conversationId}/messages/${messageId}/reactions`,
+    { params }
+  );
+  return response.data;
+}
+
+// src/modules/chat/markAsRead.ts
+async function markAsRead(client, data) {
+  const { conversationId, messageId } = data;
+  const response = await client.projectInstance.post(
+    `/chat/conversations/${conversationId}/read`,
+    { messageId }
+  );
+  return response.data;
+}
+
+// src/modules/chat/reportMessage.ts
+async function reportMessage(client, data) {
+  const { conversationId, messageId, ...body } = data;
+  const response = await client.projectInstance.post(
+    `/chat/conversations/${conversationId}/messages/${messageId}/report`,
+    body
+  );
   return response.data;
 }
 
 // src/index.ts
 var SublayClient = class _SublayClient {
   http;
+  auth;
   users;
   entities;
   comments;
+  spaces;
+  collections;
+  follows;
+  connections;
+  appNotifications;
+  reports;
+  search;
+  storage;
+  oauth;
+  chat;
   constructor(http) {
     this.http = http;
+    this.auth = bindModule(auth_exports, this.http);
     this.users = bindModule(users_exports, this.http);
     this.entities = bindModule(entities_exports, this.http);
     this.comments = bindModule(comments_exports, this.http);
+    this.spaces = bindModule(spaces_exports, this.http);
+    this.collections = bindModule(collections_exports, this.http);
+    this.follows = bindModule(follows_exports, this.http);
+    this.connections = bindModule(connections_exports, this.http);
+    this.appNotifications = bindModule(app_notifications_exports, this.http);
+    this.reports = bindModule(reports_exports, this.http);
+    this.search = bindModule(search_exports, this.http);
+    this.storage = bindModule(storage_exports, this.http);
+    this.oauth = bindModule(oauth_exports, this.http);
+    this.chat = bindModule(chat_exports, this.http);
   }
   static async init(config) {
     const http = new SublayHttpClient(config);
     return new _SublayClient(http);
   }
+  /** Imperatively set the session tokens (SDK-managed mode). */
+  setTokens(tokens) {
+    this.http.setTokens(tokens);
+  }
+  /** Imperatively clear the session tokens, e.g. on logout (SDK-managed mode). */
+  clearTokens() {
+    this.http.clearTokens();
+  }
 };
 function bindModule(module, client) {
   const bound = {};