@dodopayments/convex 0.2.2 → 0.2.3

package/dist/index.cjs

@@ -4959,351 +4959,346 @@ ZodPromise.create;
 ZodOptional.create;
 ZodNullable.create;
 
+// src/schemas/webhook.ts
 var PaymentSchema = objectType({
-    payload_type: literalType("Payment"),
-    billing: objectType({
-        city: stringType().nullable(),
-        country: stringType().nullable(),
-        state: stringType().nullable(),
-        street: stringType().nullable(),
-        zipcode: stringType().nullable(),
-    }),
-    brand_id: stringType(),
-    business_id: stringType(),
-    card_issuing_country: stringType().nullable(),
-    card_last_four: stringType().nullable(),
-    card_network: stringType().nullable(),
-    card_type: stringType().nullable(),
-    created_at: stringType().transform(function (d) { return new Date(d); }),
-    currency: stringType(),
-    customer: objectType({
-        customer_id: stringType(),
-        email: stringType(),
-        name: stringType().nullable(),
-    }),
-    digital_products_delivered: booleanType(),
-    discount_id: stringType().nullable(),
-    disputes: arrayType(objectType({
-        amount: stringType(),
-        business_id: stringType(),
-        created_at: stringType().transform(function (d) { return new Date(d); }),
-        currency: stringType(),
-        dispute_id: stringType(),
-        dispute_stage: enumType([
-            "pre_dispute",
-            "dispute_opened",
-            "dispute_won",
-            "dispute_lost",
-        ]),
-        dispute_status: enumType([
-            "dispute_opened",
-            "dispute_won",
-            "dispute_lost",
-            "dispute_accepted",
-            "dispute_cancelled",
-            "dispute_challenged",
-        ]),
-        payment_id: stringType(),
-        remarks: stringType().nullable(),
-    }))
-        .nullable(),
-    error_code: stringType().nullable(),
-    error_message: stringType().nullable(),
-    metadata: recordType(anyType()).nullable(),
-    payment_id: stringType(),
-    payment_link: stringType().nullable(),
-    payment_method: stringType().nullable(),
-    payment_method_type: stringType().nullable(),
-    product_cart: arrayType(objectType({
-        product_id: stringType(),
-        quantity: numberType(),
-    }))
-        .nullable(),
-    refunds: arrayType(objectType({
-        amount: numberType(),
-        business_id: stringType(),
-        created_at: stringType().transform(function (d) { return new Date(d); }),
-        currency: stringType(),
-        is_partial: booleanType(),
-        payment_id: stringType(),
-        reason: stringType().nullable(),
-        refund_id: stringType(),
-        status: enumType(["succeeded", "failed", "pending"]),
-    }))
-        .nullable(),
-    settlement_amount: numberType(),
-    settlement_currency: stringType(),
-    settlement_tax: numberType().nullable(),
-    status: enumType(["succeeded", "failed", "pending", "processing", "cancelled"]),
-    subscription_id: stringType().nullable(),
-    tax: numberType().nullable(),
-    total_amount: numberType(),
-    updated_at: stringType()
-        .transform(function (d) { return new Date(d); })
-        .nullable(),
-});
-var SubscriptionSchema = objectType({
-    payload_type: literalType("Subscription"),
-    addons: arrayType(objectType({
-        addon_id: stringType(),
-        quantity: numberType(),
-    }))
-        .nullable(),
-    billing: objectType({
-        city: stringType().nullable(),
-        country: stringType().nullable(),
-        state: stringType().nullable(),
-        street: stringType().nullable(),
-        zipcode: stringType().nullable(),
-    }),
-    cancel_at_next_billing_date: booleanType(),
-    cancelled_at: stringType()
-        .transform(function (d) { return new Date(d); })
-        .nullable(),
-    created_at: stringType().transform(function (d) { return new Date(d); }),
-    currency: stringType(),
-    customer: objectType({
-        customer_id: stringType(),
-        email: stringType(),
-        name: stringType().nullable(),
-    }),
-    discount_id: stringType().nullable(),
-    metadata: recordType(anyType()).nullable(),
-    next_billing_date: stringType()
-        .transform(function (d) { return new Date(d); })
-        .nullable(),
-    on_demand: booleanType(),
-    payment_frequency_count: numberType(),
-    payment_frequency_interval: enumType(["Day", "Week", "Month", "Year"]),
-    previous_billing_date: stringType()
-        .transform(function (d) { return new Date(d); })
-        .nullable(),
-    product_id: stringType(),
-    quantity: numberType(),
-    recurring_pre_tax_amount: numberType(),
-    status: enumType([
-        "pending",
-        "active",
-        "on_hold",
-        "paused",
-        "cancelled",
-        "expired",
-        "failed",
-    ]),
-    subscription_id: stringType(),
-    subscription_period_count: numberType(),
-    subscription_period_interval: enumType(["Day", "Week", "Month", "Year"]),
-    tax_inclusive: booleanType(),
-    trial_period_days: numberType(),
-});
-var RefundSchema = objectType({
-    payload_type: literalType("Refund"),
-    amount: numberType(),
-    business_id: stringType(),
-    created_at: stringType().transform(function (d) { return new Date(d); }),
-    currency: stringType(),
-    is_partial: booleanType(),
-    payment_id: stringType(),
-    reason: stringType().nullable(),
-    refund_id: stringType(),
-    status: enumType(["succeeded", "failed", "pending"]),
-});
-var DisputeSchema = objectType({
-    payload_type: literalType("Dispute"),
-    amount: stringType(),
-    business_id: stringType(),
-    created_at: stringType().transform(function (d) { return new Date(d); }),
-    currency: stringType(),
-    dispute_id: stringType(),
-    dispute_stage: enumType([
+  payload_type: literalType("Payment"),
+  billing: objectType({
+    city: stringType().nullable(),
+    country: stringType().nullable(),
+    state: stringType().nullable(),
+    street: stringType().nullable(),
+    zipcode: stringType().nullable()
+  }),
+  brand_id: stringType(),
+  business_id: stringType(),
+  card_issuing_country: stringType().nullable(),
+  card_last_four: stringType().nullable(),
+  card_network: stringType().nullable(),
+  card_type: stringType().nullable(),
+  created_at: stringType().transform((d) => new Date(d)),
+  currency: stringType(),
+  customer: objectType({
+    customer_id: stringType(),
+    email: stringType(),
+    name: stringType().nullable()
+  }),
+  digital_products_delivered: booleanType(),
+  discount_id: stringType().nullable(),
+  disputes: arrayType(
+    objectType({
+      amount: stringType(),
+      business_id: stringType(),
+      created_at: stringType().transform((d) => new Date(d)),
+      currency: stringType(),
+      dispute_id: stringType(),
+      dispute_stage: enumType([
         "pre_dispute",
         "dispute_opened",
         "dispute_won",
-        "dispute_lost",
-    ]),
-    dispute_status: enumType([
+        "dispute_lost"
+      ]),
+      dispute_status: enumType([
         "dispute_opened",
         "dispute_won",
         "dispute_lost",
         "dispute_accepted",
         "dispute_cancelled",
-        "dispute_challenged",
-    ]),
-    payment_id: stringType(),
-    remarks: stringType().nullable(),
+        "dispute_challenged"
+      ]),
+      payment_id: stringType(),
+      remarks: stringType().nullable()
+    })
+  ).nullable(),
+  error_code: stringType().nullable(),
+  error_message: stringType().nullable(),
+  metadata: recordType(anyType()).nullable(),
+  payment_id: stringType(),
+  payment_link: stringType().nullable(),
+  payment_method: stringType().nullable(),
+  payment_method_type: stringType().nullable(),
+  product_cart: arrayType(
+    objectType({
+      product_id: stringType(),
+      quantity: numberType()
+    })
+  ).nullable(),
+  refunds: arrayType(
+    objectType({
+      amount: numberType(),
+      business_id: stringType(),
+      created_at: stringType().transform((d) => new Date(d)),
+      currency: stringType(),
+      is_partial: booleanType(),
+      payment_id: stringType(),
+      reason: stringType().nullable(),
+      refund_id: stringType(),
+      status: enumType(["succeeded", "failed", "pending"])
+    })
+  ).nullable(),
+  settlement_amount: numberType(),
+  settlement_currency: stringType(),
+  settlement_tax: numberType().nullable(),
+  status: enumType(["succeeded", "failed", "pending", "processing", "cancelled"]),
+  subscription_id: stringType().nullable(),
+  tax: numberType().nullable(),
+  total_amount: numberType(),
+  updated_at: stringType().transform((d) => new Date(d)).nullable()
 });
-var LicenseKeySchema = objectType({
-    payload_type: literalType("LicenseKey"),
-    activations_limit: numberType(),
-    business_id: stringType(),
-    created_at: stringType().transform(function (d) { return new Date(d); }),
+var SubscriptionSchema = objectType({
+  payload_type: literalType("Subscription"),
+  addons: arrayType(
+    objectType({
+      addon_id: stringType(),
+      quantity: numberType()
+    })
+  ).nullable(),
+  billing: objectType({
+    city: stringType().nullable(),
+    country: stringType().nullable(),
+    state: stringType().nullable(),
+    street: stringType().nullable(),
+    zipcode: stringType().nullable()
+  }),
+  cancel_at_next_billing_date: booleanType(),
+  cancelled_at: stringType().transform((d) => new Date(d)).nullable(),
+  created_at: stringType().transform((d) => new Date(d)),
+  currency: stringType(),
+  customer: objectType({
     customer_id: stringType(),
-    expires_at: stringType()
-        .transform(function (d) { return new Date(d); })
-        .nullable(),
-    id: stringType(),
-    instances_count: numberType(),
-    key: stringType(),
-    payment_id: stringType(),
-    product_id: stringType(),
-    status: enumType(["active", "inactive", "expired"]),
-    subscription_id: stringType().nullable(),
+    email: stringType(),
+    name: stringType().nullable()
+  }),
+  discount_id: stringType().nullable(),
+  metadata: recordType(anyType()).nullable(),
+  next_billing_date: stringType().transform((d) => new Date(d)).nullable(),
+  on_demand: booleanType(),
+  payment_frequency_count: numberType(),
+  payment_frequency_interval: enumType(["Day", "Week", "Month", "Year"]),
+  previous_billing_date: stringType().transform((d) => new Date(d)).nullable(),
+  product_id: stringType(),
+  quantity: numberType(),
+  recurring_pre_tax_amount: numberType(),
+  status: enumType([
+    "pending",
+    "active",
+    "on_hold",
+    "paused",
+    "cancelled",
+    "expired",
+    "failed"
+  ]),
+  subscription_id: stringType(),
+  subscription_period_count: numberType(),
+  subscription_period_interval: enumType(["Day", "Week", "Month", "Year"]),
+  tax_inclusive: booleanType(),
+  trial_period_days: numberType()
+});
+var RefundSchema = objectType({
+  payload_type: literalType("Refund"),
+  amount: numberType(),
+  business_id: stringType(),
+  created_at: stringType().transform((d) => new Date(d)),
+  currency: stringType(),
+  is_partial: booleanType(),
+  payment_id: stringType(),
+  reason: stringType().nullable(),
+  refund_id: stringType(),
+  status: enumType(["succeeded", "failed", "pending"])
+});
+var DisputeSchema = objectType({
+  payload_type: literalType("Dispute"),
+  amount: stringType(),
+  business_id: stringType(),
+  created_at: stringType().transform((d) => new Date(d)),
+  currency: stringType(),
+  dispute_id: stringType(),
+  dispute_stage: enumType([
+    "pre_dispute",
+    "dispute_opened",
+    "dispute_won",
+    "dispute_lost"
+  ]),
+  dispute_status: enumType([
+    "dispute_opened",
+    "dispute_won",
+    "dispute_lost",
+    "dispute_accepted",
+    "dispute_cancelled",
+    "dispute_challenged"
+  ]),
+  payment_id: stringType(),
+  remarks: stringType().nullable()
+});
+var LicenseKeySchema = objectType({
+  payload_type: literalType("LicenseKey"),
+  activations_limit: numberType(),
+  business_id: stringType(),
+  created_at: stringType().transform((d) => new Date(d)),
+  customer_id: stringType(),
+  expires_at: stringType().transform((d) => new Date(d)).nullable(),
+  id: stringType(),
+  instances_count: numberType(),
+  key: stringType(),
+  payment_id: stringType(),
+  product_id: stringType(),
+  status: enumType(["active", "inactive", "expired"]),
+  subscription_id: stringType().nullable()
 });
 var PaymentSucceededPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("payment.succeeded"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: PaymentSchema,
+  business_id: stringType(),
+  type: literalType("payment.succeeded"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: PaymentSchema
 });
 var PaymentFailedPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("payment.failed"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: PaymentSchema,
+  business_id: stringType(),
+  type: literalType("payment.failed"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: PaymentSchema
 });
 var PaymentProcessingPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("payment.processing"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: PaymentSchema,
+  business_id: stringType(),
+  type: literalType("payment.processing"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: PaymentSchema
 });
 var PaymentCancelledPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("payment.cancelled"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: PaymentSchema,
+  business_id: stringType(),
+  type: literalType("payment.cancelled"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: PaymentSchema
 });
 var RefundSucceededPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("refund.succeeded"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: RefundSchema,
+  business_id: stringType(),
+  type: literalType("refund.succeeded"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: RefundSchema
 });
 var RefundFailedPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("refund.failed"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: RefundSchema,
+  business_id: stringType(),
+  type: literalType("refund.failed"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: RefundSchema
 });
 var DisputeOpenedPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("dispute.opened"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: DisputeSchema,
+  business_id: stringType(),
+  type: literalType("dispute.opened"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: DisputeSchema
 });
 var DisputeExpiredPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("dispute.expired"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: DisputeSchema,
+  business_id: stringType(),
+  type: literalType("dispute.expired"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: DisputeSchema
 });
 var DisputeAcceptedPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("dispute.accepted"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: DisputeSchema,
+  business_id: stringType(),
+  type: literalType("dispute.accepted"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: DisputeSchema
 });
 var DisputeCancelledPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("dispute.cancelled"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: DisputeSchema,
+  business_id: stringType(),
+  type: literalType("dispute.cancelled"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: DisputeSchema
 });
 var DisputeChallengedPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("dispute.challenged"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: DisputeSchema,
+  business_id: stringType(),
+  type: literalType("dispute.challenged"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: DisputeSchema
 });
 var DisputeWonPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("dispute.won"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: DisputeSchema,
+  business_id: stringType(),
+  type: literalType("dispute.won"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: DisputeSchema
 });
 var DisputeLostPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("dispute.lost"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: DisputeSchema,
+  business_id: stringType(),
+  type: literalType("dispute.lost"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: DisputeSchema
 });
 var SubscriptionActivePayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("subscription.active"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: SubscriptionSchema,
+  business_id: stringType(),
+  type: literalType("subscription.active"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: SubscriptionSchema
 });
 var SubscriptionOnHoldPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("subscription.on_hold"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: SubscriptionSchema,
+  business_id: stringType(),
+  type: literalType("subscription.on_hold"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: SubscriptionSchema
 });
 var SubscriptionRenewedPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("subscription.renewed"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: SubscriptionSchema,
+  business_id: stringType(),
+  type: literalType("subscription.renewed"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: SubscriptionSchema
 });
 var SubscriptionPausedPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("subscription.paused"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: SubscriptionSchema,
+  business_id: stringType(),
+  type: literalType("subscription.paused"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: SubscriptionSchema
 });
 var SubscriptionPlanChangedPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("subscription.plan_changed"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: SubscriptionSchema,
+  business_id: stringType(),
+  type: literalType("subscription.plan_changed"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: SubscriptionSchema
 });
 var SubscriptionCancelledPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("subscription.cancelled"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: SubscriptionSchema,
+  business_id: stringType(),
+  type: literalType("subscription.cancelled"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: SubscriptionSchema
 });
 var SubscriptionFailedPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("subscription.failed"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: SubscriptionSchema,
+  business_id: stringType(),
+  type: literalType("subscription.failed"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: SubscriptionSchema
 });
 var SubscriptionExpiredPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("subscription.expired"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: SubscriptionSchema,
+  business_id: stringType(),
+  type: literalType("subscription.expired"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: SubscriptionSchema
 });
 var LicenseKeyCreatedPayloadSchema = objectType({
-    business_id: stringType(),
-    type: literalType("license_key.created"),
-    timestamp: stringType().transform(function (d) { return new Date(d); }),
-    data: LicenseKeySchema,
+  business_id: stringType(),
+  type: literalType("license_key.created"),
+  timestamp: stringType().transform((d) => new Date(d)),
+  data: LicenseKeySchema
 });
 var WebhookPayloadSchema = discriminatedUnionType("type", [
-    PaymentSucceededPayloadSchema,
-    PaymentFailedPayloadSchema,
-    PaymentProcessingPayloadSchema,
-    PaymentCancelledPayloadSchema,
-    RefundSucceededPayloadSchema,
-    RefundFailedPayloadSchema,
-    DisputeOpenedPayloadSchema,
-    DisputeExpiredPayloadSchema,
-    DisputeAcceptedPayloadSchema,
-    DisputeCancelledPayloadSchema,
-    DisputeChallengedPayloadSchema,
-    DisputeWonPayloadSchema,
-    DisputeLostPayloadSchema,
-    SubscriptionActivePayloadSchema,
-    SubscriptionOnHoldPayloadSchema,
-    SubscriptionRenewedPayloadSchema,
-    SubscriptionPausedPayloadSchema,
-    SubscriptionPlanChangedPayloadSchema,
-    SubscriptionCancelledPayloadSchema,
-    SubscriptionFailedPayloadSchema,
-    SubscriptionExpiredPayloadSchema,
-    LicenseKeyCreatedPayloadSchema,
+  PaymentSucceededPayloadSchema,
+  PaymentFailedPayloadSchema,
+  PaymentProcessingPayloadSchema,
+  PaymentCancelledPayloadSchema,
+  RefundSucceededPayloadSchema,
+  RefundFailedPayloadSchema,
+  DisputeOpenedPayloadSchema,
+  DisputeExpiredPayloadSchema,
+  DisputeAcceptedPayloadSchema,
+  DisputeCancelledPayloadSchema,
+  DisputeChallengedPayloadSchema,
+  DisputeWonPayloadSchema,
+  DisputeLostPayloadSchema,
+  SubscriptionActivePayloadSchema,
+  SubscriptionOnHoldPayloadSchema,
+  SubscriptionRenewedPayloadSchema,
+  SubscriptionPausedPayloadSchema,
+  SubscriptionPlanChangedPayloadSchema,
+  SubscriptionCancelledPayloadSchema,
+  SubscriptionFailedPayloadSchema,
+  SubscriptionExpiredPayloadSchema,
+  LicenseKeyCreatedPayloadSchema
 ]);
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -6157,220 +6152,108 @@ class Webhook {
 Webhook_1 = dist.Webhook = Webhook;
 Webhook.prefix = "whsec_";
 
-var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (undefined && undefined.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+async function handleWebhookPayload(payload, config, context) {
+  const callHandler = (handler, payload2) => {
+    if (!handler) return;
+    if (context !== void 0) {
+      return handler(context, payload2);
     }
-};
-// Implementation
-function handleWebhookPayload(payload, config, context) {
-    return __awaiter(this, void 0, void 0, function () {
-        var callHandler;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    callHandler = function (handler, payload) {
-                        if (!handler)
-                            return;
-                        if (context !== undefined) {
-                            return handler(context, payload);
-                        }
-                        return handler(payload);
-                    };
-                    if (!config.onPayload) return [3 /*break*/, 2];
-                    return [4 /*yield*/, callHandler(config.onPayload, payload)];
-                case 1:
-                    _a.sent();
-                    _a.label = 2;
-                case 2:
-                    if (!(payload.type === "payment.succeeded")) return [3 /*break*/, 4];
-                    return [4 /*yield*/, callHandler(config.onPaymentSucceeded, payload)];
-                case 3:
-                    _a.sent();
-                    _a.label = 4;
-                case 4:
-                    if (!(payload.type === "payment.failed")) return [3 /*break*/, 6];
-                    return [4 /*yield*/, callHandler(config.onPaymentFailed, payload)];
-                case 5:
-                    _a.sent();
-                    _a.label = 6;
-                case 6:
-                    if (!(payload.type === "payment.processing")) return [3 /*break*/, 8];
-                    return [4 /*yield*/, callHandler(config.onPaymentProcessing, payload)];
-                case 7:
-                    _a.sent();
-                    _a.label = 8;
-                case 8:
-                    if (!(payload.type === "payment.cancelled")) return [3 /*break*/, 10];
-                    return [4 /*yield*/, callHandler(config.onPaymentCancelled, payload)];
-                case 9:
-                    _a.sent();
-                    _a.label = 10;
-                case 10:
-                    if (!(payload.type === "refund.succeeded")) return [3 /*break*/, 12];
-                    return [4 /*yield*/, callHandler(config.onRefundSucceeded, payload)];
-                case 11:
-                    _a.sent();
-                    _a.label = 12;
-                case 12:
-                    if (!(payload.type === "refund.failed")) return [3 /*break*/, 14];
-                    return [4 /*yield*/, callHandler(config.onRefundFailed, payload)];
-                case 13:
-                    _a.sent();
-                    _a.label = 14;
-                case 14:
-                    if (!(payload.type === "dispute.opened")) return [3 /*break*/, 16];
-                    return [4 /*yield*/, callHandler(config.onDisputeOpened, payload)];
-                case 15:
-                    _a.sent();
-                    _a.label = 16;
-                case 16:
-                    if (!(payload.type === "dispute.expired")) return [3 /*break*/, 18];
-                    return [4 /*yield*/, callHandler(config.onDisputeExpired, payload)];
-                case 17:
-                    _a.sent();
-                    _a.label = 18;
-                case 18:
-                    if (!(payload.type === "dispute.accepted")) return [3 /*break*/, 20];
-                    return [4 /*yield*/, callHandler(config.onDisputeAccepted, payload)];
-                case 19:
-                    _a.sent();
-                    _a.label = 20;
-                case 20:
-                    if (!(payload.type === "dispute.cancelled")) return [3 /*break*/, 22];
-                    return [4 /*yield*/, callHandler(config.onDisputeCancelled, payload)];
-                case 21:
-                    _a.sent();
-                    _a.label = 22;
-                case 22:
-                    if (!(payload.type === "dispute.challenged")) return [3 /*break*/, 24];
-                    return [4 /*yield*/, callHandler(config.onDisputeChallenged, payload)];
-                case 23:
-                    _a.sent();
-                    _a.label = 24;
-                case 24:
-                    if (!(payload.type === "dispute.won")) return [3 /*break*/, 26];
-                    return [4 /*yield*/, callHandler(config.onDisputeWon, payload)];
-                case 25:
-                    _a.sent();
-                    _a.label = 26;
-                case 26:
-                    if (!(payload.type === "dispute.lost")) return [3 /*break*/, 28];
-                    return [4 /*yield*/, callHandler(config.onDisputeLost, payload)];
-                case 27:
-                    _a.sent();
-                    _a.label = 28;
-                case 28:
-                    if (!(payload.type === "subscription.active")) return [3 /*break*/, 30];
-                    return [4 /*yield*/, callHandler(config.onSubscriptionActive, payload)];
-                case 29:
-                    _a.sent();
-                    _a.label = 30;
-                case 30:
-                    if (!(payload.type === "subscription.on_hold")) return [3 /*break*/, 32];
-                    return [4 /*yield*/, callHandler(config.onSubscriptionOnHold, payload)];
-                case 31:
-                    _a.sent();
-                    _a.label = 32;
-                case 32:
-                    if (!(payload.type === "subscription.renewed")) return [3 /*break*/, 34];
-                    return [4 /*yield*/, callHandler(config.onSubscriptionRenewed, payload)];
-                case 33:
-                    _a.sent();
-                    _a.label = 34;
-                case 34:
-                    if (!(payload.type === "subscription.paused")) return [3 /*break*/, 36];
-                    return [4 /*yield*/, callHandler(config.onSubscriptionPaused, payload)];
-                case 35:
-                    _a.sent();
-                    _a.label = 36;
-                case 36:
-                    if (!(payload.type === "subscription.plan_changed")) return [3 /*break*/, 38];
-                    return [4 /*yield*/, callHandler(config.onSubscriptionPlanChanged, payload)];
-                case 37:
-                    _a.sent();
-                    _a.label = 38;
-                case 38:
-                    if (!(payload.type === "subscription.cancelled")) return [3 /*break*/, 40];
-                    return [4 /*yield*/, callHandler(config.onSubscriptionCancelled, payload)];
-                case 39:
-                    _a.sent();
-                    _a.label = 40;
-                case 40:
-                    if (!(payload.type === "subscription.failed")) return [3 /*break*/, 42];
-                    return [4 /*yield*/, callHandler(config.onSubscriptionFailed, payload)];
-                case 41:
-                    _a.sent();
-                    _a.label = 42;
-                case 42:
-                    if (!(payload.type === "subscription.expired")) return [3 /*break*/, 44];
-                    return [4 /*yield*/, callHandler(config.onSubscriptionExpired, payload)];
-                case 43:
-                    _a.sent();
-                    _a.label = 44;
-                case 44:
-                    if (!(payload.type === "license_key.created")) return [3 /*break*/, 46];
-                    return [4 /*yield*/, callHandler(config.onLicenseKeyCreated, payload)];
-                case 45:
-                    _a.sent();
-                    _a.label = 46;
-                case 46: return [2 /*return*/];
-            }
-        });
-    });
+    return handler(payload2);
+  };
+  if (config.onPayload) {
+    await callHandler(config.onPayload, payload);
+  }
+  if (payload.type === "payment.succeeded") {
+    await callHandler(config.onPaymentSucceeded, payload);
+  }
+  if (payload.type === "payment.failed") {
+    await callHandler(config.onPaymentFailed, payload);
+  }
+  if (payload.type === "payment.processing") {
+    await callHandler(config.onPaymentProcessing, payload);
+  }
+  if (payload.type === "payment.cancelled") {
+    await callHandler(config.onPaymentCancelled, payload);
+  }
+  if (payload.type === "refund.succeeded") {
+    await callHandler(config.onRefundSucceeded, payload);
+  }
+  if (payload.type === "refund.failed") {
+    await callHandler(config.onRefundFailed, payload);
+  }
+  if (payload.type === "dispute.opened") {
+    await callHandler(config.onDisputeOpened, payload);
+  }
+  if (payload.type === "dispute.expired") {
+    await callHandler(config.onDisputeExpired, payload);
+  }
+  if (payload.type === "dispute.accepted") {
+    await callHandler(config.onDisputeAccepted, payload);
+  }
+  if (payload.type === "dispute.cancelled") {
+    await callHandler(config.onDisputeCancelled, payload);
+  }
+  if (payload.type === "dispute.challenged") {
+    await callHandler(config.onDisputeChallenged, payload);
+  }
+  if (payload.type === "dispute.won") {
+    await callHandler(config.onDisputeWon, payload);
+  }
+  if (payload.type === "dispute.lost") {
+    await callHandler(config.onDisputeLost, payload);
+  }
+  if (payload.type === "subscription.active") {
+    await callHandler(config.onSubscriptionActive, payload);
+  }
+  if (payload.type === "subscription.on_hold") {
+    await callHandler(config.onSubscriptionOnHold, payload);
+  }
+  if (payload.type === "subscription.renewed") {
+    await callHandler(config.onSubscriptionRenewed, payload);
+  }
+  if (payload.type === "subscription.paused") {
+    await callHandler(config.onSubscriptionPaused, payload);
+  }
+  if (payload.type === "subscription.plan_changed") {
+    await callHandler(config.onSubscriptionPlanChanged, payload);
+  }
+  if (payload.type === "subscription.cancelled") {
+    await callHandler(config.onSubscriptionCancelled, payload);
+  }
+  if (payload.type === "subscription.failed") {
+    await callHandler(config.onSubscriptionFailed, payload);
+  }
+  if (payload.type === "subscription.expired") {
+    await callHandler(config.onSubscriptionExpired, payload);
+  }
+  if (payload.type === "license_key.created") {
+    await callHandler(config.onLicenseKeyCreated, payload);
+  }
 }
-var verifyWebhookPayload = function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
-    var standardWebhook, _c, success, payload, error;
-    var webhookKey = _b.webhookKey, headers = _b.headers, body = _b.body;
-    return __generator(this, function (_d) {
-        standardWebhook = new Webhook_1(webhookKey);
-        try {
-            standardWebhook.verify(body, headers);
-        }
-        catch (e) {
-            if (e instanceof WebhookVerificationError_1) {
-                throw new Error(e.message);
-            }
-            throw e;
-        }
-        _c = WebhookPayloadSchema.safeParse(JSON.parse(body)), success = _c.success, payload = _c.data, error = _c.error;
-        if (!success) {
-            throw new Error(error.message);
-        }
-        return [2 /*return*/, payload];
-    });
-}); };
+var verifyWebhookPayload = async ({
+  webhookKey,
+  headers,
+  body
+}) => {
+  const standardWebhook = new Webhook_1(webhookKey);
+  try {
+    standardWebhook.verify(body, headers);
+  } catch (e) {
+    if (e instanceof WebhookVerificationError_1) {
+      throw new Error(e.message);
+    }
+    throw e;
+  }
+  const {
+    success,
+    data: payload,
+    error
+  } = WebhookPayloadSchema.safeParse(JSON.parse(body));
+  if (!success) {
+    throw new Error(error.message);
+  }
+  return payload;
+};
 
 /**
  * Creates a Convex HTTP action to securely handle Dodo Payments webhooks.