mezon-js 2.13.74 → 2.13.75

package/api.gen.ts

@@ -3621,19 +3621,21 @@ export class MezonApi {
       fetchOptions.headers["Authorization"] =
         "Basic " + encode(basicAuthUsername + ":" + basicAuthPassword);
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
 
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then(async (response) => {
         if (response.status == 204) {
-          return response;
+          return {} as ApiSession;
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = await response.arrayBuffer();      
+          return tsproto.Session.decode(new Uint8Array(buffer)) as unknown as ApiSession;
         } else {
           throw response;
         }
       }),
-      new Promise((_, reject) =>
-        setTimeout(reject, this.timeoutMs, "Request timed out.")
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       ),
     ]);
   }
@@ -3816,19 +3818,21 @@ export class MezonApi {
     if (basicAuthUsername) {
       fetchOptions.headers["Authorization"] = "Basic " + encode(basicAuthUsername + ":" + basicAuthPassword);
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
 
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then(async (response) => {
         if (response.status == 204) {
-          return response;
+          return {} as ApiSession;
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = await response.arrayBuffer();      
+          return tsproto.Session.decode(new Uint8Array(buffer)) as unknown as ApiSession;
         } else {
           throw response;
         }
       }),
-      new Promise((_, reject) =>
-        setTimeout(reject, this.timeoutMs, "Request timed out.")
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       ),
     ]);
   }
@@ -3861,19 +3865,21 @@ export class MezonApi {
 		if (basicAuthUsername) {
 			fetchOptions.headers["Authorization"] = "Basic " + encode(basicAuthUsername + ":" + basicAuthPassword);
 		}
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
 
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then(async (response) => {
         if (response.status == 204) {
-          return response;
+          return {} as ApiSession;
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = await response.arrayBuffer();      
+          return tsproto.Session.decode(new Uint8Array(buffer)) as unknown as ApiSession;
         } else {
           throw response;
         }
       }),
-      new Promise((_, reject) =>
-        setTimeout(reject, this.timeoutMs, "Request timed out.")
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       ),
     ]);
   }
@@ -3972,19 +3978,21 @@ export class MezonApi {
     if (bearerToken) {
         fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
 
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then(async (response) => {
         if (response.status == 204) {
-          return response;
+          return {} as ApiSession;
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = await response.arrayBuffer();      
+          return tsproto.Session.decode(new Uint8Array(buffer)) as unknown as ApiSession;
         } else {
           throw response;
         }
       }),
-      new Promise((_, reject) =>
-        setTimeout(reject, this.timeoutMs, "Request timed out.")
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       ),
     ]);
   }
@@ -4010,19 +4018,21 @@ export class MezonApi {
     if (basicAuthUsername) {
       fetchOptions.headers["Authorization"] = "Basic " + encode(basicAuthUsername + ":" + basicAuthPassword);
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
 
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then(async(response) => {
         if (response.status == 204) {
-          return response;
+          return {} as ApiSession;
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = await response.arrayBuffer();      
+          return tsproto.Session.decode(new Uint8Array(buffer)) as unknown as ApiSession;
         } else {
           throw response;
         }
       }),
-      new Promise((_, reject) =>
-        setTimeout(reject, this.timeoutMs, "Request timed out.")
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       ),
     ]);
   }
@@ -4049,19 +4059,21 @@ export class MezonApi {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
 
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then(async (response) => {
         if (response.status == 204) {
-          return response;
+          return {} as ApiSession;
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = await response.arrayBuffer();      
+          return tsproto.Session.decode(new Uint8Array(buffer)) as unknown as ApiSession;
         } else {
           throw response;
         }
       }),
-      new Promise((_, reject) =>
-        setTimeout(reject, this.timeoutMs, "Request timed out.")
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       ),
     ]);
   }
@@ -11636,19 +11648,21 @@ export class MezonApi {
     if (bearerToken) {
         fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
 
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then(async (response) => {
         if (response.status == 204) {
-          return response;
+          return {} as ApiSession;
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = await response.arrayBuffer();      
+          return tsproto.Session.decode(new Uint8Array(buffer)) as unknown as ApiSession;
         } else {
           throw response;
         }
       }),
-      new Promise((_, reject) =>
-        setTimeout(reject, this.timeoutMs, "Request timed out.")
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       ),
     ]);
   }

package/dist/mezon-js.cjs.js

@@ -15193,18 +15193,20 @@ var MezonApi = class {
     if (basicAuthUsername) {
       fetchOptions.headers["Authorization"] = "Basic " + encode(basicAuthUsername + ":" + basicAuthPassword);
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Session.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -15342,18 +15344,20 @@ var MezonApi = class {
     if (basicAuthUsername) {
       fetchOptions.headers["Authorization"] = "Basic " + encode(basicAuthUsername + ":" + basicAuthPassword);
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Session.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -15374,18 +15378,20 @@ var MezonApi = class {
     if (basicAuthUsername) {
       fetchOptions.headers["Authorization"] = "Basic " + encode(basicAuthUsername + ":" + basicAuthPassword);
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Session.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -15463,18 +15469,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Session.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -15492,18 +15500,20 @@ var MezonApi = class {
     if (basicAuthUsername) {
       fetchOptions.headers["Authorization"] = "Basic " + encode(basicAuthUsername + ":" + basicAuthPassword);
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Session.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -15523,18 +15533,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Session.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -21467,18 +21479,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Session.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }

package/dist/mezon-js.esm.mjs

@@ -15168,18 +15168,20 @@ var MezonApi = class {
     if (basicAuthUsername) {
       fetchOptions.headers["Authorization"] = "Basic " + encode(basicAuthUsername + ":" + basicAuthPassword);
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Session.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -15317,18 +15319,20 @@ var MezonApi = class {
     if (basicAuthUsername) {
       fetchOptions.headers["Authorization"] = "Basic " + encode(basicAuthUsername + ":" + basicAuthPassword);
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Session.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -15349,18 +15353,20 @@ var MezonApi = class {
     if (basicAuthUsername) {
       fetchOptions.headers["Authorization"] = "Basic " + encode(basicAuthUsername + ":" + basicAuthPassword);
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Session.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -15438,18 +15444,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Session.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -15467,18 +15475,20 @@ var MezonApi = class {
     if (basicAuthUsername) {
       fetchOptions.headers["Authorization"] = "Basic " + encode(basicAuthUsername + ":" + basicAuthPassword);
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Session.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -15498,18 +15508,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Session.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }
@@ -21442,18 +21454,20 @@ var MezonApi = class {
     if (bearerToken) {
       fetchOptions.headers["Authorization"] = "Bearer " + bearerToken;
     }
+    fetchOptions.headers["Accept"] = "application/x-protobuf";
     return Promise.race([
-      fetch(fullUrl, fetchOptions).then((response) => {
+      fetch(fullUrl, fetchOptions).then((response) => __async(this, null, function* () {
         if (response.status == 204) {
-          return response;
+          return {};
         } else if (response.status >= 200 && response.status < 300) {
-          return response.json();
+          const buffer = yield response.arrayBuffer();
+          return Session.decode(new Uint8Array(buffer));
         } else {
           throw response;
         }
-      }),
+      })),
       new Promise(
-        (_, reject) => setTimeout(reject, this.timeoutMs, "Request timed out.")
+        (_, reject) => setTimeout(() => reject(new Error("Request timed out.")), this.timeoutMs)
       )
     ]);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mezon-js",
-  "version": "2.13.74",
+  "version": "2.13.75",
   "scripts": {
     "build": "npx tsc && npx rollup -c --bundleConfigAsCjs && node build.mjs"
   },