mezon-js 2.9.58 → 2.9.61

package/dist/mezon-js.cjs.js

@@ -2110,6 +2110,36 @@ var MezonApi = class {
     ]);
   }
   /**  */
+  listAuditLog(bearerToken, actionLog, userId, clanId, page, pageSize, options = {}) {
+    const urlPath = "/v2/audit_log";
+    const queryParams = /* @__PURE__ */ new Map();
+    queryParams.set("action_log", actionLog);
+    queryParams.set("user_id", userId);
+    queryParams.set("clan_id", clanId);
+    queryParams.set("page", page);
+    queryParams.set("page_size", pageSize);
+    let bodyJson = "";
+    const fullUrl = this.buildFullUrl(this.basePath, urlPath, queryParams);
+    const fetchOptions = buildFetchOptions("GET", options, bodyJson);
+    if (bearerToken) {
+      fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
+    }
+    return Promise.race([
+      fetch(fullUrl, fetchOptions).then((response) => {
+        if (response.status == 204) {
+          return response;
+        } else if (response.status >= 200 && response.status < 300) {
+          return response.json();
+        } else {
+          throw response;
+        }
+      }),
+      new Promise(
+        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+      )
+    ]);
+  }
+  /**  */
   updateCategoryOrder(bearerToken, body, options = {}) {
     if (body === null || body === void 0) {
       throw new Error(
@@ -2428,6 +2458,67 @@ var MezonApi = class {
       )
     ]);
   }
+  /** get channel encryption method */
+  getChanEncryptionMethod(bearerToken, channelId, method, options = {}) {
+    if (channelId === null || channelId === void 0) {
+      throw new Error("'channelId' is a required parameter but is null or undefined.");
+    }
+    const urlPath = "/v2/channel/{channelId}/encrypt_method".replace("{channelId}", encodeURIComponent(String(channelId)));
+    const queryParams = /* @__PURE__ */ new Map();
+    queryParams.set("method", method);
+    let bodyJson = "";
+    const fullUrl = this.buildFullUrl(this.basePath, urlPath, queryParams);
+    const fetchOptions = buildFetchOptions("GET", options, bodyJson);
+    if (bearerToken) {
+      fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
+    }
+    return Promise.race([
+      fetch(fullUrl, fetchOptions).then((response) => {
+        if (response.status == 204) {
+          return response;
+        } else if (response.status >= 200 && response.status < 300) {
+          return response.json();
+        } else {
+          throw response;
+        }
+      }),
+      new Promise(
+        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+      )
+    ]);
+  }
+  /** store channel encryption method */
+  setChanEncryptionMethod(bearerToken, channelId, body, options = {}) {
+    if (channelId === null || channelId === void 0) {
+      throw new Error("'channelId' is a required parameter but is null or undefined.");
+    }
+    if (body === null || body === void 0) {
+      throw new Error("'body' is a required parameter but is null or undefined.");
+    }
+    const urlPath = "/v2/channel/{channelId}/encrypt_method".replace("{channelId}", encodeURIComponent(String(channelId)));
+    const queryParams = /* @__PURE__ */ new Map();
+    let bodyJson = "";
+    bodyJson = JSON.stringify(body || {});
+    const fullUrl = this.buildFullUrl(this.basePath, urlPath, queryParams);
+    const fetchOptions = buildFetchOptions("POST", options, bodyJson);
+    if (bearerToken) {
+      fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
+    }
+    return Promise.race([
+      fetch(fullUrl, fetchOptions).then((response) => {
+        if (response.status == 204) {
+          return response;
+        } else if (response.status >= 200 && response.status < 300) {
+          return response.json();
+        } else {
+          throw response;
+        }
+      }),
+      new Promise(
+        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+      )
+    ]);
+  }
   /** Leave a channel the user is a member of. */
   leaveThread(bearerToken, channelId, options = {}) {
     if (channelId === null || channelId === void 0) {
@@ -3969,6 +4060,31 @@ var MezonApi = class {
       )
     ]);
   }
+  /** get key server */
+  getKeyServer(bearerToken, options = {}) {
+    const urlPath = "/v2/e2ee/key_server";
+    const queryParams = /* @__PURE__ */ new Map();
+    let bodyJson = "";
+    const fullUrl = this.buildFullUrl(this.basePath, urlPath, queryParams);
+    const fetchOptions = buildFetchOptions("GET", options, bodyJson);
+    if (bearerToken) {
+      fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
+    }
+    return Promise.race([
+      fetch(fullUrl, fetchOptions).then((response) => {
+        if (response.status == 204) {
+          return response;
+        } else if (response.status >= 200 && response.status < 300) {
+          return response.json();
+        } else {
+          throw response;
+        }
+      }),
+      new Promise(
+        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+      )
+    ]);
+  }
   /** List HashtagDMList */
   hashtagDMList(bearerToken, userId, limit, options = {}) {
     const urlPath = "/v2/hashtagdmlist";
@@ -4663,6 +4779,61 @@ var MezonApi = class {
       )
     ]);
   }
+  /** get pubkey */
+  getPubKeys(bearerToken, userIds, options = {}) {
+    const urlPath = "/v2/pubkey";
+    const queryParams = /* @__PURE__ */ new Map();
+    queryParams.set("user_ids", userIds);
+    let bodyJson = "";
+    const fullUrl = this.buildFullUrl(this.basePath, urlPath, queryParams);
+    const fetchOptions = buildFetchOptions("GET", options, bodyJson);
+    if (bearerToken) {
+      fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
+    }
+    return Promise.race([
+      fetch(fullUrl, fetchOptions).then((response) => {
+        if (response.status == 204) {
+          return response;
+        } else if (response.status >= 200 && response.status < 300) {
+          return response.json();
+        } else {
+          throw response;
+        }
+      }),
+      new Promise(
+        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+      )
+    ]);
+  }
+  /** store pubkey for e2ee */
+  pushPubKey(bearerToken, body, options = {}) {
+    if (body === null || body === void 0) {
+      throw new Error("'body' is a required parameter but is null or undefined.");
+    }
+    const urlPath = "/v2/pubkey/push";
+    const queryParams = /* @__PURE__ */ new Map();
+    let bodyJson = "";
+    bodyJson = JSON.stringify(body || {});
+    const fullUrl = this.buildFullUrl(this.basePath, urlPath, queryParams);
+    const fetchOptions = buildFetchOptions("POST", options, bodyJson);
+    if (bearerToken) {
+      fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
+    }
+    return Promise.race([
+      fetch(fullUrl, fetchOptions).then((response) => {
+        if (response.status == 204) {
+          return response;
+        } else if (response.status >= 200 && response.status < 300) {
+          return response.json();
+        } else {
+          throw response;
+        }
+      }),
+      new Promise(
+        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+      )
+    ]);
+  }
   /**  */
   addRolesChannelDesc(bearerToken, body, options = {}) {
     if (body === null || body === void 0) {
@@ -6378,10 +6549,12 @@ var _DefaultSocket = class _DefaultSocket {
           this.onstreamingchanneljoined(message.streaming_joined_event);
         } else if (message.streaming_leaved_event) {
           this.onstreamingchannelleaved(message.streaming_leaved_event);
-        } else if (message.set_permission_channel_event) {
-          this.onsetpermissionchannel(message.set_permission_channel_event);
-        } else if (message.event_user_permission_channel) {
-          this.onuserpermissionchannel(message.event_user_permission_channel);
+        } else if (message.permission_set_event) {
+          this.onpermissionset(message.permission_set_event);
+        } else if (message.permission_changed_event) {
+          this.onpermissionchanged(message.permission_changed_event);
+        } else if (message.token_sent_event) {
+          this.ontokensent(message.token_sent_event);
         } else {
           if (this.verbose && window && window.console) {
             console.log("Unrecognized message received: %o", message);
@@ -6639,14 +6812,19 @@ var _DefaultSocket = class _DefaultSocket {
       console.log(streaming_leaved_event);
     }
   }
-  onsetpermissionchannel(set_permission_channel_event) {
+  onpermissionset(permission_set_event) {
+    if (this.verbose && window && window.console) {
+      console.log(permission_set_event);
+    }
+  }
+  onpermissionchanged(permission_changed_event) {
     if (this.verbose && window && window.console) {
-      console.log(set_permission_channel_event);
+      console.log(permission_changed_event);
     }
   }
-  onuserpermissionchannel(event_user_permission_channel) {
+  ontokensent(tokenSentEvent) {
     if (this.verbose && window && window.console) {
-      console.log(event_user_permission_channel);
+      console.log(tokenSentEvent);
     }
   }
   send(message, sendTimeout = _DefaultSocket.DefaultSendTimeoutMs) {
@@ -6800,6 +6978,12 @@ var _DefaultSocket = class _DefaultSocket {
       return response.check_name_existed_event;
     });
   }
+  sendToken(receiver_id, amount) {
+    return __async(this, null, function* () {
+      const response = yield this.send({ token_sent_event: { receiver_id, amount } });
+      return response.token_sent_event;
+    });
+  }
   pingPong() {
     return __async(this, null, function* () {
       if (!this.adapter.isOpen()) {
@@ -9106,4 +9290,64 @@ var Client = class {
       });
     });
   }
+  getChanEncryptionMethod(session, channelId) {
+    return __async(this, null, function* () {
+      if (this.autoRefreshSession && session.refresh_token && session.isexpired((Date.now() + this.expiredTimespanMs) / 1e3)) {
+        yield this.sessionRefresh(session);
+      }
+      return this.apiClient.getChanEncryptionMethod(session.token, channelId).then((response) => {
+        return response;
+      });
+    });
+  }
+  setChanEncryptionMethod(session, channelId, method) {
+    return __async(this, null, function* () {
+      if (this.autoRefreshSession && session.refresh_token && session.isexpired((Date.now() + this.expiredTimespanMs) / 1e3)) {
+        yield this.sessionRefresh(session);
+      }
+      return this.apiClient.setChanEncryptionMethod(session.token, channelId, { method }).then((response) => {
+        return response;
+      });
+    });
+  }
+  getPubKeys(session, userIds) {
+    return __async(this, null, function* () {
+      if (this.autoRefreshSession && session.refresh_token && session.isexpired((Date.now() + this.expiredTimespanMs) / 1e3)) {
+        yield this.sessionRefresh(session);
+      }
+      return this.apiClient.getPubKeys(session.token, userIds).then((response) => {
+        return response;
+      });
+    });
+  }
+  pushPubKey(session, PK) {
+    return __async(this, null, function* () {
+      if (this.autoRefreshSession && session.refresh_token && session.isexpired((Date.now() + this.expiredTimespanMs) / 1e3)) {
+        yield this.sessionRefresh(session);
+      }
+      return this.apiClient.pushPubKey(session.token, { PK }).then((response) => {
+        return response;
+      });
+    });
+  }
+  getKeyServer(session) {
+    return __async(this, null, function* () {
+      if (this.autoRefreshSession && session.refresh_token && session.isexpired((Date.now() + this.expiredTimespanMs) / 1e3)) {
+        yield this.sessionRefresh(session);
+      }
+      return this.apiClient.getKeyServer(session.token).then((response) => {
+        return response;
+      });
+    });
+  }
+  listAuditLog(session) {
+    return __async(this, null, function* () {
+      if (this.autoRefreshSession && session.refresh_token && session.isexpired((Date.now() + this.expiredTimespanMs) / 1e3)) {
+        yield this.sessionRefresh(session);
+      }
+      return this.apiClient.listAuditLog(session.token).then((response) => {
+        return response;
+      });
+    });
+  }
 };

package/dist/mezon-js.esm.mjs

@@ -2081,6 +2081,36 @@ var MezonApi = class {
     ]);
   }
   /**  */
+  listAuditLog(bearerToken, actionLog, userId, clanId, page, pageSize, options = {}) {
+    const urlPath = "/v2/audit_log";
+    const queryParams = /* @__PURE__ */ new Map();
+    queryParams.set("action_log", actionLog);
+    queryParams.set("user_id", userId);
+    queryParams.set("clan_id", clanId);
+    queryParams.set("page", page);
+    queryParams.set("page_size", pageSize);
+    let bodyJson = "";
+    const fullUrl = this.buildFullUrl(this.basePath, urlPath, queryParams);
+    const fetchOptions = buildFetchOptions("GET", options, bodyJson);
+    if (bearerToken) {
+      fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
+    }
+    return Promise.race([
+      fetch(fullUrl, fetchOptions).then((response) => {
+        if (response.status == 204) {
+          return response;
+        } else if (response.status >= 200 && response.status < 300) {
+          return response.json();
+        } else {
+          throw response;
+        }
+      }),
+      new Promise(
+        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+      )
+    ]);
+  }
+  /**  */
   updateCategoryOrder(bearerToken, body, options = {}) {
     if (body === null || body === void 0) {
       throw new Error(
@@ -2399,6 +2429,67 @@ var MezonApi = class {
       )
     ]);
   }
+  /** get channel encryption method */
+  getChanEncryptionMethod(bearerToken, channelId, method, options = {}) {
+    if (channelId === null || channelId === void 0) {
+      throw new Error("'channelId' is a required parameter but is null or undefined.");
+    }
+    const urlPath = "/v2/channel/{channelId}/encrypt_method".replace("{channelId}", encodeURIComponent(String(channelId)));
+    const queryParams = /* @__PURE__ */ new Map();
+    queryParams.set("method", method);
+    let bodyJson = "";
+    const fullUrl = this.buildFullUrl(this.basePath, urlPath, queryParams);
+    const fetchOptions = buildFetchOptions("GET", options, bodyJson);
+    if (bearerToken) {
+      fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
+    }
+    return Promise.race([
+      fetch(fullUrl, fetchOptions).then((response) => {
+        if (response.status == 204) {
+          return response;
+        } else if (response.status >= 200 && response.status < 300) {
+          return response.json();
+        } else {
+          throw response;
+        }
+      }),
+      new Promise(
+        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+      )
+    ]);
+  }
+  /** store channel encryption method */
+  setChanEncryptionMethod(bearerToken, channelId, body, options = {}) {
+    if (channelId === null || channelId === void 0) {
+      throw new Error("'channelId' is a required parameter but is null or undefined.");
+    }
+    if (body === null || body === void 0) {
+      throw new Error("'body' is a required parameter but is null or undefined.");
+    }
+    const urlPath = "/v2/channel/{channelId}/encrypt_method".replace("{channelId}", encodeURIComponent(String(channelId)));
+    const queryParams = /* @__PURE__ */ new Map();
+    let bodyJson = "";
+    bodyJson = JSON.stringify(body || {});
+    const fullUrl = this.buildFullUrl(this.basePath, urlPath, queryParams);
+    const fetchOptions = buildFetchOptions("POST", options, bodyJson);
+    if (bearerToken) {
+      fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
+    }
+    return Promise.race([
+      fetch(fullUrl, fetchOptions).then((response) => {
+        if (response.status == 204) {
+          return response;
+        } else if (response.status >= 200 && response.status < 300) {
+          return response.json();
+        } else {
+          throw response;
+        }
+      }),
+      new Promise(
+        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+      )
+    ]);
+  }
   /** Leave a channel the user is a member of. */
   leaveThread(bearerToken, channelId, options = {}) {
     if (channelId === null || channelId === void 0) {
@@ -3940,6 +4031,31 @@ var MezonApi = class {
       )
     ]);
   }
+  /** get key server */
+  getKeyServer(bearerToken, options = {}) {
+    const urlPath = "/v2/e2ee/key_server";
+    const queryParams = /* @__PURE__ */ new Map();
+    let bodyJson = "";
+    const fullUrl = this.buildFullUrl(this.basePath, urlPath, queryParams);
+    const fetchOptions = buildFetchOptions("GET", options, bodyJson);
+    if (bearerToken) {
+      fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
+    }
+    return Promise.race([
+      fetch(fullUrl, fetchOptions).then((response) => {
+        if (response.status == 204) {
+          return response;
+        } else if (response.status >= 200 && response.status < 300) {
+          return response.json();
+        } else {
+          throw response;
+        }
+      }),
+      new Promise(
+        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+      )
+    ]);
+  }
   /** List HashtagDMList */
   hashtagDMList(bearerToken, userId, limit, options = {}) {
     const urlPath = "/v2/hashtagdmlist";
@@ -4634,6 +4750,61 @@ var MezonApi = class {
       )
     ]);
   }
+  /** get pubkey */
+  getPubKeys(bearerToken, userIds, options = {}) {
+    const urlPath = "/v2/pubkey";
+    const queryParams = /* @__PURE__ */ new Map();
+    queryParams.set("user_ids", userIds);
+    let bodyJson = "";
+    const fullUrl = this.buildFullUrl(this.basePath, urlPath, queryParams);
+    const fetchOptions = buildFetchOptions("GET", options, bodyJson);
+    if (bearerToken) {
+      fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
+    }
+    return Promise.race([
+      fetch(fullUrl, fetchOptions).then((response) => {
+        if (response.status == 204) {
+          return response;
+        } else if (response.status >= 200 && response.status < 300) {
+          return response.json();
+        } else {
+          throw response;
+        }
+      }),
+      new Promise(
+        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+      )
+    ]);
+  }
+  /** store pubkey for e2ee */
+  pushPubKey(bearerToken, body, options = {}) {
+    if (body === null || body === void 0) {
+      throw new Error("'body' is a required parameter but is null or undefined.");
+    }
+    const urlPath = "/v2/pubkey/push";
+    const queryParams = /* @__PURE__ */ new Map();
+    let bodyJson = "";
+    bodyJson = JSON.stringify(body || {});
+    const fullUrl = this.buildFullUrl(this.basePath, urlPath, queryParams);
+    const fetchOptions = buildFetchOptions("POST", options, bodyJson);
+    if (bearerToken) {
+      fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
+    }
+    return Promise.race([
+      fetch(fullUrl, fetchOptions).then((response) => {
+        if (response.status == 204) {
+          return response;
+        } else if (response.status >= 200 && response.status < 300) {
+          return response.json();
+        } else {
+          throw response;
+        }
+      }),
+      new Promise(
+        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+      )
+    ]);
+  }
   /**  */
   addRolesChannelDesc(bearerToken, body, options = {}) {
     if (body === null || body === void 0) {
@@ -6349,10 +6520,12 @@ var _DefaultSocket = class _DefaultSocket {
           this.onstreamingchanneljoined(message.streaming_joined_event);
         } else if (message.streaming_leaved_event) {
           this.onstreamingchannelleaved(message.streaming_leaved_event);
-        } else if (message.set_permission_channel_event) {
-          this.onsetpermissionchannel(message.set_permission_channel_event);
-        } else if (message.event_user_permission_channel) {
-          this.onuserpermissionchannel(message.event_user_permission_channel);
+        } else if (message.permission_set_event) {
+          this.onpermissionset(message.permission_set_event);
+        } else if (message.permission_changed_event) {
+          this.onpermissionchanged(message.permission_changed_event);
+        } else if (message.token_sent_event) {
+          this.ontokensent(message.token_sent_event);
         } else {
           if (this.verbose && window && window.console) {
             console.log("Unrecognized message received: %o", message);
@@ -6610,14 +6783,19 @@ var _DefaultSocket = class _DefaultSocket {
       console.log(streaming_leaved_event);
     }
   }
-  onsetpermissionchannel(set_permission_channel_event) {
+  onpermissionset(permission_set_event) {
+    if (this.verbose && window && window.console) {
+      console.log(permission_set_event);
+    }
+  }
+  onpermissionchanged(permission_changed_event) {
     if (this.verbose && window && window.console) {
-      console.log(set_permission_channel_event);
+      console.log(permission_changed_event);
     }
   }
-  onuserpermissionchannel(event_user_permission_channel) {
+  ontokensent(tokenSentEvent) {
     if (this.verbose && window && window.console) {
-      console.log(event_user_permission_channel);
+      console.log(tokenSentEvent);
     }
   }
   send(message, sendTimeout = _DefaultSocket.DefaultSendTimeoutMs) {
@@ -6771,6 +6949,12 @@ var _DefaultSocket = class _DefaultSocket {
       return response.check_name_existed_event;
     });
   }
+  sendToken(receiver_id, amount) {
+    return __async(this, null, function* () {
+      const response = yield this.send({ token_sent_event: { receiver_id, amount } });
+      return response.token_sent_event;
+    });
+  }
   pingPong() {
     return __async(this, null, function* () {
       if (!this.adapter.isOpen()) {
@@ -9077,6 +9261,66 @@ var Client = class {
       });
     });
   }
+  getChanEncryptionMethod(session, channelId) {
+    return __async(this, null, function* () {
+      if (this.autoRefreshSession && session.refresh_token && session.isexpired((Date.now() + this.expiredTimespanMs) / 1e3)) {
+        yield this.sessionRefresh(session);
+      }
+      return this.apiClient.getChanEncryptionMethod(session.token, channelId).then((response) => {
+        return response;
+      });
+    });
+  }
+  setChanEncryptionMethod(session, channelId, method) {
+    return __async(this, null, function* () {
+      if (this.autoRefreshSession && session.refresh_token && session.isexpired((Date.now() + this.expiredTimespanMs) / 1e3)) {
+        yield this.sessionRefresh(session);
+      }
+      return this.apiClient.setChanEncryptionMethod(session.token, channelId, { method }).then((response) => {
+        return response;
+      });
+    });
+  }
+  getPubKeys(session, userIds) {
+    return __async(this, null, function* () {
+      if (this.autoRefreshSession && session.refresh_token && session.isexpired((Date.now() + this.expiredTimespanMs) / 1e3)) {
+        yield this.sessionRefresh(session);
+      }
+      return this.apiClient.getPubKeys(session.token, userIds).then((response) => {
+        return response;
+      });
+    });
+  }
+  pushPubKey(session, PK) {
+    return __async(this, null, function* () {
+      if (this.autoRefreshSession && session.refresh_token && session.isexpired((Date.now() + this.expiredTimespanMs) / 1e3)) {
+        yield this.sessionRefresh(session);
+      }
+      return this.apiClient.pushPubKey(session.token, { PK }).then((response) => {
+        return response;
+      });
+    });
+  }
+  getKeyServer(session) {
+    return __async(this, null, function* () {
+      if (this.autoRefreshSession && session.refresh_token && session.isexpired((Date.now() + this.expiredTimespanMs) / 1e3)) {
+        yield this.sessionRefresh(session);
+      }
+      return this.apiClient.getKeyServer(session.token).then((response) => {
+        return response;
+      });
+    });
+  }
+  listAuditLog(session) {
+    return __async(this, null, function* () {
+      if (this.autoRefreshSession && session.refresh_token && session.isexpired((Date.now() + this.expiredTimespanMs) / 1e3)) {
+        yield this.sessionRefresh(session);
+      }
+      return this.apiClient.listAuditLog(session.token).then((response) => {
+        return response;
+      });
+    });
+  }
 };
 export {
   ChannelStreamMode,