@moonbase.sh/storefront-api 0.1.78

package/dist/index.cjs

@@ -0,0 +1,685 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ActivationMethod: () => ActivationMethod,
+  ActivationStatus: () => ActivationStatus,
+  LicenseStatus: () => LicenseStatus,
+  MoonbaseClient: () => MoonbaseClient,
+  NotAuthenticatedError: () => NotAuthenticatedError,
+  NotAuthorizedError: () => NotAuthorizedError,
+  NotFoundError: () => NotFoundError,
+  OrderStatus: () => OrderStatus,
+  Platform: () => Platform
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/identity/endpoints.ts
+var import_cross_fetch = __toESM(require("cross-fetch"), 1);
+
+// src/utils/problemHandler.ts
+var import_zod = require("zod");
+
+// src/utils/errors.ts
+var NotAuthorizedError = class extends Error {
+  constructor() {
+    super();
+    this.name = "NotAuthorizedError";
+  }
+};
+var NotAuthenticatedError = class extends Error {
+  constructor() {
+    super();
+    this.name = "NotAuthenticatedError";
+  }
+};
+var NotFoundError = class extends Error {
+  constructor() {
+    super();
+    this.name = "NotFoundError";
+  }
+};
+
+// src/utils/problemHandler.ts
+var problemDetailsSchema = import_zod.z.object({
+  type: import_zod.z.string(),
+  title: import_zod.z.string(),
+  detail: import_zod.z.string().optional(),
+  status: import_zod.z.number()
+});
+async function handleResponseProblem(response) {
+  if (response.status === 404)
+    throw new NotFoundError();
+  if (response.status === 401)
+    throw new NotAuthenticatedError();
+  if (response.status === 403)
+    throw new NotAuthorizedError();
+  let problemDetails;
+  try {
+    const json = await response.json();
+    problemDetails = problemDetailsSchema.parse(json);
+  } catch (e) {
+    throw new Error("An unknown problem occurred");
+  }
+  if (problemDetails.detail)
+    throw new Error(problemDetails.detail);
+  if (problemDetails.title)
+    throw new Error(problemDetails.title);
+  throw new Error("An unknown problem occurred");
+}
+
+// src/identity/schemas.ts
+var import_zod2 = require("zod");
+var addressSchema = import_zod2.z.object({
+  countryCode: import_zod2.z.string(),
+  streetAddress1: import_zod2.z.string(),
+  streetAddress2: import_zod2.z.string().nullable(),
+  locality: import_zod2.z.string().nullable(),
+  region: import_zod2.z.string().nullable(),
+  postCode: import_zod2.z.string()
+});
+var communicationPreferencesSchema = import_zod2.z.object({
+  newsletterOptIn: import_zod2.z.boolean()
+  // productUpdatesOptIn: z.boolean(), // TODO: Enable when relevant
+});
+var userSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  email: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  tenantId: import_zod2.z.string(),
+  address: addressSchema.optional(),
+  communicationPreferences: communicationPreferencesSchema
+});
+var identityUserSchema = userSchema.and(import_zod2.z.object({
+  accessToken: import_zod2.z.string(),
+  refreshToken: import_zod2.z.string()
+}));
+
+// src/identity/endpoints.ts
+var IdentityEndpoints = class {
+  constructor(api, tokenStore) {
+    this.api = api;
+    this.tokenStore = tokenStore;
+  }
+  async get() {
+    const response = await this.api.authenticatedFetch("/api/customer/meta/user");
+    return userSchema.parse(response);
+  }
+  async signIn(email, password) {
+    const response = await (0, import_cross_fetch.default)(`${this.api.baseUrl}/api/customer/identity/sign-in?email=${email}&scheme=JWT`, {
+      method: "POST",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "text/plain",
+        "x-mb-cors": "1"
+      },
+      body: password
+    });
+    if (response.status >= 400)
+      await handleResponseProblem(response);
+    const data = await response.json();
+    const user = identityUserSchema.parse(data);
+    this.tokenStore.setUser(user);
+    return user;
+  }
+  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 user = identityUserSchema.parse(response);
+    this.tokenStore.setUser(user);
+    return user;
+  }
+  async update(name, email, emailConfirmationToken, communicationPreferences) {
+    const response = await this.api.authenticatedFetch("/api/customer/identity", "PATCH", {
+      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
+    });
+  }
+  async forgotPassword(email) {
+    await this.api.fetch(`/api/customer/identity/forgot-password?email=${encodeURIComponent(email)}`, "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=${code}`, {
+      method: "POST",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "text/plain",
+        "x-mb-cors": "1"
+      },
+      body: newPassword
+    });
+    if (response.status >= 400)
+      await handleResponseProblem(response);
+  }
+};
+
+// src/globalSchemas.ts
+var import_zod3 = require("zod");
+var priceCollectionSchema = import_zod3.z.record(import_zod3.z.number());
+var percentageOffDiscountSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("PercentageOffDiscount"),
+  name: import_zod3.z.string(),
+  description: import_zod3.z.string().optional(),
+  percentage: import_zod3.z.number(),
+  total: priceCollectionSchema
+});
+var flatAmountOffDiscountSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("FlatAmountOffDiscount"),
+  name: import_zod3.z.string(),
+  description: import_zod3.z.string().optional(),
+  total: priceCollectionSchema
+});
+var discountSchema = import_zod3.z.discriminatedUnion("type", [
+  percentageOffDiscountSchema,
+  flatAmountOffDiscountSchema
+]);
+var pricingVariationSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  name: import_zod3.z.string(),
+  originalPrice: priceCollectionSchema,
+  price: priceCollectionSchema,
+  hasDiscount: import_zod3.z.boolean(),
+  discount: discountSchema.optional()
+});
+function paged(itemSchema) {
+  return import_zod3.z.object({
+    items: import_zod3.z.array(itemSchema),
+    hasMore: import_zod3.z.boolean(),
+    next: import_zod3.z.string().nullable()
+  });
+}
+function quantifiable(itemSchema) {
+  return import_zod3.z.object({
+    value: itemSchema,
+    quantity: import_zod3.z.number()
+  });
+}
+
+// src/licenses/schemas.ts
+var import_zod5 = require("zod");
+
+// src/products/schemas.ts
+var import_zod4 = require("zod");
+
+// src/products/models.ts
+var Platform = /* @__PURE__ */ ((Platform2) => {
+  Platform2["Universal"] = "Universal";
+  Platform2["Windows"] = "Windows";
+  Platform2["Linux"] = "Linux";
+  Platform2["Mac"] = "Mac";
+  return Platform2;
+})(Platform || {});
+
+// src/products/schemas.ts
+var downloadSchema = import_zod4.z.object({
+  name: import_zod4.z.string(),
+  key: import_zod4.z.string(),
+  platform: import_zod4.z.nativeEnum(Platform),
+  size: import_zod4.z.number(),
+  path: import_zod4.z.string().nullable()
+});
+var productSummarySchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  name: import_zod4.z.string(),
+  tagline: import_zod4.z.string(),
+  website: import_zod4.z.string().optional(),
+  iconUrl: import_zod4.z.string().optional(),
+  numberOfLicenses: import_zod4.z.number().optional(),
+  numberOfTrials: import_zod4.z.number().optional(),
+  currentActivations: import_zod4.z.number().optional(),
+  maxActivations: import_zod4.z.number().optional(),
+  currentVersion: import_zod4.z.string().nullable(),
+  downloadsNeedsUser: import_zod4.z.boolean(),
+  downloadsNeedsOwnership: import_zod4.z.boolean(),
+  downloads: import_zod4.z.array(downloadSchema).optional()
+});
+
+// src/licenses/models.ts
+var LicenseStatus = /* @__PURE__ */ ((LicenseStatus2) => {
+  LicenseStatus2["Active"] = "Active";
+  LicenseStatus2["Revoked"] = "Revoked";
+  return LicenseStatus2;
+})(LicenseStatus || {});
+var ActivationStatus = /* @__PURE__ */ ((ActivationStatus2) => {
+  ActivationStatus2["Active"] = "Active";
+  ActivationStatus2["Revoked"] = "Revoked";
+  return ActivationStatus2;
+})(ActivationStatus || {});
+var ActivationMethod = /* @__PURE__ */ ((ActivationMethod2) => {
+  ActivationMethod2["Online"] = "Online";
+  ActivationMethod2["Offline"] = "Offline";
+  return ActivationMethod2;
+})(ActivationMethod || {});
+
+// src/licenses/schemas.ts
+var licenseSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  status: import_zod5.z.nativeEnum(LicenseStatus),
+  product: productSummarySchema.optional(),
+  activeNumberOfActivations: import_zod5.z.number(),
+  maxNumberOfActivations: import_zod5.z.number(),
+  createdAt: import_zod5.z.coerce.date()
+});
+var activationSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  licenseId: import_zod5.z.string(),
+  name: import_zod5.z.string(),
+  status: import_zod5.z.nativeEnum(ActivationStatus),
+  activationMethod: import_zod5.z.nativeEnum(ActivationMethod),
+  lastValidatedAt: import_zod5.z.coerce.date().nullable()
+});
+
+// src/licenses/endpoints.ts
+var LicenseEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async get(nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/licenses");
+    return paged(licenseSchema).parse(response);
+  }
+  async getActivations(licenseId, nextUrl) {
+    const response = await this.api.authenticatedFetch(
+      nextUrl || `/api/customer/licenses/${licenseId}/activations`
+    );
+    return paged(activationSchema).parse(response);
+  }
+  async revokeActivation(licenseId, activationId) {
+    await this.api.authenticatedFetch(`/api/customer/licenses/${licenseId}/activations/${activationId}/revoke`);
+  }
+};
+
+// src/orders/schemas.ts
+var import_zod7 = require("zod");
+
+// src/storefront/schemas.ts
+var import_zod6 = require("zod");
+var storefrontProductSchema = import_zod6.z.object({
+  id: import_zod6.z.string(),
+  name: import_zod6.z.string(),
+  tagline: import_zod6.z.string(),
+  iconUrl: import_zod6.z.string().nullable(),
+  owned: import_zod6.z.boolean(),
+  defaultVariation: pricingVariationSchema.optional(),
+  variations: pricingVariationSchema.array().optional(),
+  type: import_zod6.z.void().transform(() => "product").pipe(import_zod6.z.literal("product"))
+});
+var storefrontBundleSchema = import_zod6.z.object({
+  id: import_zod6.z.string(),
+  name: import_zod6.z.string(),
+  tagline: import_zod6.z.string(),
+  iconUrl: import_zod6.z.string().nullable(),
+  owned: import_zod6.z.boolean(),
+  partial: import_zod6.z.boolean(),
+  products: storefrontProductSchema.and(import_zod6.z.object({
+    included: import_zod6.z.boolean()
+  })).array(),
+  defaultVariation: pricingVariationSchema.optional(),
+  variations: pricingVariationSchema.array().optional(),
+  type: import_zod6.z.void().transform(() => "bundle").pipe(import_zod6.z.literal("bundle"))
+});
+var storefrontSchema = import_zod6.z.object({
+  suggestedCurrency: import_zod6.z.string(),
+  products: storefrontProductSchema.array(),
+  bundles: storefrontBundleSchema.array()
+});
+
+// src/orders/models.ts
+var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
+  OrderStatus2["Open"] = "Open";
+  OrderStatus2["PaymentRequested"] = "PaymentRequested";
+  OrderStatus2["Completed"] = "Completed";
+  OrderStatus2["Fulfilled"] = "Fulfilled";
+  OrderStatus2["Returned"] = "Returned";
+  OrderStatus2["Failed"] = "Failed";
+  return OrderStatus2;
+})(OrderStatus || {});
+
+// src/orders/schemas.ts
+var couponSchema = import_zod7.z.object({
+  code: import_zod7.z.string(),
+  name: import_zod7.z.string(),
+  description: import_zod7.z.string()
+});
+var percentageOffDiscountSchema2 = import_zod7.z.object({
+  type: import_zod7.z.literal("PercentageOffDiscount"),
+  name: import_zod7.z.string(),
+  description: import_zod7.z.string().optional(),
+  percentage: import_zod7.z.number(),
+  total: priceCollectionSchema.optional(),
+  isExclusive: import_zod7.z.boolean()
+});
+var flatAmountOffDiscountSchema2 = import_zod7.z.object({
+  type: import_zod7.z.literal("FlatAmountOffDiscount"),
+  name: import_zod7.z.string(),
+  description: import_zod7.z.string().optional(),
+  total: priceCollectionSchema.optional(),
+  isExclusive: import_zod7.z.boolean()
+});
+var discountSchema2 = import_zod7.z.discriminatedUnion("type", [
+  percentageOffDiscountSchema2,
+  flatAmountOffDiscountSchema2
+]);
+var openProductLineItem = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  type: import_zod7.z.literal("Product"),
+  productId: import_zod7.z.string(),
+  quantity: import_zod7.z.number(),
+  variationId: import_zod7.z.string(),
+  price: priceCollectionSchema.optional(),
+  variation: pricingVariationSchema.optional(),
+  product: storefrontProductSchema.optional(),
+  appliedDiscount: discountSchema2.optional()
+});
+var openBundleLineItem = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  type: import_zod7.z.literal("Bundle"),
+  bundleId: import_zod7.z.string(),
+  quantity: import_zod7.z.number(),
+  variationId: import_zod7.z.string(),
+  price: priceCollectionSchema.optional(),
+  variation: pricingVariationSchema.optional(),
+  bundle: storefrontBundleSchema.optional(),
+  appliedDiscount: discountSchema2.optional()
+});
+var openOrderLineItem = import_zod7.z.discriminatedUnion("type", [
+  openProductLineItem,
+  openBundleLineItem
+]);
+var openOrderSchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  status: import_zod7.z.literal("Open" /* Open */),
+  currency: import_zod7.z.string(),
+  items: openOrderLineItem.array(),
+  couponsApplied: couponSchema.array(),
+  checkoutUrl: import_zod7.z.string().optional()
+});
+var orderSchema = import_zod7.z.discriminatedUnion("status", [
+  openOrderSchema
+]);
+
+// src/orders/endpoints.ts
+var OrderEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async get(orderId) {
+    const response = await this.api.fetch(`/api/customer/orders/${orderId}`);
+    return orderSchema.parse(response);
+  }
+  async pushContent(order, checkout) {
+    const response = await this.api.fetch(
+      `/api/customer/orders/${order.id}${checkout ? `?checkout=true&returnUrl=${encodeURIComponent(checkout.returnUrl)}` : ""}`,
+      "PATCH",
+      {
+        currency: order.currency,
+        items: order.items
+      }
+    );
+    return openOrderSchema.parse(response);
+  }
+};
+
+// src/products/endpoints.ts
+var ProductEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async getOwned(nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/products");
+    return paged(productSummarySchema).parse(response);
+  }
+  async getLicenses(productId, nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/products/${productId}/licenses`);
+    return paged(licenseSchema).parse(response);
+  }
+  async getActivations(productId, nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/products/${productId}/licenses/activations`);
+    return paged(activationSchema).parse(response);
+  }
+};
+
+// src/storefront/endpoints.ts
+var StorefrontEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async get() {
+    const response = await this.api.fetch("/api/customer/storefront");
+    return storefrontSchema.parse(response);
+  }
+};
+
+// src/utils/api.ts
+var import_cross_fetch2 = __toESM(require("cross-fetch"), 1);
+var MoonbaseApi = class {
+  constructor(baseUrl, tokenStore) {
+    this.baseUrl = baseUrl;
+    this.tokenStore = tokenStore;
+  }
+  async authenticatedFetch(path, method, body) {
+    if (!this.tokenStore.hasAccessToken)
+      throw new NotAuthenticatedError();
+    return await this.fetch(path, method, body);
+  }
+  async fetch(path, method, body) {
+    const accessToken = await this.tokenStore.getAccessToken();
+    const response = await (0, import_cross_fetch2.default)(this.baseUrl + path, {
+      method: method || "GET",
+      mode: "cors",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        // While this fetch can be anonymous, we add the token if we have it
+        ...accessToken ? { Authorization: `Bearer ${accessToken}` } : {},
+        // Force CORS on all calls
+        "x-mb-cors": "1"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (response.status >= 400)
+      await handleResponseProblem(response);
+    return await response.json();
+  }
+};
+
+// src/utils/tokenStore.ts
+var import_cross_fetch3 = __toESM(require("cross-fetch"), 1);
+var _TokenStore = class _TokenStore {
+  constructor(configuration) {
+    this.configuration = configuration;
+    this.tokens = null;
+    this.refreshTimeoutId = null;
+    this.refreshPromise = null;
+    if (typeof window !== "undefined") {
+      window.addEventListener("storage", (event) => this.handleStorageUpdate(event));
+      const storedTokens = localStorage.getItem(_TokenStore.storageKey);
+      if (storedTokens) {
+        this.tokens = JSON.parse(storedTokens);
+        this.tokens.expiresAt = new Date(this.tokens.expiresAt);
+      }
+    }
+  }
+  get user() {
+    if (this.tokens)
+      return this.tokens;
+    return null;
+  }
+  get hasAccessToken() {
+    return !!this.tokens;
+  }
+  async getAccessToken() {
+    var _a, _b, _c;
+    if (this.isExpired) {
+      if (this.refreshPromise) {
+        const tokens2 = await this.refreshPromise;
+        return (_a = tokens2 == null ? void 0 : tokens2.accessToken) != null ? _a : null;
+      }
+      this.refreshPromise = this.refreshTokens();
+      const tokens = await this.refreshPromise;
+      return (_b = tokens == null ? void 0 : tokens.accessToken) != null ? _b : null;
+    }
+    return ((_c = this.tokens) == null ? void 0 : _c.accessToken) || null;
+  }
+  setUser(user) {
+    if (user === null) {
+      this.tokens = null;
+      if (typeof window !== "undefined" && localStorage)
+        localStorage.removeItem(_TokenStore.storageKey);
+      if (this.refreshTimeoutId != null)
+        window.clearTimeout(this.refreshTimeoutId);
+      return null;
+    }
+    this.tokens = {
+      ...user,
+      // Hardcoded 15 minutes now, might want to check the JWT tho
+      expiresAt: new Date((/* @__PURE__ */ new Date()).getTime() + 15 * 60 * 1e3)
+    };
+    if (typeof window !== "undefined" && localStorage)
+      localStorage.setItem(_TokenStore.storageKey, JSON.stringify(this.tokens));
+    if (this.refreshTimeoutId != null)
+      window.clearTimeout(this.refreshTimeoutId);
+    this.refreshTimeoutId = window.setTimeout(() => {
+      this.refreshPromise = this.refreshTokens();
+    }, 10 * 60 * 1e3);
+    return this.tokens;
+  }
+  get isExpired() {
+    return this.tokens != null && this.tokens.expiresAt < /* @__PURE__ */ new Date();
+  }
+  async refreshTokens() {
+    if (!this.tokens)
+      throw new Error("No tokens found to refresh");
+    const response = await (0, import_cross_fetch3.default)(`${this.configuration.endpoint}/api/customer/identity/refresh?token=${this.tokens.refreshToken}`, {
+      method: "POST",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "text/plain",
+        "x-mb-cors": "1"
+      },
+      body: this.tokens.accessToken
+    });
+    if (response.status !== 200) {
+      if (response.status === 403) {
+        this.setUser(null);
+        return null;
+      }
+      throw new Error(`Could not refresh access token, status code ${response.status}`);
+    }
+    const result = identityUserSchema.parse(await response.json());
+    return this.setUser(result);
+  }
+  handleStorageUpdate(event) {
+    switch (event.key) {
+      case _TokenStore.storageKey:
+        this.tokens = JSON.parse(event.newValue);
+        this.tokens.expiresAt = new Date(this.tokens.expiresAt);
+        break;
+    }
+  }
+};
+_TokenStore.storageKey = "moonbase_auth";
+var TokenStore = _TokenStore;
+
+// src/vouchers/schemas.ts
+var import_zod8 = require("zod");
+var voucherSchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  name: import_zod8.z.string(),
+  description: import_zod8.z.string(),
+  code: import_zod8.z.string(),
+  redeemed: import_zod8.z.boolean(),
+  redeemsProducts: quantifiable(storefrontProductSchema).array(),
+  redeemsBundles: quantifiable(storefrontBundleSchema).array()
+});
+
+// src/vouchers/endpoints.ts
+var VoucherEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async peek(code) {
+    const response = await this.api.fetch(`/api/customer/vouchers?code=${encodeURIComponent(code)}`);
+    return voucherSchema.parse(response);
+  }
+  async redeem(code) {
+    const response = await this.api.authenticatedFetch(
+      `/api/customer/vouchers/redeem?code=${encodeURIComponent(code)}`,
+      "POST"
+    );
+    return voucherSchema.parse(response);
+  }
+};
+
+// src/index.ts
+var MoonbaseClient = class {
+  constructor(configuration) {
+    this.configuration = configuration;
+    this.configuration.endpoint = this.configuration.endpoint.replace(/\/$/, "");
+    this.tokenStore = new TokenStore(configuration);
+    const api = new MoonbaseApi(this.configuration.endpoint, this.tokenStore);
+    this.storefront = new StorefrontEndpoints(api);
+    this.identity = new IdentityEndpoints(api, this.tokenStore);
+    this.vouchers = new VoucherEndpoints(api);
+    this.orders = new OrderEndpoints(api);
+    this.licenses = new LicenseEndpoints(api);
+    this.products = new ProductEndpoints(api);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActivationMethod,
+  ActivationStatus,
+  LicenseStatus,
+  MoonbaseClient,
+  NotAuthenticatedError,
+  NotAuthorizedError,
+  NotFoundError,
+  OrderStatus,
+  Platform
+});