@moonbase.sh/storefront-api 1.0.36 → 2.0.0

package/dist/index.cjs

@@ -47,7 +47,7 @@ __export(index_exports, {
   TokenStore: () => TokenStore,
   objectToQuery: () => objectToQuery,
   problemDetailsSchema: () => problemDetailsSchema,
-  schemas: () => schemas_exports11,
+  schemas: () => schemas_exports12,
   utmToObject: () => utmToObject
 });
 module.exports = __toCommonJS(index_exports);
@@ -353,6 +353,81 @@ var ActivationRequestEndpoints = class {
   }
 };
 
+// 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() {
@@ -392,14 +467,14 @@ var MoonbaseError = class extends Error {
 };
 
 // src/utils/problemDetails.ts
-var import_zod6 = require("zod");
-var problemDetailsSchema = import_zod6.z.object({
-  type: import_zod6.z.string().optional(),
-  title: import_zod6.z.string(),
-  detail: import_zod6.z.string().optional(),
-  status: import_zod6.z.number().optional(),
-  instance: import_zod6.z.string().optional(),
-  errors: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string().array()).optional()
+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
@@ -438,18 +513,20 @@ async function handleResponseProblem(response, logger) {
 }
 
 // src/identity/schemas.ts
-var schemas_exports4 = {};
-__export(schemas_exports4, {
+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_zod7 = require("zod");
+var import_zod8 = require("zod");
 
 // src/identity/models.ts
 var ConnectableAccountProvider = /* @__PURE__ */ ((ConnectableAccountProvider2) => {
@@ -458,54 +535,64 @@ var ConnectableAccountProvider = /* @__PURE__ */ ((ConnectableAccountProvider2)
 })(ConnectableAccountProvider || {});
 
 // src/identity/schemas.ts
-var addressSchema = import_zod7.z.object({
-  countryCode: import_zod7.z.string(),
-  streetAddress1: import_zod7.z.string(),
-  streetAddress2: import_zod7.z.string().nullable(),
-  locality: import_zod7.z.string().nullable(),
-  region: import_zod7.z.string().nullable(),
-  postCode: import_zod7.z.string().nullable()
+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_zod7.z.object({
-  newsletterOptIn: import_zod7.z.boolean()
-  // productUpdatesOptIn: z.boolean(), // TODO: Enable when relevant
+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_zod7.z.object({
-  provider: import_zod7.z.literal("iLok" /* iLok */),
-  isConnected: import_zod7.z.boolean(),
-  pendingLicenseFulfillments: import_zod7.z.boolean(),
-  accountId: import_zod7.z.string().nullish()
+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_zod7.z.discriminatedUnion("provider", [
+var connectedAccountSchema = import_zod8.z.discriminatedUnion("provider", [
   ilokConnectedAccountSchema
 ]);
-var connectionUrlSchema = import_zod7.z.object({
-  url: import_zod7.z.string()
+var connectionUrlSchema = import_zod8.z.object({
+  url: import_zod8.z.string()
 });
-var userSchema = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  email: import_zod7.z.string(),
-  name: import_zod7.z.string(),
-  tenantId: import_zod7.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_zod7.z.string().optional(),
+  phone: import_zod8.z.string().optional(),
   communicationPreferences: communicationPreferencesSchema,
-  ownedProducts: import_zod7.z.string().array().optional(),
-  subscribedProducts: import_zod7.z.string().array().optional(),
-  confirmedAccount: import_zod7.z.boolean().optional(),
-  hasProducts: import_zod7.z.boolean().nullish(),
-  hasSubscriptions: import_zod7.z.boolean().nullish(),
-  connectedAccounts: import_zod7.z.array(connectedAccountSchema).default([])
+  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_zod7.z.object({
-  accessToken: import_zod7.z.string(),
-  refreshToken: import_zod7.z.string()
+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 userAccountConfirmedSchema = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  name: import_zod7.z.string(),
-  email: import_zod7.z.string(),
-  resetPasswordToken: import_zod7.z.string().nullable()
+var pendingActivationSchema = import_zod8.z.object({
+  status: import_zod8.z.literal("activation_pending"),
+  email: import_zod8.z.string()
 });
 
 // src/identity/endpoints.ts
@@ -544,19 +631,38 @@ 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"}`, identitySchema, {
+    const path = `/api/customer/identity/sign-up?scheme=JWT&communicationOptIn=${communicationOptIn ? "true" : "false"}`;
+    const response = await fetch(`${this.api.baseUrl}${path}`, {
       method: "POST",
-      body: {
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "x-mb-cors": "1"
+      },
+      body: JSON.stringify({
         name,
         email,
         password,
         address,
         acceptedPrivacyPolicy,
         acceptedTermsAndConditions
-      }
+      })
     });
-    this.tokenStore.setUser(response.data);
-    return userSchema.parse(response.data);
+    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();
@@ -603,13 +709,24 @@ var IdentityEndpoints = class {
       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(" ", "+"))}`, userAccountConfirmedSchema, { method: "POST" });
-    try {
-      return userAccountConfirmedSchema.parse(response.data);
-    } catch (err) {
-      this.logger.warn("Could not confirm user account", { email, code, response, err });
-      throw new MoonbaseError("Bad response", "Could not confirm user account", response.status);
+    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" });
@@ -633,16 +750,16 @@ var IdentityEndpoints = class {
 };
 
 // src/inventory/activation/endpoints.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // src/inventory/licenses/schemas.ts
-var schemas_exports5 = {};
-__export(schemas_exports5, {
+var schemas_exports6 = {};
+__export(schemas_exports6, {
   activationSchema: () => activationSchema,
   externalLicenseContent: () => externalLicenseContent,
   licenseSchema: () => licenseSchema
 });
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 
 // src/inventory/licenses/models.ts
 var LicenseStatus = /* @__PURE__ */ ((LicenseStatus2) => {
@@ -663,43 +780,43 @@ var ActivationMethod = /* @__PURE__ */ ((ActivationMethod2) => {
 })(ActivationMethod || {});
 
 // src/inventory/licenses/schemas.ts
-var externalLicenseFileContent = import_zod8.z.object({
-  type: import_zod8.z.literal("file"),
-  fileName: import_zod8.z.string(),
-  contentType: import_zod8.z.string(),
-  data: import_zod8.z.string()
+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_zod8.z.object({
-  type: import_zod8.z.literal("iLok")
+var externalLicenseILokContent = import_zod9.z.object({
+  type: import_zod9.z.literal("iLok")
 });
-var externalLicenseContent = import_zod8.z.union([
-  import_zod8.z.string(),
-  import_zod8.z.discriminatedUnion("type", [
+var externalLicenseContent = import_zod9.z.union([
+  import_zod9.z.string(),
+  import_zod9.z.discriminatedUnion("type", [
     externalLicenseFileContent,
     externalLicenseILokContent
   ])
 ]);
-var licenseSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  status: import_zod8.z.nativeEnum(LicenseStatus),
+var licenseSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  status: import_zod9.z.nativeEnum(LicenseStatus),
   product: productSummarySchema,
-  activeNumberOfActivations: import_zod8.z.number(),
-  maxNumberOfActivations: import_zod8.z.number(),
+  activeNumberOfActivations: import_zod9.z.number(),
+  maxNumberOfActivations: import_zod9.z.number(),
   externalFulfillment: externalLicenseContent.optional(),
-  requiredConnectedAccount: import_zod8.z.nativeEnum(ConnectableAccountProvider).nullish(),
-  fulfillmentMessage: import_zod8.z.string().optional(),
-  properties: import_zod8.z.record(rawPropertyValueSchema).nullish(),
-  expiresAt: import_zod8.z.coerce.date().optional(),
-  createdAt: import_zod8.z.coerce.date()
+  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_zod8.z.object({
-  id: import_zod8.z.string(),
-  licenseId: import_zod8.z.string(),
-  name: import_zod8.z.string(),
-  status: import_zod8.z.nativeEnum(ActivationStatus),
-  activationMethod: import_zod8.z.nativeEnum(ActivationMethod),
-  firstValidatedAt: import_zod8.z.coerce.date(),
-  lastValidatedAt: import_zod8.z.coerce.date().nullable()
+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
@@ -716,7 +833,7 @@ var ActivationEndpoints = class {
     });
     return {
       license: response.data,
-      url: import_zod9.z.string().parse(response.headers.location)
+      url: import_zod10.z.string().parse(response.headers.location)
     };
   }
 };
@@ -744,7 +861,7 @@ var LicenseEndpoints = class {
 };
 
 // src/inventory/products/endpoints.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var ProductEndpoints = class {
   constructor(api, configuration) {
     this.api = api;
@@ -769,8 +886,8 @@ var ProductEndpoints = class {
   async getDownloadUrl(path) {
     const url = new URL(path);
     url.searchParams.append("redirect", "false");
-    const response = await this.api.fetch(url.pathname + url.search, import_zod10.z.object({
-      location: import_zod10.z.string()
+    const response = await this.api.fetch(url.pathname + url.search, import_zod11.z.object({
+      location: import_zod11.z.string()
     }));
     return response.data.location;
   }
@@ -902,15 +1019,15 @@ var MoonbaseApi = class {
 };
 
 // src/inventory/subscriptions/endpoints.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 
 // src/inventory/subscriptions/schemas.ts
-var schemas_exports7 = {};
-__export(schemas_exports7, {
+var schemas_exports8 = {};
+__export(schemas_exports8, {
   milestoneProgressSchema: () => milestoneProgressSchema,
   subscriptionSchema: () => subscriptionSchema
 });
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 
 // src/inventory/subscriptions/models.ts
 var SubscriptionStatus = /* @__PURE__ */ ((SubscriptionStatus2) => {
@@ -922,8 +1039,8 @@ var SubscriptionStatus = /* @__PURE__ */ ((SubscriptionStatus2) => {
 })(SubscriptionStatus || {});
 
 // src/orders/schemas.ts
-var schemas_exports6 = {};
-__export(schemas_exports6, {
+var schemas_exports7 = {};
+__export(schemas_exports7, {
   completedOrderSchema: () => completedOrderSchema,
   openBundleLineItem: () => openBundleLineItem,
   openOrderLineItem: () => openOrderLineItem,
@@ -932,7 +1049,7 @@ __export(schemas_exports6, {
   orderSchema: () => orderSchema,
   orderTotalSchema: () => orderTotalSchema
 });
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 
 // src/orders/models.ts
 var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
@@ -945,171 +1062,171 @@ var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
 })(OrderStatus || {});
 
 // src/orders/schemas.ts
-var couponSchema = import_zod11.z.object({
-  code: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  description: import_zod11.z.string()
+var couponSchema = import_zod12.z.object({
+  code: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  description: import_zod12.z.string()
 });
-var lineItemProductSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  tagline: import_zod11.z.string(),
-  iconUrl: import_zod11.z.string().nullable()
+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_zod11.z.object({
+var lineItemTotalSchema = import_zod12.z.object({
   original: moneySchema,
   discount: moneySchema,
   subtotal: moneySchema,
   due: moneySchema
 });
-var openProductLineItem = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  type: import_zod11.z.literal("Product"),
-  productId: import_zod11.z.string(),
-  quantity: import_zod11.z.number(),
-  variationId: import_zod11.z.string(),
-  offerId: import_zod11.z.string().optional(),
-  isDefaultVariation: import_zod11.z.boolean().nullish(),
-  isSubcriptionPayment: import_zod11.z.boolean().nullish(),
+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_zod11.z.object({
-  id: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  tagline: import_zod11.z.string(),
-  iconUrl: import_zod11.z.string().nullable(),
-  products: lineItemProductSchema.and(import_zod11.z.object({
-    included: import_zod11.z.boolean().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_zod11.z.object({
-  id: import_zod11.z.string(),
-  type: import_zod11.z.literal("Bundle"),
-  bundleId: import_zod11.z.string(),
-  quantity: import_zod11.z.number(),
-  variationId: import_zod11.z.string(),
-  offerId: import_zod11.z.string().optional(),
-  partial: import_zod11.z.boolean().optional(),
-  replaced: import_zod11.z.string().array().optional(),
-  isDefaultVariation: import_zod11.z.boolean().nullish(),
-  isSubcriptionPayment: import_zod11.z.boolean().nullish(),
+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_zod11.z.discriminatedUnion("type", [
+var openOrderLineItem = import_zod12.z.discriminatedUnion("type", [
   openProductLineItem,
   openBundleLineItem
 ]);
-var orderTotalSchema = import_zod11.z.object({
+var orderTotalSchema = import_zod12.z.object({
   original: moneySchema,
   discount: moneySchema,
   subtotal: moneySchema,
   taxes: moneySchema,
   due: moneySchema
 });
-var openOrderSchema = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  currency: import_zod11.z.string(),
+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_zod11.z.string().optional(),
-  hostedCheckoutUrl: import_zod11.z.string().optional(),
-  embeddedCheckoutUrl: import_zod11.z.string().optional()
+  checkoutUrl: import_zod12.z.string().optional(),
+  hostedCheckoutUrl: import_zod12.z.string().optional(),
+  embeddedCheckoutUrl: import_zod12.z.string().optional()
 });
-var customerSnapshotSchema = import_zod11.z.object({
-  name: import_zod11.z.string().nullable(),
-  businessName: import_zod11.z.string().nullable(),
-  taxId: import_zod11.z.string().nullable(),
-  email: import_zod11.z.string().nullable(),
-  phone: import_zod11.z.string().nullable(),
+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_zod11.z.object({
-  id: import_zod11.z.string(),
-  status: import_zod11.z.literal("Completed" /* Completed */),
-  currency: import_zod11.z.string(),
+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_zod11.z.discriminatedUnion("status", [
+var orderSchema = import_zod12.z.discriminatedUnion("status", [
   openOrderSchema.extend({
-    status: import_zod11.z.literal("Open" /* Open */)
+    status: import_zod12.z.literal("Open" /* Open */)
   }),
   openOrderSchema.extend({
-    status: import_zod11.z.literal("PaymentProcessing" /* PaymentProcessing */)
+    status: import_zod12.z.literal("PaymentProcessing" /* PaymentProcessing */)
   }),
   openOrderSchema.extend({
-    status: import_zod11.z.literal("Paid" /* Paid */)
+    status: import_zod12.z.literal("Paid" /* Paid */)
   }),
   openOrderSchema.extend({
-    status: import_zod11.z.literal("Failed" /* Failed */)
+    status: import_zod12.z.literal("Failed" /* Failed */)
   }),
   completedOrderSchema
 ]);
 
 // src/inventory/subscriptions/schemas.ts
-var baseMilestoneProgressEventSchema = import_zod12.z.object({
-  milestoneId: import_zod12.z.string(),
-  fulfilled: import_zod12.z.boolean(),
-  afterCycleNumber: import_zod12.z.number(),
-  afterNormalizedCycleNumber: import_zod12.z.number(),
-  message: import_zod12.z.string().optional()
+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_zod12.z.discriminatedUnion("type", [
+var milestoneProgressEventSchema = import_zod13.z.discriminatedUnion("type", [
   baseMilestoneProgressEventSchema.extend({
-    type: import_zod12.z.literal("CouponCodeMilestone"),
-    code: import_zod12.z.string().optional(),
-    redeemed: import_zod12.z.boolean().optional()
+    type: import_zod13.z.literal("CouponCodeMilestone"),
+    code: import_zod13.z.string().optional(),
+    redeemed: import_zod13.z.boolean().optional()
   }),
   baseMilestoneProgressEventSchema.extend({
-    type: import_zod12.z.literal("PerpetualLicenseConversionMilestone")
+    type: import_zod13.z.literal("PerpetualLicenseConversionMilestone")
   })
 ]);
-var milestoneProgressSchema = import_zod12.z.object({
-  title: import_zod12.z.string(),
-  description: import_zod12.z.string().nullish(),
-  currentCycleNumber: import_zod12.z.number(),
-  currentNormalizedCycleNumber: import_zod12.z.number(),
-  currentCycleIsCompleted: import_zod12.z.boolean(),
-  fromCycleNumber: import_zod12.z.number(),
-  fromNormalizedCycleNumber: import_zod12.z.number(),
-  toCycleNumber: import_zod12.z.number(),
-  toNormalizedCycleNumber: import_zod12.z.number(),
-  events: import_zod12.z.record(import_zod12.z.coerce.number(), milestoneProgressEventSchema.array())
+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_zod12.z.object({
-  id: import_zod12.z.string(),
-  status: import_zod12.z.nativeEnum(SubscriptionStatus),
-  hasPaymentMethod: import_zod12.z.boolean(),
-  cancellable: import_zod12.z.boolean(),
-  expiresAt: import_zod12.z.coerce.date(),
-  renewedAt: import_zod12.z.coerce.date().nullable(),
-  nextPaymentScheduledAt: import_zod12.z.coerce.date().nullable(),
-  startedAt: import_zod12.z.coerce.date(),
+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_zod12.z.nativeEnum(CycleLength),
-  paymentMethod: import_zod12.z.string().optional(),
+  cycleLength: import_zod13.z.nativeEnum(CycleLength),
+  paymentMethod: import_zod13.z.string().optional(),
   milestoneProgress: milestoneProgressSchema.nullish(),
-  embeddedUpdatePaymentUrl: import_zod12.z.string().optional(),
-  content: import_zod12.z.discriminatedUnion("type", [
-    import_zod12.z.object({
-      type: import_zod12.z.literal("Product"),
-      quantity: import_zod12.z.number(),
+  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_zod12.z.object({
-      type: import_zod12.z.literal("Bundle"),
-      quantity: import_zod12.z.number(),
+    import_zod13.z.object({
+      type: import_zod13.z.literal("Bundle"),
+      quantity: import_zod13.z.number(),
       bundle: storefrontBundleSchema
     })
   ])
@@ -1134,8 +1251,8 @@ var SubscriptionEndpoints = class {
     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_zod13.z.object({
-      location: import_zod13.z.string()
+    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;
   }
@@ -1393,15 +1510,15 @@ _TokenStore.storageKey = "moonbase_auth";
 var TokenStore = _TokenStore;
 
 // src/vendor/schemas.ts
-var schemas_exports8 = {};
-__export(schemas_exports8, {
+var schemas_exports9 = {};
+__export(schemas_exports9, {
   vendorSchema: () => vendorSchema
 });
-var import_zod14 = require("zod");
-var vendorSchema = import_zod14.z.object({
-  id: import_zod14.z.string(),
-  name: import_zod14.z.string(),
-  logoUrl: import_zod14.z.string().nullable()
+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
@@ -1416,20 +1533,20 @@ var VendorEndpoints = class {
 };
 
 // src/vouchers/schemas.ts
-var schemas_exports9 = {};
-__export(schemas_exports9, {
+var schemas_exports10 = {};
+__export(schemas_exports10, {
   voucherSchema: () => voucherSchema
 });
-var import_zod15 = require("zod");
-var voucherSchema = import_zod15.z.object({
-  id: import_zod15.z.string(),
-  name: import_zod15.z.string(),
-  description: import_zod15.z.string(),
-  code: import_zod15.z.string(),
-  redeemed: import_zod15.z.boolean(),
+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_zod15.z.record(rawPropertyValueSchema).nullish()
+  properties: import_zod16.z.record(rawPropertyValueSchema).nullish()
 });
 
 // src/vouchers/endpoints.ts
@@ -1480,23 +1597,24 @@ var ConsoleLogger = class {
 };
 
 // src/schemas.ts
-var schemas_exports11 = {};
-__export(schemas_exports11, {
+var schemas_exports12 = {};
+__export(schemas_exports12, {
   activationRequests: () => schemas_exports3,
-  identity: () => schemas_exports4,
-  inventory: () => schemas_exports10,
-  orders: () => schemas_exports6,
+  communications: () => schemas_exports4,
+  identity: () => schemas_exports5,
+  inventory: () => schemas_exports11,
+  orders: () => schemas_exports7,
   storefront: () => schemas_exports2,
-  vendor: () => schemas_exports8,
-  vouchers: () => schemas_exports9
+  vendor: () => schemas_exports9,
+  vouchers: () => schemas_exports10
 });
 
 // src/inventory/schemas.ts
-var schemas_exports10 = {};
-__export(schemas_exports10, {
-  licenses: () => schemas_exports5,
+var schemas_exports11 = {};
+__export(schemas_exports11, {
+  licenses: () => schemas_exports6,
   products: () => schemas_exports,
-  subscriptions: () => schemas_exports7
+  subscriptions: () => schemas_exports8
 });
 
 // src/utils/discount.ts
@@ -1578,6 +1696,7 @@ var MoonbaseClient = class {
     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);