@dodopayments/remix 0.2.1 → 0.2.2

package/dist/index.js

@@ -6166,532 +6166,432 @@ DodoPayments.Webhooks = Webhooks$1;
 DodoPayments.UsageEvents = UsageEvents;
 DodoPayments.Meters = Meters;
 
-var __assign = (undefined && undefined.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter$1 = (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$1 = (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 };
-    }
-};
+// src/checkout/checkout.ts
 var checkoutQuerySchema = objectType({
-    productId: stringType(),
-    quantity: stringType().optional(),
-    // Customer fields
-    fullName: stringType().optional(),
-    firstName: stringType().optional(),
-    lastName: stringType().optional(),
-    email: stringType().optional(),
-    country: stringType().optional(),
-    addressLine: stringType().optional(),
-    city: stringType().optional(),
-    state: stringType().optional(),
-    zipCode: stringType().optional(),
-    // Disable flags
-    disableFullName: stringType().optional(),
-    disableFirstName: stringType().optional(),
-    disableLastName: stringType().optional(),
-    disableEmail: stringType().optional(),
-    disableCountry: stringType().optional(),
-    disableAddressLine: stringType().optional(),
-    disableCity: stringType().optional(),
-    disableState: stringType().optional(),
-    disableZipCode: stringType().optional(),
-    // Advanced controls
-    paymentCurrency: stringType().optional(),
-    showCurrencySelector: stringType().optional(),
-    paymentAmount: stringType().optional(),
-    showDiscounts: stringType().optional(),
-    // Metadata (allow any key starting with metadata_)
-    // We'll handle metadata separately in the handler
-})
-    .catchall(unknownType());
-// Add Zod schema for dynamic checkout body
+  productId: stringType(),
+  quantity: stringType().optional(),
+  // Customer fields
+  fullName: stringType().optional(),
+  firstName: stringType().optional(),
+  lastName: stringType().optional(),
+  email: stringType().optional(),
+  country: stringType().optional(),
+  addressLine: stringType().optional(),
+  city: stringType().optional(),
+  state: stringType().optional(),
+  zipCode: stringType().optional(),
+  // Disable flags
+  disableFullName: stringType().optional(),
+  disableFirstName: stringType().optional(),
+  disableLastName: stringType().optional(),
+  disableEmail: stringType().optional(),
+  disableCountry: stringType().optional(),
+  disableAddressLine: stringType().optional(),
+  disableCity: stringType().optional(),
+  disableState: stringType().optional(),
+  disableZipCode: stringType().optional(),
+  // Advanced controls
+  paymentCurrency: stringType().optional(),
+  showCurrencySelector: stringType().optional(),
+  paymentAmount: stringType().optional(),
+  showDiscounts: stringType().optional()
+  // Metadata (allow any key starting with metadata_)
+  // We'll handle metadata separately in the handler
+}).catchall(unknownType());
 var dynamicCheckoutBodySchema = objectType({
-    // For subscription
-    product_id: stringType().optional(),
-    quantity: numberType().optional(),
-    // For one-time payment
-    product_cart: arrayType(objectType({
-        product_id: stringType(),
-        quantity: numberType(),
-    }))
-        .optional(),
-    // Common fields
-    billing: objectType({
-        city: stringType(),
-        country: stringType(),
-        state: stringType(),
-        street: stringType(),
-        zipcode: stringType(),
-    }),
-    customer: objectType({
-        customer_id: stringType().optional(),
-        email: stringType().optional(),
-        name: stringType().optional(),
-    }),
-    discount_id: stringType().optional(),
-    addons: arrayType(objectType({
-        addon_id: stringType(),
-        quantity: numberType(),
-    }))
-        .optional(),
-    metadata: recordType(stringType(), stringType()).optional(),
-    currency: stringType().optional(),
-    // Allow any additional fields (for future compatibility)
-})
-    .catchall(unknownType());
-// ========================================
-// CHECKOUT SESSIONS SCHEMAS & TYPES
-// ========================================
-// Product cart item schema for checkout sessions
+  // For subscription
+  product_id: stringType().optional(),
+  quantity: numberType().optional(),
+  // For one-time payment
+  product_cart: arrayType(
+    objectType({
+      product_id: stringType(),
+      quantity: numberType()
+    })
+  ).optional(),
+  // Common fields
+  billing: objectType({
+    city: stringType(),
+    country: stringType(),
+    state: stringType(),
+    street: stringType(),
+    zipcode: stringType()
+  }),
+  customer: objectType({
+    customer_id: stringType().optional(),
+    email: stringType().optional(),
+    name: stringType().optional()
+  }),
+  discount_id: stringType().optional(),
+  addons: arrayType(
+    objectType({
+      addon_id: stringType(),
+      quantity: numberType()
+    })
+  ).optional(),
+  metadata: recordType(stringType(), stringType()).optional(),
+  currency: stringType().optional()
+  // Allow any additional fields (for future compatibility)
+}).catchall(unknownType());
 var checkoutSessionProductCartItemSchema = objectType({
-    product_id: stringType().min(1, "Product ID is required"),
-    quantity: numberType().int().positive("Quantity must be a positive integer"),
+  product_id: stringType().min(1, "Product ID is required"),
+  quantity: numberType().int().positive("Quantity must be a positive integer")
 });
-// Customer information schema for checkout sessions
 var checkoutSessionCustomerSchema = objectType({
-    email: stringType().email().optional(),
-    name: stringType().min(1).optional(),
-    phone_number: stringType().optional(),
-})
-    .optional();
-// Billing address schema for checkout sessions
+  email: stringType().email().optional(),
+  name: stringType().min(1).optional(),
+  phone_number: stringType().optional()
+}).optional();
 var checkoutSessionBillingAddressSchema = objectType({
-    street: stringType().optional(),
-    city: stringType().optional(),
-    state: stringType().optional(),
-    country: stringType().length(2, "Country must be a 2-letter ISO code"),
-    zipcode: stringType().optional(),
-})
-    .optional();
-// Payment method types enum based on Dodo Payments documentation
+  street: stringType().optional(),
+  city: stringType().optional(),
+  state: stringType().optional(),
+  country: stringType().length(2, "Country must be a 2-letter ISO code"),
+  zipcode: stringType().optional()
+}).optional();
 var paymentMethodTypeSchema = enumType([
-    "credit",
-    "debit",
-    "upi_collect",
-    "upi_intent",
-    "apple_pay",
-    "google_pay",
-    "amazon_pay",
-    "klarna",
-    "affirm",
-    "afterpay_clearpay",
-    "sepa",
-    "ach",
+  "credit",
+  "debit",
+  "upi_collect",
+  "upi_intent",
+  "apple_pay",
+  "google_pay",
+  "amazon_pay",
+  "klarna",
+  "affirm",
+  "afterpay_clearpay",
+  "sepa",
+  "ach"
 ]);
-// Customization options schema
 var checkoutSessionCustomizationSchema = objectType({
-    theme: enumType(["light", "dark", "system"]).optional(),
-    show_order_details: booleanType().optional(),
-    show_on_demand_tag: booleanType().optional(),
-})
-    .optional();
-// Feature flags schema
+  theme: enumType(["light", "dark", "system"]).optional(),
+  show_order_details: booleanType().optional(),
+  show_on_demand_tag: booleanType().optional()
+}).optional();
 var checkoutSessionFeatureFlagsSchema = objectType({
-    allow_currency_selection: booleanType().optional(),
-    allow_discount_code: booleanType().optional(),
-    allow_phone_number_collection: booleanType().optional(),
-    allow_tax_id: booleanType().optional(),
-    always_create_new_customer: booleanType().optional(),
-})
-    .optional();
-// Subscription data schema
+  allow_currency_selection: booleanType().optional(),
+  allow_discount_code: booleanType().optional(),
+  allow_phone_number_collection: booleanType().optional(),
+  allow_tax_id: booleanType().optional(),
+  always_create_new_customer: booleanType().optional()
+}).optional();
 var checkoutSessionSubscriptionDataSchema = objectType({
-    trial_period_days: numberType().int().nonnegative().optional(),
-})
-    .optional();
-// Main checkout session payload schema
+  trial_period_days: numberType().int().nonnegative().optional()
+}).optional();
 var checkoutSessionPayloadSchema = objectType({
-    // Required fields
-    product_cart: arrayType(checkoutSessionProductCartItemSchema)
-        .min(1, "At least one product is required"),
-    // Optional fields
-    customer: checkoutSessionCustomerSchema,
-    billing_address: checkoutSessionBillingAddressSchema,
-    return_url: stringType().url().optional(),
-    allowed_payment_method_types: arrayType(paymentMethodTypeSchema).optional(),
-    billing_currency: stringType()
-        .length(3, "Currency must be a 3-letter ISO code")
-        .optional(),
-    show_saved_payment_methods: booleanType().optional(),
-    confirm: booleanType().optional(),
-    discount_code: stringType().optional(),
-    metadata: recordType(stringType(), stringType()).optional(),
-    customization: checkoutSessionCustomizationSchema,
-    feature_flags: checkoutSessionFeatureFlagsSchema,
-    subscription_data: checkoutSessionSubscriptionDataSchema,
+  // Required fields
+  product_cart: arrayType(checkoutSessionProductCartItemSchema).min(1, "At least one product is required"),
+  // Optional fields
+  customer: checkoutSessionCustomerSchema,
+  billing_address: checkoutSessionBillingAddressSchema,
+  return_url: stringType().url().optional(),
+  allowed_payment_method_types: arrayType(paymentMethodTypeSchema).optional(),
+  billing_currency: stringType().length(3, "Currency must be a 3-letter ISO code").optional(),
+  show_saved_payment_methods: booleanType().optional(),
+  confirm: booleanType().optional(),
+  discount_code: stringType().optional(),
+  metadata: recordType(stringType(), stringType()).optional(),
+  customization: checkoutSessionCustomizationSchema,
+  feature_flags: checkoutSessionFeatureFlagsSchema,
+  subscription_data: checkoutSessionSubscriptionDataSchema
 });
-// Checkout session response schema
 var checkoutSessionResponseSchema = objectType({
-    session_id: stringType().min(1, "Session ID is required"),
-    checkout_url: stringType().url("Invalid checkout URL"),
+  session_id: stringType().min(1, "Session ID is required"),
+  checkout_url: stringType().url("Invalid checkout URL")
 });
-/**
- * Creates a new Dodo Payments Checkout Session using the modern /checkouts endpoint.
- * This function provides a clean, type-safe interface to the Checkout Sessions API.
- *
- * @param payload - The checkout session data, validated against CheckoutSessionPayloadSchema
- * @param config - Dodo Payments client configuration (bearerToken, environment)
- * @returns Promise<CheckoutSessionResponse> - The checkout session with session_id and checkout_url
- *
- * @throws {Error} When payload validation fails or API request fails
- *
- * @example
- * ```typescript
- * const session = await createCheckoutSession({
- *   product_cart: [{ product_id: 'prod_123', quantity: 1 }],
- *   customer: { email: 'customer@example.com' },
- *   return_url: 'https://yoursite.com/success'
- * }, {
- *   bearerToken: process.env.DODO_PAYMENTS_API_KEY,
- *   environment: 'test_mode'
- * });
- *
- * ```
- */
-var createCheckoutSession = function (payload, config) { return __awaiter$1(void 0, void 0, void 0, function () {
-    var validation, dodopayments, sdkPayload, session, responseValidation, error_1;
-    return __generator$1(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                validation = checkoutSessionPayloadSchema.safeParse(payload);
-                if (!validation.success) {
-                    throw new Error("Invalid checkout session payload: ".concat(validation.error.issues
-                        .map(function (issue) { return "".concat(issue.path.join("."), ": ").concat(issue.message); })
-                        .join(", ")));
-                }
-                dodopayments = new DodoPayments({
-                    bearerToken: config.bearerToken,
-                    environment: config.environment,
-                });
-                _a.label = 1;
-            case 1:
-                _a.trys.push([1, 3, , 4]);
-                sdkPayload = __assign(__assign({}, validation.data), (validation.data.billing_address && {
-                    billing_address: __assign(__assign({}, validation.data.billing_address), { country: validation.data.billing_address.country }),
-                }));
-                return [4 /*yield*/, dodopayments.checkoutSessions.create(sdkPayload)];
-            case 2:
-                session = _a.sent();
-                responseValidation = checkoutSessionResponseSchema.safeParse(session);
-                if (!responseValidation.success) {
-                    throw new Error("Invalid checkout session response from API: ".concat(responseValidation.error.issues
-                        .map(function (issue) { return "".concat(issue.path.join("."), ": ").concat(issue.message); })
-                        .join(", ")));
-                }
-                return [2 /*return*/, responseValidation.data];
-            case 3:
-                error_1 = _a.sent();
-                if (error_1 instanceof Error) {
-                    console.error("Dodo Payments Checkout Session API Error:", {
-                        message: error_1.message,
-                        payload: validation.data,
-                        config: {
-                            environment: config.environment,
-                            hasBearerToken: !!config.bearerToken,
-                        },
-                    });
-                    // Re-throw with a more user-friendly message
-                    throw new Error("Failed to create checkout session: ".concat(error_1.message));
-                }
-                // Handle non-Error objects
-                console.error("Unknown error creating checkout session:", error_1);
-                throw new Error("Failed to create checkout session due to an unknown error");
-            case 4: return [2 /*return*/];
-        }
+var createCheckoutSession = async (payload, config) => {
+  const validation = checkoutSessionPayloadSchema.safeParse(payload);
+  if (!validation.success) {
+    throw new Error(
+      `Invalid checkout session payload: ${validation.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ")}`
+    );
+  }
+  const dodopayments = new DodoPayments({
+    bearerToken: config.bearerToken,
+    environment: config.environment
+  });
+  try {
+    const sdkPayload = {
+      ...validation.data,
+      ...validation.data.billing_address && {
+        billing_address: {
+          ...validation.data.billing_address,
+          country: validation.data.billing_address.country
+        }
+      }
+    };
+    const session = await dodopayments.checkoutSessions.create(
+      sdkPayload
+    );
+    const responseValidation = checkoutSessionResponseSchema.safeParse(session);
+    if (!responseValidation.success) {
+      throw new Error(
+        `Invalid checkout session response from API: ${responseValidation.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ")}`
+      );
+    }
+    return responseValidation.data;
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error("Dodo Payments Checkout Session API Error:", {
+        message: error.message,
+        payload: validation.data,
+        config: {
+          environment: config.environment,
+          hasBearerToken: !!config.bearerToken
+        }
+      });
+      throw new Error(`Failed to create checkout session: ${error.message}`);
+    }
+    console.error("Unknown error creating checkout session:", error);
+    throw new Error(
+      "Failed to create checkout session due to an unknown error"
+    );
+  }
+};
+var buildCheckoutUrl = async ({
+  queryParams,
+  body,
+  sessionPayload,
+  returnUrl,
+  bearerToken,
+  environment,
+  type = "static"
+}) => {
+  if (type === "session") {
+    if (!sessionPayload) {
+      throw new Error("sessionPayload is required when type is 'session'");
+    }
+    const session = await createCheckoutSession(sessionPayload, {
+      bearerToken,
+      environment
     });
-}); };
-var buildCheckoutUrl = function (_a) { return __awaiter$1(void 0, [_a], void 0, function (_b) {
-    var session, inputData, parseResult, success, data, error, _c, productId, quantity_1, fullName, firstName, lastName, email, country, addressLine, city, state, zipCode, disableFullName, disableFirstName, disableLastName, disableEmail, disableCountry, disableAddressLine, disableCity, disableState, disableZipCode, paymentCurrency, showCurrencySelector, paymentAmount, showDiscounts, dodopayments_1, err_1, url, _i, _d, _e, key, value, dyn, product_id, product_cart, quantity, billing, customer, addons, metadata, allowed_payment_method_types, billing_currency, discount_code, on_demand, bodyReturnUrl, show_saved_payment_methods, tax_id, trial_period_days, dodopayments, isSubscription, productIdToFetch, product, err_2, subscriptionPayload, subscription, err_3, cart, paymentPayload, payment, err_4;
-    var queryParams = _b.queryParams, body = _b.body, sessionPayload = _b.sessionPayload, returnUrl = _b.returnUrl, bearerToken = _b.bearerToken, environment = _b.environment, _f = _b.type, type = _f === void 0 ? "static" : _f;
-    return __generator$1(this, function (_g) {
-        switch (_g.label) {
-            case 0:
-                if (!(type === "session")) return [3 /*break*/, 2];
-                if (!sessionPayload) {
-                    throw new Error("sessionPayload is required when type is 'session'");
-                }
-                return [4 /*yield*/, createCheckoutSession(sessionPayload, {
-                        bearerToken: bearerToken,
-                        environment: environment,
-                    })];
-            case 1:
-                session = _g.sent();
-                return [2 /*return*/, session.checkout_url];
-            case 2:
-                inputData = type === "dynamic" ? body : queryParams;
-                if (type === "dynamic") {
-                    parseResult = dynamicCheckoutBodySchema.safeParse(inputData);
-                }
-                else {
-                    parseResult = checkoutQuerySchema.safeParse(inputData);
-                }
-                success = parseResult.success, data = parseResult.data, error = parseResult.error;
-                if (!success) {
-                    throw new Error("Invalid ".concat(type === "dynamic" ? "body" : "query parameters", ".\n ").concat(error.message));
-                }
-                if (!(type !== "dynamic")) return [3 /*break*/, 7];
-                _c = data, productId = _c.productId, quantity_1 = _c.quantity, fullName = _c.fullName, firstName = _c.firstName, lastName = _c.lastName, email = _c.email, country = _c.country, addressLine = _c.addressLine, city = _c.city, state = _c.state, zipCode = _c.zipCode, disableFullName = _c.disableFullName, disableFirstName = _c.disableFirstName, disableLastName = _c.disableLastName, disableEmail = _c.disableEmail, disableCountry = _c.disableCountry, disableAddressLine = _c.disableAddressLine, disableCity = _c.disableCity, disableState = _c.disableState, disableZipCode = _c.disableZipCode, paymentCurrency = _c.paymentCurrency, showCurrencySelector = _c.showCurrencySelector, paymentAmount = _c.paymentAmount, showDiscounts = _c.showDiscounts;
-                dodopayments_1 = new DodoPayments({
-                    bearerToken: bearerToken,
-                    environment: environment,
-                });
-                // Check that the product exists for this merchant
-                if (!productId)
-                    throw new Error("Missing required field: productId");
-                _g.label = 3;
-            case 3:
-                _g.trys.push([3, 5, , 6]);
-                return [4 /*yield*/, dodopayments_1.products.retrieve(productId)];
-            case 4:
-                _g.sent();
-                return [3 /*break*/, 6];
-            case 5:
-                err_1 = _g.sent();
-                console.error(err_1);
-                throw new Error("Product not found");
-            case 6:
-                url = new URL("".concat(environment === "test_mode" ? "https://test.checkout.dodopayments.com" : "https://checkout.dodopayments.com", "/buy/").concat(productId));
-                url.searchParams.set("quantity", quantity_1 ? String(quantity_1) : "1");
-                if (returnUrl)
-                    url.searchParams.set("redirect_url", returnUrl);
-                // Customer/billing fields
-                if (fullName)
-                    url.searchParams.set("fullName", String(fullName));
-                if (firstName)
-                    url.searchParams.set("firstName", String(firstName));
-                if (lastName)
-                    url.searchParams.set("lastName", String(lastName));
-                if (email)
-                    url.searchParams.set("email", String(email));
-                if (country)
-                    url.searchParams.set("country", String(country));
-                if (addressLine)
-                    url.searchParams.set("addressLine", String(addressLine));
-                if (city)
-                    url.searchParams.set("city", String(city));
-                if (state)
-                    url.searchParams.set("state", String(state));
-                if (zipCode)
-                    url.searchParams.set("zipCode", String(zipCode));
-                // Disable flags (must be set to 'true' to disable)
-                if (disableFullName === "true")
-                    url.searchParams.set("disableFullName", "true");
-                if (disableFirstName === "true")
-                    url.searchParams.set("disableFirstName", "true");
-                if (disableLastName === "true")
-                    url.searchParams.set("disableLastName", "true");
-                if (disableEmail === "true")
-                    url.searchParams.set("disableEmail", "true");
-                if (disableCountry === "true")
-                    url.searchParams.set("disableCountry", "true");
-                if (disableAddressLine === "true")
-                    url.searchParams.set("disableAddressLine", "true");
-                if (disableCity === "true")
-                    url.searchParams.set("disableCity", "true");
-                if (disableState === "true")
-                    url.searchParams.set("disableState", "true");
-                if (disableZipCode === "true")
-                    url.searchParams.set("disableZipCode", "true");
-                // Advanced controls
-                if (paymentCurrency)
-                    url.searchParams.set("paymentCurrency", String(paymentCurrency));
-                if (showCurrencySelector)
-                    url.searchParams.set("showCurrencySelector", String(showCurrencySelector));
-                if (paymentAmount)
-                    url.searchParams.set("paymentAmount", String(paymentAmount));
-                if (showDiscounts)
-                    url.searchParams.set("showDiscounts", String(showDiscounts));
-                // Metadata: add all query params starting with metadata_
-                for (_i = 0, _d = Object.entries(queryParams || {}); _i < _d.length; _i++) {
-                    _e = _d[_i], key = _e[0], value = _e[1];
-                    if (key.startsWith("metadata_") && value && typeof value !== "object") {
-                        url.searchParams.set(key, String(value));
-                    }
-                }
-                return [2 /*return*/, url.toString()];
-            case 7:
-                dyn = data;
-                product_id = dyn.product_id, product_cart = dyn.product_cart, quantity = dyn.quantity, billing = dyn.billing, customer = dyn.customer, addons = dyn.addons, metadata = dyn.metadata, allowed_payment_method_types = dyn.allowed_payment_method_types, billing_currency = dyn.billing_currency, discount_code = dyn.discount_code, on_demand = dyn.on_demand, bodyReturnUrl = dyn.return_url, show_saved_payment_methods = dyn.show_saved_payment_methods, tax_id = dyn.tax_id, trial_period_days = dyn.trial_period_days;
-                dodopayments = new DodoPayments({
-                    bearerToken: bearerToken,
-                    environment: environment,
-                });
-                isSubscription = false;
-                productIdToFetch = product_id;
-                if (!product_id && product_cart && product_cart.length > 0) {
-                    productIdToFetch = product_cart[0].product_id;
-                }
-                if (!productIdToFetch)
-                    throw new Error("Missing required field: product_id or product_cart[0].product_id");
-                _g.label = 8;
-            case 8:
-                _g.trys.push([8, 10, , 11]);
-                return [4 /*yield*/, dodopayments.products.retrieve(productIdToFetch)];
-            case 9:
-                product = _g.sent();
-                return [3 /*break*/, 11];
-            case 10:
-                err_2 = _g.sent();
-                console.error(err_2);
-                throw new Error("Product not found");
-            case 11:
-                isSubscription = Boolean(product.is_recurring);
-                // Required field validation
-                if (isSubscription && !product_id)
-                    throw new Error("Missing required field: product_id for subscription");
-                if (!billing)
-                    throw new Error("Missing required field: billing");
-                if (!customer)
-                    throw new Error("Missing required field: customer");
-                if (!isSubscription) return [3 /*break*/, 16];
-                subscriptionPayload = {
-                    billing: billing,
-                    customer: customer,
-                    product_id: product_id,
-                    quantity: quantity ? Number(quantity) : 1,
-                };
-                if (metadata)
-                    subscriptionPayload.metadata = metadata;
-                if (discount_code)
-                    subscriptionPayload.discount_code = discount_code;
-                if (addons)
-                    subscriptionPayload.addons = addons;
-                if (allowed_payment_method_types)
-                    subscriptionPayload.allowed_payment_method_types =
-                        allowed_payment_method_types;
-                if (billing_currency)
-                    subscriptionPayload.billing_currency = billing_currency;
-                if (on_demand)
-                    subscriptionPayload.on_demand = on_demand;
-                subscriptionPayload.payment_link = true;
-                // Use bodyReturnUrl if present, otherwise use top-level returnUrl
-                if (bodyReturnUrl) {
-                    subscriptionPayload.return_url = bodyReturnUrl;
-                }
-                else if (returnUrl) {
-                    subscriptionPayload.return_url = returnUrl;
-                }
-                if (show_saved_payment_methods)
-                    subscriptionPayload.show_saved_payment_methods =
-                        show_saved_payment_methods;
-                if (tax_id)
-                    subscriptionPayload.tax_id = tax_id;
-                if (trial_period_days)
-                    subscriptionPayload.trial_period_days = trial_period_days;
-                subscription = void 0;
-                _g.label = 12;
-            case 12:
-                _g.trys.push([12, 14, , 15]);
-                return [4 /*yield*/, dodopayments.subscriptions.create(subscriptionPayload)];
-            case 13:
-                subscription =
-                    _g.sent();
-                return [3 /*break*/, 15];
-            case 14:
-                err_3 = _g.sent();
-                console.error("Error when creating subscription", err_3);
-                throw new Error(err_3 instanceof Error ? err_3.message : String(err_3));
-            case 15:
-                if (!subscription || !subscription.payment_link) {
-                    throw new Error("No payment link returned from Dodo Payments API (subscription). Make sure to set payment_link as true in payload");
-                }
-                return [2 /*return*/, subscription.payment_link];
-            case 16:
-                cart = product_cart;
-                if (!cart && product_id) {
-                    cart = [
-                        { product_id: product_id, quantity: quantity ? Number(quantity) : 1 },
-                    ];
-                }
-                if (!cart || cart.length === 0)
-                    throw new Error("Missing required field: product_cart or product_id");
-                paymentPayload = {
-                    billing: billing,
-                    customer: customer,
-                    product_cart: cart,
-                };
-                if (metadata)
-                    paymentPayload.metadata = metadata;
-                paymentPayload.payment_link = true;
-                if (allowed_payment_method_types)
-                    paymentPayload.allowed_payment_method_types =
-                        allowed_payment_method_types;
-                if (billing_currency)
-                    paymentPayload.billing_currency = billing_currency;
-                if (discount_code)
-                    paymentPayload.discount_code = discount_code;
-                // Use bodyReturnUrl if present, otherwise use top-level returnUrl
-                if (bodyReturnUrl) {
-                    paymentPayload.return_url = bodyReturnUrl;
-                }
-                else if (returnUrl) {
-                    paymentPayload.return_url = returnUrl;
-                }
-                if (show_saved_payment_methods)
-                    paymentPayload.show_saved_payment_methods = show_saved_payment_methods;
-                if (tax_id)
-                    paymentPayload.tax_id = tax_id;
-                payment = void 0;
-                _g.label = 17;
-            case 17:
-                _g.trys.push([17, 19, , 20]);
-                return [4 /*yield*/, dodopayments.payments.create(paymentPayload)];
-            case 18:
-                payment = _g.sent();
-                return [3 /*break*/, 20];
-            case 19:
-                err_4 = _g.sent();
-                console.error("Error when creating payment link", err_4);
-                throw new Error(err_4 instanceof Error ? err_4.message : String(err_4));
-            case 20:
-                if (!payment || !payment.payment_link) {
-                    throw new Error("No payment link returned from Dodo Payments API. Make sure to set payment_link as true in payload.");
-                }
-                return [2 /*return*/, payment.payment_link];
-        }
+    return session.checkout_url;
+  }
+  const inputData = type === "dynamic" ? body : queryParams;
+  let parseResult;
+  if (type === "dynamic") {
+    parseResult = dynamicCheckoutBodySchema.safeParse(inputData);
+  } else {
+    parseResult = checkoutQuerySchema.safeParse(inputData);
+  }
+  const { success, data, error } = parseResult;
+  if (!success) {
+    throw new Error(
+      `Invalid ${type === "dynamic" ? "body" : "query parameters"}.
+ ${error.message}`
+    );
+  }
+  if (type !== "dynamic") {
+    const {
+      productId,
+      quantity: quantity2,
+      fullName,
+      firstName,
+      lastName,
+      email,
+      country,
+      addressLine,
+      city,
+      state,
+      zipCode,
+      disableFullName,
+      disableFirstName,
+      disableLastName,
+      disableEmail,
+      disableCountry,
+      disableAddressLine,
+      disableCity,
+      disableState,
+      disableZipCode,
+      paymentCurrency,
+      showCurrencySelector,
+      paymentAmount,
+      showDiscounts
+      // metadata handled below
+    } = data;
+    const dodopayments2 = new DodoPayments({
+      bearerToken,
+      environment
     });
-}); };
+    if (!productId) throw new Error("Missing required field: productId");
+    try {
+      await dodopayments2.products.retrieve(productId);
+    } catch (err) {
+      console.error(err);
+      throw new Error("Product not found");
+    }
+    const url = new URL(
+      `${environment === "test_mode" ? "https://test.checkout.dodopayments.com" : "https://checkout.dodopayments.com"}/buy/${productId}`
+    );
+    url.searchParams.set("quantity", quantity2 ? String(quantity2) : "1");
+    if (returnUrl) url.searchParams.set("redirect_url", returnUrl);
+    if (fullName) url.searchParams.set("fullName", String(fullName));
+    if (firstName) url.searchParams.set("firstName", String(firstName));
+    if (lastName) url.searchParams.set("lastName", String(lastName));
+    if (email) url.searchParams.set("email", String(email));
+    if (country) url.searchParams.set("country", String(country));
+    if (addressLine) url.searchParams.set("addressLine", String(addressLine));
+    if (city) url.searchParams.set("city", String(city));
+    if (state) url.searchParams.set("state", String(state));
+    if (zipCode) url.searchParams.set("zipCode", String(zipCode));
+    if (disableFullName === "true")
+      url.searchParams.set("disableFullName", "true");
+    if (disableFirstName === "true")
+      url.searchParams.set("disableFirstName", "true");
+    if (disableLastName === "true")
+      url.searchParams.set("disableLastName", "true");
+    if (disableEmail === "true") url.searchParams.set("disableEmail", "true");
+    if (disableCountry === "true")
+      url.searchParams.set("disableCountry", "true");
+    if (disableAddressLine === "true")
+      url.searchParams.set("disableAddressLine", "true");
+    if (disableCity === "true") url.searchParams.set("disableCity", "true");
+    if (disableState === "true") url.searchParams.set("disableState", "true");
+    if (disableZipCode === "true")
+      url.searchParams.set("disableZipCode", "true");
+    if (paymentCurrency)
+      url.searchParams.set("paymentCurrency", String(paymentCurrency));
+    if (showCurrencySelector)
+      url.searchParams.set(
+        "showCurrencySelector",
+        String(showCurrencySelector)
+      );
+    if (paymentAmount)
+      url.searchParams.set("paymentAmount", String(paymentAmount));
+    if (showDiscounts)
+      url.searchParams.set("showDiscounts", String(showDiscounts));
+    for (const [key, value] of Object.entries(queryParams || {})) {
+      if (key.startsWith("metadata_") && value && typeof value !== "object") {
+        url.searchParams.set(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+  const dyn = data;
+  const {
+    product_id,
+    product_cart,
+    quantity,
+    billing,
+    customer,
+    addons,
+    metadata,
+    allowed_payment_method_types,
+    billing_currency,
+    discount_code,
+    on_demand,
+    return_url: bodyReturnUrl,
+    show_saved_payment_methods,
+    tax_id,
+    trial_period_days
+  } = dyn;
+  const dodopayments = new DodoPayments({
+    bearerToken,
+    environment
+  });
+  let isSubscription = false;
+  let productIdToFetch = product_id;
+  if (!product_id && product_cart && product_cart.length > 0) {
+    productIdToFetch = product_cart[0].product_id;
+  }
+  if (!productIdToFetch)
+    throw new Error(
+      "Missing required field: product_id or product_cart[0].product_id"
+    );
+  let product;
+  try {
+    product = await dodopayments.products.retrieve(productIdToFetch);
+  } catch (err) {
+    console.error(err);
+    throw new Error("Product not found");
+  }
+  isSubscription = Boolean(product.is_recurring);
+  if (isSubscription && !product_id)
+    throw new Error("Missing required field: product_id for subscription");
+  if (!billing) throw new Error("Missing required field: billing");
+  if (!customer) throw new Error("Missing required field: customer");
+  if (isSubscription) {
+    const subscriptionPayload = {
+      billing,
+      customer,
+      product_id,
+      quantity: quantity ? Number(quantity) : 1
+    };
+    if (metadata) subscriptionPayload.metadata = metadata;
+    if (discount_code) subscriptionPayload.discount_code = discount_code;
+    if (addons) subscriptionPayload.addons = addons;
+    if (allowed_payment_method_types)
+      subscriptionPayload.allowed_payment_method_types = allowed_payment_method_types;
+    if (billing_currency)
+      subscriptionPayload.billing_currency = billing_currency;
+    if (on_demand) subscriptionPayload.on_demand = on_demand;
+    subscriptionPayload.payment_link = true;
+    if (bodyReturnUrl) {
+      subscriptionPayload.return_url = bodyReturnUrl;
+    } else if (returnUrl) {
+      subscriptionPayload.return_url = returnUrl;
+    }
+    if (show_saved_payment_methods)
+      subscriptionPayload.show_saved_payment_methods = show_saved_payment_methods;
+    if (tax_id) subscriptionPayload.tax_id = tax_id;
+    if (trial_period_days)
+      subscriptionPayload.trial_period_days = trial_period_days;
+    let subscription;
+    try {
+      subscription = await dodopayments.subscriptions.create(subscriptionPayload);
+    } catch (err) {
+      console.error("Error when creating subscription", err);
+      throw new Error(err instanceof Error ? err.message : String(err));
+    }
+    if (!subscription || !subscription.payment_link) {
+      throw new Error(
+        "No payment link returned from Dodo Payments API (subscription). Make sure to set payment_link as true in payload"
+      );
+    }
+    return subscription.payment_link;
+  } else {
+    let cart = product_cart;
+    if (!cart && product_id) {
+      cart = [
+        { product_id, quantity: quantity ? Number(quantity) : 1 }
+      ];
+    }
+    if (!cart || cart.length === 0)
+      throw new Error("Missing required field: product_cart or product_id");
+    const paymentPayload = {
+      billing,
+      customer,
+      product_cart: cart
+    };
+    if (metadata) paymentPayload.metadata = metadata;
+    paymentPayload.payment_link = true;
+    if (allowed_payment_method_types)
+      paymentPayload.allowed_payment_method_types = allowed_payment_method_types;
+    if (billing_currency) paymentPayload.billing_currency = billing_currency;
+    if (discount_code) paymentPayload.discount_code = discount_code;
+    if (bodyReturnUrl) {
+      paymentPayload.return_url = bodyReturnUrl;
+    } else if (returnUrl) {
+      paymentPayload.return_url = returnUrl;
+    }
+    if (show_saved_payment_methods)
+      paymentPayload.show_saved_payment_methods = show_saved_payment_methods;
+    if (tax_id) paymentPayload.tax_id = tax_id;
+    let payment;
+    try {
+      payment = await dodopayments.payments.create(paymentPayload);
+    } catch (err) {
+      console.error("Error when creating payment link", err);
+      throw new Error(err instanceof Error ? err.message : String(err));
+    }
+    if (!payment || !payment.payment_link) {
+      throw new Error(
+        "No payment link returned from Dodo Payments API. Make sure to set payment_link as true in payload."
+      );
+    }
+    return payment.payment_link;
+  }
+};
 
 /**
  * Remix Checkout handler
@@ -7634,542 +7534,422 @@ class Webhook {
 Webhook_1 = dist.Webhook = Webhook;
 Webhook.prefix = "whsec_";
 
+// 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 __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 };
-    }
-};
-// 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;
-                        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*/];
-            }
-        });
-    });
+async function handleWebhookPayload(payload, config, context) {
+  const callHandler = (handler, payload2) => {
+    if (!handler) 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);
+  }
 }
 
 const Webhooks = ({ webhookKey, ...eventHandlers }) => {