@moonbase.sh/storefront-api 1.0.37 → 2.0.1

package/dist/index.js

@@ -305,6 +305,81 @@ var ActivationRequestEndpoints = class {
   }
 };
 
+// src/communications/schemas.ts
+var schemas_exports4 = {};
+__export(schemas_exports4, {
+  communicationPreferencesViewSchema: () => communicationPreferencesViewSchema,
+  subscribeResponseSchema: () => subscribeResponseSchema
+});
+import { z as z6 } from "zod";
+var subscribeResponseSchema = z6.object({
+  status: z6.enum(["subscribed", "confirmation_sent"])
+});
+var communicationPreferencesViewSchema = z6.object({
+  email: z6.string(),
+  name: z6.string().nullish(),
+  newsletter: z6.boolean(),
+  productUpdates: z6.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() {
@@ -344,14 +419,14 @@ var MoonbaseError = class extends Error {
 };
 
 // src/utils/problemDetails.ts
-import { z as z6 } from "zod";
-var problemDetailsSchema = z6.object({
-  type: z6.string().optional(),
-  title: z6.string(),
-  detail: z6.string().optional(),
-  status: z6.number().optional(),
-  instance: z6.string().optional(),
-  errors: z6.record(z6.string(), z6.string().array()).optional()
+import { z as z7 } from "zod";
+var problemDetailsSchema = z7.object({
+  type: z7.string().optional(),
+  title: z7.string(),
+  detail: z7.string().optional(),
+  status: z7.number().optional(),
+  instance: z7.string().optional(),
+  errors: z7.record(z7.string(), z7.string().array()).optional()
 });
 
 // src/utils/problemHandler.ts
@@ -390,18 +465,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
 });
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/identity/models.ts
 var ConnectableAccountProvider = /* @__PURE__ */ ((ConnectableAccountProvider2) => {
@@ -410,54 +487,64 @@ var ConnectableAccountProvider = /* @__PURE__ */ ((ConnectableAccountProvider2)
 })(ConnectableAccountProvider || {});
 
 // src/identity/schemas.ts
-var addressSchema = z7.object({
-  countryCode: z7.string(),
-  streetAddress1: z7.string(),
-  streetAddress2: z7.string().nullable(),
-  locality: z7.string().nullable(),
-  region: z7.string().nullable(),
-  postCode: z7.string().nullable()
+var addressSchema = z8.object({
+  countryCode: z8.string(),
+  streetAddress1: z8.string(),
+  streetAddress2: z8.string().nullable(),
+  locality: z8.string().nullable(),
+  region: z8.string().nullable(),
+  postCode: z8.string().nullable()
 });
-var communicationPreferencesSchema = z7.object({
-  newsletterOptIn: z7.boolean()
-  // productUpdatesOptIn: z.boolean(), // TODO: Enable when relevant
+var communicationPreferencesSchema = z8.object({
+  newsletterOptIn: z8.boolean(),
+  // Default keeps older persisted identities (pre productUpdatesOptIn) parseable
+  // during boot. The server-side value is hydrated by updateUser() right after.
+  productUpdatesOptIn: z8.boolean().default(false)
 });
-var ilokConnectedAccountSchema = z7.object({
-  provider: z7.literal("iLok" /* iLok */),
-  isConnected: z7.boolean(),
-  pendingLicenseFulfillments: z7.boolean(),
-  accountId: z7.string().nullish()
+var ilokConnectedAccountSchema = z8.object({
+  provider: z8.literal("iLok" /* iLok */),
+  isConnected: z8.boolean(),
+  pendingLicenseFulfillments: z8.boolean(),
+  accountId: z8.string().nullish()
 });
-var connectedAccountSchema = z7.discriminatedUnion("provider", [
+var connectedAccountSchema = z8.discriminatedUnion("provider", [
   ilokConnectedAccountSchema
 ]);
-var connectionUrlSchema = z7.object({
-  url: z7.string()
+var connectionUrlSchema = z8.object({
+  url: z8.string()
 });
-var userSchema = z7.object({
-  id: z7.string(),
-  email: z7.string(),
-  name: z7.string(),
-  tenantId: z7.string(),
+var userSchema = z8.object({
+  id: z8.string(),
+  email: z8.string(),
+  name: z8.string(),
+  tenantId: z8.string(),
   address: addressSchema.optional(),
-  phone: z7.string().optional(),
+  phone: z8.string().optional(),
   communicationPreferences: communicationPreferencesSchema,
-  ownedProducts: z7.string().array().optional(),
-  subscribedProducts: z7.string().array().optional(),
-  confirmedAccount: z7.boolean().optional(),
-  hasProducts: z7.boolean().nullish(),
-  hasSubscriptions: z7.boolean().nullish(),
-  connectedAccounts: z7.array(connectedAccountSchema).default([])
+  ownedProducts: z8.string().array().optional(),
+  subscribedProducts: z8.string().array().optional(),
+  confirmedAccount: z8.boolean().optional(),
+  hasProducts: z8.boolean().nullish(),
+  hasSubscriptions: z8.boolean().nullish(),
+  connectedAccounts: z8.array(connectedAccountSchema).default([])
 });
-var identitySchema = userSchema.and(z7.object({
-  accessToken: z7.string(),
-  refreshToken: z7.string()
+var identitySchema = userSchema.and(z8.object({
+  accessToken: z8.string(),
+  refreshToken: z8.string()
+}));
+var userAccountConfirmedStatusSchema = z8.enum([
+  "PasswordSetupRequired",
+  "SignedIn"
+]);
+var userAccountConfirmedSchema = userSchema.and(z8.object({
+  status: userAccountConfirmedStatusSchema,
+  resetPasswordToken: z8.string().nullish(),
+  accessToken: z8.string().nullish(),
+  refreshToken: z8.string().nullish()
 }));
-var userAccountConfirmedSchema = z7.object({
-  id: z7.string(),
-  name: z7.string(),
-  email: z7.string(),
-  resetPasswordToken: z7.string().nullable()
+var pendingActivationSchema = z8.object({
+  status: z8.literal("activation_pending"),
+  email: z8.string()
 });
 
 // src/identity/endpoints.ts
@@ -496,19 +583,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();
@@ -555,13 +661,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" });
@@ -585,16 +702,16 @@ var IdentityEndpoints = class {
 };
 
 // src/inventory/activation/endpoints.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/inventory/licenses/schemas.ts
-var schemas_exports5 = {};
-__export(schemas_exports5, {
+var schemas_exports6 = {};
+__export(schemas_exports6, {
   activationSchema: () => activationSchema,
   externalLicenseContent: () => externalLicenseContent,
   licenseSchema: () => licenseSchema
 });
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/inventory/licenses/models.ts
 var LicenseStatus = /* @__PURE__ */ ((LicenseStatus2) => {
@@ -615,43 +732,43 @@ var ActivationMethod = /* @__PURE__ */ ((ActivationMethod2) => {
 })(ActivationMethod || {});
 
 // src/inventory/licenses/schemas.ts
-var externalLicenseFileContent = z8.object({
-  type: z8.literal("file"),
-  fileName: z8.string(),
-  contentType: z8.string(),
-  data: z8.string()
+var externalLicenseFileContent = z9.object({
+  type: z9.literal("file"),
+  fileName: z9.string(),
+  contentType: z9.string(),
+  data: z9.string()
 });
-var externalLicenseILokContent = z8.object({
-  type: z8.literal("iLok")
+var externalLicenseILokContent = z9.object({
+  type: z9.literal("iLok")
 });
-var externalLicenseContent = z8.union([
-  z8.string(),
-  z8.discriminatedUnion("type", [
+var externalLicenseContent = z9.union([
+  z9.string(),
+  z9.discriminatedUnion("type", [
     externalLicenseFileContent,
     externalLicenseILokContent
   ])
 ]);
-var licenseSchema = z8.object({
-  id: z8.string(),
-  status: z8.nativeEnum(LicenseStatus),
+var licenseSchema = z9.object({
+  id: z9.string(),
+  status: z9.nativeEnum(LicenseStatus),
   product: productSummarySchema,
-  activeNumberOfActivations: z8.number(),
-  maxNumberOfActivations: z8.number(),
+  activeNumberOfActivations: z9.number(),
+  maxNumberOfActivations: z9.number(),
   externalFulfillment: externalLicenseContent.optional(),
-  requiredConnectedAccount: z8.nativeEnum(ConnectableAccountProvider).nullish(),
-  fulfillmentMessage: z8.string().optional(),
-  properties: z8.record(rawPropertyValueSchema).nullish(),
-  expiresAt: z8.coerce.date().optional(),
-  createdAt: z8.coerce.date()
+  requiredConnectedAccount: z9.nativeEnum(ConnectableAccountProvider).nullish(),
+  fulfillmentMessage: z9.string().optional(),
+  properties: z9.record(rawPropertyValueSchema).nullish(),
+  expiresAt: z9.coerce.date().optional(),
+  createdAt: z9.coerce.date()
 });
-var activationSchema = z8.object({
-  id: z8.string(),
-  licenseId: z8.string(),
-  name: z8.string(),
-  status: z8.nativeEnum(ActivationStatus),
-  activationMethod: z8.nativeEnum(ActivationMethod),
-  firstValidatedAt: z8.coerce.date(),
-  lastValidatedAt: z8.coerce.date().nullable()
+var activationSchema = z9.object({
+  id: z9.string(),
+  licenseId: z9.string(),
+  name: z9.string(),
+  status: z9.nativeEnum(ActivationStatus),
+  activationMethod: z9.nativeEnum(ActivationMethod),
+  firstValidatedAt: z9.coerce.date(),
+  lastValidatedAt: z9.coerce.date().nullable()
 });
 
 // src/inventory/activation/endpoints.ts
@@ -668,7 +785,7 @@ var ActivationEndpoints = class {
     });
     return {
       license: response.data,
-      url: z9.string().parse(response.headers.location)
+      url: z10.string().parse(response.headers.location)
     };
   }
 };
@@ -696,7 +813,7 @@ var LicenseEndpoints = class {
 };
 
 // src/inventory/products/endpoints.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var ProductEndpoints = class {
   constructor(api, configuration) {
     this.api = api;
@@ -721,8 +838,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, z10.object({
-      location: z10.string()
+    const response = await this.api.fetch(url.pathname + url.search, z11.object({
+      location: z11.string()
     }));
     return response.data.location;
   }
@@ -854,15 +971,15 @@ var MoonbaseApi = class {
 };
 
 // src/inventory/subscriptions/endpoints.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/inventory/subscriptions/schemas.ts
-var schemas_exports7 = {};
-__export(schemas_exports7, {
+var schemas_exports8 = {};
+__export(schemas_exports8, {
   milestoneProgressSchema: () => milestoneProgressSchema,
   subscriptionSchema: () => subscriptionSchema
 });
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // src/inventory/subscriptions/models.ts
 var SubscriptionStatus = /* @__PURE__ */ ((SubscriptionStatus2) => {
@@ -874,8 +991,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,
@@ -884,7 +1001,7 @@ __export(schemas_exports6, {
   orderSchema: () => orderSchema,
   orderTotalSchema: () => orderTotalSchema
 });
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/orders/models.ts
 var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
@@ -897,171 +1014,171 @@ var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
 })(OrderStatus || {});
 
 // src/orders/schemas.ts
-var couponSchema = z11.object({
-  code: z11.string(),
-  name: z11.string(),
-  description: z11.string()
+var couponSchema = z12.object({
+  code: z12.string(),
+  name: z12.string(),
+  description: z12.string()
 });
-var lineItemProductSchema = z11.object({
-  id: z11.string(),
-  name: z11.string(),
-  tagline: z11.string(),
-  iconUrl: z11.string().nullable()
+var lineItemProductSchema = z12.object({
+  id: z12.string(),
+  name: z12.string(),
+  tagline: z12.string(),
+  iconUrl: z12.string().nullable()
 });
-var lineItemTotalSchema = z11.object({
+var lineItemTotalSchema = z12.object({
   original: moneySchema,
   discount: moneySchema,
   subtotal: moneySchema,
   due: moneySchema
 });
-var openProductLineItem = z11.object({
-  id: z11.string(),
-  type: z11.literal("Product"),
-  productId: z11.string(),
-  quantity: z11.number(),
-  variationId: z11.string(),
-  offerId: z11.string().optional(),
-  isDefaultVariation: z11.boolean().nullish(),
-  isSubcriptionPayment: z11.boolean().nullish(),
+var openProductLineItem = z12.object({
+  id: z12.string(),
+  type: z12.literal("Product"),
+  productId: z12.string(),
+  quantity: z12.number(),
+  variationId: z12.string(),
+  offerId: z12.string().optional(),
+  isDefaultVariation: z12.boolean().nullish(),
+  isSubcriptionPayment: z12.boolean().nullish(),
   price: priceCollectionSchema.optional(),
   variation: pricingVariationSchema.optional(),
   total: lineItemTotalSchema.nullish(),
   product: lineItemProductSchema.optional(),
   appliedDiscount: discountSchema.optional()
 });
-var lineItemBundleSchema = z11.object({
-  id: z11.string(),
-  name: z11.string(),
-  tagline: z11.string(),
-  iconUrl: z11.string().nullable(),
-  products: lineItemProductSchema.and(z11.object({
-    included: z11.boolean().optional()
+var lineItemBundleSchema = z12.object({
+  id: z12.string(),
+  name: z12.string(),
+  tagline: z12.string(),
+  iconUrl: z12.string().nullable(),
+  products: lineItemProductSchema.and(z12.object({
+    included: z12.boolean().optional()
   })).array()
 });
-var openBundleLineItem = z11.object({
-  id: z11.string(),
-  type: z11.literal("Bundle"),
-  bundleId: z11.string(),
-  quantity: z11.number(),
-  variationId: z11.string(),
-  offerId: z11.string().optional(),
-  partial: z11.boolean().optional(),
-  replaced: z11.string().array().optional(),
-  isDefaultVariation: z11.boolean().nullish(),
-  isSubcriptionPayment: z11.boolean().nullish(),
+var openBundleLineItem = z12.object({
+  id: z12.string(),
+  type: z12.literal("Bundle"),
+  bundleId: z12.string(),
+  quantity: z12.number(),
+  variationId: z12.string(),
+  offerId: z12.string().optional(),
+  partial: z12.boolean().optional(),
+  replaced: z12.string().array().optional(),
+  isDefaultVariation: z12.boolean().nullish(),
+  isSubcriptionPayment: z12.boolean().nullish(),
   price: priceCollectionSchema.optional(),
   variation: pricingVariationSchema.optional(),
   total: lineItemTotalSchema.nullish(),
   bundle: lineItemBundleSchema.optional(),
   appliedDiscount: discountSchema.optional()
 });
-var openOrderLineItem = z11.discriminatedUnion("type", [
+var openOrderLineItem = z12.discriminatedUnion("type", [
   openProductLineItem,
   openBundleLineItem
 ]);
-var orderTotalSchema = z11.object({
+var orderTotalSchema = z12.object({
   original: moneySchema,
   discount: moneySchema,
   subtotal: moneySchema,
   taxes: moneySchema,
   due: moneySchema
 });
-var openOrderSchema = z11.object({
-  id: z11.string(),
-  currency: z11.string(),
+var openOrderSchema = z12.object({
+  id: z12.string(),
+  currency: z12.string(),
   total: orderTotalSchema.nullish(),
   items: openOrderLineItem.array(),
   couponsApplied: couponSchema.array(),
-  checkoutUrl: z11.string().optional(),
-  hostedCheckoutUrl: z11.string().optional(),
-  embeddedCheckoutUrl: z11.string().optional()
+  checkoutUrl: z12.string().optional(),
+  hostedCheckoutUrl: z12.string().optional(),
+  embeddedCheckoutUrl: z12.string().optional()
 });
-var customerSnapshotSchema = z11.object({
-  name: z11.string().nullable(),
-  businessName: z11.string().nullable(),
-  taxId: z11.string().nullable(),
-  email: z11.string().nullable(),
-  phone: z11.string().nullable(),
+var customerSnapshotSchema = z12.object({
+  name: z12.string().nullable(),
+  businessName: z12.string().nullable(),
+  taxId: z12.string().nullable(),
+  email: z12.string().nullable(),
+  phone: z12.string().nullable(),
   address: addressSchema.nullable()
 });
-var completedOrderSchema = z11.object({
-  id: z11.string(),
-  status: z11.literal("Completed" /* Completed */),
-  currency: z11.string(),
+var completedOrderSchema = z12.object({
+  id: z12.string(),
+  status: z12.literal("Completed" /* Completed */),
+  currency: z12.string(),
   customer: customerSnapshotSchema,
   total: orderTotalSchema,
   items: openOrderLineItem.array(),
   couponsApplied: couponSchema.array()
 });
-var orderSchema = z11.discriminatedUnion("status", [
+var orderSchema = z12.discriminatedUnion("status", [
   openOrderSchema.extend({
-    status: z11.literal("Open" /* Open */)
+    status: z12.literal("Open" /* Open */)
   }),
   openOrderSchema.extend({
-    status: z11.literal("PaymentProcessing" /* PaymentProcessing */)
+    status: z12.literal("PaymentProcessing" /* PaymentProcessing */)
   }),
   openOrderSchema.extend({
-    status: z11.literal("Paid" /* Paid */)
+    status: z12.literal("Paid" /* Paid */)
   }),
   openOrderSchema.extend({
-    status: z11.literal("Failed" /* Failed */)
+    status: z12.literal("Failed" /* Failed */)
   }),
   completedOrderSchema
 ]);
 
 // src/inventory/subscriptions/schemas.ts
-var baseMilestoneProgressEventSchema = z12.object({
-  milestoneId: z12.string(),
-  fulfilled: z12.boolean(),
-  afterCycleNumber: z12.number(),
-  afterNormalizedCycleNumber: z12.number(),
-  message: z12.string().optional()
+var baseMilestoneProgressEventSchema = z13.object({
+  milestoneId: z13.string(),
+  fulfilled: z13.boolean(),
+  afterCycleNumber: z13.number(),
+  afterNormalizedCycleNumber: z13.number(),
+  message: z13.string().optional()
 });
-var milestoneProgressEventSchema = z12.discriminatedUnion("type", [
+var milestoneProgressEventSchema = z13.discriminatedUnion("type", [
   baseMilestoneProgressEventSchema.extend({
-    type: z12.literal("CouponCodeMilestone"),
-    code: z12.string().optional(),
-    redeemed: z12.boolean().optional()
+    type: z13.literal("CouponCodeMilestone"),
+    code: z13.string().optional(),
+    redeemed: z13.boolean().optional()
   }),
   baseMilestoneProgressEventSchema.extend({
-    type: z12.literal("PerpetualLicenseConversionMilestone")
+    type: z13.literal("PerpetualLicenseConversionMilestone")
   })
 ]);
-var milestoneProgressSchema = z12.object({
-  title: z12.string(),
-  description: z12.string().nullish(),
-  currentCycleNumber: z12.number(),
-  currentNormalizedCycleNumber: z12.number(),
-  currentCycleIsCompleted: z12.boolean(),
-  fromCycleNumber: z12.number(),
-  fromNormalizedCycleNumber: z12.number(),
-  toCycleNumber: z12.number(),
-  toNormalizedCycleNumber: z12.number(),
-  events: z12.record(z12.coerce.number(), milestoneProgressEventSchema.array())
+var milestoneProgressSchema = z13.object({
+  title: z13.string(),
+  description: z13.string().nullish(),
+  currentCycleNumber: z13.number(),
+  currentNormalizedCycleNumber: z13.number(),
+  currentCycleIsCompleted: z13.boolean(),
+  fromCycleNumber: z13.number(),
+  fromNormalizedCycleNumber: z13.number(),
+  toCycleNumber: z13.number(),
+  toNormalizedCycleNumber: z13.number(),
+  events: z13.record(z13.coerce.number(), milestoneProgressEventSchema.array())
 });
-var subscriptionSchema = z12.object({
-  id: z12.string(),
-  status: z12.nativeEnum(SubscriptionStatus),
-  hasPaymentMethod: z12.boolean(),
-  cancellable: z12.boolean(),
-  expiresAt: z12.coerce.date(),
-  renewedAt: z12.coerce.date().nullable(),
-  nextPaymentScheduledAt: z12.coerce.date().nullable(),
-  startedAt: z12.coerce.date(),
+var subscriptionSchema = z13.object({
+  id: z13.string(),
+  status: z13.nativeEnum(SubscriptionStatus),
+  hasPaymentMethod: z13.boolean(),
+  cancellable: z13.boolean(),
+  expiresAt: z13.coerce.date(),
+  renewedAt: z13.coerce.date().nullable(),
+  nextPaymentScheduledAt: z13.coerce.date().nullable(),
+  startedAt: z13.coerce.date(),
   total: orderTotalSchema,
-  cycleLength: z12.nativeEnum(CycleLength),
-  paymentMethod: z12.string().optional(),
+  cycleLength: z13.nativeEnum(CycleLength),
+  paymentMethod: z13.string().optional(),
   milestoneProgress: milestoneProgressSchema.nullish(),
-  embeddedUpdatePaymentUrl: z12.string().optional(),
-  content: z12.discriminatedUnion("type", [
-    z12.object({
-      type: z12.literal("Product"),
-      quantity: z12.number(),
+  embeddedUpdatePaymentUrl: z13.string().optional(),
+  content: z13.discriminatedUnion("type", [
+    z13.object({
+      type: z13.literal("Product"),
+      quantity: z13.number(),
       product: storefrontProductSchema
     }),
-    z12.object({
-      type: z12.literal("Bundle"),
-      quantity: z12.number(),
+    z13.object({
+      type: z13.literal("Bundle"),
+      quantity: z13.number(),
       bundle: storefrontBundleSchema
     })
   ])
@@ -1086,8 +1203,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"}`, z13.object({
-      location: z13.string()
+    const response = await this.api.authenticatedFetch(`/api/customer/inventory/subscriptions/${subscriptionId}/renew?redirect=false&return=${returnUrl}&embedded=${embedded ? "true" : "false"}`, z14.object({
+      location: z14.string()
     }), { method: "POST" });
     return response.data;
   }
@@ -1345,15 +1462,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
 });
-import { z as z14 } from "zod";
-var vendorSchema = z14.object({
-  id: z14.string(),
-  name: z14.string(),
-  logoUrl: z14.string().nullable()
+import { z as z15 } from "zod";
+var vendorSchema = z15.object({
+  id: z15.string(),
+  name: z15.string(),
+  logoUrl: z15.string().nullable()
 });
 
 // src/vendor/endpoints.ts
@@ -1368,20 +1485,20 @@ var VendorEndpoints = class {
 };
 
 // src/vouchers/schemas.ts
-var schemas_exports9 = {};
-__export(schemas_exports9, {
+var schemas_exports10 = {};
+__export(schemas_exports10, {
   voucherSchema: () => voucherSchema
 });
-import { z as z15 } from "zod";
-var voucherSchema = z15.object({
-  id: z15.string(),
-  name: z15.string(),
-  description: z15.string(),
-  code: z15.string(),
-  redeemed: z15.boolean(),
+import { z as z16 } from "zod";
+var voucherSchema = z16.object({
+  id: z16.string(),
+  name: z16.string(),
+  description: z16.string(),
+  code: z16.string(),
+  redeemed: z16.boolean(),
   redeemsProducts: quantifiable(storefrontProductSchema).array(),
   redeemsBundles: quantifiable(storefrontBundleSchema).array(),
-  properties: z15.record(rawPropertyValueSchema).nullish()
+  properties: z16.record(rawPropertyValueSchema).nullish()
 });
 
 // src/vouchers/endpoints.ts
@@ -1432,23 +1549,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
@@ -1530,6 +1648,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);
@@ -1565,6 +1684,6 @@ export {
   TokenStore,
   objectToQuery,
   problemDetailsSchema,
-  schemas_exports11 as schemas,
+  schemas_exports12 as schemas,
   utmToObject
 };