@freemius/sdk 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1430 @@
+import * as crypto$1 from "crypto";
+import crypto, { createHash, createHmac, timingSafeEqual } from "crypto";
+import createClient from "openapi-fetch";
+import { buildFreemiusQueryFromOptions, convertCheckoutOptionsToQueryParams } from "@freemius/checkout";
+
+//#region src/contracts/types.ts
+/**
+* This file holds all generic types used across the SDK, not specific to any contract.
+*/
+let BILLING_CYCLE = /* @__PURE__ */ function(BILLING_CYCLE$1) {
+	BILLING_CYCLE$1["MONTHLY"] = "monthly";
+	BILLING_CYCLE$1["YEARLY"] = "yearly";
+	BILLING_CYCLE$1["ONEOFF"] = "oneoff";
+	return BILLING_CYCLE$1;
+}({});
+let CURRENCY = /* @__PURE__ */ function(CURRENCY$1) {
+	CURRENCY$1["USD"] = "USD";
+	CURRENCY$1["EUR"] = "EUR";
+	CURRENCY$1["GBP"] = "GBP";
+	return CURRENCY$1;
+}({});
+
+//#endregion
+//#region src/api/parser.ts
+function idToNumber(id) {
+	if (typeof id === "number") return id;
+	else if (typeof id === "bigint") return Number(id);
+	else if (typeof id === "string") {
+		const parsed = Number.parseInt(id, 10);
+		if (Number.isNaN(parsed)) throw new Error(`Invalid FSId: ${id}`);
+		return parsed;
+	} else throw new Error(`Unsupported FSId type: ${typeof id}`);
+}
+function idToString(id) {
+	if (typeof id === "string") return id;
+	else if (typeof id === "number" || typeof id === "bigint") return String(id);
+	else throw new Error(`Unsupported FSId type: ${typeof id}`);
+}
+function isIdsEqual(id1, id2) {
+	return idToString(id1) === idToString(id2);
+}
+function parseBillingCycle(cycle) {
+	const billingCycle = Number.parseInt(cycle?.toString() ?? "", 10);
+	if (billingCycle === 1) return BILLING_CYCLE.MONTHLY;
+	if (billingCycle === 12) return BILLING_CYCLE.YEARLY;
+	return BILLING_CYCLE.ONEOFF;
+}
+function parseNumber(value) {
+	if (typeof value === "number") return value;
+	else if (typeof value === "string") {
+		const parsed = Number.parseFloat(value);
+		return Number.isNaN(parsed) ? null : parsed;
+	} else return null;
+}
+function parseDateTime(dateString) {
+	if (!dateString) return null;
+	const dateParts = dateString.split(" ");
+	if (dateParts.length !== 2) return null;
+	const date = dateParts[0].split("-");
+	const time = dateParts[1].split(":");
+	if (date.length !== 3 || time.length !== 3) return null;
+	const year = Number.parseInt(date[0]);
+	const month = Number.parseInt(date[1]) - 1;
+	const day = Number.parseInt(date[2]);
+	const hours = Number.parseInt(time[0]);
+	const minutes = Number.parseInt(time[1]);
+	const seconds = Number.parseInt(time[2]);
+	if (Number.isNaN(year) || Number.isNaN(month) || Number.isNaN(day) || Number.isNaN(hours) || Number.isNaN(minutes) || Number.isNaN(seconds)) return null;
+	const utcDate = new Date(Date.UTC(year, month, day, hours, minutes, seconds, 0));
+	return utcDate;
+}
+function parseDate(dateString) {
+	if (!dateString) return null;
+	return parseDateTime(dateString + " 00:00:00");
+}
+function parseCurrency(currency) {
+	switch (currency?.toLowerCase?.()) {
+		case "usd": return CURRENCY.USD;
+		case "eur": return CURRENCY.EUR;
+		case "gbp": return CURRENCY.GBP;
+		default: return null;
+	}
+}
+function parsePaymentMethod(gateway) {
+	return gateway?.startsWith("stripe") ? "card" : gateway?.startsWith("paypal") ? "paypal" : null;
+}
+
+//#endregion
+//#region src/api/client.ts
+function createApiClient(baseUrl, bearerToken) {
+	return createClient({
+		baseUrl,
+		headers: { Authorization: bearerToken ? `Bearer ${bearerToken}` : void 0 }
+	});
+}
+
+//#endregion
+//#region src/api/ApiBase.ts
+const PAGING_DEFAULT_LIMIT = 150;
+const defaultPagingOptions = {
+	count: PAGING_DEFAULT_LIMIT,
+	offset: 0
+};
+var ApiBase = class {
+	productId;
+	constructor(productId, client) {
+		this.client = client;
+		this.productId = idToNumber(productId);
+	}
+	/**
+	* Async generator that yields all entities by paginating through retrieveMany.
+	* @param filter Optional filter for entities
+	* @param pageSize Optional page size (default: PAGING_DEFAULT_LIMIT)
+	*
+	* @example
+	* // Usage example:
+	* for await (const entity of apiInstance.iterateAll({ status: 'active' })) {
+	*   console.log(entity);
+	* }
+	*/
+	async *iterateAll(filter, pageSize = PAGING_DEFAULT_LIMIT) {
+		let offset = 0;
+		while (true) {
+			const page = await this.retrieveMany(filter, {
+				count: pageSize,
+				offset
+			});
+			if (!page.length) break;
+			for (const entity of page) yield entity;
+			if (page.length < pageSize) break;
+			offset += page.length;
+		}
+	}
+	getPagingParams(paging = defaultPagingOptions) {
+		return {
+			count: paging.count ?? PAGING_DEFAULT_LIMIT,
+			offset: paging.offset ?? 0
+		};
+	}
+	getIdForPath(id) {
+		return idToNumber(id);
+	}
+	isGoodResponse(response) {
+		return response.status >= 200 && response.status < 300;
+	}
+};
+
+//#endregion
+//#region src/api/License.ts
+var License = class extends ApiBase {
+	async retrieve(licenseId) {
+		const licenseResponse = await this.client.GET(`/products/{product_id}/licenses/{license_id}.json`, { params: { path: {
+			product_id: this.productId,
+			license_id: this.getIdForPath(licenseId)
+		} } });
+		if (!this.isGoodResponse(licenseResponse.response) || !licenseResponse.data || !licenseResponse.data.id) return null;
+		return licenseResponse.data;
+	}
+	async retrieveMany(filter, pagination) {
+		const response = await this.client.GET(`/products/{product_id}/licenses.json`, { params: {
+			path: { product_id: this.productId },
+			query: {
+				...this.getPagingParams(pagination),
+				...filter ?? {}
+			}
+		} });
+		if (!this.isGoodResponse(response.response) || !response.data || !Array.isArray(response.data.licenses)) return [];
+		return response.data.licenses;
+	}
+	async retrieveSubscription(licenseId) {
+		const subscriptionResponse = await this.client.GET(`/products/{product_id}/licenses/{license_id}/subscription.json`, { params: { path: {
+			product_id: this.productId,
+			license_id: this.getIdForPath(licenseId)
+		} } });
+		if (!this.isGoodResponse(subscriptionResponse.response) || !subscriptionResponse.data || !subscriptionResponse.data.id) return null;
+		return subscriptionResponse.data;
+	}
+	async retrieveCheckoutUpgradeAuthorization(licenseId) {
+		const response = await this.client.POST(`/products/{product_id}/licenses/{license_id}/checkout/link.json`, {
+			params: { path: {
+				product_id: this.productId,
+				license_id: this.getIdForPath(licenseId)
+			} },
+			body: { is_payment_method_update: true }
+		});
+		if (!this.isGoodResponse(response.response) || !response.data || !response.data.settings) return null;
+		return response.data.settings.authorization;
+	}
+};
+
+//#endregion
+//#region src/api/Product.ts
+var Product = class extends ApiBase {
+	async retrieve() {
+		const response = await this.client.GET(`/products/{product_id}.json`, { params: { path: { product_id: this.productId } } });
+		if (response.response.status !== 200 || !response.data) return null;
+		return response.data;
+	}
+	async retrieveMany() {
+		throw new Error("retrieveMany is not supported for Product API");
+	}
+	async retrievePricingData() {
+		const response = await this.client.GET(`/products/{product_id}/pricing.json`, { params: { path: { product_id: this.productId } } });
+		if (response.response.status !== 200 || !response.data) return null;
+		return response.data;
+	}
+};
+
+//#endregion
+//#region src/api/Subscription.ts
+var Subscription = class extends ApiBase {
+	async retrieve(subscriptionId) {
+		const response = await this.client.GET(`/products/{product_id}/subscriptions/{subscription_id}.json`, { params: { path: {
+			product_id: this.productId,
+			subscription_id: this.getIdForPath(subscriptionId)
+		} } });
+		if (response.response.status !== 200 || !response.data || !response.data.id) return null;
+		return response.data;
+	}
+	async retrieveMany(filter, pagination) {
+		const response = await this.client.GET(`/products/{product_id}/subscriptions.json`, { params: {
+			path: { product_id: this.productId },
+			query: {
+				...this.getPagingParams(pagination),
+				...filter ?? {}
+			}
+		} });
+		if (response.response.status !== 200 || !response.data || !Array.isArray(response.data.subscriptions)) return [];
+		return response.data.subscriptions;
+	}
+};
+
+//#endregion
+//#region src/api/User.ts
+const USER_FIELDS = "email,first,last,picture,is_verified,id,created,updated,is_marketing_allowed";
+var User = class extends ApiBase {
+	async retrieve(userId) {
+		const userResponse = await this.client.GET(`/products/{product_id}/users/{user_id}.json`, { params: {
+			path: {
+				product_id: this.productId,
+				user_id: this.getIdForPath(userId)
+			},
+			query: { fields: USER_FIELDS }
+		} });
+		if (userResponse.response.status !== 200 || !userResponse.data || !userResponse.data.id) return null;
+		return userResponse.data;
+	}
+	async retrieveMany(filter, pagination) {
+		const response = await this.client.GET(`/products/{product_id}/users.json`, { params: {
+			path: { product_id: this.productId },
+			query: {
+				...this.getPagingParams(pagination),
+				...filter ?? {},
+				fields: USER_FIELDS
+			}
+		} });
+		if (response.response.status !== 200 || !response.data || !Array.isArray(response.data.users)) return [];
+		return response.data.users;
+	}
+	async retrieveByEmail(email) {
+		const response = await this.client.GET(`/products/{product_id}/users.json`, { params: {
+			path: { product_id: this.productId },
+			query: { email }
+		} });
+		if (!this.isGoodResponse(response.response) || !Array.isArray(response.data?.users)) return null;
+		return response.data.users?.[0] ?? null;
+	}
+	async retrieveBilling(userId) {
+		const billingResponse = await this.client.GET(`/products/{product_id}/users/{user_id}/billing.json`, { params: { path: {
+			product_id: this.productId,
+			user_id: this.getIdForPath(userId)
+		} } });
+		if (billingResponse.response.status !== 200 || !billingResponse.data || !billingResponse.data) return null;
+		return billingResponse.data;
+	}
+	async retrieveSubscriptions(userId, filters, pagination) {
+		const response = await this.client.GET(`/products/{product_id}/users/{user_id}/subscriptions.json`, { params: {
+			path: {
+				product_id: this.productId,
+				user_id: this.getIdForPath(userId)
+			},
+			query: {
+				...filters ?? {},
+				...this.getPagingParams(pagination)
+			}
+		} });
+		if (response.response.status !== 200 || !response.data || !Array.isArray(response.data.subscriptions)) return [];
+		return response.data.subscriptions;
+	}
+	async retrieveLicenses(userId, filters, pagination) {
+		const response = await this.client.GET(`/products/{product_id}/users/{user_id}/licenses.json`, { params: {
+			path: {
+				product_id: this.productId,
+				user_id: this.getIdForPath(userId)
+			},
+			query: {
+				...filters ?? {},
+				...this.getPagingParams(pagination)
+			}
+		} });
+		if (response.response.status !== 200 || !response.data || !Array.isArray(response.data.licenses)) return [];
+		return response.data.licenses;
+	}
+	async retrievePayments(userId, filters, pagination) {
+		const response = await this.client.GET(`/products/{product_id}/users/{user_id}/payments.json`, { params: {
+			path: {
+				product_id: this.productId,
+				user_id: this.getIdForPath(userId)
+			},
+			query: {
+				...filters ?? {},
+				...this.getPagingParams(pagination)
+			}
+		} });
+		if (response.response.status !== 200 || !response.data || !Array.isArray(response.data.payments)) return [];
+		return response.data.payments;
+	}
+};
+
+//#endregion
+//#region src/services/ApiService.ts
+const API_ENDPOINT_PRODUCTION = "https://api.freemius.com/v1/";
+const API_ENDPOINT_TEST = "http://api.freemius-local.com:8080/v1/";
+var ApiService = class {
+	client;
+	productId;
+	user;
+	license;
+	product;
+	subscription;
+	baseUrl;
+	constructor(productId, apiKey, secretKey, publicKey) {
+		this.secretKey = secretKey;
+		this.publicKey = publicKey;
+		const isTestServer = process.env.FS__INTERNAL__IS_DEVELOPMENT_MODE === "true";
+		this.baseUrl = isTestServer ? API_ENDPOINT_TEST : API_ENDPOINT_PRODUCTION;
+		this.client = createApiClient(this.baseUrl, apiKey);
+		this.productId = idToString(productId);
+		this.user = new User(this.productId, this.client);
+		this.license = new License(this.productId, this.client);
+		this.product = new Product(this.productId, this.client);
+		this.subscription = new Subscription(this.productId, this.client);
+	}
+	/**
+	* Low level API client for direct access to the Freemius API.
+	* Use this for advanced use cases where you need to make custom API calls.
+	*
+	* For regular operations, prefer using the provided services like `User`, `Subscription`, `License` etc.
+	*/
+	get __unstable_ApiClient() {
+		return this.client;
+	}
+	createUrl(path) {
+		path = path.replace(/^\/+/, "");
+		return `${this.baseUrl}products/${this.productId}/${path}`;
+	}
+	/**
+	* Generate signed URL for the given full URL
+	*/
+	getSignedUrl(fullUrl) {
+		const url = new URL(fullUrl);
+		const resourcePath = url.pathname;
+		const auth = this.generateAuthorizationParams(resourcePath);
+		url.searchParams.set("auth_date", auth.date);
+		url.searchParams.set("authorization", auth.authorization);
+		return url.toString();
+	}
+	/**
+	* Generate authorization parameters for signing
+	*/
+	generateAuthorizationParams(resourcePath, method = "GET", jsonEncodedParams = "", contentType = "") {
+		const eol = "\n";
+		let contentMd5 = "";
+		const date = this.toDateTimeString(/* @__PURE__ */ new Date());
+		if (["POST", "PUT"].includes(method) && jsonEncodedParams) contentMd5 = crypto$1.createHash("md5").update(jsonEncodedParams).digest("hex");
+		const stringToSign = [
+			method,
+			contentMd5,
+			contentType,
+			date,
+			resourcePath
+		].join(eol);
+		const authType = this.secretKey !== this.publicKey ? "FS" : "FSP";
+		const signature = crypto$1.createHmac("sha256", this.secretKey).update(stringToSign).digest("hex");
+		const base64 = this.base64UrlEncode(signature);
+		return {
+			date,
+			authorization: `${authType} ${this.productId}:${this.publicKey}:${base64}`
+		};
+	}
+	/**
+	* Base64 encoding that doesn't need to be urlencode()ed.
+	* Exactly the same as base64_encode except it uses
+	*   - instead of +
+	*   _ instead of /
+	*/
+	base64UrlEncode(input) {
+		return Buffer.from(input, "utf8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+	}
+	toDateTimeString(date) {
+		const year = date.getUTCFullYear();
+		const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+		const day = String(date.getUTCDate()).padStart(2, "0");
+		const hours = String(date.getUTCHours()).padStart(2, "0");
+		const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+		const seconds = String(date.getUTCSeconds()).padStart(2, "0");
+		return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+	}
+};
+
+//#endregion
+//#region src/utils/ops.ts
+function splitName(name) {
+	const parts = name.split(" ");
+	return {
+		firstName: parts[0] ?? "",
+		lastName: parts.slice(1).join(" ") ?? ""
+	};
+}
+
+//#endregion
+//#region src/models/CheckoutBuilder.ts
+/**
+* A builder class for constructing checkout parameters. This class provides a fluent
+* API to create Checkout parameters for a product with various configurations.
+*
+*
+*
+* Every method returns a new instance of the builder with the updated options,
+* allowing for method chaining. The final `toOptions()` method returns the constructed
+* `CheckoutOptions` object. So the class itself is immutable and does not modify the original instance.
+*/
+var CheckoutBuilder = class CheckoutBuilder {
+	constructor(options, productId, publicKey, secretKey) {
+		this.options = options;
+		this.productId = productId;
+		this.publicKey = publicKey;
+		this.secretKey = secretKey;
+	}
+	/**
+	* Enables sandbox mode for testing purposes.
+	*
+	* @returns A new builder instance with sandbox configuration
+	*/
+	inSandbox() {
+		const timestamp = Math.floor(Date.now() / 1e3).toString();
+		const token = `${timestamp}${this.productId}${this.secretKey}${this.publicKey}checkout`;
+		return new CheckoutBuilder({
+			...this.options,
+			sandbox: {
+				ctx: timestamp,
+				token: createHash("md5").update(token).digest("hex")
+			}
+		}, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Sets user information for the checkout session.
+	*
+	* @param user User object with email and optional name fields. The shape matches the session from `better-auth` or next-auth packages. Also handles `null` or `undefined` gracefully.
+	* @param readonly If true, the user information will be read-only in the checkout session.
+	*
+	* @returns A new builder instance with user configuration
+	*/
+	withUser(user, readonly = true) {
+		if (!user) return this;
+		let firstName = user.firstName ?? "";
+		let lastName = user.lastName ?? "";
+		if (user.name) {
+			const { firstName: fn, lastName: ln } = splitName(user.name);
+			firstName = fn;
+			lastName = ln;
+		}
+		return new CheckoutBuilder({
+			...this.options,
+			user_email: user.email,
+			user_first_name: firstName,
+			user_last_name: lastName,
+			readonly_user: readonly
+		}, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Applies recommended UI settings for better user experience.
+	* This includes fullscreen mode, upsells, refund badge, and reviews display.
+	*
+	* @returns A new builder instance with recommended UI settings
+	*/
+	withRecommendation() {
+		return new CheckoutBuilder({
+			...this.options,
+			fullscreen: true,
+			show_refund_badge: true,
+			show_reviews: true,
+			locale: "auto",
+			currency: "auto"
+		}, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Sets the plan ID for the checkout.
+	*
+	* @param planId The plan ID to purchase
+	* @returns A new builder instance with plan ID set
+	*/
+	withPlan(planId) {
+		return new CheckoutBuilder({
+			...this.options,
+			plan_id: planId.toString()
+		}, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Sets the number of licenses to purchase.
+	*
+	* @param count Number of licenses
+	* @returns A new builder instance with license count set
+	*/
+	withQuota(count) {
+		return new CheckoutBuilder({
+			...this.options,
+			licenses: count
+		}, this.productId, this.publicKey, this.secretKey);
+	}
+	withPricing(pricingId) {
+		return new CheckoutBuilder({
+			...this.options,
+			pricing_id: pricingId.toString()
+		}, this.productId, this.publicKey, this.secretKey);
+	}
+	withTitle(title) {
+		return new CheckoutBuilder({
+			...this.options,
+			title
+		}, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Sets a coupon code for the checkout.
+	*
+	* @param coupon The coupon code to apply
+	* @param hideUI Whether to hide the coupon input field from users
+	* @returns A new builder instance with coupon configuration
+	*/
+	withCoupon(options) {
+		const { code: coupon, hideUI = false } = options;
+		const newOptions = {
+			...this.options,
+			hide_coupon: hideUI
+		};
+		if (coupon !== void 0) newOptions.coupon = coupon;
+		return new CheckoutBuilder(newOptions, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Enables trial mode for the checkout.
+	*
+	* @param mode Trial type - true/false for plan default, or specific 'free'/'paid' mode
+	* @returns A new builder instance with trial configuration
+	*/
+	inTrial(mode = true) {
+		return new CheckoutBuilder({
+			...this.options,
+			trial: mode
+		}, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Configures the visual layout and appearance of the checkout.
+	*
+	* @param options Appearance configuration options
+	* @returns A new builder instance with appearance configuration
+	*/
+	withAppearance(options) {
+		const newOptions = { ...this.options };
+		if (options.layout !== void 0) newOptions.layout = options.layout;
+		if (options.formPosition !== void 0) newOptions.form_position = options.formPosition;
+		if (options.fullscreen !== void 0) newOptions.fullscreen = options.fullscreen;
+		if (options.modalTitle !== void 0) newOptions.modal_title = options.modalTitle;
+		if (options.id !== void 0) newOptions.id = options.id;
+		return new CheckoutBuilder(newOptions, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Configures discount display settings.
+	*
+	* @param options Discount configuration options
+	* @returns A new builder instance with discount configuration
+	*/
+	withDiscounts(options) {
+		const newOptions = { ...this.options };
+		if (options.annual !== void 0) newOptions.annual_discount = options.annual;
+		if (options.multisite !== void 0) newOptions.multisite_discount = options.multisite;
+		if (options.bundle !== void 0) newOptions.bundle_discount = options.bundle;
+		if (options.showMonthlySwitch !== void 0) newOptions.show_monthly_switch = options.showMonthlySwitch;
+		return new CheckoutBuilder(newOptions, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Configures billing cycle selector interface.
+	*
+	* @param selector Type of billing cycle selector to show
+	* @param defaultCycle Default billing cycle to select
+	* @returns A new builder instance with billing cycle configuration
+	*/
+	withBillingCycle(defaultCycle, selector) {
+		const newOptions = { ...this.options };
+		if (selector !== void 0) newOptions.billing_cycle_selector = selector;
+		if (defaultCycle !== void 0) newOptions.billing_cycle = defaultCycle;
+		return new CheckoutBuilder(newOptions, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Sets the language/locale for the checkout.
+	*
+	* @param locale Language setting - 'auto', 'auto-beta', or specific locale like 'en_US'
+	* @returns A new builder instance with locale configuration
+	*/
+	withLanguage(locale = "auto") {
+		return new CheckoutBuilder({
+			...this.options,
+			language: locale,
+			locale
+		}, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Configures review and badge display settings.
+	*
+	* @param options Review and badge configuration
+	* @returns A new builder instance with reviews and badges configuration
+	*/
+	withReviewsAndBadges(options) {
+		const newOptions = { ...this.options };
+		if (options.showReviews !== void 0) newOptions.show_reviews = options.showReviews;
+		if (options.reviewId !== void 0) newOptions.review_id = options.reviewId;
+		if (options.showRefundBadge !== void 0) newOptions.show_refund_badge = options.showRefundBadge;
+		if (options.refundPolicyPosition !== void 0) newOptions.refund_policy_position = options.refundPolicyPosition;
+		return new CheckoutBuilder(newOptions, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Enhanced currency configuration.
+	*
+	* @param currency Primary currency or 'auto' for automatic detection
+	* @param defaultCurrency Default currency when using 'auto'
+	* @param showInlineSelector Whether to show inline currency selector
+	* @returns A new builder instance with currency configuration
+	*/
+	withCurrency(currency, defaultCurrency = "usd", showInlineSelector = true) {
+		const options = {
+			...this.options,
+			show_inline_currency_selector: showInlineSelector,
+			default_currency: defaultCurrency
+		};
+		if (currency !== "auto") options.currency = currency;
+		return new CheckoutBuilder(options, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Configures navigation and cancel behavior.
+	*
+	* @param cancelUrl URL for back button when in page mode
+	* @param cancelIcon Custom cancel icon URL
+	* @returns A new builder instance with navigation configuration
+	*/
+	withNavigation(cancelUrl, cancelIcon) {
+		const newOptions = { ...this.options };
+		if (cancelUrl !== void 0) newOptions.cancel_url = cancelUrl;
+		if (cancelIcon !== void 0) newOptions.cancel_icon = cancelIcon;
+		return new CheckoutBuilder(newOptions, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Associates purchases with an affiliate account.
+	*
+	* @param userId Affiliate user ID
+	* @returns A new builder instance with affiliate configuration
+	*/
+	withAffiliate(userId) {
+		return new CheckoutBuilder({
+			...this.options,
+			affiliate_user_id: userId
+		}, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Sets a custom image/icon for the checkout.
+	*
+	* @param imageUrl Secure HTTPS URL to the image
+	* @returns A new builder instance with custom image
+	*/
+	withImage(imageUrl) {
+		return new CheckoutBuilder({
+			...this.options,
+			image: imageUrl
+		}, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Configures the checkout for license renewal.
+	*
+	* @param licenseKey The license key to renew
+	* @returns A new builder instance configured for renewal
+	*/
+	forRenewal(licenseKey) {
+		return new CheckoutBuilder({
+			...this.options,
+			license_key: licenseKey
+		}, this.productId, this.publicKey, this.secretKey);
+	}
+	/**
+	* Builds and returns the final checkout options to be used with the `@freemius/checkout` package.
+	*
+	* @returns The constructed CheckoutOptions object
+	*/
+	toOptions(additionalOptions) {
+		return {
+			...this.options,
+			...additionalOptions,
+			product_id: this.productId
+		};
+	}
+	toLink() {
+		const checkoutOptions = convertCheckoutOptionsToQueryParams(this.options);
+		const queryParams = buildFreemiusQueryFromOptions(checkoutOptions);
+		const url = new URL(`https://checkout.freemius.com/product/${this.productId}/`);
+		url.search = queryParams;
+		return url.href;
+	}
+};
+
+//#endregion
+//#region src/models/CheckoutRedirectInfo.ts
+var CheckoutRedirectInfo = class {
+	user_id;
+	plan_id;
+	email;
+	pricing_id;
+	currency;
+	license_id;
+	expiration;
+	quota;
+	action;
+	amount;
+	tax;
+	type;
+	subscription_id;
+	billing_cycle;
+	payment_id;
+	constructor(data) {
+		this.user_id = idToString(data.user_id);
+		this.plan_id = idToString(data.plan_id);
+		this.email = data.email;
+		this.pricing_id = idToString(data.pricing_id);
+		this.currency = data.currency ? parseCurrency(data.currency) : CURRENCY.USD;
+		this.license_id = idToString(data.license_id);
+		this.expiration = data.expiration ? parseDateTime(data.expiration) : null;
+		this.quota = data.quota ? parseNumber(data.quota) : null;
+		this.action = data.action ? data.action : null;
+		this.amount = parseNumber(data.amount);
+		this.tax = parseNumber(data.tax);
+		this.type = data.type === "subscription" ? "subscription" : "one-off";
+		this.subscription_id = data.subscription_id ? idToString(data.subscription_id) : null;
+		this.billing_cycle = data.billing_cycle ? parseBillingCycle(data.billing_cycle) : null;
+		this.payment_id = data.payment_id ? idToString(data.payment_id) : null;
+	}
+	isSubscription() {
+		return this.type === "subscription";
+	}
+	toData() {
+		return {
+			user_id: this.user_id,
+			plan_id: this.plan_id,
+			email: this.email,
+			pricing_id: this.pricing_id,
+			currency: this.currency,
+			license_id: this.license_id,
+			expiration: this.expiration,
+			quota: this.quota,
+			action: this.action,
+			amount: this.amount,
+			tax: this.tax,
+			type: this.type,
+			subscription_id: this.subscription_id,
+			billing_cycle: this.billing_cycle,
+			payment_id: this.payment_id
+		};
+	}
+};
+
+//#endregion
+//#region src/services/CheckoutService.ts
+var CheckoutService = class {
+	constructor(productId, publicKey, secretKey) {
+		this.productId = productId;
+		this.publicKey = publicKey;
+		this.secretKey = secretKey;
+	}
+	/**
+	* Use this to build a Checkout for your product.
+	* You can build a Checkout link or options for the popup.
+	*
+	* @param withRecommendation If true, the checkout will include a recommendation for the user.
+	*
+	* @return A new instance of CheckoutBuilder with the product ID and public key.
+	*
+	* @example
+	* Basic usage:
+	* ```typescript
+	* const options = freemius.checkout.params()
+	*   .withUser(session?.user)
+	*   .inSandbox()
+	*   .withRecommendation()
+	*   .toOptions(); // Or .toLink() for a hosted checkout link
+	* ```
+	*
+	* @example
+	* Advanced configuration:
+	* ```typescript
+	* const checkoutOptions = freemius.checkout.params()
+	*   .withUser(user, true)
+	*   .withPlan('1234')
+	*   .withQuota(5)
+	*   .withCurrency('eur')
+	*   .withCoupon({
+	*     code: 'DISCOUNT2023',
+	*     hideUI: false
+	*   })
+	*   .inTrial('paid')
+	*   .withAppearance({
+	*     layout: 'horizontal',
+	*     formPosition: 'left',
+	*     fullscreen: true,
+	*     modalTitle: 'Upgrade Now'
+	*   })
+	*   .withDiscounts({
+	*     annual: true,
+	*     multisite: 'auto',
+	*     bundle: 'maximize',
+	*     showMonthlySwitch: true
+	*   })
+	*   .withReviewsAndBadges({
+	*     showReviews: true,
+	*     showRefundBadge: true,
+	*     refundPolicyPosition: 'below_form'
+	*   })
+	*   .withBillingCycle('dropdown', 'annual')
+	*   .withLocale('en_US')
+	*   .withAffiliate(12345)
+	*   .inSandbox()
+	*   .toOptions();
+	* ```
+	*/
+	create(withRecommendation = true) {
+		const productId = idToString(this.productId);
+		const builder = new CheckoutBuilder({}, productId, this.publicKey, this.secretKey);
+		return withRecommendation ? builder.withRecommendation() : builder;
+	}
+	/**
+	* Convenience method to create checkout options for a specific user with or without sandbox mode.
+	*
+	* Useful for generating recommended checkout options for SaaS.
+	*/
+	createUserOptions(user, isSandbox = false) {
+		let builder = this.create().withUser(user);
+		if (isSandbox) builder = builder.inSandbox();
+		return builder.toOptions();
+	}
+	/**
+	* Convenience method to create a checkout link for a specific user with or without sandbox mode.
+	*
+	* Useful for generating recommended checkout links for SaaS.
+	*/
+	createUserLink(user, isSandbox = false) {
+		let builder = this.create().withUser(user);
+		if (isSandbox) builder = builder.inSandbox();
+		return builder.toLink();
+	}
+	/**
+	* Retrieves the sandbox parameters for the checkout.
+	*
+	* This shouldn't be used in production, but is useful for testing purposes.
+	*
+	* @note This is intentionally set as `async` because we would use the API in the future to generate more fine grained sandbox params (for example for a specific email address only).
+	*
+	* @todo - This has a duplication with the `inSandbox` method in the builder. Consider refactoring to avoid this duplication.
+	*         Also think about whether we should make the builder's `inSandbox` method async as well.
+	*/
+	async getSandboxParams() {
+		const timestamp = Math.floor(Date.now() / 1e3).toString();
+		const token = `${timestamp}${this.productId}${this.secretKey}${this.publicKey}checkout`;
+		return {
+			ctx: timestamp,
+			token: createHash("md5").update(token).digest("hex")
+		};
+	}
+	/**
+	* Processes the redirect from Freemius Checkout.
+	*
+	* This method verifies the signature in the URL and returns a CheckoutRedirectInfo object if successful.
+	*
+	* For nextjs like applications, make sure to replace the URL from the `Request` object with the right hostname to take care of the proxy.
+	*
+	* For example, if you have put the nextjs application behind nginx proxy (or ngrok during local development), then nextjs will still see the `request.url` as `https://localhost:3000/...`.
+	* In this case, you should replace it with the actual URL of your application, like `https://xyz.ngrok-free.app/...`.
+	*
+	* @example
+	* ```ts
+	* export async function GET(request: Request) {
+	*     // Replace the URL with the actual hostname of your application
+	*     // This is important for the signature verification to work correctly.
+	*     const data = await freemius.checkout.processRedirect(
+	*         request.url.replace('https://localhost:3000', 'https://xyz.ngrok-free.app')
+	*     );
+	* }
+	* ```
+	*/
+	async processRedirect(currentUrl) {
+		const url = new URL(currentUrl.replace(/%20/g, "+"));
+		const signature = url.searchParams.get("signature");
+		if (!signature) return null;
+		const cleanUrl = this.getCleanUrl(url.href);
+		const calculatedSignature = createHmac("sha256", this.secretKey).update(cleanUrl).digest("hex");
+		const result = timingSafeEqual(Buffer.from(calculatedSignature), Buffer.from(signature));
+		if (!result) return null;
+		const params = Object.fromEntries(url.searchParams.entries());
+		if (!params.user_id || !params.plan_id || !params.pricing_id || !params.email) return null;
+		return new CheckoutRedirectInfo(params);
+	}
+	getCleanUrl(url) {
+		const signatureParam = "&signature=";
+		const signatureParamFirst = "?signature=";
+		let signaturePos = url.indexOf(signatureParam);
+		if (signaturePos === -1) signaturePos = url.indexOf(signatureParamFirst);
+		if (signaturePos === -1) return url;
+		return url.substring(0, signaturePos);
+	}
+};
+
+//#endregion
+//#region src/services/CustomerPortalService.ts
+var CustomerPortalService = class {
+	constructor(api, checkout) {
+		this.api = api;
+		this.checkout = checkout;
+	}
+	/**
+	* Retrieves the customer portal data for a user, including subscriptions, billing, and payments.
+	*
+	* @param userId The ID of the user for whom to retrieve portal data.
+	* @param primaryLicenseId Optional primary license ID to include in the portal data. If present then the `primary` field will be populated with related information which our `@freemius/saas-starter` package uses to display the primary purchase information.
+	*/
+	async retrieveData(userId, primaryLicenseId = null, sandbox = false) {
+		const [user, pricingData, subscriptions, payments, billing] = await Promise.all([
+			this.api.user.retrieve(userId),
+			this.api.product.retrievePricingData(),
+			this.api.user.retrieveSubscriptions(userId),
+			this.api.user.retrievePayments(userId),
+			this.api.user.retrieveBilling(userId)
+		]);
+		if (!user || !pricingData || !subscriptions) return null;
+		const planTitles = this.getPlanTitleById(pricingData);
+		const allPricingsById = this.getPricingById(pricingData);
+		const portalPayments = payments.map((payment) => ({
+			...payment,
+			invoiceUrl: this.api.getSignedUrl(this.api.createUrl(`payments/${payment.id}/invoice.pdf`)),
+			paymentMethod: parsePaymentMethod(payment.gateway),
+			createdAt: parseDateTime(payment.created) ?? /* @__PURE__ */ new Date(),
+			planTitle: planTitles[payment.plan_id] ?? `Plan ${payment.plan_id}`,
+			quota: allPricingsById[payment.pricing_id]?.licenses ?? null
+		}));
+		const checkoutOptions = { product_id: this.api.productId };
+		if (sandbox) checkoutOptions.sandbox = await this.checkout.getSandboxParams();
+		const billingData = {
+			user,
+			checkoutOptions,
+			billing,
+			subscriptions: {
+				primary: null,
+				active: [],
+				past: []
+			},
+			payments: portalPayments,
+			plans: pricingData.plans ?? [],
+			sellingUnit: pricingData.selling_unit_label ?? {
+				singular: "Unit",
+				plural: "Units"
+			},
+			productId: this.api.productId
+		};
+		subscriptions.forEach((subscription) => {
+			const isActive = null === subscription.canceled_at;
+			const subscriptionData = {
+				subscriptionId: idToString(subscription.id),
+				planId: idToString(subscription.plan_id),
+				pricingId: idToString(subscription.pricing_id),
+				planTitle: planTitles[subscription.plan_id] ?? `Plan ${subscription.plan_id}`,
+				renewalAmount: parseNumber(subscription.renewal_amount),
+				initialAmount: parseNumber(subscription.initial_amount),
+				billingCycle: parseBillingCycle(subscription.billing_cycle),
+				isActive,
+				renewalDate: parseDateTime(subscription.next_payment),
+				licenseId: idToString(subscription.license_id),
+				currency: parseCurrency(subscription.currency) ?? CURRENCY.USD,
+				createdAt: parseDateTime(subscription.created) ?? /* @__PURE__ */ new Date(),
+				cancelledAt: subscription.canceled_at ? parseDateTime(subscription.canceled_at) : null,
+				quota: allPricingsById[subscription.pricing_id]?.licenses ?? null,
+				paymentMethod: parsePaymentMethod(subscription.gateway)
+			};
+			if (isActive) billingData.subscriptions.active.push(subscriptionData);
+			else billingData.subscriptions.past.push(subscriptionData);
+			if (isActive && primaryLicenseId && isIdsEqual(subscription.license_id, primaryLicenseId)) billingData.subscriptions.primary = subscriptionData;
+		});
+		billingData.subscriptions.active.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+		billingData.subscriptions.past.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+		if (!billingData.subscriptions.primary) billingData.subscriptions.primary = billingData.subscriptions.active[0] ?? billingData.subscriptions.past[0] ?? null;
+		if (billingData.subscriptions.primary) billingData.subscriptions.primary.checkoutUpgradeAuthorization = await this.api.license.retrieveCheckoutUpgradeAuthorization(billingData.subscriptions.primary.licenseId);
+		return billingData;
+	}
+	/**
+	* @todo - Implement this method to handle actions like get cancel coupon, cancel subscription, update billing, get upgrade auth for Checkout etc.
+	*/
+	getPlanTitleById(pricingData) {
+		const planTitles = {};
+		pricingData.plans?.forEach((plan) => {
+			planTitles[plan.id] = plan.title ?? plan.name ?? "Unknown Plan";
+		});
+		return planTitles;
+	}
+	getPricingById(pricingData) {
+		const pricing = {};
+		pricingData.plans?.forEach((plan) => {
+			plan.pricing?.forEach((p) => {
+				pricing[p.id] = p;
+			});
+		});
+		return pricing;
+	}
+};
+
+//#endregion
+//#region src/models/PurchaseInfo.ts
+var PurchaseInfo = class {
+	email;
+	firstName;
+	lastName;
+	userId;
+	planId;
+	pricingId;
+	licenseId;
+	expiration;
+	canceled;
+	subscriptionId;
+	billingCycle;
+	quota;
+	initialAmount;
+	renewalAmount;
+	currency;
+	renewalDate;
+	paymentMethod;
+	created;
+	constructor(user, license, subscription) {
+		this.email = user.email;
+		this.firstName = user.first ?? "";
+		this.lastName = user.last ?? "";
+		this.userId = idToString(license.user_id);
+		this.canceled = license.is_cancelled ?? false;
+		this.expiration = license.expiration ? parseDateTime(license.expiration) : null;
+		this.licenseId = idToString(license.id);
+		this.planId = idToString(license.plan_id);
+		this.subscriptionId = null;
+		this.billingCycle = null;
+		this.quota = license.quota ?? null;
+		this.pricingId = idToString(license.pricing_id);
+		this.initialAmount = null;
+		this.renewalAmount = null;
+		this.currency = null;
+		this.renewalDate = null;
+		this.paymentMethod = null;
+		this.created = parseDateTime(license.created) ?? /* @__PURE__ */ new Date();
+		if (subscription) {
+			this.subscriptionId = idToString(subscription.id);
+			this.billingCycle = parseBillingCycle(subscription.billing_cycle);
+			this.initialAmount = parseNumber(subscription.initial_amount);
+			this.renewalAmount = parseNumber(subscription.renewal_amount);
+			this.currency = parseCurrency(subscription.currency);
+			this.renewalDate = subscription.next_payment ? parseDateTime(subscription.next_payment) : null;
+			this.paymentMethod = parsePaymentMethod(subscription.gateway);
+		}
+	}
+	isPlan(planId) {
+		return this.planId === idToString(planId);
+	}
+	isFromPlans(planIds) {
+		return planIds.some((planId) => this.isPlan(planId));
+	}
+	toData() {
+		return {
+			email: this.email,
+			firstName: this.firstName,
+			lastName: this.lastName,
+			userId: this.userId,
+			planId: this.planId,
+			pricingId: this.pricingId,
+			licenseId: this.licenseId,
+			expiration: this.expiration,
+			canceled: this.canceled,
+			subscriptionId: this.subscriptionId,
+			billingCycle: this.billingCycle,
+			quota: this.quota,
+			isActive: this.isActive,
+			initialAmount: this.initialAmount,
+			renewalAmount: this.renewalAmount,
+			currency: this.currency,
+			renewalDate: this.renewalDate,
+			paymentMethod: this.paymentMethod,
+			created: this.created
+		};
+	}
+	get isActive() {
+		if (this.canceled) return false;
+		if (this.expiration && this.expiration < /* @__PURE__ */ new Date()) return false;
+		return true;
+	}
+	hasSubscription() {
+		return this.subscriptionId !== null;
+	}
+	isAnnual() {
+		return this.billingCycle === BILLING_CYCLE.YEARLY;
+	}
+	isMonthly() {
+		return this.billingCycle === BILLING_CYCLE.MONTHLY;
+	}
+	isOneOff() {
+		return this.billingCycle === BILLING_CYCLE.ONEOFF || this.billingCycle === null;
+	}
+	getPlanTitle(pricingData) {
+		const plan = pricingData?.plans?.find((p) => isIdsEqual(p.id, this.planId));
+		return plan?.title ?? plan?.name ?? "Deleted Plan";
+	}
+};
+
+//#endregion
+//#region src/services/PurchaseService.ts
+var PurchaseService = class {
+	constructor(api) {
+		this.api = api;
+	}
+	/**
+	* Retrieve purchase information from the Freemius API based on the license ID.
+	*
+	* The license is the primary entitlement for a purchase, and it may or may not be associated with a subscription.
+	* With this method, you can retrieve detailed information about the purchase, including user details, plan, expiration, and more.
+	*/
+	async retrievePurchase(licenseId) {
+		const [license, subscription] = await Promise.all([await this.api.license.retrieve(licenseId), await this.api.license.retrieveSubscription(licenseId)]);
+		if (!license) return null;
+		const user = await this.api.user.retrieve(license.user_id);
+		if (!user) return null;
+		return new PurchaseInfo(user, license, subscription);
+	}
+	/**
+	* A helper method to retrieve raw purchase data instead of a full PurchaseInfo object.
+	*
+	* This is useful when passing data from server to client in frameworks like Next.js, where only serializable data should be sent.
+	*/
+	async retrievePurchaseData(licenseId) {
+		const purchaseInfo = await this.retrievePurchase(licenseId);
+		if (!purchaseInfo) return null;
+		return purchaseInfo.toData();
+	}
+	/**
+	* Retrieve a list of active subscriptions for a user. You can use this method to find or sync subscriptions from freemius to your system.
+	*/
+	async retrieveSubscriptions(userId, pagination) {
+		const user = await this.api.user.retrieve(userId);
+		if (!user) return [];
+		const subscriptions = await this.api.user.retrieveSubscriptions(userId, { filter: "active" }, pagination);
+		if (!subscriptions || !subscriptions.length) return [];
+		const licenseSubscriptionPromises = subscriptions.map(async (subscription) => {
+			const license = await this.api.license.retrieve(subscription.license_id);
+			if (!license) return null;
+			return new PurchaseInfo(user, license, subscription);
+		});
+		return await Promise.all(licenseSubscriptionPromises).then((results) => results.filter((result) => result !== null).sort((a, b) => b.created.getTime() - a.created.getTime()));
+	}
+	/**
+	* Retrieve a list of purchase data for a user.
+	*
+	* This is a convenience method that returns the purchase data in a format suitable for client-side rendering or serialization.
+	*/
+	async retrieveSubscriptionsData(userId, pagination) {
+		const purchaseInfos = await this.retrieveSubscriptions(userId, pagination);
+		return purchaseInfos.map((info) => info.toData());
+	}
+	async retrieveBySubscription(subscription, subscriptionUser) {
+		if (!subscription.license_id) return null;
+		const license = await this.api.license.retrieve(subscription.license_id);
+		if (!license) return null;
+		const user = subscriptionUser && isIdsEqual(subscriptionUser.id, license.user_id) ? subscriptionUser : await this.api.user.retrieve(license.user_id);
+		if (!user) return null;
+		return new PurchaseInfo(user, license, subscription);
+	}
+	async retrieveActiveSubscriptionByEmail(email, pagination) {
+		const user = await this.api.user.retrieveByEmail(email);
+		if (!user) return null;
+		return await this.retrieveSubscriptions(user.id, pagination);
+	}
+};
+
+//#endregion
+//#region src/webhook/WebhookListener.ts
+const SIGNATURE_HEADER = "x-signature";
+var WebhookListener = class {
+	eventHandlers = /* @__PURE__ */ new Map();
+	constructor(secretKey, onError = console.error) {
+		this.secretKey = secretKey;
+		this.onError = onError;
+	}
+	on(type, handler) {
+		if (!this.eventHandlers.has(type)) this.eventHandlers.set(type, /* @__PURE__ */ new Set());
+		const existingHandlers = this.eventHandlers.get(type);
+		existingHandlers?.add(handler);
+		return this;
+	}
+	off(type, handler) {
+		const currentHandlers = this.eventHandlers.get(type);
+		if (!currentHandlers) return this;
+		currentHandlers.delete(handler);
+		if (currentHandlers.size === 0) this.eventHandlers.delete(type);
+		return this;
+	}
+	onMultiple(handlers) {
+		for (const [type, handler] of Object.entries(handlers)) if (handler) this.on(type, handler);
+		return this;
+	}
+	removeAll(type) {
+		this.eventHandlers.delete(type);
+		return this;
+	}
+	getHandlerCount(type) {
+		return this.eventHandlers.get(type)?.size ?? 0;
+	}
+	getEventTypeCount() {
+		return this.eventHandlers.size;
+	}
+	getRegisteredEventTypes() {
+		return Array.from(this.eventHandlers.keys());
+	}
+	hasHandlers(type) {
+		const handlers = this.eventHandlers.get(type);
+		return handlers !== void 0 && handlers.size > 0;
+	}
+	hasHandler(type, handler) {
+		const handlers = this.eventHandlers.get(type);
+		return handlers ? handlers.has(handler) : false;
+	}
+	getHandlers(type) {
+		return this.eventHandlers.get(type) || /* @__PURE__ */ new Set();
+	}
+	getTotalHandlerCount() {
+		let total = 0;
+		for (const handlers of this.eventHandlers.values()) total += handlers.size;
+		return total;
+	}
+	/**
+	* Verify hex HMAC signature against the raw body.
+	*/
+	verifySignature(rawBody, signature) {
+		if (!signature) return false;
+		const mac = crypto.createHmac("sha256", this.secretKey).update(rawBody).digest("hex");
+		try {
+			return crypto.timingSafeEqual(Buffer.from(mac, "hex"), Buffer.from(signature, "hex"));
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Process a normalized request.
+	* Returns an object you can map to your framework's response easily.
+	*/
+	async process(input) {
+		const sig = this.getHeader(SIGNATURE_HEADER, input.headers);
+		if (!this.verifySignature(input.rawBody, sig)) return {
+			status: 401,
+			success: false,
+			error: "Invalid signature"
+		};
+		let evt;
+		try {
+			const parsed = JSON.parse(typeof input.rawBody === "string" ? input.rawBody : input.rawBody.toString("utf8"));
+			if (!parsed || typeof parsed.type !== "string") return {
+				status: 400,
+				success: false,
+				error: "Invalid payload"
+			};
+			evt = parsed;
+		} catch {
+			return {
+				status: 400,
+				success: false,
+				error: "Malformed JSON"
+			};
+		}
+		const eventType = evt.type;
+		const eventHandlers = this.eventHandlers.get(eventType);
+		if (!eventHandlers || eventHandlers.size === 0) console.warn(`No handlers registered for event type: ${eventType}`);
+		try {
+			const promises = Array.from(eventHandlers || []).map((handler) => {
+				const typedHandler = handler;
+				const typedEvent = evt;
+				return typedHandler(typedEvent);
+			});
+			await Promise.all(promises);
+		} catch (error) {
+			this.onError?.(error);
+			return {
+				status: 500,
+				success: false,
+				error: "Internal Server Error"
+			};
+		}
+		return {
+			status: 200,
+			success: true
+		};
+	}
+	getHeader(name, headers) {
+		const lname = name.toLowerCase();
+		if (headers instanceof Headers) return headers.get(lname);
+		const v = headers[lname] ?? headers[name];
+		if (Array.isArray(v)) return v[0] ?? null;
+		return v ?? null;
+	}
+};
+
+//#endregion
+//#region src/services/WebhookService.ts
+var WebhookService = class {
+	constructor(secretKey) {
+		this.secretKey = secretKey;
+	}
+	createListener(onError) {
+		return new WebhookListener(this.secretKey, onError);
+	}
+	/**
+	* WHATWG Fetch API adapter for modern JavaScript environments.
+	*
+	* Compatible with:
+	* - Next.js App Router (route.ts files)
+	* - Cloudflare Workers
+	* - Deno
+	* - Bun
+	* - Vercel Edge Functions
+	* - Any environment supporting the WHATWG Fetch API
+	*
+	* This method reads the request body as text and processes the webhook,
+	* returning a standard Response object that can be directly returned
+	* from your endpoint handler.
+	*
+	* @param listener - The webhook listener instance
+	* @param request - The incoming Request object (WHATWG Fetch API)
+	* @returns A Response object with the webhook processing result
+	*
+	* @example
+	* ```typescript
+	* // Next.js App Router (app/webhook/route.ts)
+	* export async function POST(request: Request) {
+	*   const listener = webhookService.createListener();
+	*   return await webhookService.processFetch(listener, request);
+	* }
+	*
+	* // Cloudflare Workers
+	* export default {
+	*   async fetch(request: Request): Promise<Response> {
+	*     if (new URL(request.url).pathname === '/webhook') {
+	*       const listener = webhookService.createListener();
+	*       return await webhookService.processFetch(listener, request);
+	*     }
+	*     return new Response('Not Found', { status: 404 });
+	*   }
+	* };
+	* ```
+	*/
+	async processFetch(listener, request) {
+		const rawBody = await request.text();
+		const result = await listener.process({
+			headers: request.headers,
+			rawBody
+		});
+		return new Response(JSON.stringify(result), {
+			status: result.status,
+			headers: { "Content-Type": "application/json" }
+		});
+	}
+	/**
+	* Native Node.js HTTP server adapter.
+	*
+	* Reads the raw body from the request stream and writes the HTTP response directly.
+	*
+	* @example
+	* ```typescript
+	* import { createServer } from 'http';
+	*
+	* const server = createServer(async (req, res) => {
+	*   if (req.url === '/webhook') {
+	*     await freemius.webhook.processNodeHttp(listener, req, res);
+	*   }
+	* });
+	* ```
+	*/
+	async processNodeHttp(listener, req, res) {
+		const chunks = [];
+		for await (const chunk of req) chunks.push(chunk);
+		const rawBody = Buffer.concat(chunks);
+		const result = await listener.process({
+			headers: req.headers,
+			rawBody
+		});
+		res.statusCode = result.status;
+		res.setHeader("Content-Type", "application/json");
+		res.end(JSON.stringify(result));
+	}
+};
+
+//#endregion
+//#region src/Freemius.ts
+var Freemius = class {
+	api;
+	checkout;
+	purchase;
+	customerPortal;
+	webhook;
+	constructor(productId, apiKey, secretKey, publicKey) {
+		this.api = new ApiService(productId, apiKey, secretKey, publicKey);
+		this.checkout = new CheckoutService(productId, publicKey, secretKey);
+		this.purchase = new PurchaseService(this.api);
+		this.customerPortal = new CustomerPortalService(this.api, this.checkout);
+		this.webhook = new WebhookService(secretKey);
+	}
+};
+
+//#endregion
+export { BILLING_CYCLE, CURRENCY, Freemius, PurchaseInfo, idToNumber, idToString, isIdsEqual, parseBillingCycle, parseCurrency, parseDate, parseDateTime, parseNumber, parsePaymentMethod };
+//# sourceMappingURL=index.mjs.map