@moonbase.sh/storefront-api 0.1.83 → 0.1.84

package/dist/index.cjs

@@ -31,6 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   ActivationMethod: () => ActivationMethod,
+  ActivationRequestStatus: () => ActivationRequestStatus,
   ActivationStatus: () => ActivationStatus,
   LicenseStatus: () => LicenseStatus,
   MoonbaseClient: () => MoonbaseClient,
@@ -42,11 +43,179 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/activationsRequests/endpoints.ts
+var import_zod5 = require("zod");
+
+// src/activationsRequests/schemas.ts
+var import_zod4 = require("zod");
+
+// src/storefront/schemas.ts
+var import_zod3 = require("zod");
+
+// src/globalSchemas.ts
+var import_zod = require("zod");
+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
+});
+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
+});
+var discountSchema = import_zod.z.discriminatedUnion("type", [
+  percentageOffDiscountSchema,
+  flatAmountOffDiscountSchema
+]);
+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()
+});
+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()
+  });
+}
+
+// src/products/schemas.ts
+var import_zod2 = require("zod");
+
+// src/products/models.ts
+var Platform = /* @__PURE__ */ ((Platform2) => {
+  Platform2["Universal"] = "Universal";
+  Platform2["Windows"] = "Windows";
+  Platform2["Linux"] = "Linux";
+  Platform2["Mac"] = "Mac";
+  return Platform2;
+})(Platform || {});
+
+// src/products/schemas.ts
+var downloadSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  key: import_zod2.z.string(),
+  platform: import_zod2.z.nativeEnum(Platform),
+  size: import_zod2.z.number(),
+  path: import_zod2.z.string().nullable()
+});
+var productSummarySchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  tagline: import_zod2.z.string(),
+  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(),
+  currentVersion: import_zod2.z.string().nullable(),
+  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(),
+  iconUrl: import_zod3.z.string().nullable(),
+  owned: import_zod3.z.boolean(),
+  currentVersion: import_zod3.z.string().optional(),
+  downloads: downloadSchema.array().optional(),
+  defaultVariation: pricingVariationSchema.optional(),
+  variations: pricingVariationSchema.array().optional(),
+  type: import_zod3.z.void().transform(() => "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(),
+  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()
+  })).array(),
+  defaultVariation: pricingVariationSchema.optional(),
+  variations: pricingVariationSchema.array().optional(),
+  type: import_zod3.z.void().transform(() => "bundle").pipe(import_zod3.z.literal("bundle"))
+});
+var storefrontSchema = import_zod3.z.object({
+  suggestedCurrency: import_zod3.z.string(),
+  products: storefrontProductSchema.array(),
+  bundles: storefrontBundleSchema.array()
+});
+
+// src/activationsRequests/models.ts
+var ActivationRequestStatus = /* @__PURE__ */ ((ActivationRequestStatus2) => {
+  ActivationRequestStatus2["Requested"] = "Requested";
+  ActivationRequestStatus2["Fulfilled"] = "Fulfilled";
+  ActivationRequestStatus2["Completed"] = "Completed";
+  return ActivationRequestStatus2;
+})(ActivationRequestStatus || {});
+
+// src/activationsRequests/schemas.ts
+var activationRequestSchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  status: import_zod4.z.nativeEnum(ActivationRequestStatus),
+  product: storefrontProductSchema,
+  trialEligibility: import_zod4.z.object({
+    eligible: import_zod4.z.boolean(),
+    existing: import_zod4.z.boolean(),
+    requiresAccount: 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/activationsRequests/endpoints.ts
+var ActivationRequestEndpoints = class {
+  constructor(api) {
+    this.api = api;
+  }
+  async get(requestId) {
+    const response = await this.api.fetch(`/api/customer/activations/${requestId}`);
+    return activationRequestSchema.parse(response);
+  }
+  async isCompleted(requestId) {
+    const response = await this.api.fetch(`/api/customer/activations/${requestId}/completed`);
+    return import_zod5.z.boolean().parse(response.data);
+  }
+  async fulfillLicense(requestId) {
+    const response = await this.api.authenticatedFetch(`/api/customer/activations/${requestId}/license`, "POST");
+    return activationRequestSchema.parse(response.data);
+  }
+  async fulfillTrial(requestId) {
+    const response = await this.api.fetch(`/api/customer/activations/${requestId}/trial`, "POST");
+    return activationRequestSchema.parse(response.data);
+  }
+};
+
 // src/identity/endpoints.ts
 var import_cross_fetch = __toESM(require("cross-fetch"), 1);
 
 // src/utils/problemHandler.ts
-var import_zod = require("zod");
+var import_zod6 = require("zod");
 
 // src/utils/errors.ts
 var NotAuthorizedError = class extends Error {
@@ -69,11 +238,11 @@ var NotFoundError = class extends Error {
 };
 
 // src/utils/problemHandler.ts
-var problemDetailsSchema = import_zod.z.object({
-  type: import_zod.z.string(),
-  title: import_zod.z.string(),
-  detail: import_zod.z.string().optional(),
-  status: import_zod.z.number()
+var problemDetailsSchema = import_zod6.z.object({
+  type: import_zod6.z.string(),
+  title: import_zod6.z.string(),
+  detail: import_zod6.z.string().optional(),
+  status: import_zod6.z.number()
 });
 async function handleResponseProblem(response) {
   if (response.status === 404)
@@ -97,30 +266,30 @@ async function handleResponseProblem(response) {
 }
 
 // src/identity/schemas.ts
-var import_zod2 = require("zod");
-var addressSchema = import_zod2.z.object({
-  countryCode: import_zod2.z.string(),
-  streetAddress1: import_zod2.z.string(),
-  streetAddress2: import_zod2.z.string().nullable(),
-  locality: import_zod2.z.string().nullable(),
-  region: import_zod2.z.string().nullable(),
-  postCode: import_zod2.z.string()
+var import_zod7 = require("zod");
+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()
 });
-var communicationPreferencesSchema = import_zod2.z.object({
-  newsletterOptIn: import_zod2.z.boolean()
+var communicationPreferencesSchema = import_zod7.z.object({
+  newsletterOptIn: import_zod7.z.boolean()
   // productUpdatesOptIn: z.boolean(), // TODO: Enable when relevant
 });
-var userSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  email: import_zod2.z.string(),
-  name: import_zod2.z.string(),
-  tenantId: import_zod2.z.string(),
+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(),
   address: addressSchema.optional(),
   communicationPreferences: communicationPreferencesSchema
 });
-var identityUserSchema = userSchema.and(import_zod2.z.object({
-  accessToken: import_zod2.z.string(),
-  refreshToken: import_zod2.z.string()
+var identityUserSchema = userSchema.and(import_zod7.z.object({
+  accessToken: import_zod7.z.string(),
+  refreshToken: import_zod7.z.string()
 }));
 
 // src/identity/endpoints.ts
@@ -198,86 +367,8 @@ var IdentityEndpoints = class {
   }
 };
 
-// src/globalSchemas.ts
-var import_zod3 = require("zod");
-var priceCollectionSchema = import_zod3.z.record(import_zod3.z.number());
-var percentageOffDiscountSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("PercentageOffDiscount"),
-  name: import_zod3.z.string(),
-  description: import_zod3.z.string().optional(),
-  percentage: import_zod3.z.number(),
-  total: priceCollectionSchema
-});
-var flatAmountOffDiscountSchema = import_zod3.z.object({
-  type: import_zod3.z.literal("FlatAmountOffDiscount"),
-  name: import_zod3.z.string(),
-  description: import_zod3.z.string().optional(),
-  total: priceCollectionSchema
-});
-var discountSchema = import_zod3.z.discriminatedUnion("type", [
-  percentageOffDiscountSchema,
-  flatAmountOffDiscountSchema
-]);
-var pricingVariationSchema = import_zod3.z.object({
-  id: import_zod3.z.string(),
-  name: import_zod3.z.string(),
-  originalPrice: priceCollectionSchema,
-  price: priceCollectionSchema,
-  hasDiscount: import_zod3.z.boolean(),
-  discount: discountSchema.optional()
-});
-function paged(itemSchema) {
-  return import_zod3.z.object({
-    items: import_zod3.z.array(itemSchema),
-    hasMore: import_zod3.z.boolean(),
-    next: import_zod3.z.string().nullable()
-  });
-}
-function quantifiable(itemSchema) {
-  return import_zod3.z.object({
-    value: itemSchema,
-    quantity: import_zod3.z.number()
-  });
-}
-
 // src/licenses/schemas.ts
-var import_zod5 = require("zod");
-
-// src/products/schemas.ts
-var import_zod4 = require("zod");
-
-// src/products/models.ts
-var Platform = /* @__PURE__ */ ((Platform2) => {
-  Platform2["Universal"] = "Universal";
-  Platform2["Windows"] = "Windows";
-  Platform2["Linux"] = "Linux";
-  Platform2["Mac"] = "Mac";
-  return Platform2;
-})(Platform || {});
-
-// src/products/schemas.ts
-var downloadSchema = import_zod4.z.object({
-  name: import_zod4.z.string(),
-  key: import_zod4.z.string(),
-  platform: import_zod4.z.nativeEnum(Platform),
-  size: import_zod4.z.number(),
-  path: import_zod4.z.string().nullable()
-});
-var productSummarySchema = import_zod4.z.object({
-  id: import_zod4.z.string(),
-  name: import_zod4.z.string(),
-  tagline: import_zod4.z.string(),
-  website: import_zod4.z.string().optional(),
-  iconUrl: import_zod4.z.string().optional(),
-  numberOfLicenses: import_zod4.z.number().optional(),
-  numberOfTrials: import_zod4.z.number().optional(),
-  currentActivations: import_zod4.z.number().optional(),
-  maxActivations: import_zod4.z.number().optional(),
-  currentVersion: import_zod4.z.string().nullable(),
-  downloadsNeedsUser: import_zod4.z.boolean(),
-  downloadsNeedsOwnership: import_zod4.z.boolean(),
-  downloads: import_zod4.z.array(downloadSchema).optional()
-});
+var import_zod8 = require("zod");
 
 // src/licenses/models.ts
 var LicenseStatus = /* @__PURE__ */ ((LicenseStatus2) => {
@@ -297,21 +388,21 @@ var ActivationMethod = /* @__PURE__ */ ((ActivationMethod2) => {
 })(ActivationMethod || {});
 
 // src/licenses/schemas.ts
-var licenseSchema = import_zod5.z.object({
-  id: import_zod5.z.string(),
-  status: import_zod5.z.nativeEnum(LicenseStatus),
+var licenseSchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  status: import_zod8.z.nativeEnum(LicenseStatus),
   product: productSummarySchema.optional(),
-  activeNumberOfActivations: import_zod5.z.number(),
-  maxNumberOfActivations: import_zod5.z.number(),
-  createdAt: import_zod5.z.coerce.date()
+  activeNumberOfActivations: import_zod8.z.number(),
+  maxNumberOfActivations: import_zod8.z.number(),
+  createdAt: import_zod8.z.coerce.date()
 });
-var activationSchema = import_zod5.z.object({
-  id: import_zod5.z.string(),
-  licenseId: import_zod5.z.string(),
-  name: import_zod5.z.string(),
-  status: import_zod5.z.nativeEnum(ActivationStatus),
-  activationMethod: import_zod5.z.nativeEnum(ActivationMethod),
-  lastValidatedAt: import_zod5.z.coerce.date().nullable()
+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),
+  lastValidatedAt: import_zod8.z.coerce.date().nullable()
 });
 
 // src/licenses/endpoints.ts
@@ -335,41 +426,7 @@ var LicenseEndpoints = class {
 };
 
 // src/orders/schemas.ts
-var import_zod7 = require("zod");
-
-// src/storefront/schemas.ts
-var import_zod6 = require("zod");
-var storefrontProductSchema = import_zod6.z.object({
-  id: import_zod6.z.string(),
-  name: import_zod6.z.string(),
-  tagline: import_zod6.z.string(),
-  iconUrl: import_zod6.z.string().nullable(),
-  owned: import_zod6.z.boolean(),
-  currentVersion: import_zod6.z.string().optional(),
-  downloads: downloadSchema.array().optional(),
-  defaultVariation: pricingVariationSchema.optional(),
-  variations: pricingVariationSchema.array().optional(),
-  type: import_zod6.z.void().transform(() => "product").pipe(import_zod6.z.literal("product"))
-});
-var storefrontBundleSchema = import_zod6.z.object({
-  id: import_zod6.z.string(),
-  name: import_zod6.z.string(),
-  tagline: import_zod6.z.string(),
-  iconUrl: import_zod6.z.string().nullable(),
-  owned: import_zod6.z.boolean(),
-  partial: import_zod6.z.boolean(),
-  products: storefrontProductSchema.and(import_zod6.z.object({
-    included: import_zod6.z.boolean()
-  })).array(),
-  defaultVariation: pricingVariationSchema.optional(),
-  variations: pricingVariationSchema.array().optional(),
-  type: import_zod6.z.void().transform(() => "bundle").pipe(import_zod6.z.literal("bundle"))
-});
-var storefrontSchema = import_zod6.z.object({
-  suggestedCurrency: import_zod6.z.string(),
-  products: storefrontProductSchema.array(),
-  bundles: storefrontBundleSchema.array()
-});
+var import_zod9 = require("zod");
 
 // src/orders/models.ts
 var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
@@ -383,65 +440,65 @@ var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
 })(OrderStatus || {});
 
 // src/orders/schemas.ts
-var couponSchema = import_zod7.z.object({
-  code: import_zod7.z.string(),
-  name: import_zod7.z.string(),
-  description: import_zod7.z.string()
+var couponSchema = import_zod9.z.object({
+  code: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  description: import_zod9.z.string()
 });
-var percentageOffDiscountSchema2 = import_zod7.z.object({
-  type: import_zod7.z.literal("PercentageOffDiscount"),
-  name: import_zod7.z.string(),
-  description: import_zod7.z.string().optional(),
-  percentage: import_zod7.z.number(),
+var percentageOffDiscountSchema2 = import_zod9.z.object({
+  type: import_zod9.z.literal("PercentageOffDiscount"),
+  name: import_zod9.z.string(),
+  description: import_zod9.z.string().optional(),
+  percentage: import_zod9.z.number(),
   total: priceCollectionSchema.optional(),
-  isExclusive: import_zod7.z.boolean()
+  isExclusive: import_zod9.z.boolean()
 });
-var flatAmountOffDiscountSchema2 = import_zod7.z.object({
-  type: import_zod7.z.literal("FlatAmountOffDiscount"),
-  name: import_zod7.z.string(),
-  description: import_zod7.z.string().optional(),
+var flatAmountOffDiscountSchema2 = import_zod9.z.object({
+  type: import_zod9.z.literal("FlatAmountOffDiscount"),
+  name: import_zod9.z.string(),
+  description: import_zod9.z.string().optional(),
   total: priceCollectionSchema.optional(),
-  isExclusive: import_zod7.z.boolean()
+  isExclusive: import_zod9.z.boolean()
 });
-var discountSchema2 = import_zod7.z.discriminatedUnion("type", [
+var discountSchema2 = import_zod9.z.discriminatedUnion("type", [
   percentageOffDiscountSchema2,
   flatAmountOffDiscountSchema2
 ]);
-var openProductLineItem = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  type: import_zod7.z.literal("Product"),
-  productId: import_zod7.z.string(),
-  quantity: import_zod7.z.number(),
-  variationId: import_zod7.z.string(),
+var openProductLineItem = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  type: import_zod9.z.literal("Product"),
+  productId: import_zod9.z.string(),
+  quantity: import_zod9.z.number(),
+  variationId: import_zod9.z.string(),
   price: priceCollectionSchema.optional(),
   variation: pricingVariationSchema.optional(),
   product: storefrontProductSchema.optional(),
   appliedDiscount: discountSchema2.optional()
 });
-var openBundleLineItem = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  type: import_zod7.z.literal("Bundle"),
-  bundleId: import_zod7.z.string(),
-  quantity: import_zod7.z.number(),
-  variationId: import_zod7.z.string(),
+var openBundleLineItem = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  type: import_zod9.z.literal("Bundle"),
+  bundleId: import_zod9.z.string(),
+  quantity: import_zod9.z.number(),
+  variationId: import_zod9.z.string(),
   price: priceCollectionSchema.optional(),
   variation: pricingVariationSchema.optional(),
   bundle: storefrontBundleSchema.optional(),
   appliedDiscount: discountSchema2.optional()
 });
-var openOrderLineItem = import_zod7.z.discriminatedUnion("type", [
+var openOrderLineItem = import_zod9.z.discriminatedUnion("type", [
   openProductLineItem,
   openBundleLineItem
 ]);
-var openOrderSchema = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  status: import_zod7.z.literal("Open" /* Open */),
-  currency: import_zod7.z.string(),
+var openOrderSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  status: import_zod9.z.literal("Open" /* Open */),
+  currency: import_zod9.z.string(),
   items: openOrderLineItem.array(),
   couponsApplied: couponSchema.array(),
-  checkoutUrl: import_zod7.z.string().optional()
+  checkoutUrl: import_zod9.z.string().optional()
 });
-var orderSchema = import_zod7.z.discriminatedUnion("status", [
+var orderSchema = import_zod9.z.discriminatedUnion("status", [
   openOrderSchema
 ]);
 
@@ -629,13 +686,13 @@ _TokenStore.storageKey = "moonbase_auth";
 var TokenStore = _TokenStore;
 
 // src/vouchers/schemas.ts
-var import_zod8 = require("zod");
-var voucherSchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  name: import_zod8.z.string(),
-  description: import_zod8.z.string(),
-  code: import_zod8.z.string(),
-  redeemed: import_zod8.z.boolean(),
+var import_zod10 = require("zod");
+var voucherSchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  name: import_zod10.z.string(),
+  description: import_zod10.z.string(),
+  code: import_zod10.z.string(),
+  redeemed: import_zod10.z.boolean(),
   redeemsProducts: quantifiable(storefrontProductSchema).array(),
   redeemsBundles: quantifiable(storefrontBundleSchema).array()
 });
@@ -670,12 +727,14 @@ var MoonbaseClient = class {
     this.vouchers = new VoucherEndpoints(api);
     this.orders = new OrderEndpoints(api);
     this.licenses = new LicenseEndpoints(api);
+    this.activationRequests = new ActivationRequestEndpoints(api);
     this.products = new ProductEndpoints(api);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ActivationMethod,
+  ActivationRequestStatus,
   ActivationStatus,
   LicenseStatus,
   MoonbaseClient,