@moonbase.sh/api 0.4.44 → 0.4.45

package/dist/index.cjs

@@ -47,19 +47,54 @@ __export(index_exports, {
   ProductStatus: () => ProductStatus,
   SubscriptionStatus: () => SubscriptionStatus,
   TrialStatus: () => TrialStatus,
-  objectToQuery: () => objectToQuery
+  objectToQuery: () => objectToQuery,
+  schemas: () => schemas_exports11
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/activationRequests/schemas.ts
+var schemas_exports5 = {};
+__export(schemas_exports5, {
+  activationRequestSchema: () => activationRequestSchema
+});
 var import_zod6 = require("zod");
 
 // src/licenses/schemas.ts
+var schemas_exports2 = {};
+__export(schemas_exports2, {
+  importLicenseRequestSchema: () => importLicenseRequestSchema,
+  licenseActivationSchema: () => licenseActivationSchema,
+  licenseSchema: () => licenseSchema,
+  provisionLicensesRequestSchema: () => provisionLicensesRequestSchema
+});
 var import_zod3 = require("zod");
 
 // src/customers/schemas.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  addressSchema: () => addressSchema,
+  communicationPreferencesSchema: () => communicationPreferencesSchema,
+  customerSchema: () => customerSchema,
+  importCustomerRequestSchema: () => importCustomerRequestSchema
+});
 var import_zod2 = require("zod");
 
+// src/subscriptions/models.ts
+var SubscriptionStatus = /* @__PURE__ */ ((SubscriptionStatus2) => {
+  SubscriptionStatus2["Active"] = "Active";
+  SubscriptionStatus2["Expired"] = "Expired";
+  SubscriptionStatus2["Cancelled"] = "Cancelled";
+  return SubscriptionStatus2;
+})(SubscriptionStatus || {});
+var CycleLength = /* @__PURE__ */ ((CycleLength2) => {
+  CycleLength2["Daily"] = "Daily";
+  CycleLength2["Weekly"] = "Weekly";
+  CycleLength2["Monthly"] = "Monthly";
+  CycleLength2["Quarterly"] = "Quarterly";
+  CycleLength2["Yearly"] = "Yearly";
+  return CycleLength2;
+})(CycleLength || {});
+
 // src/globalSchemas.ts
 var import_zod = require("zod");
 var userSchema = import_zod.z.object({
@@ -75,7 +110,7 @@ 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 priceCollectionSchema = import_zod.z.record(import_zod.z.number()).describe("Mapping of currency code to amount");
 var percentageOffDiscountSchema = import_zod.z.object({
   type: import_zod.z.literal("PercentageOffDiscount"),
   percentage: import_zod.z.number()
@@ -92,17 +127,62 @@ var dateTimeSpanSchema = import_zod.z.object({
   from: import_zod.z.coerce.date().nullable(),
   to: import_zod.z.coerce.date().nullable()
 });
+var exclusivitySchema = import_zod.z.discriminatedUnion("type", [
+  import_zod.z.object({ type: import_zod.z.literal("Everyone") }),
+  import_zod.z.object({ type: import_zod.z.literal("None") }),
+  import_zod.z.object({ type: import_zod.z.literal("OwnsAllOf"), productIds: import_zod.z.string().array(), includeSubscriptions: import_zod.z.boolean() }),
+  import_zod.z.object({ type: import_zod.z.literal("OwnsSomeOf"), productIds: import_zod.z.string().array(), includeSubscriptions: import_zod.z.boolean() }),
+  import_zod.z.object({ type: import_zod.z.literal("CustomerGroup"), groupId: import_zod.z.string() }),
+  import_zod.z.object({
+    type: import_zod.z.literal("AtLeastNumberOfProducts"),
+    minNumberOfProducts: import_zod.z.number(),
+    includeSubscriptions: import_zod.z.boolean(),
+    including: import_zod.z.string().array(),
+    excluding: import_zod.z.string().array()
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("UTMSegment"),
+    source: import_zod.z.string().nullable(),
+    medium: import_zod.z.string().nullable(),
+    campaign: import_zod.z.string().nullable(),
+    term: import_zod.z.string().nullable(),
+    content: import_zod.z.string().nullable()
+  })
+]);
 var pricingDiscountSchema = import_zod.z.object({
   name: import_zod.z.string(),
-  description: import_zod.z.string().nullable(),
+  description: import_zod.z.string().nullish(),
   discount: discountSchema,
-  applicableVariationIds: import_zod.z.string().array().nullable(),
-  validity: dateTimeSpanSchema.nullable()
+  exclusivity: exclusivitySchema.nullish(),
+  applicableVariationIds: import_zod.z.string().array().nullish(),
+  validity: dateTimeSpanSchema.nullish(),
+  recurringPaymentUseCount: import_zod.z.number().nullish()
 });
+var entitlementSchema = import_zod.z.discriminatedUnion("type", [
+  import_zod.z.object({
+    type: import_zod.z.literal("PerpetualLicense")
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("SubscriptionLicense")
+  })
+]);
+var recurrenceSchema = import_zod.z.discriminatedUnion("type", [
+  import_zod.z.object({
+    type: import_zod.z.literal("OneOff")
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("Recurring"),
+    cycleLength: import_zod.z.nativeEnum(CycleLength),
+    renewalPrice: priceCollectionSchema.nullish()
+  })
+]);
 var pricingVariationSchema = import_zod.z.object({
   id: import_zod.z.string(),
   name: import_zod.z.string(),
-  price: priceCollectionSchema
+  price: priceCollectionSchema,
+  entitlement: entitlementSchema,
+  recurrence: recurrenceSchema,
+  requireCommunicationsOptInOnLeadGeneration: import_zod.z.boolean().optional()
 });
 function paged(itemSchema, api) {
   return import_zod.z.object({
@@ -265,6 +345,11 @@ var provisionLicensesRequestSchema = import_zod3.z.union([
 ]);
 
 // src/products/schemas.ts
+var schemas_exports3 = {};
+__export(schemas_exports3, {
+  productReleaseSchema: () => productReleaseSchema,
+  productSchema: () => productSchema
+});
 var import_zod4 = require("zod");
 
 // src/products/models.ts
@@ -313,6 +398,11 @@ var productReleaseSchema = import_zod4.z.object({
 });
 
 // src/trials/schemas.ts
+var schemas_exports4 = {};
+__export(schemas_exports4, {
+  importTrialRequestSchema: () => importTrialRequestSchema,
+  trialSchema: () => trialSchema
+});
 var import_zod5 = require("zod");
 
 // src/trials/models.ts
@@ -388,11 +478,11 @@ var import_cross_fetch = __toESM(require("cross-fetch"), 1);
 // src/utils/errors.ts
 var MoonbaseError = class extends Error {
   constructor(problemDetails) {
-    var _a, _b;
+    var _a;
     super();
     this.problemDetails = problemDetails;
     this.name = "MoonbaseError";
-    this.message = (_b = (_a = problemDetails == null ? void 0 : problemDetails.detail) != null ? _a : problemDetails == null ? void 0 : problemDetails.title) != null ? _b : "An unknown error occurred";
+    this.message = problemDetails ? ((_a = problemDetails.detail) != null ? _a : problemDetails.title) + "\n" + JSON.stringify(problemDetails, void 0, 2) : "An unknown error occurred";
   }
 };
 var NotAuthorizedError = class extends MoonbaseError {
@@ -564,6 +654,20 @@ var LicenseEndpoints = class {
 };
 
 // src/orders/schemas.ts
+var schemas_exports6 = {};
+__export(schemas_exports6, {
+  bundleLineItemFulfillmentSchema: () => bundleLineItemFulfillmentSchema,
+  bundleLineItemSchema: () => bundleLineItemSchema,
+  couponSnapshotSchema: () => couponSnapshotSchema,
+  customerSnapshotSchema: () => customerSnapshotSchema,
+  licenseLineItemFulfillmentSchema: () => licenseLineItemFulfillmentSchema,
+  lineItemFulfillmentSchema: () => lineItemFulfillmentSchema,
+  orderLineItemSchema: () => orderLineItemSchema,
+  orderSchema: () => orderSchema,
+  orderTotalSchema: () => orderTotalSchema,
+  productLineItemSchema: () => productLineItemSchema,
+  utmSchema: () => utmSchema
+});
 var import_zod8 = require("zod");
 
 // src/orders/models.ts
@@ -576,10 +680,16 @@ var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
 })(OrderStatus || {});
 
 // src/orders/schemas.ts
-var couponSchema = import_zod8.z.object({
+var couponSnapshotSchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
   code: import_zod8.z.string(),
   name: import_zod8.z.string(),
-  description: import_zod8.z.string()
+  description: import_zod8.z.string(),
+  combinable: import_zod8.z.boolean(),
+  discount: discountSchema,
+  applicableProductIds: import_zod8.z.string().array().describe("List of product IDs the coupon can be applied to, empty or missing means all products are applicable"),
+  applicableBundleIds: import_zod8.z.string().array().describe("List of bundle IDs the coupon can be applied to, empty or missing means all bundles are applicable"),
+  recurringPaymentUseCount: import_zod8.z.number().nullish()
 });
 var licenseLineItemFulfillmentSchema = import_zod8.z.object({
   type: import_zod8.z.literal("License"),
@@ -670,11 +780,11 @@ var orderPayoutSchema = import_zod8.z.object({
   feeBreakdown: import_zod8.z.string().array()
 });
 var customerSnapshotSchema = import_zod8.z.object({
-  name: import_zod8.z.string().nullable(),
-  businessName: import_zod8.z.string().nullable(),
-  taxId: import_zod8.z.string().nullable(),
-  email: import_zod8.z.string().nullable(),
-  address: addressSchema.nullable()
+  name: import_zod8.z.string().nullish(),
+  businessName: import_zod8.z.string().nullish(),
+  taxId: import_zod8.z.string().nullish(),
+  email: import_zod8.z.string().nullish(),
+  address: addressSchema.nullish()
 });
 var utmSchema = import_zod8.z.object({
   referrer: import_zod8.z.string().optional(),
@@ -699,10 +809,12 @@ var orderSchema = import_zod8.z.object({
   initialUTM: utmSchema.optional(),
   currentUTM: utmSchema.optional(),
   customer: customerSnapshotSchema.optional(),
-  couponsApplied: couponSchema.array(),
+  couponsApplied: couponSnapshotSchema.array(),
   items: orderLineItemSchema.array(),
   lastUpdated: entityChangeSchema,
-  created: entityChangeSchema
+  created: entityChangeSchema,
+  checkoutUrl: import_zod8.z.string().optional(),
+  embeddedCheckoutUrl: import_zod8.z.string().optional()
 });
 
 // src/orders/endpoints.ts
@@ -718,6 +830,10 @@ var OrderEndpoints = class {
     const response = await this.api.fetch(`/api/orders/${id}`);
     return orderSchema.parse(response.data);
   }
+  async prepare(request, returnUrl) {
+    const response = await this.api.fetch("/api/orders/prepare" + (returnUrl ? `?returnUrl=${encodeURIComponent(returnUrl)}` : ""), "POST", request);
+    return orderSchema.parse(response.data);
+  }
 };
 
 // src/products/endpoints.ts
@@ -740,25 +856,12 @@ var ProductEndpoints = class {
 };
 
 // src/subscriptions/schemas.ts
+var schemas_exports7 = {};
+__export(schemas_exports7, {
+  importSubscriptionRequestSchema: () => importSubscriptionRequestSchema,
+  subscriptionSchema: () => subscriptionSchema
+});
 var import_zod9 = require("zod");
-
-// src/subscriptions/models.ts
-var SubscriptionStatus = /* @__PURE__ */ ((SubscriptionStatus2) => {
-  SubscriptionStatus2["Active"] = "Active";
-  SubscriptionStatus2["Expired"] = "Expired";
-  SubscriptionStatus2["Cancelled"] = "Cancelled";
-  return SubscriptionStatus2;
-})(SubscriptionStatus || {});
-var CycleLength = /* @__PURE__ */ ((CycleLength2) => {
-  CycleLength2["Daily"] = "Daily";
-  CycleLength2["Weekly"] = "Weekly";
-  CycleLength2["Monthly"] = "Monthly";
-  CycleLength2["Quarterly"] = "Quarterly";
-  CycleLength2["Yearly"] = "Yearly";
-  return CycleLength2;
-})(CycleLength || {});
-
-// src/subscriptions/schemas.ts
 var subscriptionContentSchema = import_zod9.z.discriminatedUnion("type", [
   import_zod9.z.object({
     type: import_zod9.z.literal("Product"),
@@ -873,9 +976,19 @@ var TrialEndpoints = class {
 };
 
 // src/vouchers/schemas.ts
+var schemas_exports9 = {};
+__export(schemas_exports9, {
+  createVoucherRequestSchema: () => createVoucherRequestSchema,
+  voucherCodeSchema: () => voucherCodeSchema,
+  voucherSchema: () => voucherSchema
+});
 var import_zod11 = require("zod");
 
 // src/bundles/schemas.ts
+var schemas_exports8 = {};
+__export(schemas_exports8, {
+  bundleSchema: () => bundleSchema
+});
 var import_zod10 = require("zod");
 var bundleSchema = import_zod10.z.object({
   id: import_zod10.z.string(),
@@ -942,6 +1055,67 @@ var VoucherEndpoints = class {
   }
 };
 
+// src/schemas.ts
+var schemas_exports11 = {};
+__export(schemas_exports11, {
+  activationRequests: () => schemas_exports5,
+  bundles: () => schemas_exports8,
+  coupons: () => schemas_exports10,
+  customers: () => schemas_exports,
+  dateTimeSpanSchema: () => dateTimeSpanSchema,
+  discountSchema: () => discountSchema,
+  entityChangeSchema: () => entityChangeSchema,
+  licenses: () => schemas_exports2,
+  moneySchema: () => moneySchema,
+  orders: () => schemas_exports6,
+  paged: () => paged,
+  priceCollectionSchema: () => priceCollectionSchema,
+  pricingDiscountSchema: () => pricingDiscountSchema,
+  pricingVariationSchema: () => pricingVariationSchema,
+  products: () => schemas_exports3,
+  quantifiable: () => quantifiable,
+  subscriptions: () => schemas_exports7,
+  trials: () => schemas_exports4,
+  userSchema: () => userSchema,
+  vouchers: () => schemas_exports9
+});
+
+// src/coupons/schemas.ts
+var schemas_exports10 = {};
+__export(schemas_exports10, {
+  couponCodeSchema: () => couponCodeSchema,
+  couponSchema: () => couponSchema,
+  createCouponRequestSchema: () => createCouponRequestSchema
+});
+var import_zod12 = require("zod");
+var couponSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  description: import_zod12.z.string(),
+  numberOfCodes: import_zod12.z.number(),
+  numberOfRedemptions: import_zod12.z.number(),
+  combinable: import_zod12.z.boolean(),
+  recurringPaymentUseCount: import_zod12.z.number().nullable(),
+  discount: discountSchema,
+  applicableProducts: productSchema.array(),
+  applicableBundles: bundleSchema.array(),
+  applicableProductVariations: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.string().array()),
+  applicableBundleVariations: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.string().array()),
+  isDeleted: import_zod12.z.boolean(),
+  lastUpdated: entityChangeSchema,
+  created: entityChangeSchema
+});
+var createCouponRequestSchema = import_zod12.z.object({
+  name: import_zod12.z.string(),
+  description: import_zod12.z.string(),
+  applicableProducts: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.string().array()).optional().describe("Restricts the coupon to specific products, needs to be a map of product ID to array of applicable pricing variations, empty array if any variation is applicable."),
+  applicableBundles: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.string().array()).optional().describe("Restricts the coupon to specific bundles, needs to be a map of bundle ID to array of applicable pricing variations, empty array if any variation is applicable.")
+});
+var couponCodeSchema = import_zod12.z.object({
+  code: import_zod12.z.string(),
+  numberOfRedemptions: import_zod12.z.number()
+});
+
 // src/index.ts
 var MoonbaseClient = class {
   constructor(configuration) {
@@ -977,5 +1151,6 @@ var MoonbaseClient = class {
   ProductStatus,
   SubscriptionStatus,
   TrialStatus,
-  objectToQuery
+  objectToQuery,
+  schemas
 });