@moonbase.sh/storefront-api 0.2.36 → 0.2.39

package/dist/index.js

@@ -7,44 +7,6 @@ var __export = (target, all) => {
 // src/activationRequests/endpoints.ts
 import { z as z5 } from "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
 import { z as z4 } from "zod";
 
@@ -199,52 +161,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`, z5.boolean());
     return z5.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
 import fetch from "cross-fetch";
+import { z as z8 } from "zod";
 
 // src/utils/problemHandler.ts
 import { z as z6 } from "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 = z6.object({
   type: z6.string(),
   title: z6.string(),
@@ -324,13 +307,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 fetch(`${this.api.baseUrl}/api/customer/identity/sign-in?email=${email}&scheme=JWT`, {
@@ -357,42 +335,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", z8.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`, z8.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)}`, z8.null(), { method: "POST" });
   }
   async resetPassword(email, newPassword, code) {
     const response = await fetch(`${this.api.baseUrl}/api/customer/identity/reset-password?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code.replaceAll(" ", "+"))}`, {
@@ -408,7 +389,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) {
@@ -417,10 +398,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(" ", "+"))}`, z8.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(" ", "+"))}`, z8.null(), { method: "POST" });
   }
 };
 
@@ -434,7 +415,7 @@ __export(schemas_exports, {
   openProductLineItem: () => openProductLineItem,
   orderSchema: () => orderSchema
 });
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/orders/models.ts
 var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
@@ -446,90 +427,90 @@ var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
 })(OrderStatus || {});
 
 // src/orders/schemas.ts
-var couponSchema = z8.object({
-  code: z8.string(),
-  name: z8.string(),
-  description: z8.string()
+var couponSchema = z9.object({
+  code: z9.string(),
+  name: z9.string(),
+  description: z9.string()
 });
-var lineItemProductSchema = z8.object({
-  id: z8.string(),
-  name: z8.string(),
-  tagline: z8.string(),
-  iconUrl: z8.string().nullable()
+var lineItemProductSchema = z9.object({
+  id: z9.string(),
+  name: z9.string(),
+  tagline: z9.string(),
+  iconUrl: z9.string().nullable()
 });
-var openProductLineItem = z8.object({
-  id: z8.string(),
-  type: z8.literal("Product"),
-  productId: z8.string(),
-  quantity: z8.number(),
-  variationId: z8.string(),
+var openProductLineItem = z9.object({
+  id: z9.string(),
+  type: z9.literal("Product"),
+  productId: z9.string(),
+  quantity: z9.number(),
+  variationId: z9.string(),
   price: priceCollectionSchema.optional(),
   variation: pricingVariationSchema.optional(),
   product: lineItemProductSchema.optional(),
   appliedDiscount: discountSchema.optional()
 });
-var lineItemBundleSchema = z8.object({
-  id: z8.string(),
-  name: z8.string(),
-  tagline: z8.string(),
-  iconUrl: z8.string().nullable(),
-  partial: z8.boolean(),
-  products: lineItemProductSchema.and(z8.object({
-    included: z8.boolean().optional()
+var lineItemBundleSchema = z9.object({
+  id: z9.string(),
+  name: z9.string(),
+  tagline: z9.string(),
+  iconUrl: z9.string().nullable(),
+  partial: z9.boolean(),
+  products: lineItemProductSchema.and(z9.object({
+    included: z9.boolean().optional()
   })).array()
 });
-var openBundleLineItem = z8.object({
-  id: z8.string(),
-  type: z8.literal("Bundle"),
-  bundleId: z8.string(),
-  quantity: z8.number(),
-  variationId: z8.string(),
+var openBundleLineItem = z9.object({
+  id: z9.string(),
+  type: z9.literal("Bundle"),
+  bundleId: z9.string(),
+  quantity: z9.number(),
+  variationId: z9.string(),
   price: priceCollectionSchema.optional(),
   variation: pricingVariationSchema.optional(),
   bundle: lineItemBundleSchema.optional(),
   appliedDiscount: discountSchema.optional()
 });
-var openOrderLineItem = z8.discriminatedUnion("type", [
+var openOrderLineItem = z9.discriminatedUnion("type", [
   openProductLineItem,
   openBundleLineItem
 ]);
-var openOrderSchema = z8.object({
-  id: z8.string(),
-  status: z8.literal("Open" /* Open */),
-  currency: z8.string(),
+var openOrderSchema = z9.object({
+  id: z9.string(),
+  status: z9.literal("Open" /* Open */),
+  currency: z9.string(),
   items: openOrderLineItem.array(),
   couponsApplied: couponSchema.array(),
-  checkoutUrl: z8.string().optional(),
-  embeddedCheckoutUrl: z8.string().optional()
+  checkoutUrl: z9.string().optional(),
+  embeddedCheckoutUrl: z9.string().optional()
 });
-var moneySchema = z8.object({
-  currency: z8.string(),
-  amount: z8.number()
+var moneySchema = z9.object({
+  currency: z9.string(),
+  amount: z9.number()
 });
-var orderTotalSchema = z8.object({
+var orderTotalSchema = z9.object({
   original: moneySchema,
   discount: moneySchema,
   subtotal: moneySchema,
   taxes: moneySchema,
   due: moneySchema
 });
-var customerSnapshotSchema = z8.object({
-  name: z8.string().nullable(),
-  businessName: z8.string().nullable(),
-  taxId: z8.string().nullable(),
-  email: z8.string().nullable(),
+var customerSnapshotSchema = z9.object({
+  name: z9.string().nullable(),
+  businessName: z9.string().nullable(),
+  taxId: z9.string().nullable(),
+  email: z9.string().nullable(),
   address: addressSchema.nullable()
 });
-var completedOrderSchema = z8.object({
-  id: z8.string(),
-  status: z8.literal("Completed" /* Completed */),
-  currency: z8.string(),
+var completedOrderSchema = z9.object({
+  id: z9.string(),
+  status: z9.literal("Completed" /* Completed */),
+  currency: z9.string(),
   customer: customerSnapshotSchema,
   total: orderTotalSchema,
   items: openOrderLineItem.array(),
   couponsApplied: couponSchema.array()
 });
-var orderSchema = z8.discriminatedUnion("status", [
+var orderSchema = z9.discriminatedUnion("status", [
   openOrderSchema,
   completedOrderSchema
 ]);
@@ -540,8 +521,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 = {
@@ -553,18 +534,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;
   }
 };
 
@@ -590,33 +569,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
 import fetch2 from "cross-fetch";
+import { ZodNull } from "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 fetch2(this.baseUrl + path, {
-      method: method || "GET",
+      method: (options == null ? void 0 : options.method) || "GET",
       mode: "cors",
       headers: {
         "Accept": "application/json",
@@ -626,24 +602,21 @@ 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,
-        headers: response.headers,
+        data: schema instanceof ZodNull ? null : schema.parse(await response.json()),
+        headers: Object.fromEntries(response.headers.entries()),
         status: response.status
       };
     } catch (err) {
       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
       });
@@ -758,13 +731,13 @@ _TokenStore.storageKey = "moonbase_auth";
 var TokenStore = _TokenStore;
 
 // src/vouchers/schemas.ts
-import { z as z9 } from "zod";
-var voucherSchema = z9.object({
-  id: z9.string(),
-  name: z9.string(),
-  description: z9.string(),
-  code: z9.string(),
-  redeemed: z9.boolean(),
+import { z as z10 } from "zod";
+var voucherSchema = z10.object({
+  id: z10.string(),
+  name: z10.string(),
+  description: z10.string(),
+  code: z10.string(),
+  redeemed: z10.boolean(),
   redeemsProducts: quantifiable(storefrontProductSchema).array(),
   redeemsBundles: quantifiable(storefrontBundleSchema).array()
 });
@@ -775,28 +748,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
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/inventory/licenses/schemas.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/inventory/licenses/models.ts
 var LicenseStatus = /* @__PURE__ */ ((LicenseStatus2) => {
@@ -816,21 +787,21 @@ var ActivationMethod = /* @__PURE__ */ ((ActivationMethod2) => {
 })(ActivationMethod || {});
 
 // src/inventory/licenses/schemas.ts
-var licenseSchema = z10.object({
-  id: z10.string(),
-  status: z10.nativeEnum(LicenseStatus),
+var licenseSchema = z11.object({
+  id: z11.string(),
+  status: z11.nativeEnum(LicenseStatus),
   product: productSummarySchema,
-  activeNumberOfActivations: z10.number(),
-  maxNumberOfActivations: z10.number(),
-  createdAt: z10.coerce.date()
+  activeNumberOfActivations: z11.number(),
+  maxNumberOfActivations: z11.number(),
+  createdAt: z11.coerce.date()
 });
-var activationSchema = z10.object({
-  id: z10.string(),
-  licenseId: z10.string(),
-  name: z10.string(),
-  status: z10.nativeEnum(ActivationStatus),
-  activationMethod: z10.nativeEnum(ActivationMethod),
-  lastValidatedAt: z10.coerce.date().nullable()
+var activationSchema = z11.object({
+  id: z11.string(),
+  licenseId: z11.string(),
+  name: z11.string(),
+  status: z11.nativeEnum(ActivationStatus),
+  activationMethod: z11.nativeEnum(ActivationMethod),
+  lastValidatedAt: z11.coerce.date().nullable()
 });
 
 // src/inventory/activation/endpoints.ts
@@ -839,99 +810,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: z11.string().parse(response.headers.get("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: z12.string().parse(response.headers.location)
+    };
   }
 };
 
 // src/inventory/licenses/endpoints.ts
+import { z as z13 } from "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`, z13.null(), { method: "POST" });
   }
 };
 
 // src/inventory/products/endpoints.ts
-import { z as z12 } from "zod";
+import { z as z14 } from "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 = z12.object({
-      location: z12.string()
-    }).parse(response.data);
-    return content.location;
+    const response = await this.api.fetch(url.pathname + url.search, z14.object({
+      location: z14.string()
+    }));
+    return response.data.location;
   }
 };