@happyvertical/accounting 0.91.0 → 0.94.0

package/dist/chunks/{stripe-e3yn8cEJ.js → stripe-Dc061lPD.js}

@@ -1,3 +1,4 @@
+import { t as StripeApiError } from "./errors-Dvn2QzOB.js";
 import { createHmac, randomUUID, timingSafeEqual } from "node:crypto";
 //#region src/providers/stripe/index.ts
 /**
@@ -14,6 +15,7 @@ var StripeProvider = class {
 	type = "stripe";
 	options;
 	fetchImpl;
+	couponIds = /* @__PURE__ */ new Map();
 	customers;
 	invoices;
 	vendors;
@@ -42,7 +44,7 @@ var StripeProvider = class {
 	}
 	async request(method, endpoint, params, options = {}) {
 		const timeout = this.options.timeout || 3e4;
-		const maxRetries = this.options.maxRetries || 3;
+		const maxRetries = this.options.maxRetries ?? 3;
 		const idempotencyKey = method === "POST" ? options.idempotencyKey ?? `sdk-${randomUUID()}` : null;
 		let lastError = null;
 		for (let attempt = 0; attempt <= maxRetries; attempt++) {
@@ -68,7 +70,7 @@ var StripeProvider = class {
 				});
 				if (!response.ok) {
 					const errorText = await response.text();
-					const error = /* @__PURE__ */ new Error(`Stripe API error (${response.status}): ${errorText}`);
+					const error = new StripeApiError(response.status, errorText);
 					if (response.status < 500 && response.status !== 429) throw error;
 					lastError = error;
 				} else {
@@ -89,6 +91,42 @@ var StripeProvider = class {
 		}
 		throw lastError || /* @__PURE__ */ new Error("Stripe request failed after retries");
 	}
+	/**
+	* @internal
+	* A reusable amount-off coupon for a line discount, created on first use.
+	* Its id is derived from the currency and amount, so every replay and every
+	* invoice with the same discount shares one coupon instead of creating one
+	* per line.
+	*/
+	async amountOffCoupon(currency, amount) {
+		const normalized = currency.toLowerCase();
+		const id = `hv_amount_off_${normalized}_${amount}`;
+		const cached = this.couponIds.get(id);
+		if (cached) return cached;
+		const path = `/v1/coupons/${encodeURIComponent(id)}`;
+		let coupon;
+		try {
+			coupon = await this.request("GET", path);
+		} catch (error) {
+			if (!(error instanceof StripeApiError) || error.status !== 404) throw error;
+			try {
+				coupon = await this.request("POST", "/v1/coupons", {
+					id,
+					amount_off: amount,
+					currency: normalized,
+					duration: "forever",
+					name: "Discount",
+					metadata: { hv_purpose: "invoice_line_discount" }
+				});
+			} catch (createError) {
+				if (!(createError instanceof StripeApiError) || createError.code !== "resource_already_exists") throw createError;
+				coupon = await this.request("GET", path);
+			}
+		}
+		if (coupon.amount_off !== amount || (coupon.currency || "").toLowerCase() !== normalized || coupon.percent_off || coupon.valid === false) throw new Error(`Stripe coupon ${id} exists but is not a valid ${amount} ${normalized} amount-off coupon`);
+		this.couponIds.set(id, coupon.id);
+		return coupon.id;
+	}
 	buildUrl(endpoint, params) {
 		const baseUrl = this.options.apiBaseUrl || "https://api.stripe.com";
 		const url = new URL(endpoint, baseUrl);
@@ -102,12 +140,40 @@ var StripeCustomerOperations = class {
 		this.provider = provider;
 	}
 	async push(customer) {
+		if (customer.idempotencyKey !== void 0) {
+			assertIdempotencyKey(customer.idempotencyKey);
+			const existing = await this.findByLocalId(customer.id);
+			if (existing) return {
+				action: "created",
+				externalId: existing.id,
+				syncedAt: /* @__PURE__ */ new Date()
+			};
+		}
 		return {
 			action: "created",
-			externalId: (await this.provider.request("POST", "/v1/customers", mapCustomerToStripe(customer))).id,
+			externalId: (await this.provider.request("POST", "/v1/customers", mapCustomerToStripe(customer), { idempotencyKey: customer.idempotencyKey ? `${customer.idempotencyKey}:customer` : void 0 })).id,
 			syncedAt: /* @__PURE__ */ new Date()
 		};
 	}
+	/**
+	* The oldest customer tagged with this local id. Stripe search is
+	* eventually consistent (normally under a minute); inside that lag the
+	* idempotency key, retained for at least 24 hours, covers the replay.
+	*/
+	async findByLocalId(localId) {
+		const matches = [];
+		let page;
+		do {
+			const response = await this.provider.request("GET", "/v1/customers/search", {
+				query: `metadata['local_id']:'${escapeSearchValue(localId)}'`,
+				limit: 100,
+				page
+			});
+			matches.push(...response.data.filter((customer) => customer.metadata?.local_id === localId));
+			page = response.has_more ? response.next_page || void 0 : void 0;
+		} while (page);
+		return matches.sort((left, right) => (left.created ?? 0) - (right.created ?? 0) || left.id.localeCompare(right.id))[0];
+	}
 	async pull(externalId) {
 		return mapStripeCustomer(await this.provider.request("GET", `/v1/customers/${encodeURIComponent(externalId)}`));
 	}
@@ -131,6 +197,14 @@ var StripeInvoiceOperations = class {
 	}
 	async push(invoice) {
 		if (!invoice.customerExternalId) throw new Error("Stripe invoices require customerExternalId");
+		const currency = invoice.currency || "usd";
+		const collectionMethod = resolveCollectionMethod(invoice);
+		const lines = invoice.lineItems.map((lineItem) => ({
+			lineItem,
+			unitAmount: moneyToStripeMinorUnits(lineItem.unitPrice, currency),
+			discount: lineDiscountToStripe(lineItem, currency),
+			period: lineServicePeriod(lineItem)
+		}));
 		const existingInvoice = invoice.idempotencyKey ? await this.findInvoiceByLocalId(invoice.customerExternalId, invoice.id) : void 0;
 		if (existingInvoice) return {
 			action: "created",
@@ -138,14 +212,18 @@ var StripeInvoiceOperations = class {
 			syncedAt: /* @__PURE__ */ new Date()
 		};
 		const existingLineItemIndexes = invoice.idempotencyKey ? await this.findPendingLineItemIndexes(invoice.customerExternalId, invoice.id) : /* @__PURE__ */ new Set();
-		for (const [index, lineItem] of invoice.lineItems.entries()) {
+		for (const [index, line] of lines.entries()) {
 			if (existingLineItemIndexes.has(index)) continue;
+			const { lineItem, unitAmount, discount, period } = line;
+			const coupon = discount ? await this.provider.amountOffCoupon(currency, discount) : void 0;
 			await this.provider.request("POST", "/v1/invoiceitems", {
 				customer: invoice.customerExternalId,
-				currency: invoice.currency || "usd",
+				currency,
 				description: lineItem.description,
 				quantity: lineItem.quantity,
-				unit_amount_decimal: String(moneyToStripeMinorUnits(lineItem.unitPrice, invoice.currency || "usd")),
+				unit_amount_decimal: String(unitAmount),
+				period,
+				discounts: coupon ? [{ coupon }] : void 0,
 				tax_behavior: invoice.automaticTax ? "exclusive" : void 0,
 				metadata: normalizeMetadata({
 					local_invoice_id: invoice.id,
@@ -158,7 +236,7 @@ var StripeInvoiceOperations = class {
 		}
 		return {
 			action: "created",
-			externalId: (await this.provider.request("POST", "/v1/invoices", mapInvoiceToStripe(invoice), { idempotencyKey: invoice.idempotencyKey ? `${invoice.idempotencyKey}:invoice` : void 0 })).id,
+			externalId: (await this.provider.request("POST", "/v1/invoices", mapInvoiceToStripe(invoice, collectionMethod), { idempotencyKey: invoice.idempotencyKey ? `${invoice.idempotencyKey}:invoice` : void 0 })).id,
 			syncedAt: /* @__PURE__ */ new Date()
 		};
 	}
@@ -170,15 +248,59 @@ var StripeInvoiceOperations = class {
 	}
 	async sync(invoice) {
 		if (!invoice.externalId) return this.push(invoice);
-		await this.provider.request("POST", `/v1/invoices/${encodeURIComponent(invoice.externalId)}`, mapInvoiceUpdateToStripe(invoice));
+		await this.provider.request("POST", `/v1/invoices/${encodeURIComponent(invoice.externalId)}`, mapInvoiceUpdateToStripe(invoice, resolveCollectionMethod(invoice)));
 		return {
 			action: "updated",
 			externalId: invoice.externalId,
 			syncedAt: /* @__PURE__ */ new Date()
 		};
 	}
+	/**
+	* `send_invoice` invoices are emailed through Stripe's send endpoint.
+	* `charge_automatically` invoices are finalized with automatic collection
+	* on, so Stripe charges the customer's default payment method and applies
+	* its retry settings; the outcome arrives as `invoice.paid` or
+	* `invoice.payment_failed`.
+	*/
 	async send(externalId) {
-		await this.provider.request("POST", `/v1/invoices/${encodeURIComponent(externalId)}/send`);
+		const path = `/v1/invoices/${encodeURIComponent(externalId)}`;
+		const invoice = await this.provider.request("GET", path);
+		if (invoice.collection_method !== "charge_automatically") {
+			await this.provider.request("POST", `${path}/send`);
+			return;
+		}
+		if (invoice.status === "draft") {
+			await this.provider.request("POST", `${path}/finalize`, { auto_advance: true }, { idempotencyKey: `${externalId}:finalize` });
+			return;
+		}
+		if (invoice.status === "open" && invoice.auto_advance === false) await this.provider.request("POST", path, { auto_advance: true }, { idempotencyKey: `${externalId}:auto_advance` });
+	}
+	async markUncollectible(externalId) {
+		await this.provider.request("POST", `/v1/invoices/${encodeURIComponent(externalId)}/mark_uncollectible`, void 0, { idempotencyKey: `${externalId}:mark_uncollectible` });
+	}
+	/**
+	* Close an invoice paid on another rail (`paid_out_of_band`). An invoice
+	* already marked paid out of band, or paid with nothing collected, is left
+	* as is; one Stripe collected money for itself throws (a second collection needs a refund, not a silent close).
+	* A draft is finalized first without automatic collection, and refused if
+	* finalization raised the amount due. A void invoice throws; an
+	* uncollectible one can still be paid, as in Stripe.
+	*/
+	async markPaidOutOfBand(externalId) {
+		const path = `/v1/invoices/${encodeURIComponent(externalId)}`;
+		let invoice = await this.provider.request("GET", path);
+		if (invoice.status === "paid") {
+			if (invoice.paid_out_of_band === true || !(invoice.amount_paid ?? 0)) return;
+			throw new Error(`Stripe invoice ${externalId} was already paid through Stripe; it was not marked paid out of band.`);
+		}
+		if (invoice.status === "void") throw new Error(`Stripe invoice ${externalId} is void and cannot be marked paid.`);
+		if (invoice.status === "draft") {
+			const draftDue = invoice.amount_remaining ?? invoice.total ?? 0;
+			invoice = await this.provider.request("POST", `${path}/finalize`, { auto_advance: false }, { idempotencyKey: `${externalId}:finalize_out_of_band` });
+			if (invoice.status === "paid") return;
+			if ((invoice.amount_remaining ?? 0) > draftDue) throw new Error(`Stripe invoice ${externalId} grew from ${draftDue} to ${invoice.amount_remaining} on finalization; not marking it paid out of band.`);
+		}
+		await this.provider.request("POST", `${path}/pay`, { paid_out_of_band: true }, { idempotencyKey: `${externalId}:paid_out_of_band` });
 	}
 	async void(externalId) {
 		await this.provider.request("POST", `/v1/invoices/${encodeURIComponent(externalId)}/void`);
@@ -227,6 +349,79 @@ var StripePaymentOperations = class {
 	async list(options = {}) {
 		return (await this.provider.request("GET", "/v1/payment_intents", mapListOptions(options))).data.map(mapStripePaymentIntent);
 	}
+	async chargeSavedPaymentMethod(input) {
+		assertIdempotencyKey(input.idempotencyKey);
+		if (!input.customerExternalId) throw new Error("Saved payment method charges require a customer");
+		const currency = normalizeCurrencyCode(input.currency);
+		const stripeAmount = minorUnitsToStripeAmount(input.amountMinor, currency);
+		if (stripeAmount <= 0) throw new Error("Charge amount must be a positive integer of minor units");
+		const chargeKey = input.idempotencyKey;
+		const base = {
+			provider: "stripe",
+			customerExternalId: input.customerExternalId,
+			amountMinor: input.amountMinor,
+			currency,
+			chargeKey
+		};
+		const existing = await this.findByChargeKey(chargeKey);
+		if (existing) {
+			assertSameCharge(existing, input.customerExternalId, stripeAmount, currency, input.paymentMethodExternalId);
+			return {
+				...base,
+				...mapChargeOutcome(existing)
+			};
+		}
+		let paymentMethod = input.paymentMethodExternalId;
+		if (!paymentMethod) {
+			paymentMethod = idOf((await this.provider.request("GET", `/v1/customers/${encodeURIComponent(input.customerExternalId)}`)).invoice_settings?.default_payment_method);
+			if (!paymentMethod) return {
+				...base,
+				status: "failed",
+				failureCode: "payment_method_missing",
+				failureMessage: "The customer has no default payment method."
+			};
+		}
+		try {
+			const paymentIntent = await this.provider.request("POST", "/v1/payment_intents", {
+				amount: stripeAmount,
+				currency: currency.toLowerCase(),
+				customer: input.customerExternalId,
+				payment_method: paymentMethod,
+				off_session: true,
+				confirm: true,
+				description: input.description,
+				metadata: normalizeMetadata({
+					...input.metadata,
+					[CHARGE_KEY_METADATA]: chargeKey
+				})
+			}, { idempotencyKey: `${chargeKey}:payment_intent` });
+			return {
+				...base,
+				...mapChargeOutcome(paymentIntent)
+			};
+		} catch (error) {
+			if (error instanceof StripeApiError && error.status === 402 && error.type === "card_error") {
+				const paymentIntent = isRecord(error.paymentIntent) ? error.paymentIntent : void 0;
+				return {
+					...base,
+					...paymentIntent ? mapChargeOutcome(paymentIntent) : {},
+					paymentMethodExternalId: idOf(paymentIntent?.payment_method) ?? paymentMethod,
+					status: error.code === "authentication_required" ? "requires_action" : "failed",
+					failureCode: error.code,
+					declineCode: error.declineCode,
+					failureMessage: error.stripeMessage,
+					raw: paymentIntent ? withoutClientSecret(paymentIntent) : void 0
+				};
+			}
+			throw error;
+		}
+	}
+	async findByChargeKey(chargeKey) {
+		return (await this.provider.request("GET", "/v1/payment_intents/search", {
+			query: `metadata['${CHARGE_KEY_METADATA}']:'${escapeSearchValue(chargeKey)}'`,
+			limit: 10
+		})).data.filter((intent) => intent.metadata?.[CHARGE_KEY_METADATA] === chargeKey).sort((left, right) => (left.created ?? 0) - (right.created ?? 0) || left.id.localeCompare(right.id))[0];
+	}
 };
 var StripeBillingOperationsImpl = class {
 	provider;
@@ -234,16 +429,38 @@ var StripeBillingOperationsImpl = class {
 		this.provider = provider;
 	}
 	async createCheckoutSession(input) {
-		const response = await this.provider.request("POST", "/v1/checkout/sessions", mapCheckoutSessionToStripe(input), { idempotencyKey: input.idempotencyKey });
+		return mapCheckoutSessionResponse(await this.provider.request("POST", "/v1/checkout/sessions", mapCheckoutSessionToStripe(input), { idempotencyKey: input.idempotencyKey }));
+	}
+	async retrieveCheckoutSession(sessionExternalId) {
+		const session = await this.provider.request("GET", `/v1/checkout/sessions/${encodeURIComponent(sessionExternalId)}`, { expand: ["setup_intent", "payment_intent"] });
+		const intent = typeof session.setup_intent === "object" && session.setup_intent ? session.setup_intent : typeof session.payment_intent === "object" && session.payment_intent ? session.payment_intent : void 0;
+		const currency = session.currency ? session.currency.toUpperCase() : void 0;
+		const minor = (amount) => currency && typeof amount === "number" ? stripeAmountToMinorUnitsOrUndefined(amount, currency) : void 0;
 		return {
-			externalId: response.id,
-			url: response.url || null,
-			customerExternalId: response.customer || void 0,
-			subscriptionExternalId: response.subscription || void 0,
-			paymentIntentExternalId: response.payment_intent || void 0,
-			raw: response
+			...mapCheckoutSessionResponse(session),
+			raw: withoutClientSecrets(session),
+			status: oneOf(session.status, [
+				"open",
+				"complete",
+				"expired"
+			]),
+			paymentStatus: oneOf(session.payment_status, [
+				"paid",
+				"unpaid",
+				"no_payment_required"
+			]),
+			paymentMethodExternalId: idOf(intent?.payment_method),
+			currency,
+			amountSubtotalMinor: minor(session.amount_subtotal),
+			amountTaxMinor: minor(session.total_details?.amount_tax),
+			amountTotalMinor: minor(session.amount_total),
+			metadata: { ...session.metadata || {} }
 		};
 	}
+	async setDefaultPaymentMethod(customerExternalId, paymentMethodExternalId) {
+		if (!customerExternalId || !paymentMethodExternalId) throw new Error("setDefaultPaymentMethod requires a customer and a payment method");
+		await this.provider.request("POST", `/v1/customers/${encodeURIComponent(customerExternalId)}`, { invoice_settings: { default_payment_method: paymentMethodExternalId } });
+	}
 	async createCustomerPortalSession(input) {
 		const response = await this.provider.request("POST", "/v1/billing_portal/sessions", {
 			customer: input.customerExternalId,
@@ -350,7 +567,9 @@ var StripeWebhookOperations = class {
 			throw new Error(`Invalid Stripe webhook payload: ${message}`);
 		}
 		const resource = event?.data?.object;
+		const payment = resource?.object === "payment_intent" && typeof resource.id === "string" ? mapWebhookPayment(resource, event?.type || void 0) : void 0;
 		return {
+			...payment ? { payment } : {},
 			type: event?.type || "unknown",
 			id: typeof event?.id === "string" ? event.id : void 0,
 			provider: "stripe",
@@ -398,19 +617,19 @@ function mapCustomerToStripe(customer) {
 			country: customer.billingAddress.country
 		} : void 0,
 		metadata: normalizeMetadata({
-			local_id: customer.id,
 			payment_terms: customer.paymentTerms,
-			...customer.metadata
+			...customer.metadata,
+			local_id: customer.id
 		})
 	};
 	if (customer.taxExempt !== void 0) stripeCustomer.tax_exempt = customer.taxExempt ? "exempt" : "none";
 	return stripeCustomer;
 }
-function mapInvoiceToStripe(invoice) {
+function mapInvoiceToStripe(invoice, collectionMethod) {
 	return {
 		customer: invoice.customerExternalId,
-		collection_method: "send_invoice",
-		due_date: invoice.dueDate,
+		collection_method: collectionMethod,
+		due_date: collectionMethod === "send_invoice" ? invoice.dueDate : void 0,
 		auto_advance: false,
 		pending_invoice_items_behavior: "include",
 		automatic_tax: invoice.automaticTax ? { enabled: true } : void 0,
@@ -426,9 +645,10 @@ function mapInvoiceToStripe(invoice) {
 		})
 	};
 }
-function mapInvoiceUpdateToStripe(invoice) {
+function mapInvoiceUpdateToStripe(invoice, collectionMethod) {
 	return {
-		due_date: invoice.dueDate,
+		collection_method: invoice.collectionMethod ? collectionMethod : void 0,
+		due_date: collectionMethod === "send_invoice" ? invoice.dueDate : void 0,
 		metadata: normalizeMetadata({
 			local_id: invoice.id,
 			invoice_number: invoice.invoiceNumber,
@@ -439,35 +659,76 @@ function mapInvoiceUpdateToStripe(invoice) {
 	};
 }
 function mapCheckoutSessionToStripe(input) {
+	const mode = input.mode || "subscription";
+	const lineItems = input.lineItems || [];
+	if (mode === "setup") {
+		if (lineItems.length > 0) throw new Error("Stripe setup-mode Checkout does not accept line items");
+		if (!input.currency && !input.paymentMethodTypes?.length) throw new Error("Stripe setup-mode Checkout requires currency or paymentMethodTypes");
+		if (input.automaticTax) throw new Error("Stripe setup-mode Checkout does not calculate tax");
+	} else if (lineItems.length === 0) throw new Error(`Stripe ${mode}-mode Checkout requires line items`);
+	if (input.setupFutureUsage && mode !== "payment") throw new Error("setupFutureUsage applies only to payment-mode Checkout");
+	if (input.customerUpdate && !input.customerExternalId) throw new Error("customerUpdate requires customerExternalId");
 	return {
-		mode: input.mode || "subscription",
+		mode,
 		success_url: input.successUrl,
 		cancel_url: input.cancelUrl,
 		customer: input.customerExternalId,
 		customer_email: input.customerExternalId ? void 0 : input.customerEmail,
 		client_reference_id: input.clientReferenceId,
 		allow_promotion_codes: input.allowPromotionCodes,
-		line_items: input.lineItems.map(mapCheckoutLineItem),
+		currency: input.currency ? input.currency.toLowerCase() : void 0,
+		payment_method_types: input.paymentMethodTypes,
+		automatic_tax: input.automaticTax ? { enabled: true } : void 0,
+		billing_address_collection: input.billingAddressCollection,
+		customer_update: input.customerUpdate ? {
+			address: input.customerUpdate.address,
+			name: input.customerUpdate.name,
+			shipping: input.customerUpdate.shipping
+		} : void 0,
+		payment_intent_data: input.setupFutureUsage ? { setup_future_usage: input.setupFutureUsage } : void 0,
+		line_items: mode === "setup" ? void 0 : lineItems.map((lineItem) => mapCheckoutLineItem(lineItem, Boolean(input.automaticTax))),
 		metadata: normalizeMetadata(input.metadata || {})
 	};
 }
-function mapCheckoutLineItem(lineItem) {
+function mapCheckoutSessionResponse(response) {
+	return {
+		externalId: response.id,
+		url: response.url || null,
+		mode: oneOf(response.mode, [
+			"payment",
+			"setup",
+			"subscription"
+		]),
+		customerExternalId: idOf(response.customer),
+		subscriptionExternalId: idOf(response.subscription),
+		paymentIntentExternalId: idOf(response.payment_intent),
+		setupIntentExternalId: idOf(response.setup_intent),
+		raw: withoutClientSecrets(response)
+	};
+}
+function mapCheckoutLineItem(lineItem, automaticTax = false) {
 	if (lineItem.price) return {
 		price: lineItem.price,
 		quantity: lineItem.quantity || 1
 	};
 	if (!lineItem.priceData) throw new Error("Stripe checkout line item requires price or priceData");
-	const productData = lineItem.priceData.product ? void 0 : { name: lineItem.priceData.productName || "Subscription" };
+	const { priceData } = lineItem;
+	const productData = priceData.product ? void 0 : { name: priceData.productName || "Subscription" };
+	const hasStripeAmount = priceData.unitAmount !== void 0;
+	const hasMinorAmount = priceData.unitAmountMinor !== void 0;
+	if (hasStripeAmount === hasMinorAmount) throw new Error("Stripe checkout priceData requires exactly one of unitAmount or unitAmountMinor");
+	const unitAmount = hasMinorAmount ? minorUnitsToStripeAmount(priceData.unitAmountMinor, normalizeCurrencyCode(priceData.currency)) : priceData.unitAmount;
 	return {
 		quantity: lineItem.quantity || 1,
 		price_data: {
-			currency: lineItem.priceData.currency,
-			unit_amount: lineItem.priceData.unitAmount,
-			product: lineItem.priceData.product,
+			currency: priceData.currency.toLowerCase(),
+			unit_amount: unitAmount,
+			tax_behavior: priceData.taxBehavior ?? (automaticTax ? "exclusive" : void 0),
+			product: priceData.product,
 			product_data: productData,
-			recurring: lineItem.priceData.recurring ? {
-				interval: lineItem.priceData.recurring.interval,
-				interval_count: lineItem.priceData.recurring.intervalCount
+			recurring: priceData.recurring ? {
+				interval: priceData.recurring.interval,
+				interval_count: priceData.recurring.intervalCount
 			} : void 0
 		}
 	};
@@ -520,6 +781,7 @@ function mapStripeInvoice(invoice) {
 		balance: stripeMinorUnitsToMoney(invoice.amount_remaining || 0, invoice.currency),
 		status: mapStripeInvoiceStatus(invoice.status, invoice.due_date),
 		currency: invoice.currency || "usd",
+		paidOutOfBand: invoice.paid_out_of_band === true,
 		raw: invoice
 	};
 }
@@ -556,6 +818,7 @@ function mapStripeInvoiceStatus(status, dueDate) {
 		case "draft": return "draft";
 		case "paid": return "paid";
 		case "void": return "voided";
+		case "uncollectible": return "uncollectible";
 		case "open":
 			if (dueDate && dueDate * 1e3 < Date.now()) return "overdue";
 			return "sent";
@@ -715,6 +978,187 @@ function moneyToStripeMinorUnits(amount, currency) {
 function stripeMinorUnitsToMoney(amount, currency) {
 	return amount / stripeCurrencyMinorUnitFactor(currency);
 }
+var CHARGE_KEY_METADATA = "hv_charge_key";
+function assertIdempotencyKey(key) {
+	if (typeof key !== "string" || key.trim() === "") throw new Error("idempotencyKey must be a non-empty string");
+}
+/** Escape a value for a single-quoted Stripe Search Query Language string. */
+function escapeSearchValue(value) {
+	return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function resolveCollectionMethod(invoice) {
+	const method = invoice.collectionMethod ?? "send_invoice";
+	if (method !== "send_invoice" && method !== "charge_automatically") throw new Error(`Unsupported invoice collectionMethod '${method}'`);
+	return method;
+}
+/** The line's discount in Stripe units, validated against the line total. */
+function lineDiscountToStripe(lineItem, currency) {
+	if (lineItem.discount === void 0 || lineItem.discount === 0) return;
+	if (!Number.isFinite(lineItem.discount) || lineItem.discount < 0) throw new Error(`Invoice line '${lineItem.description}' discount must be a non-negative amount`);
+	const discount = moneyToStripeMinorUnits(lineItem.discount, currency);
+	if (discount > Math.round(moneyToStripeMinorUnits(lineItem.unitPrice, currency) * lineItem.quantity)) throw new Error(`Invoice line '${lineItem.description}' discount exceeds the line total`);
+	return discount > 0 ? discount : void 0;
+}
+function lineServicePeriod(lineItem) {
+	const { periodStart, periodEnd } = lineItem;
+	if (!periodStart && !periodEnd) return;
+	if (!(periodStart instanceof Date) || !(periodEnd instanceof Date)) throw new Error(`Invoice line '${lineItem.description}' needs both periodStart and periodEnd`);
+	if (Number.isNaN(periodStart.getTime()) || Number.isNaN(periodEnd.getTime()) || periodEnd.getTime() < periodStart.getTime()) throw new Error(`Invoice line '${lineItem.description}' has an invalid service period`);
+	return {
+		start: periodStart,
+		end: periodEnd
+	};
+}
+function mapChargeOutcome(paymentIntent) {
+	const error = paymentIntent.last_payment_error;
+	const status = mapPaymentIntentChargeStatus(paymentIntent.status, error?.code);
+	return {
+		status,
+		paymentExternalId: paymentIntent.id,
+		paymentMethodExternalId: idOf(paymentIntent.payment_method),
+		failureCode: status === "succeeded" ? void 0 : error?.code || void 0,
+		declineCode: status === "succeeded" ? void 0 : error?.decline_code || void 0,
+		failureMessage: status === "succeeded" ? void 0 : error?.message || void 0,
+		raw: withoutClientSecret(paymentIntent)
+	};
+}
+/**
+* A PaymentIntent found by charge key after Stripe's idempotency window must
+* be the charge this call describes; a key reused for a different amount,
+* currency, or customer is refused instead of reporting the wrong charge.
+*/
+function assertSameCharge(paymentIntent, customerExternalId, stripeAmount, currency, paymentMethodExternalId) {
+	const customer = idOf(paymentIntent.customer);
+	const paymentMethod = idOf(paymentIntent.payment_method);
+	if (paymentIntent.amount !== stripeAmount || (paymentIntent.currency || "").toUpperCase() !== currency || customer !== void 0 && customer !== customerExternalId || paymentMethodExternalId !== void 0 && paymentMethod !== void 0 && paymentMethod !== paymentMethodExternalId) throw new Error(`idempotencyKey was already used for a different charge (${paymentIntent.id}); use a new key for a new charge`);
+}
+/** Remove `client_secret` from a Stripe object and its expanded intents. */
+function withoutClientSecrets(value) {
+	const copy = withoutClientSecret(value);
+	for (const key of ["payment_intent", "setup_intent"]) {
+		const nested = copy[key];
+		if (isRecord(nested)) copy[key] = withoutClientSecret(nested);
+	}
+	return copy;
+}
+/**
+* Drop the intent client secret before handing objects to callers, including
+* `next_action`, whose redirect URL and SDK payload embed the same secret.
+*/
+function withoutClientSecret(value) {
+	const { client_secret: _secret, next_action: _nextAction, ...rest } = value;
+	return rest;
+}
+function mapPaymentIntentChargeStatus(status, errorCode) {
+	switch (status) {
+		case "succeeded": return "succeeded";
+		case "processing":
+		case "requires_capture": return "processing";
+		case "requires_action":
+		case "requires_confirmation": return "requires_action";
+		case "canceled": return "canceled";
+		case "requires_payment_method": return errorCode === "authentication_required" ? "requires_action" : "failed";
+		default: return "processing";
+	}
+}
+function mapWebhookPayment(paymentIntent, eventType) {
+	const error = paymentIntent.last_payment_error;
+	let status = mapPaymentIntentChargeStatus(paymentIntent.status, error?.code);
+	if (eventType === "payment_intent.succeeded") status = "succeeded";
+	if (eventType === "payment_intent.canceled") status = "canceled";
+	if (eventType === "payment_intent.payment_failed") status = error?.code === "authentication_required" ? "requires_action" : "failed";
+	const currency = paymentIntent.currency ? paymentIntent.currency.toUpperCase() : void 0;
+	const metadata = { ...paymentIntent.metadata || {} };
+	return {
+		status,
+		paymentExternalId: paymentIntent.id,
+		customerExternalId: idOf(paymentIntent.customer),
+		amountMinor: currency && typeof paymentIntent.amount === "number" ? stripeAmountToMinorUnitsOrUndefined(paymentIntent.amount, currency) : void 0,
+		currency,
+		chargeKey: metadata[CHARGE_KEY_METADATA],
+		failureCode: status === "succeeded" ? void 0 : error?.code || void 0,
+		declineCode: status === "succeeded" ? void 0 : error?.decline_code || void 0,
+		failureMessage: status === "succeeded" ? void 0 : error?.message || void 0,
+		metadata
+	};
+}
+function idOf(value) {
+	if (typeof value === "string") return value || void 0;
+	return value?.id || void 0;
+}
+function oneOf(value, allowed) {
+	return allowed.find((candidate) => candidate === value);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function normalizeCurrencyCode(currency) {
+	const code = String(currency ?? "").trim().toUpperCase();
+	if (!/^[A-Z]{3}$/.test(code)) throw new Error(`Currency '${currency}' must be a three-letter code`);
+	return code;
+}
+/** ISO 4217 minor-unit exponents other than 2. */
+var ISO_ZERO_DECIMAL_CURRENCIES = /* @__PURE__ */ new Set([
+	"BIF",
+	"CLP",
+	"DJF",
+	"GNF",
+	"ISK",
+	"JPY",
+	"KMF",
+	"KRW",
+	"PYG",
+	"RWF",
+	"UGX",
+	"UYI",
+	"VND",
+	"VUV",
+	"XAF",
+	"XOF",
+	"XPF"
+]);
+var ISO_THREE_DECIMAL_CURRENCIES = /* @__PURE__ */ new Set([
+	"BHD",
+	"IQD",
+	"JOD",
+	"KWD",
+	"LYD",
+	"OMR",
+	"TND"
+]);
+var ISO_FOUR_DECIMAL_CURRENCIES = /* @__PURE__ */ new Set(["CLF", "UYW"]);
+/**
+* ISO 4217 minor-unit exponent (2 for USD, 0 for JPY and ISK), from the
+* explicit tables above rather than the runtime's `Intl`/CLDR display digits,
+* which differ for some currencies (for example RSD, IQD, MGA) and change
+* between ICU releases.
+*/
+function isoMinorUnitExponent(currency) {
+	if (ISO_ZERO_DECIMAL_CURRENCIES.has(currency)) return 0;
+	if (ISO_THREE_DECIMAL_CURRENCIES.has(currency)) return 3;
+	if (ISO_FOUR_DECIMAL_CURRENCIES.has(currency)) return 4;
+	return 2;
+}
+/**
+* Integer ISO minor units → Stripe's smallest unit. They differ where Stripe
+* keeps a two-decimal representation for a zero-decimal currency (ISK, UGX).
+*/
+function minorUnitsToStripeAmount(amountMinor, currency) {
+	if (!Number.isSafeInteger(amountMinor)) throw new Error(`Amount ${amountMinor} must be a safe integer number of minor units`);
+	const iso = 10 ** isoMinorUnitExponent(currency);
+	const stripe = stripeCurrencyMinorUnitFactor(currency);
+	if (stripe >= iso) return amountMinor * (stripe / iso);
+	const divisor = iso / stripe;
+	if (amountMinor % divisor !== 0) throw new Error(`Amount ${amountMinor} ${currency} minor units is not representable in Stripe's currency unit`);
+	return amountMinor / divisor;
+}
+function stripeAmountToMinorUnitsOrUndefined(amount, currency) {
+	if (!Number.isSafeInteger(amount)) return;
+	const iso = 10 ** isoMinorUnitExponent(currency);
+	const stripe = stripeCurrencyMinorUnitFactor(currency);
+	const minor = amount * iso / stripe;
+	return Number.isSafeInteger(minor) ? minor : void 0;
+}
 function toUnixSeconds(date) {
 	return Math.floor(date.getTime() / 1e3);
 }
@@ -727,4 +1171,4 @@ function sleep(ms) {
 //#endregion
 export { StripeProvider };
 
-//# sourceMappingURL=stripe-e3yn8cEJ.js.map
+//# sourceMappingURL=stripe-Dc061lPD.js.map