@amboras-dev/money 0.1.0 → 0.2.0

package/dist/{wire-DQZ6fA3c.cjs → wire-Bhuut8cW.cjs}

@@ -1,8 +1,8 @@
-const require_money = require("./money-D5-vlv0h.cjs");
-const require_allocate = require("./allocate-D7tm_t_o.cjs");
+const require_money = require("./money-B3wH_Z4S.cjs");
+const require_allocate = require("./allocate-CZRg4TOP.cjs");
 const require_own = require("./own-oP9DXFWv.cjs");
-const require_iso_minor = require("./iso-minor--gQWI1f2.cjs");
-const require_number_text = require("./number-text-BpvN6NAo.cjs");
+const require_iso_minor = require("./iso-minor-wSwJN57T.cjs");
+const require_number_text = require("./number-text-BWu67jUq.cjs");
 //#region src/wire/anet.ts
 const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 /**
@@ -678,6 +678,118 @@ const STRIPE_PRESENTMENT_CURRENCIES = [
 	"ZAR",
 	"ZMW"
 ];
+/**
+* Presentment currencies only accounts registered in the named countries can charge.
+* Stripe: support.stripe.com/questions/which-payments-methods-and-products-are-available-in-the-uae
+* (retrieved 2026-10-07): "We also support charges in the following three-decimal currencies:
+* Bahraini dinar (BHD), Jordanian dinar (JOD), Kuwaiti dinar (KWD), Omani rial (OMR), Tunisian
+* dinar (TND)"; no other country's list on docs.stripe.com/currencies carries them.
+* PayPal: developer.paypal.com/reference/currency-codes (retrieved 2026-10-07) footnotes BRL, CNY
+* and MYR as supported "only for in-country PayPal accounts" (Medusa models the conservative
+* reading: an out-of-country account cannot charge them; unverified by a sandbox probe).
+*/
+const PRESENTMENT_REQUIRES_ACCOUNT_COUNTRY = {
+	stripe: {
+		BHD: ["AE"],
+		JOD: ["AE"],
+		KWD: ["AE"],
+		OMR: ["AE"],
+		TND: ["AE"]
+	},
+	paypal: {
+		BRL: ["BR"],
+		CNY: ["CN"],
+		MYR: ["MY"]
+	}
+};
+/**
+* Account countries whose card processing takes only the listed currencies.
+* Airwallex: airwallex.com/docs/payments/payment-methods/global/cards (retrieved 2026-10-26,
+* matching Medusa's 2026-10-07 copy): "Supported processing currencies can differ based on where
+* your business is registered and the card scheme." US and MX are listed below; AU, CA, SG, HK,
+* NZ, JP, MY, the EEA, CH, UK and IL take "Visa, MasterCard: All currencies".
+*/
+const PRESENTMENT_ACCOUNT_COUNTRY_ALLOWS_ONLY = { airwallex: {
+	US: [
+		"USD",
+		"EUR",
+		"GBP",
+		"AUD",
+		"SGD",
+		"JPY",
+		"CHF",
+		"NOK",
+		"DKK",
+		"CAD",
+		"NZD",
+		"HKD",
+		"KRW",
+		"PHP",
+		"MYR",
+		"TWD",
+		"VND",
+		"EGP",
+		"SAR",
+		"THB",
+		"MXN",
+		"TRY",
+		"INR",
+		"BRL",
+		"CNY",
+		"PKR",
+		"PLN",
+		"SEK",
+		"NGN",
+		"AED",
+		"IDR",
+		"BDT",
+		"ILS",
+		"ISK",
+		"MAD",
+		"ZAR",
+		"CZK",
+		"HUF",
+		"RON",
+		"CLP",
+		"QAR",
+		"COP",
+		"RUB",
+		"MWK",
+		"PEN",
+		"BGN",
+		"UAH",
+		"ARS",
+		"MOP",
+		"HRK",
+		"KZT",
+		"ALL",
+		"CRC",
+		"XOF",
+		"KES",
+		"UYU",
+		"LKR",
+		"BOB",
+		"PAB",
+		"GTQ",
+		"DOP",
+		"MMK",
+		"RSD",
+		"BZD",
+		"DZD",
+		"SHP",
+		"HNL",
+		"GEL",
+		"BAM",
+		"MKD",
+		"JMD",
+		"AWG",
+		"BBD",
+		"TTD",
+		"PYG",
+		"XAF"
+	],
+	MX: ["MXN"]
+} };
 /** Stripe's not-two-decimal set (capabilities/stripe-connect.ts:47), incl. the UAE-only five. */
 const STRIPE_NOT_TWO_DECIMAL = [
 	"BIF",
@@ -933,6 +1045,31 @@ function wireStored(m) {
 		units: BigInt(m.amount)
 	};
 }
+const SAFE_LIMIT = BigInt(Number.MAX_SAFE_INTEGER);
+/**
+* A Money's or FractionalMoney's currency entry and its exact stored amount, normalized (scale 0
+* when whole, so a whole amount reads exactly as `wireStored` reads it). A number must be finite
+* and safe when whole, text plain decimal; the amount must round within the safe integers.
+*/
+function wireStoredDecimal(m) {
+	const info = resolveWireCurrency(m.currency);
+	const { amount } = m;
+	if (typeof amount === "string") {
+		const parsed = require_money.parseDecimal(amount, "plain");
+		if (parsed === null) throw new require_money.MoneyError("amount_invalid", `Stored amount must be plain decimal text, got ${require_money.describeValue(amount)}`);
+		if (!require_money.unitsWithin(require_money.roundToScale(parsed, 0, "up"), SAFE_LIMIT)) throw new require_money.MoneyError("amount_invalid", `Stored amount is beyond the safe integers: ${amount}`);
+		return {
+			info,
+			stored: require_money.normalizeDecimal(parsed)
+		};
+	}
+	const parsed = typeof amount === "number" ? require_money.strictNumberDecimal(amount) : null;
+	if (parsed === null) throw new require_money.MoneyError("amount_invalid", `Stored amount must be a safe integer, got ${require_money.describeValue(amount)}`);
+	return {
+		info,
+		stored: require_money.normalizeDecimal(parsed)
+	};
+}
 //#endregion
 //#region src/wire/descriptors.ts
 function digitTable(groups) {
@@ -957,6 +1094,7 @@ const vndOnlyFacade = (code) => code === "VND";
 const NONE = /* @__PURE__ */ new Set();
 const NO_DIGITS = /* @__PURE__ */ new Map();
 function describe(id, input) {
+	const currencies = new Set(input.currencies);
 	return Object.freeze({
 		id,
 		tag: input.tag,
@@ -964,7 +1102,9 @@ function describe(id, input) {
 		gated: input.gated ?? false,
 		encodeGated: input.encodeGated ?? false,
 		preCutoverNeedsFactorOne: input.preCutoverNeedsFactorOne ?? false,
-		currencies: new Set(input.currencies),
+		roundsToStoredUnitFirst: input.roundsToStoredUnitFirst ?? false,
+		currencies,
+		presentmentCurrencies: input.presentmentCurrencies ? new Set(input.presentmentCurrencies) : currencies,
 		digits: input.digits ?? NO_DIGITS,
 		sentAsTwoDecimal: input.sentAsTwoDecimal ? new Set(input.sentAsTwoDecimal) : NONE,
 		sentAsZeroDecimal: input.sentAsZeroDecimal ? new Set(input.sentAsZeroDecimal) : NONE,
@@ -996,7 +1136,9 @@ const PSP_DESCRIPTORS = Object.freeze({
 		family: "iso-minor",
 		gated: true,
 		encodeGated: true,
+		roundsToStoredUnitFirst: true,
 		currencies: STRIPE_SENDABLE,
+		presentmentCurrencies: STRIPE_PRESENTMENT_CURRENCIES,
 		sentAsTwoDecimal: STRIPE_SENT_AS_TWO_DECIMAL
 	}),
 	adyen: describe("adyen", {
@@ -1004,6 +1146,7 @@ const PSP_DESCRIPTORS = Object.freeze({
 		family: "iso-minor",
 		gated: true,
 		encodeGated: true,
+		roundsToStoredUnitFirst: true,
 		currencies: digitTable(ADYEN_CURRENCY_DIGITS).keys(),
 		digits: digitTable(ADYEN_CURRENCY_DIGITS),
 		sentAsTwoDecimal: ADYEN_SENT_AS_TWO_DECIMAL,
@@ -1258,32 +1401,39 @@ function requireConvention(d, convention) {
 }
 function encodeWire(psp, m, options = {}) {
 	const d = pspDescriptor(psp);
-	const { info, units } = wireStored(m);
-	const value = {
-		units,
-		scale: require_money.storageExponent(info)
-	};
+	const { info, stored: held } = wireStoredDecimal(m);
 	facadeCurrency(d, info.code);
 	const label = options.label ?? "amount";
-	const stored = value.units;
-	if (stored < 0n || stored === 0n && !options.allowZero) throw new require_money.MoneyError("wire_refused", `[${d.tag}] Invalid ${label}: ${m.amount}`);
+	const shown = require_money.formatDecimal(held);
+	const exponent = require_money.storageExponent(info);
+	const majorText = require_money.formatDecimal({
+		units: held.units,
+		scale: exponent + held.scale
+	});
+	if (held.units < 0n || held.units === 0n && !options.allowZero) throw new require_money.MoneyError("wire_refused", `[${d.tag}] Invalid ${label}: ${shown}`);
+	const stored = d.roundsToStoredUnitFirst ? require_money.roundToScale(held, 0, "half-up") : held;
+	const positive = held.units > 0n;
 	const factor = d.family === "iso-minor" ? factorOf(d, info) : 1n;
 	if (d.encodeGated && requireConvention(d, options.convention) === "pre-cutover") {
-		if (d.preCutoverNeedsFactorOne && require_money.divRound(stored, factor, "half-up") !== stored) throw new require_money.MoneyError("wire_refused", preCutoverRefusal(d.tag, info.code));
-		return m.amount;
+		if (!(stored.scale === 0 && (!d.preCutoverNeedsFactorOne || require_money.divRound(stored.units, factor, "half-up") === stored.units))) throw new require_money.MoneyError("wire_refused", preCutoverRefusal(d.tag, info.code));
+		if (stored.units === 0n && positive) throw subUnitRefusal(d, info, majorText, exponent, label);
+		return Number(stored.units);
 	}
-	if (d.wholeUnit?.applies(info) && stored % BigInt(info.storageScale) !== 0n) throw new require_money.MoneyError("wire_refused", d.wholeUnit.message(info, m.amount, label, require_money.formatDecimal(value)));
+	if (d.wholeUnit?.applies(info) && stored.units % (BigInt(info.storageScale) * require_money.pow10(stored.scale)) !== 0n) throw new require_money.MoneyError("wire_refused", d.wholeUnit.message(info, shown, label, majorText));
 	const digits = wireDigitsOf(d, info);
 	if (d.family === "iso-minor") {
-		const exact = require_money.divRound(stored, factor, "half-up");
-		if (exact === 0n && stored > 0n) throw subUnitRefusal(d, info, require_money.formatDecimal(value), digits, label);
+		const exact = require_money.divRound(stored.units, factor * require_money.pow10(stored.scale), "half-up");
+		if (exact === 0n && positive) throw subUnitRefusal(d, info, majorText, digits, label);
 		if (!d.threeDecimalStepOfTen || d.digits.get(info.code) !== 3) return Number(exact);
 		const stepped = exact - exact % 10n;
-		if (stepped === 0n && exact > 0n) throw new require_money.MoneyError("wire_refused", roundsToNothing(d.tag, info.code, require_money.formatDecimal(value)));
+		if (stepped === 0n && exact > 0n) throw new require_money.MoneyError("wire_refused", roundsToNothing(d.tag, info.code, majorText));
 		return Number(stepped);
 	}
-	const rounded = require_money.roundToScale(value, digits, "half-up");
-	if (rounded.units === 0n && stored > 0n) throw subUnitRefusal(d, info, require_money.formatDecimal(value), digits, label);
+	const rounded = require_money.roundToScale({
+		units: stored.units,
+		scale: exponent + stored.scale
+	}, digits, "half-up");
+	if (rounded.units === 0n && positive) throw subUnitRefusal(d, info, majorText, digits, label);
 	const text = require_money.formatDecimal(rounded);
 	return d.family === "major-number" ? Number(text) : text;
 }
@@ -1305,11 +1455,13 @@ function roundsToNothing(tag, code, major) {
 function wireDecimal(wire) {
 	return typeof wire === "number" ? require_money.strictNumberDecimal(wire) : require_money.parseDecimal(wire, "plain");
 }
-function decodeWith(d, w, info, kind) {
+/** `w` at storage scale, half-up; with `exact`, a wire naming a fraction of a storage unit throws `amount_invalid`. */
+function decodeWith(d, w, info, kind, exact = false) {
 	const scale = require_money.pow10(w.scale);
 	let multiplier;
 	if (d.family !== "iso-minor") multiplier = BigInt(info.storageScale);
 	else multiplier = kind === "pre-cutover" ? 1n : factorOf(d, info);
+	if (exact && w.units * multiplier % scale !== 0n) throw new require_money.MoneyError("amount_invalid", `[${d.tag}] ${require_money.formatDecimal(w)} is not a whole ${info.code} storage amount`);
 	return require_money.boundedMoney(require_money.mulDiv(w.units, multiplier, scale, "half-up"), info);
 }
 /** VNPay: a positive whole safe integer, as Medusa's `vnpayWireAmountToStorage` reads one. */
@@ -1318,7 +1470,7 @@ function isWholePositive(w) {
 	return w.units > 0n && w.units % scale === 0n && w.units / scale <= BigInt(Number.MAX_SAFE_INTEGER);
 }
 /** Every inbound check: facade currency gate, convention, strict wire text, VNPay's "no amount", the sign. */
-function decodeChecked(d, wire, currency, convention, allowNegative) {
+function decodeChecked(d, wire, currency, convention, allowNegative, exact = false) {
 	if (isBlank(currency)) throw missingCurrency(d);
 	const info = facadeCurrency(d, currency);
 	const kind = d.gated ? requireConvention(d, convention) : null;
@@ -1326,7 +1478,7 @@ function decodeChecked(d, wire, currency, convention, allowNegative) {
 	if (!w) throw new require_money.MoneyError("amount_invalid", `[${d.tag}] Not a wire amount: ${require_money.describeValue(wire)}`);
 	if (d.inboundWholePositive && !isWholePositive(w)) throw new require_money.MoneyError("amount_invalid", `[${d.tag}] No amount: ${d.tag} amounts are positive whole numbers, got ${require_money.describeValue(wire)}`);
 	if (w.units < 0n && !allowNegative) throw new require_money.MoneyError("amount_invalid", `[${d.tag}] Negative wire amount: ${require_money.describeValue(wire)}`);
-	return decodeWith(d, w, info, kind);
+	return decodeWith(d, w, info, kind, exact);
 }
 function decodeWire(psp, wire, currency, convention) {
 	return decodeChecked(pspDescriptor(psp), wire, currency, convention, true);
@@ -1344,13 +1496,25 @@ function tryDecodeWire(psp, wire, currency, options = {}) {
 		return;
 	}
 }
-/** Internal: the major-unit text of `m` at its display digits (the pre-PSP-table ISO spelling). */
+/**
+* Internal: `tryDecodeWire` (no negatives) that is also undefined for a wire naming a fraction of a
+* storage unit (Airwallex 43.004 is not USD 43.00): the comparators' reading of a reported amount.
+*/
+function tryDecodeWireExactly(psp, wire, currency, convention) {
+	try {
+		return decodeChecked(pspDescriptor(psp), wire, currency, convention, false, true);
+	} catch {
+		return;
+	}
+}
+/** Internal: the major-unit text of `m` at its display digits, half-up (the pre-PSP-table ISO spelling). */
 function legacyIsoMajor(m) {
-	const { info, units } = wireStored(m);
-	return require_money.formatDecimal(require_money.roundToScale({
-		units,
-		scale: require_money.storageExponent(info)
-	}, info.displayDigits, "half-up"));
+	const { info, stored } = wireStoredDecimal(m);
+	const major = {
+		units: stored.units,
+		scale: require_money.storageExponent(info) + stored.scale
+	};
+	return require_money.formatDecimal(require_money.roundToScale(major, info.displayDigits, "half-up"));
 }
 /** Internal: one unit of the PSP's last wire digit as Money. */
 function wireUnit(psp, currency, convention) {
@@ -1397,10 +1561,12 @@ function wireBreakdown(psp, total, parts, convention) {
 //#endregion
 //#region src/wire/compare.ts
 /**
-* Whether a PSP-reported amount is `expected`. The expected wire is `encodeWire(psp, expected,
-* { convention, allowZero: true })` (a refusal means false); the reported one must decode
-* (`tryDecodeWire`: strict, never `''` or an exponent, no negatives) to the same stored amount,
-* so `'44.00'` matches a sent `'44'`. Never throws.
+* Whether a PSP-reported amount is `expected`, a Money or a FractionalMoney (Medusa's unrounded
+* session total). The expected wire is `encodeWire(psp, expected, { convention, allowZero: true })`
+* (a refusal means false); the reported one must decode exactly (strict like `tryDecodeWire`:
+* never `''` or an exponent, no negatives, and never a fraction of a storage unit) to the same
+* stored amount, so `'44.00'` matches a sent `'44'` and Airwallex `43.004` does not match `43`.
+* Never throws.
 */
 function sameWireAmount(psp, reported, expected, options = {}) {
 	const { convention } = options;
@@ -1411,7 +1577,7 @@ function sameWireAmount(psp, reported, expected, options = {}) {
 	const targets = expectedTargets(psp, expected, convention, options.acceptLegacyIsoDigits === true);
 	if (targets === null) return false;
 	const { target, legacy } = targets;
-	const decode = (value) => tryDecodeWire(psp, value, expected.currency, { convention });
+	const decode = (value) => options.textOnly && typeof value !== "string" ? void 0 : tryDecodeWireExactly(psp, value, expected.currency, convention);
 	if (options.policy === "requested-exact-collected-covers" && options.requested !== void 0 && options.requested !== null) {
 		const requested = decode(options.requested);
 		const collected = decode(reported);
@@ -1572,6 +1738,53 @@ function eventMoney(m) {
 	};
 }
 //#endregion
+//#region src/wire/presentment.ts
+/** Registry codes only, sorted: a provider-only code (Adyen CNH) or one the registry does not know is left out. */
+function knownCodes(codes) {
+	const known = [];
+	for (const code of codes) {
+		const info = wireCurrency(code);
+		if (info) known.push(info.code);
+	}
+	return known.sort();
+}
+/**
+* The PSP's presentment rules, as data: the union of currencies some account can charge, the
+* currencies that need an account in particular countries, and the account countries limited to
+* a list. For capability declarations that hold the rules themselves; `pspPresentmentCurrencies`
+* applies them to one account. Fresh collections on every call. An unknown PSP throws
+* `wire_unsupported`.
+*/
+function pspPresentment(psp) {
+	const d = pspDescriptor(psp);
+	const requires = PRESENTMENT_REQUIRES_ACCOUNT_COUNTRY[d.id] ?? {};
+	const allowsOnly = PRESENTMENT_ACCOUNT_COUNTRY_ALLOWS_ONLY[d.id] ?? {};
+	return Object.freeze({
+		currencies: new Set(knownCodes(d.presentmentCurrencies)),
+		currencyRequiresAccountCountry: new Map(knownCodes(Object.keys(requires)).map((code) => [code, new Set(requires[code])])),
+		accountCountryAllowsOnly: new Map(Object.keys(allowsOnly).map((country) => [country, new Set(knownCodes(allowsOnly[country]))]))
+	});
+}
+/**
+* The currencies `psp` lets an account present (charge buyers in). Without `accountCountry`, the
+* union over every account country; with it (ISO 3166 alpha-2, any case), only what an account
+* registered there can charge: Stripe's three-decimal five need a UAE account, PayPal's BRL, CNY
+* and MYR an in-country one, Airwallex cards on a US account take its documented 76 and on an MX
+* account MXN only. Not `pspCurrencies`, which is what the codec scales and the facade lets
+* through (Stripe's adds every two-decimal ISO code it accepts on the wire).
+*/
+function pspPresentmentCurrencies(psp, options = {}) {
+	const rules = pspPresentment(psp);
+	if (options.accountCountry === void 0) return rules.currencies;
+	const country = options.accountCountry.trim().toUpperCase();
+	const only = rules.accountCountryAllowsOnly.get(country);
+	const codes = [...rules.currencies].filter((code) => {
+		const required = rules.currencyRequiresAccountCountry.get(code);
+		return (required === void 0 || required.has(country)) && (only === void 0 || only.has(code));
+	});
+	return new Set(codes);
+}
+//#endregion
 //#region src/wire/provider-amount.ts
 /**
 * A provider's major-unit amount (finite number, or text read by the separator engine, which
@@ -1810,6 +2023,18 @@ Object.defineProperty(exports, "pspMinimumAmount", {
 		return pspMinimumAmount;
 	}
 });
+Object.defineProperty(exports, "pspPresentment", {
+	enumerable: true,
+	get: function() {
+		return pspPresentment;
+	}
+});
+Object.defineProperty(exports, "pspPresentmentCurrencies", {
+	enumerable: true,
+	get: function() {
+		return pspPresentmentCurrencies;
+	}
+});
 Object.defineProperty(exports, "pspSupportsCurrency", {
 	enumerable: true,
 	get: function() {

package/dist/{wire-Cd4Q1Jmm.d.ts → wire-CaUN9Vf_.d.ts}

@@ -1,4 +1,4 @@
-import { R as RoundingMode, a as StoredAmount, h as CurrencyCode, r as Money, y as FractionDigits } from "./money-CbhsT0fB.js";
+import { b as FractionDigits, g as CurrencyCode, i as Money, o as StoredAmount, t as FractionalMoney, z as RoundingMode } from "./money-B-3aFjNJ.js";
 //#region src/wire/anet.d.ts
 /**
  * The first `"<field>": <decimal>` (quoted or not) in a raw JSON body, verbatim: `JSON.parse`
@@ -102,26 +102,29 @@ interface EncodeWireOptions {
   allowZero?: boolean;
 }
 /**
- * A stored amount as `psp` receives it. In order: the currency must pass the PSP's Medusa amount
- * facade (`wire_unsupported` with the facade's message: Razorpay only its exponent table, Paystack
- * no zero-decimal code but XOF, MoMo, Payoo and VNPay only VND; every other PSP scales any
- * currency, so call `assertPspCurrency` for eligibility); the amount must be positive
- * (`wire_refused` `[<Tag>] Invalid <label>: <amount>`, zero allowed with `allowZero`); Stripe,
- * Adyen and Razorpay on a pre-cutover payment send the stored integer as is (Razorpay refuses
- * unless its factor is 1; MoMo and Paystack encode ignore the convention, as today); the
- * whole-unit rules refuse fractions of a dong (MoMo, Payoo, VNPay) or a franc (Paystack XOF);
- * then ISO minor `half-up(S / wireFactor)` (Razorpay three-decimal floored to steps of 10), or
- * major units exactly at the PSP's wire digits, half-up, as fixed-point text (a number for
- * Airwallex and Payoo). A positive amount whose wire rounds to zero is refused (`wire_refused`).
+ * A stored amount as `psp` receives it. `m` is a Money or a FractionalMoney (Medusa's unrounded
+ * session totals, 107.8175). In order: the currency must pass the PSP's Medusa amount facade
+ * (`wire_unsupported` with the facade's message: Razorpay only its exponent table, Paystack no
+ * zero-decimal code but XOF, MoMo, Payoo and VNPay only VND; every other PSP scales any currency,
+ * so call `assertPspCurrency` for eligibility); the amount must be positive (`wire_refused`
+ * `[<Tag>] Invalid <label>: <amount>`, zero allowed with `allowZero`); Stripe and Adyen round a
+ * fractional amount half-up to a whole storage unit first; Stripe, Adyen and Razorpay on a
+ * pre-cutover payment send the stored integer as is (Razorpay refuses unless its factor is 1, and
+ * refuses a fractional amount, which has no stored integer; MoMo and Paystack encode ignore the
+ * convention, as today); the whole-unit rules refuse fractions of a dong (MoMo, Payoo, VNPay) or a
+ * franc (Paystack XOF), naming the amount as held; then, rounding once and exactly, ISO minor
+ * `half-up(S / wireFactor)` (Razorpay three-decimal floored to steps of 10), or major units at the
+ * PSP's wire digits, half-up, as fixed-point text (a number for Airwallex and Payoo). A positive
+ * amount whose wire rounds to zero is refused (`wire_refused`), with `allowZero` too.
  * This is package policy, safer than Medusa today: Medusa puts 0 on the wire at initiate for
  * Stripe and Adyen, and for Razorpay, PayPal and Airwallex everywhere; it refuses at refund and
  * capture for Stripe and Adyen, and in Mollie, iyzico and Authorize.Net; Razorpay and Paystack
  * read a zero refund as a full one. Otherwise byte-identical to Medusa's codecs for every Money.
  */
-declare function encodeWire<P extends EncodeGatedPsp>(psp: P, m: Money, options: EncodeWireOptions & {
+declare function encodeWire<P extends EncodeGatedPsp>(psp: P, m: Money | FractionalMoney, options: EncodeWireOptions & {
   convention: Convention;
 }): WireAmount<P>;
-declare function encodeWire<P extends Exclude<PspId, EncodeGatedPsp>>(psp: P, m: Money, options?: EncodeWireOptions): WireAmount<P>;
+declare function encodeWire<P extends Exclude<PspId, EncodeGatedPsp>>(psp: P, m: Money | FractionalMoney, options?: EncodeWireOptions): WireAmount<P>;
 /**
  * A PSP wire amount as Money: ISO minor `half-up(w x wireFactor)` (pre-cutover: `half-up(w)`, the
  * PSP already held storage units), major `half-up(w x storageScale)`. `wire` is a finite number
@@ -155,9 +158,15 @@ interface SameWireAmountOptions {
   convention?: Convention;
   /**
    * Also accept the ISO-digit spelling held by a session created before the PSP digit tables
-   * (PayPal, Mollie, Airwallex HUF/TWD...).
+   * (PayPal, Mollie, Airwallex HUF/TWD...): the expected amount in major units at its display
+   * digits, half-up (HUF 44.50 went as `'45'`). Major-unit PSPs only.
    */
   acceptLegacyIsoDigits?: boolean;
+  /**
+   * The PSP only ever reports decimal text (Mollie, PayPal): a reported (or `requested`) value
+   * that is not a string is not its amount, whatever number it holds.
+   */
+  textOnly?: boolean;
   /** When given, it must be the same currency as `expected` (any case). */
   reportedCurrency?: unknown;
   /** Paystack fee pass-through: the amount the buyer was asked for. */
@@ -169,12 +178,14 @@ interface SameWireAmountOptions {
   policy?: 'exact' | 'requested-exact-collected-covers';
 }
 /**
- * Whether a PSP-reported amount is `expected`. The expected wire is `encodeWire(psp, expected,
- * { convention, allowZero: true })` (a refusal means false); the reported one must decode
- * (`tryDecodeWire`: strict, never `''` or an exponent, no negatives) to the same stored amount,
- * so `'44.00'` matches a sent `'44'`. Never throws.
+ * Whether a PSP-reported amount is `expected`, a Money or a FractionalMoney (Medusa's unrounded
+ * session total). The expected wire is `encodeWire(psp, expected, { convention, allowZero: true })`
+ * (a refusal means false); the reported one must decode exactly (strict like `tryDecodeWire`:
+ * never `''` or an exponent, no negatives, and never a fraction of a storage unit) to the same
+ * stored amount, so `'44.00'` matches a sent `'44'` and Airwallex `43.004` does not match `43`.
+ * Never throws.
  */
-declare function sameWireAmount(psp: PspId, reported: unknown, expected: Money, options?: SameWireAmountOptions): boolean;
+declare function sameWireAmount(psp: PspId, reported: unknown, expected: Money | FractionalMoney, options?: SameWireAmountOptions): boolean;
 /**
  * One unit of the PSP's last wire digit, as Money: for ISO-minor PSPs `decodeWire(psp, 1)` (the
  * factor on an iso-minor-v2 payment, 1 storage unit on a pre-cutover one; gated PSPs need the
@@ -213,6 +224,35 @@ interface EventMoney {
 /** First-party analytics money: the stored integer and the lower-case code (the ClickHouse `Int64` contract). */
 declare function eventMoney(m: Money): EventMoney;
 //#endregion
+//#region src/wire/presentment.d.ts
+interface PspPresentment {
+  /** Every currency some account of the PSP can present: the union over account countries. */
+  readonly currencies: ReadonlySet<CurrencyCode>;
+  /** Currencies only accounts registered in these countries can present (Stripe KWD: AE; PayPal BRL: BR). */
+  readonly currencyRequiresAccountCountry: ReadonlyMap<CurrencyCode, ReadonlySet<string>>;
+  /** Account countries limited to these currencies (Airwallex cards on a US or MX account). */
+  readonly accountCountryAllowsOnly: ReadonlyMap<string, ReadonlySet<CurrencyCode>>;
+}
+/**
+ * The PSP's presentment rules, as data: the union of currencies some account can charge, the
+ * currencies that need an account in particular countries, and the account countries limited to
+ * a list. For capability declarations that hold the rules themselves; `pspPresentmentCurrencies`
+ * applies them to one account. Fresh collections on every call. An unknown PSP throws
+ * `wire_unsupported`.
+ */
+declare function pspPresentment(psp: PspId): PspPresentment;
+/**
+ * The currencies `psp` lets an account present (charge buyers in). Without `accountCountry`, the
+ * union over every account country; with it (ISO 3166 alpha-2, any case), only what an account
+ * registered there can charge: Stripe's three-decimal five need a UAE account, PayPal's BRL, CNY
+ * and MYR an in-country one, Airwallex cards on a US account take its documented 76 and on an MX
+ * account MXN only. Not `pspCurrencies`, which is what the codec scales and the facade lets
+ * through (Stripe's adds every two-decimal ISO code it accepts on the wire).
+ */
+declare function pspPresentmentCurrencies(psp: PspId, options?: {
+  accountCountry?: string;
+}): ReadonlySet<CurrencyCode>;
+//#endregion
 //#region src/wire/provider-amount.d.ts
 interface ProviderAmountOptions {
   /** Accept a negative amount (refunds, credits). Default false. */
@@ -266,4 +306,4 @@ declare function slotMoney(m: Money): SlotMoney;
  */
 declare function readSlotMoney(context: unknown): SlotMoney | undefined;
 //#endregion
-export { tryDecodeWire as A, EncodeGatedPsp as B, decodeWire as C, pspMinimumAmount as D, pspDefaultCurrency as E, PRE_CUTOVER as F, PSP_IDS as G, IsoMinorPsp as H, WIRE_SCALE_ISO_MINOR_V2 as I, AuthorizeNetAmounts as J, PspId as K, WIRE_SCALE_KEY as L, wireBreakdown as M, Convention as N, pspSupportsCurrency as O, ISO_MINOR_V2 as P, WIRE_SCALE_MARKER as R, assertPspCurrency as S, pspCurrencies as T, MajorNumberPsp as U, GatedPsp as V, MajorStringPsp as W, jsonDecimalLiteral as X, authorizeNetReversibleAmount as Y, oneWireUnit as _, iyzicoPrice as a, EncodeWireOptions as b, parseProviderAmount as c, destinationAmount as d, eventMoney as f, SameWireAmountOptions as g, DestinationId as h, RAZORPAY_AFA_FREE_CAP as i, wireFactor as j, pspWireDigits as k, DestinationValue as l, googleMicros as m, readSlotMoney as n, verificationCharge as o, feedPrice as p, WireAmount as q, slotMoney as r, ProviderAmountOptions as s, SlotMoney as t, EventMoney as u, sameWireAmount as v, encodeWire as w, TryDecodeWireOptions as x, wireKeyPart as y, conventionOf as z };
+export { jsonDecimalLiteral as $, pspMinimumAmount as A, WIRE_SCALE_KEY as B, EncodeWireOptions as C, encodeWire as D, decodeWire as E, wireBreakdown as F, IsoMinorPsp as G, conventionOf as H, Convention as I, PSP_IDS as J, MajorNumberPsp as K, ISO_MINOR_V2 as L, pspWireDigits as M, tryDecodeWire as N, pspCurrencies as O, wireFactor as P, authorizeNetReversibleAmount as Q, PRE_CUTOVER as R, wireKeyPart as S, assertPspCurrency as T, EncodeGatedPsp as U, WIRE_SCALE_MARKER as V, GatedPsp as W, WireAmount as X, PspId as Y, AuthorizeNetAmounts as Z, googleMicros as _, iyzicoPrice as a, oneWireUnit as b, parseProviderAmount as c, pspPresentmentCurrencies as d, DestinationValue as f, feedPrice as g, eventMoney as h, RAZORPAY_AFA_FREE_CAP as i, pspSupportsCurrency as j, pspDefaultCurrency as k, PspPresentment as l, destinationAmount as m, readSlotMoney as n, verificationCharge as o, EventMoney as p, MajorStringPsp as q, slotMoney as r, ProviderAmountOptions as s, SlotMoney as t, pspPresentment as u, DestinationId as v, TryDecodeWireOptions as w, sameWireAmount as x, SameWireAmountOptions as y, WIRE_SCALE_ISO_MINOR_V2 as z };