@moonbase.sh/api 0.4.31 → 0.4.33

package/dist/index.cjs

@@ -50,49 +50,118 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/activationRequests/schemas.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 
 // src/licenses/schemas.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 
 // src/customers/schemas.ts
+var import_zod2 = require("zod");
+
+// src/globalSchemas.ts
 var import_zod = require("zod");
-var addressSchema = import_zod.z.object({
-  countryCode: import_zod.z.string(),
-  streetAddress1: import_zod.z.string(),
-  streetAddress2: import_zod.z.string().nullable(),
-  locality: import_zod.z.string().nullable(),
-  region: import_zod.z.string().nullable(),
-  postCode: import_zod.z.string().nullable()
-});
-var communicationPreferencesSchema = import_zod.z.object({
-  newsletterOptIn: import_zod.z.boolean()
-  // productUpdatesOptIn: z.boolean(), // TODO: Enable when relevant
+var userSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  name: import_zod.z.string(),
+  email: import_zod.z.string()
+});
+var entityChangeSchema = import_zod.z.object({
+  at: import_zod.z.coerce.date(),
+  by: userSchema
+});
+var moneySchema = import_zod.z.object({
+  currency: import_zod.z.string(),
+  amount: import_zod.z.number()
+});
+var priceCollectionSchema = import_zod.z.record(import_zod.z.number());
+var percentageOffDiscountSchema = import_zod.z.object({
+  type: import_zod.z.literal("PercentageOffDiscount"),
+  percentage: import_zod.z.number()
+});
+var flatAmountOffDiscountSchema = import_zod.z.object({
+  type: import_zod.z.literal("FlatAmountOffDiscount"),
+  total: priceCollectionSchema
 });
-var customerSchema = import_zod.z.object({
+var discountSchema = import_zod.z.discriminatedUnion("type", [
+  percentageOffDiscountSchema,
+  flatAmountOffDiscountSchema
+]);
+var dateTimeSpanSchema = import_zod.z.object({
+  from: import_zod.z.coerce.date().nullable(),
+  to: import_zod.z.coerce.date().nullable()
+});
+var pricingDiscountSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  description: import_zod.z.string().nullable(),
+  discount: discountSchema,
+  applicableVariationIds: import_zod.z.string().array().nullable(),
+  validity: dateTimeSpanSchema.nullable()
+});
+var pricingVariationSchema = import_zod.z.object({
   id: import_zod.z.string(),
-  externalId: import_zod.z.string().optional(),
   name: import_zod.z.string(),
-  businessName: import_zod.z.string().nullable(),
-  taxId: import_zod.z.string().nullable(),
-  email: import_zod.z.string(),
-  numberOfLicenses: import_zod.z.number(),
-  numberOfTrials: import_zod.z.number(),
-  emailConfirmed: import_zod.z.boolean(),
-  hasPassword: import_zod.z.boolean(),
-  isDeleted: import_zod.z.boolean(),
-  ownedProducts: import_zod.z.string().array().transform((arr) => arr.sort()),
-  subscribedProducts: import_zod.z.string().array().transform((arr) => arr.sort()),
+  price: priceCollectionSchema
+});
+function paged(itemSchema, api) {
+  return import_zod.z.object({
+    items: import_zod.z.array(itemSchema),
+    hasMore: import_zod.z.boolean(),
+    next: import_zod.z.string().nullable()
+  }).transform((page) => ({
+    ...page,
+    getNext: () => {
+      if (!page.hasMore || !page.next)
+        throw new Error("Response indicates no more results");
+      return api.fetch(page.next).then((response) => paged(itemSchema, api).parse(response.data));
+    }
+  }));
+}
+function quantifiable(itemSchema) {
+  return import_zod.z.object({
+    value: itemSchema,
+    quantity: import_zod.z.number()
+  });
+}
+
+// src/customers/schemas.ts
+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().nullable()
+});
+var communicationPreferencesSchema = import_zod2.z.object({
+  newsletterOptIn: import_zod2.z.boolean()
+  // productUpdatesOptIn: z.boolean(), // TODO: Enable when relevant
+});
+var customerSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  externalId: import_zod2.z.string().optional(),
+  name: import_zod2.z.string(),
+  businessName: import_zod2.z.string().nullable(),
+  taxId: import_zod2.z.string().nullable(),
+  email: import_zod2.z.string(),
+  numberOfLicenses: import_zod2.z.number(),
+  numberOfTrials: import_zod2.z.number(),
+  emailConfirmed: import_zod2.z.boolean(),
+  hasPassword: import_zod2.z.boolean(),
+  isDeleted: import_zod2.z.boolean(),
+  ownedProducts: import_zod2.z.string().array().transform((arr) => arr.sort()),
+  subscribedProducts: import_zod2.z.string().array().transform((arr) => arr.sort()),
   address: addressSchema.nullable(),
-  communicationPreferences: communicationPreferencesSchema
+  communicationPreferences: communicationPreferencesSchema,
+  lastUpdated: entityChangeSchema,
+  created: entityChangeSchema
 });
-var importCustomerRequestSchema = import_zod.z.object({
-  name: import_zod.z.string(),
-  email: import_zod.z.string(),
-  externalId: import_zod.z.string().optional(),
-  password: import_zod.z.string().optional(),
+var importCustomerRequestSchema = import_zod2.z.object({
+  name: import_zod2.z.string(),
+  email: import_zod2.z.string(),
+  externalId: import_zod2.z.string().optional(),
+  password: import_zod2.z.string().optional(),
   address: addressSchema.optional(),
-  createdAt: import_zod.z.date().optional()
+  createdAt: import_zod2.z.date().optional()
 });
 
 // src/licenses/models.ts
@@ -114,61 +183,86 @@ var ActivationMethod = /* @__PURE__ */ ((ActivationMethod2) => {
 })(ActivationMethod || {});
 
 // src/licenses/schemas.ts
-var licenseSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  externalId: import_zod2.z.string().optional(),
-  productId: import_zod2.z.string(),
-  ownerId: import_zod2.z.string(),
-  status: import_zod2.z.nativeEnum(LicenseStatus),
-  activeNumberOfActivations: import_zod2.z.number(),
-  maxNumberOfActivations: import_zod2.z.number(),
-  offlineActivationsAllowed: import_zod2.z.boolean()
-});
-var licenseActivationSchema = import_zod2.z.object({
-  id: import_zod2.z.string(),
-  name: import_zod2.z.string(),
-  signature: import_zod2.z.string(),
-  status: import_zod2.z.nativeEnum(ActivationStatus),
-  activationMethod: import_zod2.z.nativeEnum(ActivationMethod),
-  lastValidatedAt: import_zod2.z.coerce.date(),
+var licenseSourceSchema = import_zod3.z.discriminatedUnion("type", [
+  import_zod3.z.object({
+    type: import_zod3.z.literal("Order"),
+    orderId: import_zod3.z.string()
+  }),
+  import_zod3.z.object({
+    type: import_zod3.z.literal("Subscription"),
+    subscriptionId: import_zod3.z.string()
+  }),
+  import_zod3.z.object({
+    type: import_zod3.z.literal("Voucher"),
+    voucherId: import_zod3.z.string(),
+    code: import_zod3.z.string()
+  }),
+  import_zod3.z.object({
+    type: import_zod3.z.literal("Fastspring"),
+    reference: import_zod3.z.string(),
+    testMode: import_zod3.z.boolean()
+  })
+]);
+var licenseSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  externalId: import_zod3.z.string().optional(),
+  productId: import_zod3.z.string(),
+  ownerId: import_zod3.z.string(),
+  status: import_zod3.z.nativeEnum(LicenseStatus),
+  activeNumberOfActivations: import_zod3.z.number(),
+  maxNumberOfActivations: import_zod3.z.number(),
+  offlineActivationsAllowed: import_zod3.z.boolean(),
+  source: licenseSourceSchema.nullable(),
+  lastUpdated: entityChangeSchema,
+  created: entityChangeSchema
+});
+var licenseActivationSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  name: import_zod3.z.string(),
+  signature: import_zod3.z.string(),
+  status: import_zod3.z.nativeEnum(ActivationStatus),
+  activationMethod: import_zod3.z.nativeEnum(ActivationMethod),
+  lastValidatedAt: import_zod3.z.coerce.date(),
   license: licenseSchema,
-  customer: customerSchema.optional()
+  customer: customerSchema.optional(),
+  lastUpdated: entityChangeSchema,
+  created: entityChangeSchema
 });
-var importLicenseRequestSchema = import_zod2.z.object({
-  ownerId: import_zod2.z.string(),
-  productId: import_zod2.z.string(),
-  externalId: import_zod2.z.string().optional(),
-  createdAt: import_zod2.z.date().optional(),
-  maxNumberOfActivations: import_zod2.z.number().optional(),
-  offlineActivationsAllowed: import_zod2.z.boolean().optional(),
-  activations: import_zod2.z.object({
-    activationMethod: import_zod2.z.nativeEnum(ActivationMethod),
-    deviceName: import_zod2.z.string(),
-    deviceSignature: import_zod2.z.string(),
-    lastValidation: import_zod2.z.date().optional()
+var importLicenseRequestSchema = import_zod3.z.object({
+  ownerId: import_zod3.z.string(),
+  productId: import_zod3.z.string(),
+  externalId: import_zod3.z.string().optional(),
+  createdAt: import_zod3.z.date().optional(),
+  maxNumberOfActivations: import_zod3.z.number().optional(),
+  offlineActivationsAllowed: import_zod3.z.boolean().optional(),
+  activations: import_zod3.z.object({
+    activationMethod: import_zod3.z.nativeEnum(ActivationMethod),
+    deviceName: import_zod3.z.string(),
+    deviceSignature: import_zod3.z.string(),
+    lastValidation: import_zod3.z.date().optional()
   }).array().optional()
 });
-var provisionLicensesRequestRequestSchema = import_zod2.z.object({
-  productId: import_zod2.z.string(),
-  quantity: import_zod2.z.number().optional(),
-  limitPerCustomer: import_zod2.z.number().optional()
+var provisionLicensesRequestRequestSchema = import_zod3.z.object({
+  productId: import_zod3.z.string(),
+  quantity: import_zod3.z.number().optional(),
+  limitPerCustomer: import_zod3.z.number().optional()
 }).array();
-var provisionLicensesRequestSchema = import_zod2.z.union([
-  import_zod2.z.object({
-    ownerId: import_zod2.z.string(),
+var provisionLicensesRequestSchema = import_zod3.z.union([
+  import_zod3.z.object({
+    ownerId: import_zod3.z.string(),
     requests: provisionLicensesRequestRequestSchema
   }),
-  import_zod2.z.object({
-    customer: import_zod2.z.object({
-      name: import_zod2.z.string(),
-      email: import_zod2.z.string()
+  import_zod3.z.object({
+    customer: import_zod3.z.object({
+      name: import_zod3.z.string(),
+      email: import_zod3.z.string()
     }),
     requests: provisionLicensesRequestRequestSchema
   })
 ]);
 
 // src/products/schemas.ts
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // src/products/models.ts
 var Platform = /* @__PURE__ */ ((Platform2) => {
@@ -187,36 +281,36 @@ var ProductStatus = /* @__PURE__ */ ((ProductStatus2) => {
 })(ProductStatus || {});
 
 // src/products/schemas.ts
-var productSchema = import_zod3.z.object({
-  id: import_zod3.z.string(),
-  name: import_zod3.z.string(),
-  tagline: import_zod3.z.string(),
-  description: import_zod3.z.string(),
-  website: import_zod3.z.string().nullable(),
-  iconUrl: import_zod3.z.string().nullable(),
-  status: import_zod3.z.nativeEnum(ProductStatus),
-  purchasable: import_zod3.z.boolean(),
-  currentReleaseVersion: import_zod3.z.string().nullable()
-});
-var productReleaseSchema = import_zod3.z.object({
-  version: import_zod3.z.string(),
-  description: import_zod3.z.string().nullable(),
-  publishedAt: import_zod3.z.coerce.date().nullable(),
-  downloadUrl: import_zod3.z.string(),
-  hostedDownloadUrl: import_zod3.z.string(),
-  downloads: import_zod3.z.object({
-    name: import_zod3.z.string(),
-    key: import_zod3.z.string(),
-    platform: import_zod3.z.nativeEnum(Platform),
-    size: import_zod3.z.number(),
-    downloadUrl: import_zod3.z.string(),
-    hostedDownloadUrl: import_zod3.z.string(),
-    directUrl: import_zod3.z.string()
+var productSchema = import_zod4.z.object({
+  id: import_zod4.z.string(),
+  name: import_zod4.z.string(),
+  tagline: import_zod4.z.string(),
+  description: import_zod4.z.string(),
+  website: import_zod4.z.string().nullable(),
+  iconUrl: import_zod4.z.string().nullable(),
+  status: import_zod4.z.nativeEnum(ProductStatus),
+  purchasable: import_zod4.z.boolean(),
+  currentReleaseVersion: import_zod4.z.string().nullable()
+});
+var productReleaseSchema = import_zod4.z.object({
+  version: import_zod4.z.string(),
+  description: import_zod4.z.string().nullable(),
+  publishedAt: import_zod4.z.coerce.date().nullable(),
+  downloadUrl: import_zod4.z.string(),
+  hostedDownloadUrl: import_zod4.z.string(),
+  downloads: 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(),
+    downloadUrl: import_zod4.z.string(),
+    hostedDownloadUrl: import_zod4.z.string(),
+    directUrl: import_zod4.z.string()
   }).array()
 });
 
 // src/trials/schemas.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 
 // src/trials/models.ts
 var TrialStatus = /* @__PURE__ */ ((TrialStatus2) => {
@@ -226,26 +320,28 @@ var TrialStatus = /* @__PURE__ */ ((TrialStatus2) => {
 })(TrialStatus || {});
 
 // src/trials/schemas.ts
-var trialSchema = import_zod4.z.object({
-  id: import_zod4.z.string(),
-  externalId: import_zod4.z.string().optional(),
-  productId: import_zod4.z.string(),
-  deviceName: import_zod4.z.string(),
-  deviceSignature: import_zod4.z.string(),
-  status: import_zod4.z.nativeEnum(TrialStatus),
-  expiresAt: import_zod4.z.coerce.date(),
-  lastValidatedAt: import_zod4.z.coerce.date(),
-  customer: customerSchema.optional()
-});
-var importTrialRequestSchema = import_zod4.z.object({
-  productId: import_zod4.z.string(),
-  externalId: import_zod4.z.string().optional(),
-  deviceName: import_zod4.z.string(),
-  deviceSignature: import_zod4.z.string(),
-  expiresAt: import_zod4.z.date(),
-  ownerId: import_zod4.z.string().optional(),
-  lastValidation: import_zod4.z.date().optional(),
-  createdAt: import_zod4.z.date().optional()
+var trialSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  externalId: import_zod5.z.string().optional(),
+  productId: import_zod5.z.string(),
+  deviceName: import_zod5.z.string(),
+  deviceSignature: import_zod5.z.string(),
+  status: import_zod5.z.nativeEnum(TrialStatus),
+  expiresAt: import_zod5.z.coerce.date(),
+  lastValidatedAt: import_zod5.z.coerce.date(),
+  customer: customerSchema.optional(),
+  lastUpdated: entityChangeSchema,
+  created: entityChangeSchema
+});
+var importTrialRequestSchema = import_zod5.z.object({
+  productId: import_zod5.z.string(),
+  externalId: import_zod5.z.string().optional(),
+  deviceName: import_zod5.z.string(),
+  deviceSignature: import_zod5.z.string(),
+  expiresAt: import_zod5.z.date(),
+  ownerId: import_zod5.z.string().optional(),
+  lastValidation: import_zod5.z.date().optional(),
+  createdAt: import_zod5.z.date().optional()
 });
 
 // src/activationRequests/models.ts
@@ -257,11 +353,11 @@ var ActivationRequestStatus = /* @__PURE__ */ ((ActivationRequestStatus2) => {
 })(ActivationRequestStatus || {});
 
 // src/activationRequests/schemas.ts
-var activationRequestSchema = import_zod5.z.object({
-  id: import_zod5.z.string(),
-  deviceName: import_zod5.z.string(),
-  deviceSignature: import_zod5.z.string(),
-  status: import_zod5.z.nativeEnum(ActivationRequestStatus),
+var activationRequestSchema = import_zod6.z.object({
+  id: import_zod6.z.string(),
+  deviceName: import_zod6.z.string(),
+  deviceSignature: import_zod6.z.string(),
+  status: import_zod6.z.nativeEnum(ActivationRequestStatus),
   product: productSchema,
   activation: licenseActivationSchema.optional(),
   trial: trialSchema.optional()
@@ -282,71 +378,6 @@ var ActivationRequestEndpoints = class {
   }
 };
 
-// src/globalSchemas.ts
-var import_zod6 = require("zod");
-var userSchema = import_zod6.z.object({
-  id: import_zod6.z.string(),
-  name: import_zod6.z.string(),
-  email: import_zod6.z.string()
-});
-var entityChangeSchema = import_zod6.z.object({
-  at: import_zod6.z.coerce.date(),
-  by: userSchema
-});
-var moneySchema = import_zod6.z.object({
-  currency: import_zod6.z.string(),
-  amount: import_zod6.z.number()
-});
-var priceCollectionSchema = import_zod6.z.record(import_zod6.z.number());
-var percentageOffDiscountSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("PercentageOffDiscount"),
-  percentage: import_zod6.z.number()
-});
-var flatAmountOffDiscountSchema = import_zod6.z.object({
-  type: import_zod6.z.literal("FlatAmountOffDiscount"),
-  total: priceCollectionSchema
-});
-var discountSchema = import_zod6.z.discriminatedUnion("type", [
-  percentageOffDiscountSchema,
-  flatAmountOffDiscountSchema
-]);
-var dateTimeSpanSchema = import_zod6.z.object({
-  from: import_zod6.z.coerce.date().nullable(),
-  to: import_zod6.z.coerce.date().nullable()
-});
-var pricingDiscountSchema = import_zod6.z.object({
-  name: import_zod6.z.string(),
-  description: import_zod6.z.string().nullable(),
-  discount: discountSchema,
-  applicableVariationIds: import_zod6.z.string().array().nullable(),
-  validity: dateTimeSpanSchema.nullable()
-});
-var pricingVariationSchema = import_zod6.z.object({
-  id: import_zod6.z.string(),
-  name: import_zod6.z.string(),
-  price: priceCollectionSchema
-});
-function paged(itemSchema, api) {
-  return import_zod6.z.object({
-    items: import_zod6.z.array(itemSchema),
-    hasMore: import_zod6.z.boolean(),
-    next: import_zod6.z.string().nullable()
-  }).transform((page) => ({
-    ...page,
-    getNext: () => {
-      if (!page.hasMore || !page.next)
-        throw new Error("Response indicates no more results");
-      return api.fetch(page.next).then((response) => paged(itemSchema, api).parse(response.data));
-    }
-  }));
-}
-function quantifiable(itemSchema) {
-  return import_zod6.z.object({
-    value: itemSchema,
-    quantity: import_zod6.z.number()
-  });
-}
-
 // src/utils/api.ts
 var import_cross_fetch = __toESM(require("cross-fetch"), 1);
 
@@ -506,8 +537,12 @@ var LicenseEndpoints = class {
     const response = await this.api.fetch(`/api/licenses/${licenseId}/revoke`, "POST");
     return licenseSchema.parse(response.data);
   }
-  async queryActivations(licenseId, opts) {
-    const response = await this.api.fetch(`/api/licenses/${licenseId}/activations?${objectToQuery(opts)}`);
+  async queryActivations(licenseIdOrOpt, opts) {
+    if (licenseIdOrOpt && typeof licenseIdOrOpt === "string") {
+      const response2 = await this.api.fetch(`/api/licenses/${licenseIdOrOpt}/activations?${objectToQuery(opts)}`);
+      return paged(licenseActivationSchema, this.api).parse(response2.data);
+    }
+    const response = await this.api.fetch(`/api/license-activations?${objectToQuery(opts)}`);
     return paged(licenseActivationSchema, this.api).parse(response.data);
   }
   async getActivation(licenseId, activationId) {
@@ -746,7 +781,9 @@ var voucherSchema = import_zod10.z.object({
   numberOfCodes: import_zod10.z.number(),
   numberOfRedemptions: import_zod10.z.number(),
   redeemsProducts: quantifiable(productSchema).array(),
-  redeemsBundles: quantifiable(bundleSchema).array()
+  redeemsBundles: quantifiable(bundleSchema).array(),
+  lastUpdated: entityChangeSchema,
+  created: entityChangeSchema
 });
 var createVoucherRequestSchema = import_zod10.z.object({
   name: import_zod10.z.string(),