@moonbase.sh/storefront-api 0.0.0-next-20260526085904

package/dist/index.cjs

@@ -0,0 +1,1775 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ActivationMethod: () => ActivationMethod,
+  ActivationRequestFulfillmentType: () => ActivationRequestFulfillmentType,
+  ActivationRequestStatus: () => ActivationRequestStatus,
+  ActivationStatus: () => ActivationStatus,
+  Architecture: () => Architecture,
+  ConnectableAccountProvider: () => ConnectableAccountProvider,
+  ConsoleLogger: () => ConsoleLogger,
+  CycleLength: () => CycleLength,
+  DiscountUtils: () => DiscountUtils,
+  InMemoryStore: () => InMemoryStore,
+  LicenseStatus: () => LicenseStatus,
+  LocalStorageStore: () => LocalStorageStore,
+  LogLevel: () => LogLevel,
+  MarketingConsentType: () => MarketingConsentType,
+  MoneyCollectionUtils: () => MoneyCollectionUtils,
+  MoonbaseApi: () => MoonbaseApi,
+  MoonbaseClient: () => MoonbaseClient,
+  MoonbaseError: () => MoonbaseError,
+  NotAuthenticatedError: () => NotAuthenticatedError,
+  NotAuthorizedError: () => NotAuthorizedError,
+  NotFoundError: () => NotFoundError,
+  OfferUtils: () => OfferUtils,
+  OrderStatus: () => OrderStatus,
+  Platform: () => Platform,
+  SubscriptionStatus: () => SubscriptionStatus,
+  TokenStore: () => TokenStore,
+  objectToQuery: () => objectToQuery,
+  parseOffSiteReferrer: () => parseOffSiteReferrer,
+  problemDetailsSchema: () => problemDetailsSchema,
+  resolveUtm: () => resolveUtm,
+  schemas: () => schemas_exports12,
+  utmToObject: () => utmToObject
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/activationRequests/endpoints.ts
+var import_zod5 = require("zod");
+
+// src/activationRequests/schemas.ts
+var schemas_exports3 = {};
+__export(schemas_exports3, {
+  activationRequestSchema: () => activationRequestSchema
+});
+var import_zod4 = require("zod");
+
+// src/storefront/schemas.ts
+var schemas_exports2 = {};
+__export(schemas_exports2, {
+  offerConditionSchema: () => offerConditionSchema,
+  storefrontBundleSchema: () => storefrontBundleSchema,
+  storefrontOfferSchema: () => storefrontOfferSchema,
+  storefrontProductSchema: () => storefrontProductSchema,
+  storefrontSchema: () => storefrontSchema,
+  taxEstimateSchema: () => taxEstimateSchema
+});
+var import_zod3 = require("zod");
+
+// src/globalSchemas.ts
+var import_zod = require("zod");
+
+// src/globalModels.ts
+var CycleLength = /* @__PURE__ */ ((CycleLength2) => {
+  CycleLength2["Daily"] = "Daily";
+  CycleLength2["Weekly"] = "Weekly";
+  CycleLength2["Monthly"] = "Monthly";
+  CycleLength2["Quarterly"] = "Quarterly";
+  CycleLength2["Yearly"] = "Yearly";
+  return CycleLength2;
+})(CycleLength || {});
+var MarketingConsentType = /* @__PURE__ */ ((MarketingConsentType2) => {
+  MarketingConsentType2["OptIn"] = "OptIn";
+  MarketingConsentType2["OptedInByDefault"] = "OptedInByDefault";
+  MarketingConsentType2["OptOut"] = "OptOut";
+  return MarketingConsentType2;
+})(MarketingConsentType || {});
+function utmToObject(utm) {
+  return Object.entries({
+    utm_source: utm == null ? void 0 : utm.source,
+    utm_medium: utm == null ? void 0 : utm.medium,
+    utm_campaign: utm == null ? void 0 : utm.campaign,
+    utm_term: utm == null ? void 0 : utm.term,
+    utm_content: utm == null ? void 0 : utm.content,
+    utm_referrer: utm == null ? void 0 : utm.referrer
+  }).filter(([_, value]) => value !== void 0).reduce((obj, [key, value]) => ({
+    ...obj,
+    [key]: value
+  }), {});
+}
+
+// src/globalSchemas.ts
+var priceCollectionSchema = import_zod.z.record(import_zod.z.number());
+var percentageOffDiscountSchema = import_zod.z.object({
+  type: import_zod.z.literal("PercentageOffDiscount"),
+  name: import_zod.z.string(),
+  description: import_zod.z.string().optional(),
+  percentage: import_zod.z.number(),
+  total: priceCollectionSchema.optional(),
+  isExclusive: import_zod.z.boolean(),
+  recurringPaymentUseCount: import_zod.z.number().optional()
+});
+var flatAmountOffDiscountSchema = import_zod.z.object({
+  type: import_zod.z.literal("FlatAmountOffDiscount"),
+  name: import_zod.z.string(),
+  description: import_zod.z.string().optional(),
+  total: priceCollectionSchema.optional(),
+  isExclusive: import_zod.z.boolean(),
+  recurringPaymentUseCount: import_zod.z.number().optional()
+});
+var moneySchema = import_zod.z.object({
+  currency: import_zod.z.string(),
+  amount: import_zod.z.number()
+});
+var discountSchema = import_zod.z.discriminatedUnion("type", [
+  percentageOffDiscountSchema,
+  flatAmountOffDiscountSchema
+]);
+var recurrenceSchema = import_zod.z.discriminatedUnion("type", [
+  import_zod.z.object({ type: import_zod.z.literal("OneOff") }),
+  import_zod.z.object({ type: import_zod.z.literal("Recurring"), cycleLength: import_zod.z.nativeEnum(CycleLength) })
+]);
+var pricingTierSchema = import_zod.z.object({
+  minQuantity: import_zod.z.number(),
+  originalPrice: priceCollectionSchema,
+  price: priceCollectionSchema
+});
+var pricingVariationSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  name: import_zod.z.string(),
+  originalPrice: priceCollectionSchema,
+  price: priceCollectionSchema,
+  hasDiscount: import_zod.z.boolean(),
+  discount: discountSchema.optional(),
+  recurrence: recurrenceSchema,
+  pricingTiers: import_zod.z.array(pricingTierSchema).nullish()
+});
+var rawPropertyValueSchema = import_zod.z.lazy(
+  () => import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean(), import_zod.z.record(rawPropertyValueSchema)])
+);
+function paged(itemSchema) {
+  return import_zod.z.object({
+    items: import_zod.z.array(itemSchema),
+    hasMore: import_zod.z.boolean(),
+    next: import_zod.z.string().nullable()
+  });
+}
+function quantifiable(itemSchema) {
+  return import_zod.z.object({
+    value: itemSchema,
+    quantity: import_zod.z.number()
+  });
+}
+function singleOrMultiple(schema) {
+  return import_zod.z.union([schema, import_zod.z.array(schema)]);
+}
+
+// src/inventory/products/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  downloadSchema: () => downloadSchema,
+  manifestSchema: () => manifestSchema,
+  productSummarySchema: () => productSummarySchema
+});
+var import_zod2 = require("zod");
+
+// src/inventory/products/models.ts
+var Platform = /* @__PURE__ */ ((Platform2) => {
+  Platform2["Universal"] = "Universal";
+  Platform2["Windows"] = "Windows";
+  Platform2["Linux"] = "Linux";
+  Platform2["Mac"] = "Mac";
+  Platform2["iOS"] = "iOS";
+  Platform2["Android"] = "Android";
+  return Platform2;
+})(Platform || {});
+var Architecture = /* @__PURE__ */ ((Architecture2) => {
+  Architecture2["Unknown"] = "Unknown";
+  Architecture2["Universal"] = "Universal";
+  Architecture2["X86"] = "X86";
+  Architecture2["X64"] = "X64";
+  Architecture2["Arm"] = "Arm";
+  Architecture2["Arm64"] = "Arm64";
+  return Architecture2;
+})(Architecture || {});
+
+// src/inventory/products/schemas.ts
+var manifestSchema = import_zod2.z.object({
+  files: import_zod2.z.object({
+    name: import_zod2.z.string(),
+    path: import_zod2.z.string()
+  }).array(),
+  licensePath: import_zod2.z.string().nullable()
+});
+var downloadSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  key: import_zod2.z.string(),
+  platform: import_zod2.z.nativeEnum(Platform),
+  arch: import_zod2.z.nativeEnum(Architecture).nullish(),
+  size: import_zod2.z.number(),
+  path: import_zod2.z.string().nullable(),
+  manifest: manifestSchema.optional()
+});
+var productSummarySchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  tagline: import_zod2.z.string(),
+  description: import_zod2.z.string().nullish(),
+  website: import_zod2.z.string().optional(),
+  iconUrl: import_zod2.z.string().optional(),
+  numberOfLicenses: import_zod2.z.number().optional(),
+  numberOfTrials: import_zod2.z.number().optional(),
+  currentActivations: import_zod2.z.number().optional(),
+  maxActivations: import_zod2.z.number().optional(),
+  externalLicenses: import_zod2.z.number().optional(),
+  subscriptionLicenses: import_zod2.z.number().optional(),
+  currentVersion: import_zod2.z.string().nullable(),
+  version: import_zod2.z.string().optional(),
+  prerelease: import_zod2.z.boolean().optional(),
+  releaseDescription: import_zod2.z.string().optional(),
+  downloadsNeedsUser: import_zod2.z.boolean(),
+  downloadsNeedsOwnership: import_zod2.z.boolean(),
+  downloads: import_zod2.z.array(downloadSchema).optional()
+});
+
+// src/storefront/schemas.ts
+var storefrontProductSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  name: import_zod3.z.string(),
+  tagline: import_zod3.z.string(),
+  description: import_zod3.z.string(),
+  iconUrl: import_zod3.z.string().nullable(),
+  website: import_zod3.z.string().nullish(),
+  owned: import_zod3.z.boolean(),
+  currentVersion: import_zod3.z.string().optional(),
+  downloads: downloadSchema.array().optional(),
+  defaultVariation: pricingVariationSchema.optional(),
+  variations: pricingVariationSchema.array().optional(),
+  properties: import_zod3.z.record(rawPropertyValueSchema).nullish(),
+  type: import_zod3.z.string().optional().default("Product").pipe(import_zod3.z.literal("Product"))
+});
+var storefrontBundleSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  name: import_zod3.z.string(),
+  tagline: import_zod3.z.string(),
+  description: import_zod3.z.string(),
+  iconUrl: import_zod3.z.string().nullable(),
+  owned: import_zod3.z.boolean(),
+  partial: import_zod3.z.boolean(),
+  products: storefrontProductSchema.and(import_zod3.z.object({
+    included: import_zod3.z.boolean().optional()
+  })).array(),
+  defaultVariation: pricingVariationSchema.optional(),
+  variations: pricingVariationSchema.array().optional(),
+  properties: import_zod3.z.record(rawPropertyValueSchema).nullish(),
+  type: import_zod3.z.string().optional().default("Bundle").pipe(import_zod3.z.literal("Bundle"))
+});
+var cartContainsItemsConditionSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("CartContainsItems"),
+  minimumItems: import_zod3.z.number(),
+  relevantItemVariations: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string().array())
+});
+var offerConditionSchema = import_zod3.z.discriminatedUnion("type", [cartContainsItemsConditionSchema]);
+var storefrontOfferSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  target: singleOrMultiple(import_zod3.z.union([storefrontProductSchema, storefrontBundleSchema])),
+  targetVariations: import_zod3.z.string().array(),
+  condition: offerConditionSchema,
+  discount: discountSchema
+});
+var taxEstimateSchema = import_zod3.z.object({
+  rate: import_zod3.z.number(),
+  mode: import_zod3.z.enum(["Exclusive", "Inclusive"]),
+  countryCode: import_zod3.z.string(),
+  region: import_zod3.z.string().optional()
+});
+var storefrontSchema = import_zod3.z.object({
+  suggestedCurrency: import_zod3.z.string(),
+  // Enabled currencies need to be optional since we may still have old, cached representations in browsers
+  enabledCurrencies: import_zod3.z.string().array().optional(),
+  products: storefrontProductSchema.array(),
+  bundles: storefrontBundleSchema.array(),
+  // Offers need to be optional since we may still have old, cached representations in browsers
+  offers: storefrontOfferSchema.array().optional(),
+  // Depending on circumstances, we may have a tax estimate available
+  estimatedTax: taxEstimateSchema.optional()
+});
+
+// src/activationRequests/models.ts
+var ActivationRequestFulfillmentType = /* @__PURE__ */ ((ActivationRequestFulfillmentType2) => {
+  ActivationRequestFulfillmentType2["License"] = "License";
+  ActivationRequestFulfillmentType2["Trial"] = "Trial";
+  return ActivationRequestFulfillmentType2;
+})(ActivationRequestFulfillmentType || {});
+var ActivationRequestStatus = /* @__PURE__ */ ((ActivationRequestStatus2) => {
+  ActivationRequestStatus2["Requested"] = "Requested";
+  ActivationRequestStatus2["Fulfilled"] = "Fulfilled";
+  ActivationRequestStatus2["Completed"] = "Completed";
+  ActivationRequestStatus2["Cancelled"] = "Cancelled";
+  return ActivationRequestStatus2;
+})(ActivationRequestStatus || {});
+
+// src/activationRequests/schemas.ts
+var activationRequestSchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  status: import_zod4.z.nativeEnum(ActivationRequestStatus),
+  product: storefrontProductSchema,
+  fulfillmentType: import_zod4.z.nativeEnum(ActivationRequestFulfillmentType).optional(),
+  trialEligibility: import_zod4.z.object({
+    eligible: import_zod4.z.boolean(),
+    existing: import_zod4.z.boolean(),
+    requiresAccount: import_zod4.z.boolean(),
+    requiresNewsletterOptIn: import_zod4.z.boolean(),
+    numberOfDaysPerProduct: import_zod4.z.number(),
+    numberOfDaysRemaining: import_zod4.z.number()
+  }).optional(),
+  licenseEligibility: import_zod4.z.object({
+    eligible: import_zod4.z.boolean()
+  }).optional()
+});
+
+// src/activationRequests/endpoints.ts
+var ActivationRequestEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async get(requestId) {
+    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`, 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`, activationRequestSchema, { method: "POST" });
+    return response.data;
+  }
+  async fulfillTrial(requestId) {
+    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`, activationRequestSchema, { method: "POST" });
+    return response.data;
+  }
+};
+
+// src/communications/schemas.ts
+var schemas_exports4 = {};
+__export(schemas_exports4, {
+  communicationPreferencesViewSchema: () => communicationPreferencesViewSchema,
+  subscribeResponseSchema: () => subscribeResponseSchema
+});
+var import_zod6 = require("zod");
+var subscribeResponseSchema = import_zod6.z.object({
+  status: import_zod6.z.enum(["subscribed", "confirmation_sent"])
+});
+var communicationPreferencesViewSchema = import_zod6.z.object({
+  email: import_zod6.z.string(),
+  name: import_zod6.z.string().nullish(),
+  newsletter: import_zod6.z.boolean(),
+  productUpdates: import_zod6.z.boolean()
+});
+
+// src/communications/endpoints.ts
+function encodeToken(token) {
+  return encodeURIComponent(token.replaceAll(" ", "+"));
+}
+var CommunicationsEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async subscribe(input) {
+    var _a, _b, _c;
+    const response = await this.api.fetch("/api/customer/communications/subscribe", subscribeResponseSchema, {
+      method: "POST",
+      body: {
+        email: input.email,
+        name: ((_a = input.name) == null ? void 0 : _a.trim()) || null,
+        newsletter: (_b = input.newsletter) != null ? _b : true,
+        productUpdates: (_c = input.productUpdates) != null ? _c : true
+      }
+    });
+    return response.data;
+  }
+  async confirm(email, token) {
+    await this.api.fetch(
+      `/api/customer/communications/confirm?email=${encodeURIComponent(email)}&token=${encodeToken(token)}`,
+      null,
+      { method: "POST" }
+    );
+  }
+  async getPreferences(email, token) {
+    const response = await this.api.fetch(
+      `/api/customer/communications/preferences?email=${encodeURIComponent(email)}&token=${encodeToken(token)}`,
+      communicationPreferencesViewSchema
+    );
+    return response.data;
+  }
+  async updatePreferences(email, token, preferences) {
+    const response = await this.api.fetch(
+      `/api/customer/communications/preferences?email=${encodeURIComponent(email)}&token=${encodeToken(token)}`,
+      communicationPreferencesViewSchema,
+      {
+        method: "POST",
+        body: {
+          newsletter: preferences.newsletter,
+          productUpdates: preferences.productUpdates
+        }
+      }
+    );
+    return response.data;
+  }
+  async unsubscribe(email, token) {
+    await this.api.fetch(
+      `/api/customer/communications/unsubscribe?email=${encodeURIComponent(email)}&token=${encodeToken(token)}`,
+      null,
+      { method: "POST" }
+    );
+  }
+};
+
+// 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/problemDetails.ts
+var import_zod7 = require("zod");
+var problemDetailsSchema = import_zod7.z.object({
+  type: import_zod7.z.string().optional(),
+  title: import_zod7.z.string(),
+  detail: import_zod7.z.string().optional(),
+  status: import_zod7.z.number().optional(),
+  instance: import_zod7.z.string().optional(),
+  errors: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string().array()).optional()
+});
+
+// src/utils/problemHandler.ts
+function camelCase(str) {
+  return str.split(".").map((word, index) => {
+    let [firstLetter, ...restOfLetters] = word;
+    firstLetter = index !== 0 ? firstLetter.toUpperCase() : firstLetter.toLowerCase();
+    restOfLetters = [restOfLetters.join("").toLowerCase()];
+    return firstLetter + restOfLetters[0];
+  }).join("");
+}
+async function handleResponseProblem(response, logger) {
+  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 (err) {
+    logger.warn("Could not handle response", { response, err, content: await response.text() });
+    throw new Error("An unknown problem occurred");
+  }
+  logger.debug("The response indicates a problem", problemDetails);
+  throw new MoonbaseError(
+    problemDetails.title,
+    problemDetails.detail,
+    problemDetails.status,
+    problemDetails.errors ? Object.fromEntries(Object.entries(problemDetails.errors).map(([field, errors]) => [camelCase(field), errors.join(", ")])) : void 0
+  );
+}
+
+// src/identity/schemas.ts
+var schemas_exports5 = {};
+__export(schemas_exports5, {
+  addressSchema: () => addressSchema,
+  communicationPreferencesSchema: () => communicationPreferencesSchema,
+  connectedAccountSchema: () => connectedAccountSchema,
+  connectionUrlSchema: () => connectionUrlSchema,
+  identitySchema: () => identitySchema,
+  ilokConnectedAccountSchema: () => ilokConnectedAccountSchema,
+  pendingActivationSchema: () => pendingActivationSchema,
+  userAccountConfirmedSchema: () => userAccountConfirmedSchema,
+  userAccountConfirmedStatusSchema: () => userAccountConfirmedStatusSchema,
+  userSchema: () => userSchema
+});
+var import_zod8 = require("zod");
+
+// src/identity/models.ts
+var ConnectableAccountProvider = /* @__PURE__ */ ((ConnectableAccountProvider2) => {
+  ConnectableAccountProvider2["iLok"] = "iLok";
+  return ConnectableAccountProvider2;
+})(ConnectableAccountProvider || {});
+
+// src/identity/schemas.ts
+var addressSchema = import_zod8.z.object({
+  countryCode: import_zod8.z.string(),
+  streetAddress1: import_zod8.z.string(),
+  streetAddress2: import_zod8.z.string().nullable(),
+  locality: import_zod8.z.string().nullable(),
+  region: import_zod8.z.string().nullable(),
+  postCode: import_zod8.z.string().nullable()
+});
+var communicationPreferencesSchema = import_zod8.z.object({
+  newsletterOptIn: import_zod8.z.boolean(),
+  // Default keeps older persisted identities (pre productUpdatesOptIn) parseable
+  // during boot. The server-side value is hydrated by updateUser() right after.
+  productUpdatesOptIn: import_zod8.z.boolean().default(false)
+});
+var ilokConnectedAccountSchema = import_zod8.z.object({
+  provider: import_zod8.z.literal("iLok" /* iLok */),
+  isConnected: import_zod8.z.boolean(),
+  pendingLicenseFulfillments: import_zod8.z.boolean(),
+  accountId: import_zod8.z.string().nullish()
+});
+var connectedAccountSchema = import_zod8.z.discriminatedUnion("provider", [
+  ilokConnectedAccountSchema
+]);
+var connectionUrlSchema = import_zod8.z.object({
+  url: import_zod8.z.string()
+});
+var userSchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  email: import_zod8.z.string(),
+  name: import_zod8.z.string(),
+  tenantId: import_zod8.z.string(),
+  address: addressSchema.optional(),
+  phone: import_zod8.z.string().optional(),
+  communicationPreferences: communicationPreferencesSchema,
+  ownedProducts: import_zod8.z.string().array().optional(),
+  subscribedProducts: import_zod8.z.string().array().optional(),
+  confirmedAccount: import_zod8.z.boolean().optional(),
+  hasProducts: import_zod8.z.boolean().nullish(),
+  hasSubscriptions: import_zod8.z.boolean().nullish(),
+  connectedAccounts: import_zod8.z.array(connectedAccountSchema).default([])
+});
+var identitySchema = userSchema.and(import_zod8.z.object({
+  accessToken: import_zod8.z.string(),
+  refreshToken: import_zod8.z.string()
+}));
+var userAccountConfirmedStatusSchema = import_zod8.z.enum([
+  "PasswordSetupRequired",
+  "SignedIn"
+]);
+var userAccountConfirmedSchema = userSchema.and(import_zod8.z.object({
+  status: userAccountConfirmedStatusSchema,
+  resetPasswordToken: import_zod8.z.string().nullish(),
+  accessToken: import_zod8.z.string().nullish(),
+  refreshToken: import_zod8.z.string().nullish()
+}));
+var pendingActivationSchema = import_zod8.z.object({
+  status: import_zod8.z.literal("activation_pending"),
+  email: import_zod8.z.string()
+});
+
+// src/identity/endpoints.ts
+var IdentityEndpoints = class {
+  constructor(api, tokenStore, logger) {
+    this.api = api;
+    this.tokenStore = tokenStore;
+    this.logger = logger;
+  }
+  async get() {
+    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=${encodeURIComponent(email)}&scheme=JWT`, {
+      method: "POST",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "text/plain",
+        "x-mb-cors": "1"
+      },
+      body: password
+    });
+    if (response.status === 404)
+      throw new NotFoundError("User not found");
+    if (response.status >= 400)
+      await handleResponseProblem(response, this.logger);
+    try {
+      const data = await response.json();
+      const user = identitySchema.parse(data);
+      this.tokenStore.setUser(user);
+      return userSchema.parse(user);
+    } catch (err) {
+      this.logger.warn("Could not sign in user", { email, response, err });
+      throw new MoonbaseError("Bad response", "Could not sign in user", response.status);
+    }
+  }
+  async signUp(name, email, password, address, acceptedPrivacyPolicy, acceptedTermsAndConditions, communicationOptIn) {
+    const path = `/api/customer/identity/sign-up?scheme=JWT&communicationOptIn=${communicationOptIn ? "true" : "false"}`;
+    const response = await fetch(`${this.api.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "x-mb-cors": "1"
+      },
+      body: JSON.stringify({
+        name,
+        email,
+        password,
+        address,
+        acceptedPrivacyPolicy,
+        acceptedTermsAndConditions
+      })
+    });
+    if (response.status >= 400)
+      await handleResponseProblem(response, this.logger);
+    const data = await response.json();
+    if (response.status === 202) {
+      const parsed = pendingActivationSchema.parse(data);
+      return { status: "activation-pending", email: parsed.email };
+    }
+    try {
+      const identity = identitySchema.parse(data);
+      this.tokenStore.setUser(identity);
+      return { status: "signed-in", user: userSchema.parse(identity) };
+    } catch (err) {
+      this.logger.warn("Could not sign up user", { email, response, err });
+      throw new MoonbaseError("Bad response", "Could not sign up user", response.status);
+    }
+  }
+  async signOut() {
+    this.tokenStore.clear();
+  }
+  async update(name, email, emailConfirmationToken, communicationPreferences) {
+    const response = await this.api.authenticatedFetch("/api/customer/identity", userSchema, {
+      method: "PATCH",
+      body: {
+        name,
+        email,
+        emailConfirmationToken,
+        communicationPreferences
+      }
+    });
+    this.tokenStore.setUser(response.data);
+    return {
+      needsEmailConfirmationToken: response.status === 201,
+      user: response.data
+    };
+  }
+  async setPassword(currentPassword, newPassword) {
+    await this.api.authenticatedFetch(`/api/customer/identity/set-password`, null, {
+      method: "POST",
+      body: {
+        currentPassword,
+        newPassword
+      }
+    });
+  }
+  async forgotPassword(email) {
+    await this.api.fetch(`/api/customer/identity/forgot-password?email=${encodeURIComponent(email)}`, 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(" ", "+"))}`, {
+      method: "POST",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "text/plain",
+        "x-mb-cors": "1"
+      },
+      body: newPassword
+    });
+    if (response.status >= 400)
+      await handleResponseProblem(response, this.logger);
+  }
+  async confirmAccount(email, code) {
+    const response = await this.api.fetch(`/api/customer/identity/confirm-account?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code.replaceAll(" ", "+"))}&scheme=JWT`, userAccountConfirmedSchema, { method: "POST" });
+    const result = response.data;
+    if (result.status === "SignedIn") {
+      if (!result.accessToken || !result.refreshToken) {
+        this.logger.warn("Confirm-account returned SignedIn without tokens", { email });
+        throw new MoonbaseError(
+          "Bad response",
+          "Confirm-account succeeded but the server did not return auth tokens",
+          response.status
+        );
+      }
+      this.tokenStore.setUser({
+        ...result,
+        accessToken: result.accessToken,
+        refreshToken: result.refreshToken
+      });
+    }
+    return result;
+  }
+  async confirmEmail(email, code) {
+    await this.api.fetch(`/api/customer/identity/confirm-email?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code.replaceAll(" ", "+"))}`, null, { method: "POST" });
+  }
+  async confirmEmailChange(email, code) {
+    await this.api.authenticatedFetch(`/api/customer/identity/confirm-email-change?email=${encodeURIComponent(email)}&code=${encodeURIComponent(code.replaceAll(" ", "+"))}`, null, { method: "POST" });
+  }
+  async getConnectionUrl(provider, redirectUri, loginId) {
+    const params = new URLSearchParams({ redirectUri });
+    if (loginId)
+      params.set("loginId", loginId);
+    const response = await this.api.authenticatedFetch(
+      `/api/customer/connect/${provider}/authorize?${params.toString()}`,
+      connectionUrlSchema
+    );
+    return response.data.url;
+  }
+  async disconnectAccount(provider) {
+    await this.api.authenticatedFetch(`/api/customer/connect/${provider}`, null, { method: "DELETE" });
+  }
+};
+
+// src/inventory/activation/endpoints.ts
+var import_zod10 = require("zod");
+
+// src/inventory/licenses/schemas.ts
+var schemas_exports6 = {};
+__export(schemas_exports6, {
+  activationSchema: () => activationSchema,
+  externalLicenseContent: () => externalLicenseContent,
+  licenseSchema: () => licenseSchema
+});
+var import_zod9 = require("zod");
+
+// src/inventory/licenses/models.ts
+var LicenseStatus = /* @__PURE__ */ ((LicenseStatus2) => {
+  LicenseStatus2["Active"] = "Active";
+  LicenseStatus2["Pending"] = "Pending";
+  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/inventory/licenses/schemas.ts
+var externalLicenseFileContent = import_zod9.z.object({
+  type: import_zod9.z.literal("file"),
+  fileName: import_zod9.z.string(),
+  contentType: import_zod9.z.string(),
+  data: import_zod9.z.string()
+});
+var externalLicenseILokContent = import_zod9.z.object({
+  type: import_zod9.z.literal("iLok")
+});
+var externalLicenseContent = import_zod9.z.union([
+  import_zod9.z.string(),
+  import_zod9.z.discriminatedUnion("type", [
+    externalLicenseFileContent,
+    externalLicenseILokContent
+  ])
+]);
+var licenseSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  status: import_zod9.z.nativeEnum(LicenseStatus),
+  product: productSummarySchema,
+  activeNumberOfActivations: import_zod9.z.number(),
+  maxNumberOfActivations: import_zod9.z.number(),
+  externalFulfillment: externalLicenseContent.optional(),
+  requiredConnectedAccount: import_zod9.z.nativeEnum(ConnectableAccountProvider).nullish(),
+  fulfillmentMessage: import_zod9.z.string().optional(),
+  properties: import_zod9.z.record(rawPropertyValueSchema).nullish(),
+  expiresAt: import_zod9.z.coerce.date().optional(),
+  createdAt: import_zod9.z.coerce.date()
+});
+var activationSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  licenseId: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  status: import_zod9.z.nativeEnum(ActivationStatus),
+  activationMethod: import_zod9.z.nativeEnum(ActivationMethod),
+  firstValidatedAt: import_zod9.z.coerce.date(),
+  lastValidatedAt: import_zod9.z.coerce.date().nullable()
+});
+
+// src/inventory/activation/endpoints.ts
+var ActivationEndpoints = class {
+  constructor(api, configuration) {
+    this.api = api;
+    this.configuration = configuration;
+  }
+  async activate(deviceToken, activationMethod) {
+    const response = await this.api.authenticatedFetch(`/api/customer/inventory/activate?method=${activationMethod}${this.configuration.includeManifests ? "&includeManifests=true" : ""}`, licenseSchema, {
+      method: "POST",
+      body: deviceToken,
+      contentType: "text/plain"
+    });
+    return {
+      license: response.data,
+      url: import_zod10.z.string().parse(response.headers.location)
+    };
+  }
+};
+
+// src/inventory/licenses/endpoints.ts
+var LicenseEndpoints = class {
+  constructor(api, configuration) {
+    this.api = api;
+    this.configuration = configuration;
+  }
+  async get(nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/inventory/licenses${this.configuration.includeManifests ? "?includeManifests=true" : ""}`, paged(licenseSchema));
+    return response.data;
+  }
+  async getActivations(licenseId, nextUrl) {
+    const response = await this.api.authenticatedFetch(
+      nextUrl || `/api/customer/inventory/licenses/${licenseId}/activations`,
+      paged(activationSchema)
+    );
+    return response.data;
+  }
+  async revokeActivation(licenseId, activationId) {
+    await this.api.authenticatedFetch(`/api/customer/inventory/licenses/${licenseId}/activations/${activationId}/revoke`, null, { method: "POST" });
+  }
+};
+
+// src/inventory/products/endpoints.ts
+var import_zod11 = require("zod");
+var ProductEndpoints = class {
+  constructor(api, configuration) {
+    this.api = api;
+    this.configuration = configuration;
+  }
+  async get(productId, version) {
+    const response = await this.api.fetch(`/api/customer/inventory/products/${productId}${version ? `?version=${version}${this.configuration.includeManifests ? "&includeManifests=true" : ""}` : this.configuration.includeManifests ? "?includeManifests=true" : ""}`, productSummarySchema);
+    return response.data;
+  }
+  async getOwned(nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/inventory/products${this.configuration.includeManifests ? "?includeManifests=true" : ""}`, paged(productSummarySchema));
+    return response.data;
+  }
+  async getLicenses(productId, nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || `/api/customer/inventory/products/${productId}/licenses${this.configuration.includeManifests ? "?includeManifests=true" : ""}`, paged(licenseSchema));
+    return response.data;
+  }
+  async getActivations(productId, nextUrl) {
+    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, import_zod11.z.object({
+      location: import_zod11.z.string()
+    }));
+    return response.data.location;
+  }
+};
+
+// src/utils/api.ts
+function objectToQuery(obj) {
+  return Object.entries(obj != null ? obj : {}).filter(([_, value]) => value !== void 0).map(([key, value]) => `${key}=${encodeURIComponent(value instanceof Date ? value.toISOString() : value)}`).join("&");
+}
+var MoonbaseApi = class {
+  constructor(baseUrl, tokenStore, logger) {
+    this.baseUrl = baseUrl;
+    this.tokenStore = tokenStore;
+    this.logger = logger;
+  }
+  async authenticatedFetch(path, schema, options) {
+    if (!this.tokenStore.user)
+      throw new NotAuthenticatedError();
+    return await this.fetch(path, schema, options);
+  }
+  async fetch(path, schema, options) {
+    var _a;
+    const accessToken = await this.tokenStore.getAccessToken();
+    const contentType = (_a = options == null ? void 0 : options.contentType) != null ? _a : "application/json";
+    this.logger.debug("Making request to Moonbase API...", {
+      path,
+      body: options == null ? void 0 : options.body
+    });
+    const startedAt = /* @__PURE__ */ new Date();
+    const request = {
+      method: (options == null ? void 0 : options.method) || "GET",
+      mode: "cors",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": contentType,
+        // 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: (options == null ? void 0 : options.body) ? contentType !== "application/json" ? options.body : JSON.stringify(options.body) : void 0,
+      signal: options == null ? void 0 : options.abort,
+      redirect: "manual"
+    };
+    const response = await fetch(this.baseUrl + path, request);
+    const finishedAt = /* @__PURE__ */ new Date();
+    this.logger.debug("Received response from Moonbase", {
+      path,
+      status: response.status,
+      duration: finishedAt.getTime() - startedAt.getTime()
+    });
+    if (response.status >= 400) {
+      try {
+        await handleResponseProblem(response, this.logger);
+      } catch (err) {
+        this.reportRequestProblem(path, request, response, err);
+        throw err;
+      }
+    }
+    let json;
+    try {
+      json = schema ? await response.json() : null;
+      return {
+        data: schema ? schema.parse(json) : null,
+        headers: Object.fromEntries(response.headers.entries()),
+        status: response.status
+      };
+    } catch (err) {
+      this.logger.warn("Could not parse response", {
+        status: response.status,
+        path,
+        content: json || (response.bodyUsed ? "unknown" : await response.text()),
+        headers: Object.fromEntries(response.headers.entries()),
+        userAgent: window && window.navigator && window.navigator.userAgent,
+        err
+      });
+      this.reportParsingProblem(path, err, json || (response.bodyUsed ? "unknown" : await response.text()));
+      throw new MoonbaseError("Bad response", "Could not parse server response", response.status);
+    }
+  }
+  async reportParsingProblem(path, err, body) {
+    try {
+      await fetch(`${this.baseUrl}/api/customer/insights/error`, {
+        mode: "cors",
+        method: "POST",
+        headers: {
+          "Accept": "application/json",
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          title: "Parse error",
+          detail: `Could not parse response body`,
+          path,
+          origin: window == null ? void 0 : window.location.href,
+          userAgent: window && window.navigator && window.navigator.userAgent,
+          err,
+          body
+        })
+      });
+    } catch (e) {
+    }
+  }
+  async reportRequestProblem(path, request, response, err) {
+    try {
+      await fetch(`${this.baseUrl}/api/customer/insights/warn`, {
+        mode: "cors",
+        method: "POST",
+        headers: {
+          "Accept": "application/json",
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          title: "Request error",
+          detail: `Request failed with status ${response.status}`,
+          status: response.status,
+          request: {
+            ...request,
+            headers: void 0,
+            body: void 0
+          },
+          error: err,
+          path,
+          origin: window == null ? void 0 : window.location.href
+        })
+      });
+    } catch (e) {
+    }
+  }
+};
+
+// src/inventory/subscriptions/endpoints.ts
+var import_zod14 = require("zod");
+
+// src/inventory/subscriptions/schemas.ts
+var schemas_exports8 = {};
+__export(schemas_exports8, {
+  milestoneProgressSchema: () => milestoneProgressSchema,
+  subscriptionSchema: () => subscriptionSchema
+});
+var import_zod13 = require("zod");
+
+// src/inventory/subscriptions/models.ts
+var SubscriptionStatus = /* @__PURE__ */ ((SubscriptionStatus2) => {
+  SubscriptionStatus2["Active"] = "Active";
+  SubscriptionStatus2["Expired"] = "Expired";
+  SubscriptionStatus2["Cancelled"] = "Cancelled";
+  SubscriptionStatus2["Completed"] = "Completed";
+  return SubscriptionStatus2;
+})(SubscriptionStatus || {});
+
+// src/orders/schemas.ts
+var schemas_exports7 = {};
+__export(schemas_exports7, {
+  completedOrderSchema: () => completedOrderSchema,
+  openBundleLineItem: () => openBundleLineItem,
+  openOrderLineItem: () => openOrderLineItem,
+  openOrderSchema: () => openOrderSchema,
+  openProductLineItem: () => openProductLineItem,
+  orderSchema: () => orderSchema,
+  orderTotalSchema: () => orderTotalSchema
+});
+var import_zod12 = require("zod");
+
+// src/orders/models.ts
+var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
+  OrderStatus2["Open"] = "Open";
+  OrderStatus2["PaymentProcessing"] = "PaymentProcessing";
+  OrderStatus2["Paid"] = "Paid";
+  OrderStatus2["Completed"] = "Completed";
+  OrderStatus2["Failed"] = "Failed";
+  return OrderStatus2;
+})(OrderStatus || {});
+
+// src/orders/schemas.ts
+var couponSchema = import_zod12.z.object({
+  code: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  description: import_zod12.z.string()
+});
+var lineItemProductSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  tagline: import_zod12.z.string(),
+  iconUrl: import_zod12.z.string().nullable()
+});
+var lineItemTotalSchema = import_zod12.z.object({
+  original: moneySchema,
+  discount: moneySchema,
+  subtotal: moneySchema,
+  due: moneySchema
+});
+var openProductLineItem = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  type: import_zod12.z.literal("Product"),
+  productId: import_zod12.z.string(),
+  quantity: import_zod12.z.number(),
+  variationId: import_zod12.z.string(),
+  offerId: import_zod12.z.string().optional(),
+  isDefaultVariation: import_zod12.z.boolean().nullish(),
+  isSubcriptionPayment: import_zod12.z.boolean().nullish(),
+  price: priceCollectionSchema.optional(),
+  variation: pricingVariationSchema.optional(),
+  total: lineItemTotalSchema.nullish(),
+  product: lineItemProductSchema.optional(),
+  appliedDiscount: discountSchema.optional()
+});
+var lineItemBundleSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  tagline: import_zod12.z.string(),
+  iconUrl: import_zod12.z.string().nullable(),
+  products: lineItemProductSchema.and(import_zod12.z.object({
+    included: import_zod12.z.boolean().optional()
+  })).array()
+});
+var openBundleLineItem = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  type: import_zod12.z.literal("Bundle"),
+  bundleId: import_zod12.z.string(),
+  quantity: import_zod12.z.number(),
+  variationId: import_zod12.z.string(),
+  offerId: import_zod12.z.string().optional(),
+  partial: import_zod12.z.boolean().optional(),
+  replaced: import_zod12.z.string().array().optional(),
+  isDefaultVariation: import_zod12.z.boolean().nullish(),
+  isSubcriptionPayment: import_zod12.z.boolean().nullish(),
+  price: priceCollectionSchema.optional(),
+  variation: pricingVariationSchema.optional(),
+  total: lineItemTotalSchema.nullish(),
+  bundle: lineItemBundleSchema.optional(),
+  appliedDiscount: discountSchema.optional()
+});
+var openOrderLineItem = import_zod12.z.discriminatedUnion("type", [
+  openProductLineItem,
+  openBundleLineItem
+]);
+var orderTotalSchema = import_zod12.z.object({
+  original: moneySchema,
+  discount: moneySchema,
+  subtotal: moneySchema,
+  taxes: moneySchema,
+  due: moneySchema
+});
+var openOrderSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  currency: import_zod12.z.string(),
+  total: orderTotalSchema.nullish(),
+  items: openOrderLineItem.array(),
+  couponsApplied: couponSchema.array(),
+  checkoutUrl: import_zod12.z.string().optional(),
+  hostedCheckoutUrl: import_zod12.z.string().optional(),
+  embeddedCheckoutUrl: import_zod12.z.string().optional()
+});
+var customerSnapshotSchema = import_zod12.z.object({
+  name: import_zod12.z.string().nullable(),
+  businessName: import_zod12.z.string().nullable(),
+  taxId: import_zod12.z.string().nullable(),
+  email: import_zod12.z.string().nullable(),
+  phone: import_zod12.z.string().nullable(),
+  address: addressSchema.nullable()
+});
+var completedOrderSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  status: import_zod12.z.literal("Completed" /* Completed */),
+  currency: import_zod12.z.string(),
+  customer: customerSnapshotSchema,
+  total: orderTotalSchema,
+  items: openOrderLineItem.array(),
+  couponsApplied: couponSchema.array()
+});
+var orderSchema = import_zod12.z.discriminatedUnion("status", [
+  openOrderSchema.extend({
+    status: import_zod12.z.literal("Open" /* Open */)
+  }),
+  openOrderSchema.extend({
+    status: import_zod12.z.literal("PaymentProcessing" /* PaymentProcessing */)
+  }),
+  openOrderSchema.extend({
+    status: import_zod12.z.literal("Paid" /* Paid */)
+  }),
+  openOrderSchema.extend({
+    status: import_zod12.z.literal("Failed" /* Failed */)
+  }),
+  completedOrderSchema
+]);
+
+// src/inventory/subscriptions/schemas.ts
+var baseMilestoneProgressEventSchema = import_zod13.z.object({
+  milestoneId: import_zod13.z.string(),
+  fulfilled: import_zod13.z.boolean(),
+  afterCycleNumber: import_zod13.z.number(),
+  afterNormalizedCycleNumber: import_zod13.z.number(),
+  message: import_zod13.z.string().optional()
+});
+var milestoneProgressEventSchema = import_zod13.z.discriminatedUnion("type", [
+  baseMilestoneProgressEventSchema.extend({
+    type: import_zod13.z.literal("CouponCodeMilestone"),
+    code: import_zod13.z.string().optional(),
+    redeemed: import_zod13.z.boolean().optional()
+  }),
+  baseMilestoneProgressEventSchema.extend({
+    type: import_zod13.z.literal("PerpetualLicenseConversionMilestone")
+  })
+]);
+var milestoneProgressSchema = import_zod13.z.object({
+  title: import_zod13.z.string(),
+  description: import_zod13.z.string().nullish(),
+  currentCycleNumber: import_zod13.z.number(),
+  currentNormalizedCycleNumber: import_zod13.z.number(),
+  currentCycleIsCompleted: import_zod13.z.boolean(),
+  fromCycleNumber: import_zod13.z.number(),
+  fromNormalizedCycleNumber: import_zod13.z.number(),
+  toCycleNumber: import_zod13.z.number(),
+  toNormalizedCycleNumber: import_zod13.z.number(),
+  events: import_zod13.z.record(import_zod13.z.coerce.number(), milestoneProgressEventSchema.array())
+});
+var subscriptionSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  status: import_zod13.z.nativeEnum(SubscriptionStatus),
+  hasPaymentMethod: import_zod13.z.boolean(),
+  cancellable: import_zod13.z.boolean(),
+  expiresAt: import_zod13.z.coerce.date(),
+  renewedAt: import_zod13.z.coerce.date().nullable(),
+  nextPaymentScheduledAt: import_zod13.z.coerce.date().nullable(),
+  startedAt: import_zod13.z.coerce.date(),
+  total: orderTotalSchema,
+  cycleLength: import_zod13.z.nativeEnum(CycleLength),
+  paymentMethod: import_zod13.z.string().optional(),
+  milestoneProgress: milestoneProgressSchema.nullish(),
+  embeddedUpdatePaymentUrl: import_zod13.z.string().optional(),
+  content: import_zod13.z.discriminatedUnion("type", [
+    import_zod13.z.object({
+      type: import_zod13.z.literal("Product"),
+      quantity: import_zod13.z.number(),
+      product: storefrontProductSchema
+    }),
+    import_zod13.z.object({
+      type: import_zod13.z.literal("Bundle"),
+      quantity: import_zod13.z.number(),
+      bundle: storefrontBundleSchema
+    })
+  ])
+});
+
+// src/inventory/subscriptions/endpoints.ts
+var SubscriptionEndpoints = class {
+  constructor(api, configuration) {
+    this.api = api;
+    this.configuration = configuration;
+  }
+  async get(nextUrl) {
+    const response = await this.api.authenticatedFetch(nextUrl || "/api/customer/inventory/subscriptions", paged(subscriptionSchema));
+    return response.data;
+  }
+  async getById(subscriptionId, options) {
+    const response = await this.api.authenticatedFetch(`/api/customer/inventory/subscriptions/${subscriptionId}?${objectToQuery(options)}`, subscriptionSchema);
+    return response.data;
+  }
+  async cancel(subscriptionId) {
+    const response = await this.api.authenticatedFetch(`/api/customer/inventory/subscriptions/${subscriptionId}/cancel`, subscriptionSchema, { method: "POST" });
+    return response.data;
+  }
+  async renew(subscriptionId, returnUrl, embedded) {
+    const response = await this.api.authenticatedFetch(`/api/customer/inventory/subscriptions/${subscriptionId}/renew?redirect=false&return=${returnUrl}&embedded=${embedded ? "true" : "false"}`, import_zod14.z.object({
+      location: import_zod14.z.string()
+    }), { method: "POST" });
+    return response.data;
+  }
+};
+
+// src/inventory/index.ts
+var InventoryEndpoints = class {
+  constructor(api, configuration) {
+    this.licenses = new LicenseEndpoints(api, configuration);
+    this.products = new ProductEndpoints(api, configuration);
+    this.activation = new ActivationEndpoints(api, configuration);
+    this.subscriptions = new SubscriptionEndpoints(api, configuration);
+  }
+};
+
+// src/orders/endpoints.ts
+var OrderEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async get(orderId, options) {
+    const query = new URLSearchParams();
+    if (options == null ? void 0 : options.finalize) {
+      query.append("finalize", "true");
+    }
+    if (options == null ? void 0 : options.checkout) {
+      query.append("checkout", "true");
+      if (options.checkout.returnUrl) {
+        query.append("returnUrl", options.checkout.returnUrl);
+      }
+    }
+    const response = await this.api.fetch(`/api/customer/orders/${orderId}?${query.toString()}`, orderSchema, {
+      abort: options == null ? void 0 : options.abort
+    });
+    return response.data;
+  }
+  async pushContent(order, checkout, utm) {
+    const query = {
+      ...utmToObject(utm)
+    };
+    if (checkout) {
+      query.checkout = "true";
+      if (checkout.returnUrl)
+        query.returnUrl = checkout.returnUrl;
+    }
+    const response = await this.api.fetch(
+      `/api/customer/orders/${order.id}?${new URLSearchParams(query).toString()}`,
+      openOrderSchema,
+      {
+        method: "PATCH",
+        body: {
+          currency: order.currency || void 0,
+          items: order.items
+        }
+      }
+    );
+    return response.data;
+  }
+  async addBillingDetails(orderId, details) {
+    const response = await this.api.fetch(`/api/customer/orders/${orderId}/billing-details`, openOrderSchema, { method: "PATCH", body: details });
+    return response.data;
+  }
+  async removeBillingDetails(orderId) {
+    const response = await this.api.fetch(`/api/customer/orders/${orderId}/billing-details`, openOrderSchema, { method: "DELETE" });
+    return response.data;
+  }
+  async addCouponCode(orderId, code) {
+    const response = await this.api.fetch(`/api/customer/orders/${orderId}/coupon?code=${encodeURIComponent(code)}`, openOrderSchema, { method: "PATCH" });
+    return response.data;
+  }
+  async removeCouponCode(orderId, code) {
+    const response = await this.api.fetch(`/api/customer/orders/${orderId}/coupon?code=${encodeURIComponent(code)}`, openOrderSchema, { method: "DELETE" });
+    return response.data;
+  }
+  async clearCouponCodes(orderId) {
+    const response = await this.api.fetch(`/api/customer/orders/${orderId}/coupons`, openOrderSchema, { method: "DELETE" });
+    return response.data;
+  }
+};
+
+// src/storefront/endpoints.ts
+var StorefrontEndpoints = class {
+  constructor(api, configuration) {
+    this.api = api;
+    this.configuration = configuration;
+  }
+  async get(utm) {
+    const query = new URLSearchParams(this.configuration.includeManifests ? {
+      includeManifests: "true",
+      ...utmToObject(utm)
+    } : utmToObject(utm));
+    const response = await this.api.fetch(`/api/customer/storefront?${query.toString()}`, storefrontSchema);
+    return response.data;
+  }
+};
+
+// src/utils/store.ts
+var LocalStorageStore = class {
+  get(key) {
+    const item = localStorage.getItem(key);
+    if (item) {
+      return JSON.parse(item);
+    }
+    return null;
+  }
+  set(key, item) {
+    localStorage.setItem(key, JSON.stringify(item));
+  }
+  remove(key) {
+    localStorage.removeItem(key);
+  }
+  listen(key, callback) {
+    if (typeof window !== "undefined") {
+      window.addEventListener("storage", (event) => {
+        if (event.key === key) {
+          callback(event.newValue ? JSON.parse(event.newValue) : null);
+        }
+      });
+    }
+  }
+};
+var InMemoryStore = class {
+  constructor() {
+    this.store = {};
+    this.listeners = {};
+  }
+  get(key) {
+    var _a;
+    return (_a = this.store[key]) != null ? _a : null;
+  }
+  set(key, item) {
+    this.store[key] = item;
+    for (const listener of this.listeners[key] || []) {
+      listener(item);
+    }
+  }
+  remove(key) {
+    delete this.store[key];
+    for (const listener of this.listeners[key] || []) {
+      listener(null);
+    }
+  }
+  listen(key, callback) {
+    if (!this.listeners[key]) this.listeners[key] = [];
+    this.listeners[key].push(callback);
+  }
+};
+
+// src/utils/tokenStore.ts
+var _TokenStore = class _TokenStore {
+  constructor(configuration) {
+    this.configuration = configuration;
+    this.tokens = null;
+    this.refreshTimeoutId = null;
+    this.refreshPromise = null;
+    var _a;
+    this.store = (_a = configuration.store) != null ? _a : typeof window !== "undefined" && localStorage ? new LocalStorageStore() : new InMemoryStore();
+    const storedToken = this.store.get(_TokenStore.storageKey);
+    if (storedToken) {
+      this.tokens = {
+        ...storedToken,
+        expiresAt: new Date(storedToken.expiresAt)
+      };
+    }
+    this.store.listen(_TokenStore.storageKey, (updatedTokens) => this.handleStorageUpdate(updatedTokens));
+  }
+  get user() {
+    if (this.tokens)
+      return this.tokens;
+    return null;
+  }
+  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) {
+    const identity = user;
+    if (!identity.accessToken || !identity.refreshToken) {
+      if (!this.tokens) return null;
+      this.tokens = {
+        ...user,
+        accessToken: this.tokens.accessToken,
+        refreshToken: this.tokens.refreshToken,
+        expiresAt: this.tokens.expiresAt
+      };
+    } else {
+      this.tokens = {
+        ...identity,
+        // Hardcoded 15 minutes now, might want to check the JWT tho
+        expiresAt: new Date((/* @__PURE__ */ new Date()).getTime() + 15 * 60 * 1e3)
+      };
+    }
+    this.store.set(_TokenStore.storageKey, this.tokens);
+    if (typeof window !== "undefined") {
+      if (this.refreshTimeoutId != null)
+        window.clearTimeout(this.refreshTimeoutId);
+      this.refreshTimeoutId = window.setTimeout(() => {
+        this.refreshPromise = this.refreshTokens();
+      }, 10 * 60 * 1e3);
+    }
+    return this.tokens;
+  }
+  clear() {
+    this.tokens = null;
+    this.store.remove(_TokenStore.storageKey);
+    if (this.refreshTimeoutId != null && typeof window !== "undefined")
+      window.clearTimeout(this.refreshTimeoutId);
+    return null;
+  }
+  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 fetch(`${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 || response.status === 404) {
+        this.clear();
+        return null;
+      }
+      throw new MoonbaseError("Unexpected result", `Could not refresh access token, status code ${response.status}`, response.status);
+    }
+    const result = identitySchema.parse(await response.json());
+    this.setUser(result);
+    return this.tokens;
+  }
+  handleStorageUpdate(updatedTokens) {
+    this.tokens = updatedTokens;
+    if (this.refreshTimeoutId != null)
+      window.clearTimeout(this.refreshTimeoutId);
+    if (this.tokens) {
+      this.tokens.expiresAt = new Date(this.tokens.expiresAt);
+    }
+  }
+};
+_TokenStore.storageKey = "moonbase_auth";
+var TokenStore = _TokenStore;
+
+// src/vendor/schemas.ts
+var schemas_exports9 = {};
+__export(schemas_exports9, {
+  vendorSchema: () => vendorSchema
+});
+var import_zod15 = require("zod");
+var vendorSchema = import_zod15.z.object({
+  id: import_zod15.z.string(),
+  name: import_zod15.z.string(),
+  logoUrl: import_zod15.z.string().nullable()
+});
+
+// src/vendor/endpoints.ts
+var VendorEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async get() {
+    const response = await this.api.fetch(`/api/public/vendors/current`, vendorSchema);
+    return response.data;
+  }
+};
+
+// src/vouchers/schemas.ts
+var schemas_exports10 = {};
+__export(schemas_exports10, {
+  voucherSchema: () => voucherSchema
+});
+var import_zod16 = require("zod");
+var voucherSchema = import_zod16.z.object({
+  id: import_zod16.z.string(),
+  name: import_zod16.z.string(),
+  description: import_zod16.z.string(),
+  code: import_zod16.z.string(),
+  redeemed: import_zod16.z.boolean(),
+  redeemsProducts: quantifiable(storefrontProductSchema).array(),
+  redeemsBundles: quantifiable(storefrontBundleSchema).array(),
+  properties: import_zod16.z.record(rawPropertyValueSchema).nullish()
+});
+
+// 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)}`, voucherSchema);
+    return response.data;
+  }
+  async redeem(code) {
+    const response = await this.api.authenticatedFetch(
+      `/api/customer/vouchers/redeem?code=${encodeURIComponent(code)}`,
+      voucherSchema,
+      {
+        method: "POST"
+      }
+    );
+    return response.data;
+  }
+};
+
+// src/utils/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["Debug"] = 0] = "Debug";
+  LogLevel2[LogLevel2["Information"] = 1] = "Information";
+  LogLevel2[LogLevel2["Warn"] = 2] = "Warn";
+  LogLevel2[LogLevel2["Error"] = 3] = "Error";
+  return LogLevel2;
+})(LogLevel || {});
+var ConsoleLogger = class {
+  constructor(level = 2 /* Warn */) {
+    this.level = level;
+  }
+  debug(message, ...optionalParams) {
+    if (this.level <= 0 /* Debug */) console.debug(message, ...optionalParams);
+  }
+  log(message, ...optionalParams) {
+    if (this.level <= 1 /* Information */) console.log(message, ...optionalParams);
+  }
+  warn(message, ...optionalParams) {
+    if (this.level <= 2 /* Warn */) console.warn(message, ...optionalParams);
+  }
+  error(message, ...optionalParams) {
+    if (this.level <= 3 /* Error */) console.error(message, ...optionalParams);
+  }
+};
+
+// src/schemas.ts
+var schemas_exports12 = {};
+__export(schemas_exports12, {
+  activationRequests: () => schemas_exports3,
+  communications: () => schemas_exports4,
+  identity: () => schemas_exports5,
+  inventory: () => schemas_exports11,
+  orders: () => schemas_exports7,
+  storefront: () => schemas_exports2,
+  vendor: () => schemas_exports9,
+  vouchers: () => schemas_exports10
+});
+
+// src/inventory/schemas.ts
+var schemas_exports11 = {};
+__export(schemas_exports11, {
+  licenses: () => schemas_exports6,
+  products: () => schemas_exports,
+  subscriptions: () => schemas_exports8
+});
+
+// src/utils/discount.ts
+var DiscountUtils = class {
+  static apply(discount, price) {
+    switch (discount.type) {
+      case "PercentageOffDiscount":
+        return Object.fromEntries(Object.entries(price).map(([currency, amount]) => [currency, amount * discount.percentage]));
+      case "FlatAmountOffDiscount":
+        return Object.fromEntries(Object.entries(price).map(([currency, amount]) => {
+          var _a, _b;
+          return [currency, Math.min(amount, (_b = (_a = discount.total) == null ? void 0 : _a[currency]) != null ? _b : 0)];
+        }));
+    }
+  }
+};
+
+// src/utils/money.ts
+var MoneyCollectionUtils = class {
+  static sum(a, b) {
+    return Object.fromEntries(Object.entries(a).map(([currency, amount]) => [currency, amount + b[currency]]));
+  }
+  static subtract(a, b) {
+    return Object.fromEntries(Object.entries(a).map(([currency, amount]) => [currency, amount - b[currency]]));
+  }
+};
+
+// src/utils/offer.ts
+var OfferUtils = class _OfferUtils {
+  static eligible(offer, order) {
+    switch (offer.condition.type) {
+      case "CartContainsItems":
+        const relevantItems = order.items.filter(
+          (i) => i.type === "Product" && offer.condition.relevantItemVariations[`Product/${i.productId}`] && offer.condition.relevantItemVariations[`Product/${i.productId}`].includes(i.variationId) || i.type === "Bundle" && offer.condition.relevantItemVariations[`Bundle/${i.bundleId}`] && offer.condition.relevantItemVariations[`Bundle/${i.bundleId}`].includes(i.variationId)
+        );
+        const relevantReplacedItems = order.items.flatMap((i) => {
+          var _a;
+          return offer.id === i.offerId && i.type === "Bundle" && _OfferUtils.targetContainsBundle(offer, i.id) ? (_a = i.replaced) != null ? _a : [] : [];
+        }).filter((ref) => {
+          const [productId, variationId] = ref.split("/");
+          return offer.condition.relevantItemVariations[`Product/${productId}`] && offer.condition.relevantItemVariations[`Product/${productId}`].includes(variationId);
+        });
+        return relevantItems.length + relevantReplacedItems.length >= offer.condition.minimumItems;
+    }
+    console.warn("Unsupported offer condition found:", offer.condition);
+    return false;
+  }
+  // The relevant targets of an offer with more than a single target needs to:
+  // a. Not be owned, or all targets need to be owned
+  // b. Not already in the cart
+  static relevantTargets(offer, cartItems) {
+    if (Array.isArray(offer.target)) {
+      const allOwned = offer.target.every((i) => i.owned);
+      return offer.target.filter((i) => (allOwned || !i.owned) && !cartItems.some((l) => l.type === i.type && i.id === (l.type === "Product" ? l.productId : l.bundleId)));
+    }
+    return [offer.target];
+  }
+  static applyToVariation(offer, variation) {
+    const discount = DiscountUtils.apply(offer.discount, variation.price);
+    return {
+      ...variation,
+      price: MoneyCollectionUtils.subtract(variation.price, discount),
+      hasDiscount: Object.values(discount).some((v) => v > 0) || variation.hasDiscount
+    };
+  }
+  static targetContainsBundle(offer, bundleId) {
+    if (Array.isArray(offer.target)) return offer.target.some((i) => i.type === "Bundle" && i.id === bundleId);
+  }
+};
+
+// src/utils/utm.ts
+function parseOffSiteReferrer(rawReferrer, currentOrigin) {
+  if (!rawReferrer)
+    return void 0;
+  try {
+    const referrerUrl = new URL(rawReferrer);
+    if (referrerUrl.origin === currentOrigin)
+      return void 0;
+    return referrerUrl.host || void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function resolveUtm(cached, fresh) {
+  const freshHasUtm = !!(fresh.source || fresh.medium || fresh.campaign || fresh.term || fresh.content);
+  const freshIsExternalArrival = freshHasUtm || !!fresh.referrer;
+  if (freshIsExternalArrival)
+    return fresh;
+  return cached != null ? cached : fresh;
+}
+
+// src/index.ts
+var MoonbaseClient = class {
+  constructor(configuration) {
+    var _a;
+    this.configuration = configuration;
+    this.configuration.endpoint = this.configuration.endpoint.replace(/\/$/, "");
+    this.logger = (_a = this.configuration.logger) != null ? _a : new ConsoleLogger();
+    this.tokenStore = new TokenStore(configuration);
+    this.api = new MoonbaseApi(this.configuration.endpoint, this.tokenStore, this.logger);
+    this.storefront = new StorefrontEndpoints(this.api, this.configuration);
+    this.identity = new IdentityEndpoints(this.api, this.tokenStore, this.logger);
+    this.communications = new CommunicationsEndpoints(this.api);
+    this.vouchers = new VoucherEndpoints(this.api);
+    this.orders = new OrderEndpoints(this.api);
+    this.inventory = new InventoryEndpoints(this.api, this.configuration);
+    this.activationRequests = new ActivationRequestEndpoints(this.api);
+    this.vendor = new VendorEndpoints(this.api);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActivationMethod,
+  ActivationRequestFulfillmentType,
+  ActivationRequestStatus,
+  ActivationStatus,
+  Architecture,
+  ConnectableAccountProvider,
+  ConsoleLogger,
+  CycleLength,
+  DiscountUtils,
+  InMemoryStore,
+  LicenseStatus,
+  LocalStorageStore,
+  LogLevel,
+  MarketingConsentType,
+  MoneyCollectionUtils,
+  MoonbaseApi,
+  MoonbaseClient,
+  MoonbaseError,
+  NotAuthenticatedError,
+  NotAuthorizedError,
+  NotFoundError,
+  OfferUtils,
+  OrderStatus,
+  Platform,
+  SubscriptionStatus,
+  TokenStore,
+  objectToQuery,
+  parseOffSiteReferrer,
+  problemDetailsSchema,
+  resolveUtm,
+  schemas,
+  utmToObject
+});