@moonbase.sh/storefront-api 0.2.38 → 0.2.39

package/dist/index.cjs

@@ -49,44 +49,6 @@ module.exports = __toCommonJS(src_exports);
 // src/activationRequests/endpoints.ts
 var import_zod5 = require("zod");
 
-// src/utils/errors.ts
-var NotAuthorizedError = class extends Error {
-  constructor() {
-    super();
-    this.name = "NotAuthorizedError";
-    this.message = "Not allowed";
-  }
-};
-var NotAuthenticatedError = class extends Error {
-  constructor() {
-    super();
-    this.name = "NotAuthenticatedError";
-    this.message = "Not authenticated";
-  }
-};
-var NotFoundError = class extends Error {
-  constructor(message) {
-    super();
-    this.name = "NotFoundError";
-    this.message = message != null ? message : "Not found";
-  }
-};
-var MoonbaseError = class extends Error {
-  constructor(title, detail, status, errors) {
-    super();
-    this.title = title;
-    this.detail = detail;
-    this.status = status;
-    this.errors = errors;
-    this.name = "MoonbaseError";
-    if (errors && Object.values(errors).length === 1) {
-      this.message = Object.values(errors)[0];
-    } else {
-      this.message = detail != null ? detail : title;
-    }
-  }
-};
-
 // src/activationRequests/schemas.ts
 var import_zod4 = require("zod");
 
@@ -241,52 +203,73 @@ var ActivationRequestEndpoints = class {
     this.api = api;
   }
   async get(requestId) {
-    const response = await this.api.fetch(`/api/customer/activations/${requestId}`);
-    try {
-      return activationRequestSchema.parse(response.data);
-    } catch (err) {
-      console.warn("Could not fetch activation request", { requestId, response, err });
-      throw new MoonbaseError("Bad response", "Activation request could not be fetched", response.status);
-    }
+    const response = await this.api.fetch(`/api/customer/activations/${requestId}`, activationRequestSchema);
+    return response.data;
   }
   async isCompleted(requestId) {
-    const response = await this.api.fetch(`/api/customer/activations/${requestId}/completed`);
+    const response = await this.api.fetch(`/api/customer/activations/${requestId}/completed`, import_zod5.z.boolean());
     return import_zod5.z.boolean().parse(response.data);
   }
   async fulfillLicense(requestId) {
-    const response = await this.api.authenticatedFetch(`/api/customer/activations/${requestId}/license`, "POST");
-    try {
-      return activationRequestSchema.parse(response.data);
-    } catch (err) {
-      console.warn("Could not fulfill license", { requestId, response, err });
-      throw new MoonbaseError("Bad response", "Activation request could not be fulfilled", response.status);
-    }
+    const response = await this.api.authenticatedFetch(`/api/customer/activations/${requestId}/license`, activationRequestSchema, { method: "POST" });
+    return response.data;
   }
   async fulfillTrial(requestId) {
-    const response = await this.api.fetch(`/api/customer/activations/${requestId}/trial`, "POST");
-    try {
-      return activationRequestSchema.parse(response.data);
-    } catch (err) {
-      console.warn("Could not fulfill trial", { requestId, response, err });
-      throw new MoonbaseError("Bad response", "Activation request could not be fulfilled", response.status);
-    }
+    const response = await this.api.fetch(`/api/customer/activations/${requestId}/trial`, activationRequestSchema, { method: "POST" });
+    return response.data;
   }
   async cancel(requestId) {
-    const response = await this.api.fetch(`/api/customer/activations/${requestId}/cancel`, "POST");
-    try {
-      return activationRequestSchema.parse(response.data);
-    } catch (err) {
-      console.warn("Could not cancel activation request", { requestId, response, err });
-      throw new MoonbaseError("Bad response", "Activation request could not be cancelled", response.status);
-    }
+    const response = await this.api.fetch(`/api/customer/activations/${requestId}/cancel`, activationRequestSchema, { method: "POST" });
+    return response.data;
   }
 };
 
 // src/identity/endpoints.ts
 var import_cross_fetch = __toESM(require("cross-fetch"), 1);
+var import_zod8 = require("zod");
 
 // src/utils/problemHandler.ts
 var import_zod6 = require("zod");
+
+// src/utils/errors.ts
+var NotAuthorizedError = class extends Error {
+  constructor() {
+    super();
+    this.name = "NotAuthorizedError";
+    this.message = "Not allowed";
+  }
+};
+var NotAuthenticatedError = class extends Error {
+  constructor() {
+    super();
+    this.name = "NotAuthenticatedError";
+    this.message = "Not authenticated";
+  }
+};
+var NotFoundError = class extends Error {
+  constructor(message) {
+    super();
+    this.name = "NotFoundError";
+    this.message = message != null ? message : "Not found";
+  }
+};
+var MoonbaseError = class extends Error {
+  constructor(title, detail, status, errors) {
+    super();
+    this.title = title;
+    this.detail = detail;
+    this.status = status;
+    this.errors = errors;
+    this.name = "MoonbaseError";
+    if (errors && Object.values(errors).length === 1) {
+      this.message = Object.values(errors)[0];
+    } else {
+      this.message = detail != null ? detail : title;
+    }
+  }
+};
+
+// src/utils/problemHandler.ts
 var problemDetailsSchema = import_zod6.z.object({
   type: import_zod6.z.string(),
   title: import_zod6.z.string(),
@@ -366,13 +349,8 @@ var IdentityEndpoints = class {
     this.tokenStore = tokenStore;
   }
   async get() {
-    const response = await this.api.authenticatedFetch("/api/customer/meta/user");
-    try {
-      return userSchema.parse(response.data);
-    } catch (err) {
-      console.warn("Could not fetch user", { response, err });
-      throw new MoonbaseError("Bad response", "Could not fetch user", response.status);
-    }
+    const response = await this.api.authenticatedFetch("/api/customer/meta/user", userSchema);
+    return response.data;
   }
   async signIn(email, password) {
     const response = await (0, import_cross_fetch.default)(`${this.api.baseUrl}/api/customer/identity/sign-in?email=${email}&scheme=JWT`, {
@@ -399,42 +377,45 @@ var IdentityEndpoints = class {
     }
   }
   async signUp(name, email, password, address, acceptedPrivacyPolicy, acceptedTermsAndConditions, communicationOptIn) {
-    const response = await this.api.fetch(`/api/customer/identity/sign-up?scheme=JWT&communicationOptIn=${communicationOptIn ? "true" : "false"}`, "POST", {
-      name,
-      email,
-      password,
-      address,
-      acceptedPrivacyPolicy,
-      acceptedTermsAndConditions
+    const response = await this.api.fetch(`/api/customer/identity/sign-up?scheme=JWT&communicationOptIn=${communicationOptIn ? "true" : "false"}`, identityUserSchema, {
+      method: "POST",
+      body: {
+        name,
+        email,
+        password,
+        address,
+        acceptedPrivacyPolicy,
+        acceptedTermsAndConditions
+      }
     });
-    try {
-      const user = identityUserSchema.parse(response.data);
-      this.tokenStore.setUser(user);
-      return user;
-    } catch (err) {
-      console.warn("Could not sign up user", { email, response, err });
-      throw new MoonbaseError("Bad response", "Could not sign up user", response.status);
-    }
+    this.tokenStore.setUser(response.data);
+    return response.data;
   }
   async update(name, email, emailConfirmationToken, communicationPreferences) {
-    const response = await this.api.authenticatedFetch("/api/customer/identity", "PATCH", {
-      name,
-      email,
-      emailConfirmationToken,
-      communicationPreferences
+    const response = await this.api.authenticatedFetch("/api/customer/identity", import_zod8.z.null(), {
+      method: "PATCH",
+      body: {
+        name,
+        email,
+        emailConfirmationToken,
+        communicationPreferences
+      }
     });
     return {
       needsEmailConfirmationToken: response.status === 201
     };
   }
   async setPassword(currentPassword, newPassword) {
-    await this.api.authenticatedFetch(`/api/customer/identity/set-password`, "POST", {
-      currentPassword,
-      newPassword
+    await this.api.authenticatedFetch(`/api/customer/identity/set-password`, import_zod8.z.null(), {
+      method: "POST",
+      body: {
+        currentPassword,
+        newPassword
+      }
     });
   }
   async forgotPassword(email) {
-    await this.api.fetch(`/api/customer/identity/forgot-password?email=${encodeURIComponent(email)}`, "POST");
+    await this.api.fetch(`/api/customer/identity/forgot-password?email=${encodeURIComponent(email)}`, import_zod8.z.null(), { method: "POST" });
   }
   async resetPassword(email, newPassword, code) {
     const response = await (0, import_cross_fetch.default)(`${this.api.baseUrl}/api/customer/identity/reset-password?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code.replaceAll(" ", "+"))}`, {
@@ -450,7 +431,7 @@ var IdentityEndpoints = class {
       await handleResponseProblem(response);
   }
   async confirmAccount(email, code) {
-    const response = await this.api.fetch(`/api/customer/identity/confirm-account?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code.replaceAll(" ", "+"))}`, "POST");
+    const response = await this.api.fetch(`/api/customer/identity/confirm-account?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code.replaceAll(" ", "+"))}`, userAccountConfirmedSchema, { method: "POST" });
     try {
       return userAccountConfirmedSchema.parse(response.data);
     } catch (err) {
@@ -459,10 +440,10 @@ var IdentityEndpoints = class {
     }
   }
   async confirmEmail(email, code) {
-    await this.api.fetch(`/api/customer/identity/confirm-email?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code.replaceAll(" ", "+"))}`, "POST");
+    await this.api.fetch(`/api/customer/identity/confirm-email?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code.replaceAll(" ", "+"))}`, import_zod8.z.null(), { method: "POST" });
   }
   async confirmEmailChange(email, code) {
-    await this.api.authenticatedFetch(`/api/customer/identity/confirm-email-change?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code.replaceAll(" ", "+"))}`, "POST");
+    await this.api.authenticatedFetch(`/api/customer/identity/confirm-email-change?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code.replaceAll(" ", "+"))}`, import_zod8.z.null(), { method: "POST" });
   }
 };
 
@@ -476,7 +457,7 @@ __export(schemas_exports, {
   openProductLineItem: () => openProductLineItem,
   orderSchema: () => orderSchema
 });
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 
 // src/orders/models.ts
 var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
@@ -488,90 +469,90 @@ var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
 })(OrderStatus || {});
 
 // src/orders/schemas.ts
-var couponSchema = import_zod8.z.object({
-  code: import_zod8.z.string(),
-  name: import_zod8.z.string(),
-  description: import_zod8.z.string()
+var couponSchema = import_zod9.z.object({
+  code: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  description: import_zod9.z.string()
 });
-var lineItemProductSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  name: import_zod8.z.string(),
-  tagline: import_zod8.z.string(),
-  iconUrl: import_zod8.z.string().nullable()
+var lineItemProductSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  tagline: import_zod9.z.string(),
+  iconUrl: import_zod9.z.string().nullable()
 });
-var openProductLineItem = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  type: import_zod8.z.literal("Product"),
-  productId: import_zod8.z.string(),
-  quantity: import_zod8.z.number(),
-  variationId: import_zod8.z.string(),
+var openProductLineItem = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  type: import_zod9.z.literal("Product"),
+  productId: import_zod9.z.string(),
+  quantity: import_zod9.z.number(),
+  variationId: import_zod9.z.string(),
   price: priceCollectionSchema.optional(),
   variation: pricingVariationSchema.optional(),
   product: lineItemProductSchema.optional(),
   appliedDiscount: discountSchema.optional()
 });
-var lineItemBundleSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  name: import_zod8.z.string(),
-  tagline: import_zod8.z.string(),
-  iconUrl: import_zod8.z.string().nullable(),
-  partial: import_zod8.z.boolean(),
-  products: lineItemProductSchema.and(import_zod8.z.object({
-    included: import_zod8.z.boolean().optional()
+var lineItemBundleSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  tagline: import_zod9.z.string(),
+  iconUrl: import_zod9.z.string().nullable(),
+  partial: import_zod9.z.boolean(),
+  products: lineItemProductSchema.and(import_zod9.z.object({
+    included: import_zod9.z.boolean().optional()
   })).array()
 });
-var openBundleLineItem = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  type: import_zod8.z.literal("Bundle"),
-  bundleId: import_zod8.z.string(),
-  quantity: import_zod8.z.number(),
-  variationId: import_zod8.z.string(),
+var openBundleLineItem = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  type: import_zod9.z.literal("Bundle"),
+  bundleId: import_zod9.z.string(),
+  quantity: import_zod9.z.number(),
+  variationId: import_zod9.z.string(),
   price: priceCollectionSchema.optional(),
   variation: pricingVariationSchema.optional(),
   bundle: lineItemBundleSchema.optional(),
   appliedDiscount: discountSchema.optional()
 });
-var openOrderLineItem = import_zod8.z.discriminatedUnion("type", [
+var openOrderLineItem = import_zod9.z.discriminatedUnion("type", [
   openProductLineItem,
   openBundleLineItem
 ]);
-var openOrderSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  status: import_zod8.z.literal("Open" /* Open */),
-  currency: import_zod8.z.string(),
+var openOrderSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  status: import_zod9.z.literal("Open" /* Open */),
+  currency: import_zod9.z.string(),
   items: openOrderLineItem.array(),
   couponsApplied: couponSchema.array(),
-  checkoutUrl: import_zod8.z.string().optional(),
-  embeddedCheckoutUrl: import_zod8.z.string().optional()
+  checkoutUrl: import_zod9.z.string().optional(),
+  embeddedCheckoutUrl: import_zod9.z.string().optional()
 });
-var moneySchema = import_zod8.z.object({
-  currency: import_zod8.z.string(),
-  amount: import_zod8.z.number()
+var moneySchema = import_zod9.z.object({
+  currency: import_zod9.z.string(),
+  amount: import_zod9.z.number()
 });
-var orderTotalSchema = import_zod8.z.object({
+var orderTotalSchema = import_zod9.z.object({
   original: moneySchema,
   discount: moneySchema,
   subtotal: moneySchema,
   taxes: moneySchema,
   due: moneySchema
 });
-var customerSnapshotSchema = import_zod8.z.object({
-  name: import_zod8.z.string().nullable(),
-  businessName: import_zod8.z.string().nullable(),
-  taxId: import_zod8.z.string().nullable(),
-  email: import_zod8.z.string().nullable(),
+var customerSnapshotSchema = import_zod9.z.object({
+  name: import_zod9.z.string().nullable(),
+  businessName: import_zod9.z.string().nullable(),
+  taxId: import_zod9.z.string().nullable(),
+  email: import_zod9.z.string().nullable(),
   address: addressSchema.nullable()
 });
-var completedOrderSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  status: import_zod8.z.literal("Completed" /* Completed */),
-  currency: import_zod8.z.string(),
+var completedOrderSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  status: import_zod9.z.literal("Completed" /* Completed */),
+  currency: import_zod9.z.string(),
   customer: customerSnapshotSchema,
   total: orderTotalSchema,
   items: openOrderLineItem.array(),
   couponsApplied: couponSchema.array()
 });
-var orderSchema = import_zod8.z.discriminatedUnion("status", [
+var orderSchema = import_zod9.z.discriminatedUnion("status", [
   openOrderSchema,
   completedOrderSchema
 ]);
@@ -582,8 +563,8 @@ var OrderEndpoints = class {
     this.api = api;
   }
   async get(orderId) {
-    const response = await this.api.fetch(`/api/customer/orders/${orderId}`);
-    return orderSchema.parse(response.data);
+    const response = await this.api.fetch(`/api/customer/orders/${orderId}`, orderSchema);
+    return response.data;
   }
   async pushContent(order, checkout, utm) {
     const query = {
@@ -595,18 +576,16 @@ var OrderEndpoints = class {
     }
     const response = await this.api.fetch(
       `/api/customer/orders/${order.id}?${new URLSearchParams(query).toString()}`,
-      "PATCH",
+      openOrderSchema,
       {
-        currency: order.currency || void 0,
-        items: order.items
+        method: "PATCH",
+        body: {
+          currency: order.currency || void 0,
+          items: order.items
+        }
       }
     );
-    try {
-      return openOrderSchema.parse(response.data);
-    } catch (err) {
-      console.warn("Could not fetch order", { orderId: order.id, checkout, response, err });
-      throw new MoonbaseError("Bad response", "Could not fetch order", response.status);
-    }
+    return response.data;
   }
 };
 
@@ -632,33 +611,30 @@ var StorefrontEndpoints = class {
   }
   async get(utm) {
     const query = new URLSearchParams(utmToObject(utm));
-    const response = await this.api.fetch(`/api/customer/storefront?${query.toString()}`);
-    try {
-      return storefrontSchema.parse(response.data);
-    } catch (err) {
-      console.warn("Could not fetch storefront", { response, err });
-      throw new MoonbaseError("Bad response", "Could not fetch storefront", response.status);
-    }
+    const response = await this.api.fetch(`/api/customer/storefront?${query.toString()}`, storefrontSchema);
+    return response.data;
   }
 };
 
 // src/utils/api.ts
 var import_cross_fetch2 = __toESM(require("cross-fetch"), 1);
+var import_zod10 = require("zod");
 var MoonbaseApi = class {
   constructor(baseUrl, tokenStore) {
     this.baseUrl = baseUrl;
     this.tokenStore = tokenStore;
   }
-  async authenticatedFetch(path, method, body, contentType) {
+  async authenticatedFetch(path, schema, options) {
     if (!this.tokenStore.hasAccessToken)
       throw new NotAuthenticatedError();
-    return await this.fetch(path, method, body, contentType);
+    return await this.fetch(path, schema, options);
   }
-  async fetch(path, method, body, contentType) {
+  async fetch(path, schema, options) {
+    var _a;
     const accessToken = await this.tokenStore.getAccessToken();
-    contentType != null ? contentType : contentType = "application/json";
+    const contentType = (_a = options == null ? void 0 : options.contentType) != null ? _a : "application/json";
     const response = await (0, import_cross_fetch2.default)(this.baseUrl + path, {
-      method: method || "GET",
+      method: (options == null ? void 0 : options.method) || "GET",
       mode: "cors",
       headers: {
         "Accept": "application/json",
@@ -668,15 +644,13 @@ var MoonbaseApi = class {
         // Force CORS on all calls
         "x-mb-cors": "1"
       },
-      body: body ? contentType !== "application/json" ? body : JSON.stringify(body) : void 0
+      body: (options == null ? void 0 : options.body) ? contentType !== "application/json" ? options.body : JSON.stringify(options.body) : void 0
     });
     if (response.status >= 400)
       await handleResponseProblem(response);
     try {
-      const contentLength = Number(response.headers.get("Content-Length")) || 0;
-      const data = contentLength > 0 ? await response.json() : null;
       return {
-        data,
+        data: schema instanceof import_zod10.ZodNull ? null : schema.parse(await response.json()),
         headers: Object.fromEntries(response.headers.entries()),
         status: response.status
       };
@@ -684,8 +658,7 @@ var MoonbaseApi = class {
       console.warn("Could not parse response", {
         status: response.status,
         content: await response.text(),
-        contentType: response.headers.get("Content-Type"),
-        contentLength: response.headers.get("Content-Length"),
+        headers: Object.fromEntries(response.headers.entries()),
         userAgent: window && window.navigator && window.navigator.userAgent,
         err
       });
@@ -800,13 +773,13 @@ _TokenStore.storageKey = "moonbase_auth";
 var TokenStore = _TokenStore;
 
 // src/vouchers/schemas.ts
-var import_zod9 = require("zod");
-var voucherSchema = import_zod9.z.object({
-  id: import_zod9.z.string(),
-  name: import_zod9.z.string(),
-  description: import_zod9.z.string(),
-  code: import_zod9.z.string(),
-  redeemed: import_zod9.z.boolean(),
+var import_zod11 = require("zod");
+var voucherSchema = import_zod11.z.object({
+  id: import_zod11.z.string(),
+  name: import_zod11.z.string(),
+  description: import_zod11.z.string(),
+  code: import_zod11.z.string(),
+  redeemed: import_zod11.z.boolean(),
   redeemsProducts: quantifiable(storefrontProductSchema).array(),
   redeemsBundles: quantifiable(storefrontBundleSchema).array()
 });
@@ -817,28 +790,26 @@ var VoucherEndpoints = class {
     this.api = api;
   }
   async peek(code) {
-    const response = await this.api.fetch(`/api/customer/vouchers?code=${encodeURIComponent(code)}`);
-    return voucherSchema.parse(response.data);
+    const response = await this.api.fetch(`/api/customer/vouchers?code=${encodeURIComponent(code)}`, voucherSchema);
+    return response.data;
   }
   async redeem(code) {
     const response = await this.api.authenticatedFetch(
       `/api/customer/vouchers/redeem?code=${encodeURIComponent(code)}`,
-      "POST"
+      voucherSchema,
+      {
+        method: "POST"
+      }
     );
-    try {
-      return voucherSchema.parse(response.data);
-    } catch (err) {
-      console.warn("Could not redeem voucher", { response, err });
-      throw new MoonbaseError("Bad response", "Could not redeem voucher", response.status);
-    }
+    return response.data;
   }
 };
 
 // src/inventory/activation/endpoints.ts
-var import_zod11 = require("zod");
+var import_zod13 = require("zod");
 
 // src/inventory/licenses/schemas.ts
-var import_zod10 = require("zod");
+var import_zod12 = require("zod");
 
 // src/inventory/licenses/models.ts
 var LicenseStatus = /* @__PURE__ */ ((LicenseStatus2) => {
@@ -858,21 +829,21 @@ var ActivationMethod = /* @__PURE__ */ ((ActivationMethod2) => {
 })(ActivationMethod || {});
 
 // src/inventory/licenses/schemas.ts
-var licenseSchema = import_zod10.z.object({
-  id: import_zod10.z.string(),
-  status: import_zod10.z.nativeEnum(LicenseStatus),
+var licenseSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  status: import_zod12.z.nativeEnum(LicenseStatus),
   product: productSummarySchema,
-  activeNumberOfActivations: import_zod10.z.number(),
-  maxNumberOfActivations: import_zod10.z.number(),
-  createdAt: import_zod10.z.coerce.date()
+  activeNumberOfActivations: import_zod12.z.number(),
+  maxNumberOfActivations: import_zod12.z.number(),
+  createdAt: import_zod12.z.coerce.date()
 });
-var activationSchema = import_zod10.z.object({
-  id: import_zod10.z.string(),
-  licenseId: import_zod10.z.string(),
-  name: import_zod10.z.string(),
-  status: import_zod10.z.nativeEnum(ActivationStatus),
-  activationMethod: import_zod10.z.nativeEnum(ActivationMethod),
-  lastValidatedAt: import_zod10.z.coerce.date().nullable()
+var activationSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  licenseId: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  status: import_zod12.z.nativeEnum(ActivationStatus),
+  activationMethod: import_zod12.z.nativeEnum(ActivationMethod),
+  lastValidatedAt: import_zod12.z.coerce.date().nullable()
 });
 
 // src/inventory/activation/endpoints.ts
@@ -881,99 +852,69 @@ var ActivationEndpoints = class {
     this.api = api;
   }
   async activate(deviceToken, activationMethod) {
-    const response = await this.api.authenticatedFetch(`/api/customer/inventory/activate?method=${activationMethod}`, "POST", deviceToken, "text/plain");
-    try {
-      return {
-        license: licenseSchema.parse(response.data),
-        url: import_zod11.z.string().parse(response.headers.location)
-      };
-    } catch (err) {
-      console.warn("Could not activate product", { deviceToken, activationMethod, response, err });
-      throw new MoonbaseError("Bad response", "Product could not be activated", response.status);
-    }
+    const response = await this.api.authenticatedFetch(`/api/customer/inventory/activate?method=${activationMethod}`, licenseSchema, {
+      method: "POST",
+      body: deviceToken,
+      contentType: "text/plain"
+    });
+    return {
+      license: response.data,
+      url: import_zod13.z.string().parse(response.headers.location)
+    };
   }
 };
 
 // src/inventory/licenses/endpoints.ts
+var import_zod14 = require("zod");
 var LicenseEndpoints = class {
   constructor(api) {
     this.api = api;
   }
   async get(nextUrl) {
-    const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/inventory/licenses");
-    try {
-      return paged(licenseSchema).parse(response.data);
-    } catch (err) {
-      console.warn("Could not fetch licenses", { nextUrl, response, err });
-      throw new MoonbaseError("Bad response", "Licenses could not be fetched", response.status);
-    }
+    const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/inventory/licenses", paged(licenseSchema));
+    return response.data;
   }
   async getActivations(licenseId, nextUrl) {
     const response = await this.api.authenticatedFetch(
-      nextUrl || `/api/customer/inventory/licenses/${licenseId}/activations`
+      nextUrl || `/api/customer/inventory/licenses/${licenseId}/activations`,
+      paged(activationSchema)
     );
-    try {
-      return paged(activationSchema).parse(response.data);
-    } catch (err) {
-      console.warn("Could not fetch license activations", { nextUrl, response, err });
-      throw new MoonbaseError("Bad response", "License activations could not be fetched", response.status);
-    }
+    return response.data;
   }
   async revokeActivation(licenseId, activationId) {
-    await this.api.authenticatedFetch(`/api/customer/inventory/licenses/${licenseId}/activations/${activationId}/revoke`, "POST");
+    await this.api.authenticatedFetch(`/api/customer/inventory/licenses/${licenseId}/activations/${activationId}/revoke`, import_zod14.z.null(), { method: "POST" });
   }
 };
 
 // src/inventory/products/endpoints.ts
-var import_zod12 = require("zod");
+var import_zod15 = require("zod");
 var ProductEndpoints = class {
   constructor(api) {
     this.api = api;
   }
   async get(productId, version) {
-    const response = await this.api.fetch(`/api/customer/inventory/products/${productId}${version ? `?version=${version}` : ""}`);
-    try {
-      return productSummarySchema.parse(response.data);
-    } catch (err) {
-      console.warn("Could not fetch product", { productId, version, response, err });
-      throw new MoonbaseError("Bad response", "Product could not be fetched", response.status);
-    }
+    const response = await this.api.fetch(`/api/customer/inventory/products/${productId}${version ? `?version=${version}` : ""}`, productSummarySchema);
+    return response.data;
   }
   async getOwned(nextUrl) {
-    const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/inventory/products");
-    try {
-      return paged(productSummarySchema).parse(response.data);
-    } catch (err) {
-      console.warn("Could not fetch products", { nextUrl, response, err });
-      throw new MoonbaseError("Bad response", "Products could not be fetched", response.status);
-    }
+    const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/inventory/products", paged(productSummarySchema));
+    return response.data;
   }
   async getLicenses(productId, nextUrl) {
-    const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/inventory/products/${productId}/licenses`);
-    try {
-      return paged(licenseSchema).parse(response.data);
-    } catch (err) {
-      console.warn("Could not fetch product licenses", { productId, nextUrl, response, err });
-      throw new MoonbaseError("Bad response", "Product licenses could not be fetched", response.status);
-    }
+    const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/inventory/products/${productId}/licenses`, paged(licenseSchema));
+    return response.data;
   }
   async getActivations(productId, nextUrl) {
-    const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/inventory/products/${productId}/licenses/activations`);
-    try {
-      return paged(activationSchema).parse(response.data);
-    } catch (err) {
-      console.warn("Could not fetch product activations", { productId, nextUrl, response, err });
-      throw new MoonbaseError("Bad response", "Product activations could not be fetched", response.status);
-    }
+    const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/inventory/products/${productId}/licenses/activations`, paged(activationSchema));
+    return response.data;
   }
   async getDownloadUrl(path) {
     const url = new URL(path);
     url.searchParams.append("redirect", "false");
-    const response = await this.api.fetch(url.pathname + url.search);
-    const content = import_zod12.z.object({
-      location: import_zod12.z.string()
-    }).parse(response.data);
-    return content.location;
+    const response = await this.api.fetch(url.pathname + url.search, import_zod15.z.object({
+      location: import_zod15.z.string()
+    }));
+    return response.data.location;
   }
 };