@amboras-dev/money 0.1.0 → 0.3.0

package/dist/wire-CtNJmWVP.d.cts

@@ -0,0 +1,428 @@
+import { b as FractionDigits, g as CurrencyCode, i as Money, o as StoredAmount, t as FractionalMoney, z as RoundingMode } from "./money-BkMeYDEW.cjs";
+/** paystack.com/docs/api/#supported-currency (retrieved 2026-10-07): every currency a Paystack account can charge. */
+declare const PAYSTACK_CURRENCIES: readonly ["GHS", "KES", "NGN", "USD", "XOF", "ZAR"];
+declare const IYZICO_CURRENCIES: readonly ["TRY", "USD", "EUR", "GBP", "NOK", "CHF"];
+/** developer.authorize.net createTransactionRequest `currencyCode`, retrieved 2026-10-07. */
+declare const AUTHORIZE_NET_CURRENCIES: readonly ["USD", "CAD", "GBP", "EUR", "AUD", "NZD", "DKK", "NOK", "SEK", "PLN"];
+/**
+ * The first `"<field>": <decimal>` (quoted or not) in a raw JSON body, verbatim: `JSON.parse`
+ * would turn the gateway's `43.00` into `43`. The value is the whole JSON token, held to
+ * `parseDecimal`'s `'plain'` grammar (`1e3` or `"43.10abc"` is not a decimal literal).
+ * Undefined when absent; there is no lossy fallback.
+ */
+declare function jsonDecimalLiteral(rawBody: string, field: string): string | undefined;
+/**
+ * What an unsettled Authorize.Net transaction can still be reversed for: the settle amount when
+ * present and above zero (exact), else `authAmount ?? settleAmount` (settle is `'0.00'`, not
+ * absent, for voided or unsettled transactions). Undefined when both are absent.
+ */
+interface AuthorizeNetAmounts {
+  settleAmount?: string | null;
+  authAmount?: string | null;
+}
+declare function authorizeNetReversibleAmount(details: AuthorizeNetAmounts): string | undefined;
+type PspId = 'stripe' | 'adyen' | 'razorpay' | 'paystack' | 'momo' | 'vnpay' | 'paypal' | 'mollie' | 'airwallex' | 'iyzico' | 'authorize-net' | 'payoo';
+/** ISO minor units, marker-gated decode: a payment created before the cutover holds storage units at the PSP. */
+type GatedPsp = 'stripe' | 'adyen' | 'razorpay' | 'paystack' | 'momo';
+/** Gated PSPs whose encode is gated too; MoMo and Paystack always encode ISO minor units. */
+type EncodeGatedPsp = 'stripe' | 'adyen' | 'razorpay';
+type IsoMinorPsp = GatedPsp | 'vnpay';
+type MajorStringPsp = 'paypal' | 'mollie' | 'iyzico' | 'authorize-net';
+type MajorNumberPsp = 'airwallex' | 'payoo';
+/** What a PSP receives: major-unit text for PayPal, Mollie, iyzico and Authorize.Net, a number for the rest. */
+type WireAmount<P extends PspId> = P extends MajorStringPsp ? string : number;
+/** The currencies Authorize.Net settles (createTransactionRequest `currencyCode`). */
+type AuthorizeNetCurrency = (typeof AUTHORIZE_NET_CURRENCIES)[number];
+type IyzicoCurrency = (typeof IYZICO_CURRENCIES)[number];
+type PaystackCurrency = (typeof PAYSTACK_CURRENCIES)[number];
+type VndOnlyPsp = 'momo' | 'vnpay' | 'payoo';
+/**
+ * A currency `P` takes, as a type: the literal union for the PSPs with a short fixed list
+ * (Authorize.Net, iyzico, Paystack, the VND rails), else any `CurrencyCode`. Always a
+ * `CurrencyCode` too, so it can be passed wherever one is wanted.
+ */
+type PspCurrency<P extends PspId> = CurrencyCode & (P extends 'authorize-net' ? AuthorizeNetCurrency : P extends 'iyzico' ? IyzicoCurrency : P extends 'paystack' ? PaystackCurrency : P extends VndOnlyPsp ? 'VND' : string);
+/** Every PSP id, in a stable order. */
+declare const PSP_IDS: readonly PspId[];
+declare const WIRE_SCALE_KEY = "amboras_wire_scale";
+declare const WIRE_SCALE_ISO_MINOR_V2 = "iso-minor-v2";
+declare const WIRE_SCALE_MARKER: Readonly<{
+  amboras_wire_scale: 'iso-minor-v2';
+}>;
+/** Which convention a payment was created under. Use the two singletons; build one with `conventionOf`. */
+type Convention = {
+  readonly kind: 'iso-minor-v2';
+} | {
+  readonly kind: 'pre-cutover';
+};
+declare const ISO_MINOR_V2: Convention;
+declare const PRE_CUTOVER: Convention;
+/**
+ * `ISO_MINOR_V2` iff ANY record is a non-null object whose `amboras_wire_scale` is strictly
+ * `'iso-minor-v2'` (a Stripe charge OR its PaymentIntent); else `PRE_CUTOVER`. Reads already
+ * fetched records only: it never queries (FORCE RLS would hide the row and the marker with it).
+ */
+declare function conventionOf(...records: unknown[]): Convention;
+declare const WIRE_ROUNDING_KEY = "amboras_wire_rounding";
+declare const WIRE_ROUNDING_EXACT = "exact";
+declare const WIRE_ROUNDING_MARKER: Readonly<{
+  amboras_wire_rounding: 'exact';
+}>;
+/**
+ * Whether a payment may be held at the PSP in Medusa's pre-0.2.0 float spelling: no record is a
+ * non-null object whose `amboras_wire_rounding` is strictly `'exact'`. Pass the result as
+ * `sameWireAmount`'s `acceptLegacyFloatRounding`, so only sessions created before the deploy get
+ * the legacy spelling. Reads already fetched records only.
+ */
+declare function mayHoldLegacyFloatRounding(...records: unknown[]): boolean;
+/**
+ * `total` and its `parts` (same currency, non-negative, adding up to `total`) as integer wire
+ * amounts whose sum is exactly `encodeWire(psp, total)`: the wire total split by largest
+ * remainder over the stored parts. Throws `currency_mismatch`, `amount_invalid` (parts that do not
+ * add up, or a negative part) or whatever `encodeWire` refuses.
+ */
+declare function wireBreakdown(psp: IsoMinorPsp, total: Money, parts: Readonly<Record<string, Money>>, convention: Convention): {
+  total: number;
+  parts: Record<string, number>;
+};
+/** Whether `psp` takes `currency` (any case, historic codes included). Never throws for a bad code. */
+declare function pspSupportsCurrency(psp: PspId, currency: string): boolean;
+/**
+ * Every currency `psp` takes. Provider-only codes a PSP table lists (Adyen offshore CNH) are left
+ * out: they are not ISO 4217 currencies, no store sells in them and no Money can carry them.
+ */
+declare function pspCurrencies(psp: PspId): ReadonlySet<CurrencyCode>;
+/**
+ * `currency` as a CurrencyCode `psp` takes. Empty throws `currency_missing` (`[<Tag>] Cannot
+ * scale an amount without a currency code; ...`); anything the PSP does not take throws
+ * `wire_unsupported` with the provider's own message. Typed as the PSP's literal union where it
+ * has a short fixed list (`assertPspCurrency('authorize-net', c)` is an `AuthorizeNetCurrency`).
+ */
+declare function assertPspCurrency<P extends PspId>(psp: P, currency: unknown): PspCurrency<P>;
+/** `'VND'` for the single-currency providers (MoMo, Payoo, VNPay), else null. */
+declare function pspDefaultCurrency(psp: PspId): CurrencyCode | null;
+/**
+ * The currency every account of `psp` charges without enabling anything (any other needs the
+ * account's international or multi-currency add-on, or is never taken): Razorpay INR, iyzico TRY,
+ * and for the single-currency PSPs their one currency (MoMo, VNPay and Payoo VND). Null for PSPs
+ * whose accounts have no single home currency (Stripe, Adyen, PayPal, Mollie, Airwallex, Authorize.Net, and Paystack, whose home currency is the
+ * account country's: `pspPresentment('paystack').accountCountries`). Unlike `pspDefaultCurrency`,
+ * which is non-null only for the single-currency PSPs, a home currency does not mean the PSP takes
+ * nothing else.
+ */
+declare function pspHomeCurrency(psp: PspId): CurrencyCode | null;
+/**
+ * The one country (ISO 3166 alpha-2) every account of `psp` is registered in, for PSPs whose
+ * accounts are all registered in a single country: iyzico `'TR'`, MoMo, VNPay and Payoo `'VN'`. Null
+ * for PSPs available in several countries: Razorpay (India, Malaysia, Singapore, the United States)
+ * and Paystack (its country follows the account: `pspAccountCountryForCurrency`).
+ */
+declare function pspHomeCountry(psp: PspId): string | null;
+/**
+ * Stored units per wire unit for an ISO-minor PSP: the PSP's override (Stripe ISK/UGX, Adyen
+ * ISK/CLP, Razorpay MGA, Paystack XOF, VNPay VND give 1; Adyen IDR/CVE give 100), else
+ * `storageScale / 10^storageDigits` (100 for a zero-decimal currency, else 1).
+ */
+declare function wireFactor(psp: IsoMinorPsp, currency: string): 1 | 100;
+/**
+ * Fraction digits of `psp`'s wire amount: its digit table, else (ISO-minor PSPs) the digits
+ * its factor implies, else (iyzico, Authorize.Net, Payoo) the display digits. Null when the
+ * PSP does not take the currency.
+ */
+declare function pspWireDigits(psp: PspId, currency: string): FractionDigits | null;
+/** The PSP's minimum charge in `currency` (Paystack USD 2.00), or null when it has none. */
+declare function pspMinimumAmount(psp: PspId, currency: string): Money | null;
+interface EncodeWireOptions {
+  /** Names the amount in refusals: `[<Tag>] Invalid <label>: <amount>`. Default `'amount'`; refunds pass `'refund amount'`. */
+  label?: string;
+  /** Allow a zero amount (verification, comparisons). Negative amounts are always refused. */
+  allowZero?: boolean;
+}
+/**
+ * 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 | FractionalMoney, options: EncodeWireOptions & {
+  convention: Convention;
+}): WireAmount<P>;
+declare function encodeWire<P extends Exclude<PspId, EncodeGatedPsp>>(psp: P, m: Money | FractionalMoney, options?: EncodeWireOptions): WireAmount<P>;
+interface DecodeWireOptions {
+  /** Required for gated PSPs (Stripe, Adyen, Razorpay, Paystack, MoMo); ignored by the rest. */
+  convention?: Convention;
+  /**
+   * Accept a negative wire amount (signed balance transactions, reversals). Default false, as in
+   * `tryDecodeWire`: a negative wire throws `amount_invalid` (`[<Tag>] Negative wire amount: <wire>`).
+   * Never for VNPay, whose amounts are positive whole numbers.
+   */
+  allowNegative?: boolean;
+}
+/** `tryDecodeWire` takes the same options as `decodeWire`. */
+type TryDecodeWireOptions = DecodeWireOptions;
+/**
+ * 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
+ * or strict decimal text (`/^-?\d+(\.\d+)?$/`: no `''`, exponent or hex), else `amount_invalid`.
+ * Gated PSPs need `options.convention` (no hidden default: without it `wire_refused`).
+ * A negative wire throws `amount_invalid` unless `allowNegative: true` (checked on the exact wire
+ * value before rounding, so `-0.001` is refused too; `-0` is zero), and for VNPay anything but a
+ * positive whole number is no amount (`amount_invalid`).
+ * The options are one object: anything else as the fourth argument (a positional Convention, as in
+ * 0.2.0) or any fifth argument throws `wire_refused`, so no option is ever silently dropped.
+ * The currency is required (`currency_missing`), must be known (`currency_invalid`), must not be
+ * provider-only (Adyen CNH: `wire_unsupported`), and must pass the PSP's Medusa inbound gate
+ * (`wire_unsupported` with its message: Razorpay only its exponent table, Paystack no
+ * zero-decimal code but XOF, MoMo, Payoo and VNPay only VND). Other PSPs read any currency (a PSP
+ * may report a settlement currency).
+ */
+declare function decodeWire<P extends GatedPsp>(psp: P, wire: unknown, currency: string, options: DecodeWireOptions & {
+  convention: Convention;
+}): Money;
+declare function decodeWire<P extends Exclude<PspId, GatedPsp>>(psp: P, wire: unknown, currency: string, options?: DecodeWireOptions): Money;
+/**
+ * `decodeWire` that never throws: undefined wherever it would throw (null, undefined, `''`,
+ * whitespace, unparseable or unsafe input, a missing, unknown or provider-only currency, one the
+ * PSP's inbound gate refuses, VNPay's "no amount", an unknown PSP, a gated PSP without
+ * `convention`: no hidden default) and for a negative amount unless `allowNegative`.
+ */
+declare function tryDecodeWire(psp: PspId, wire: unknown, currency: unknown, options?: TryDecodeWireOptions): Money | undefined;
+interface SameWireAmountOptions {
+  /** Required for gated PSPs (Stripe, Adyen, Razorpay, Paystack, MoMo); without it the answer is false. */
+  convention?: Convention;
+  /**
+   * Also accept the ISO-digit spelling held by a session created before the PSP digit tables
+   * (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;
+  /**
+   * Also accept the spelling Medusa's pre-0.2.0 float codec sent for a PSP that encoded in
+   * floating point (PayPal, Mollie, Airwallex, iyzico, Authorize.Net, Payoo): major units as
+   * `(stored / storageScale).toFixed(wireDigits)` on a double. It differs from today's only at an
+   * exact tie the double sits just below (USD 1072.5 went as `'10.72'`, 0.2.0 sends `'10.73'`),
+   * so a payment created before 0.2.0 still compares. With `acceptLegacyIsoDigits` the float
+   * spelling at the display digits is accepted too. Ignored for every other PSP.
+   */
+  acceptLegacyFloatRounding?: 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. */
+  requested?: unknown;
+  /**
+   * `'exact'` (default), or `'requested-exact-collected-covers'`: `requested` is exactly the
+   * expected amount and the collected `reported` covers it.
+   */
+  policy?: 'exact' | 'requested-exact-collected-covers';
+}
+/**
+ * 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 | 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
+ * convention), for major PSPs `10^-wireDigits` major. The tolerance for `excessOver`.
+ */
+declare function oneWireUnit(psp: PspId, currency: string, convention?: Convention): Money;
+/** The wire amount as it goes into Redis skip keys and idempotency keys: `String(wire)`, byte for byte. */
+declare function wireKeyPart(wire: number | string): string;
+type DestinationId = 'meta' | 'ga4' | 'google-ads' | 'tiktok' | 'snapchat' | 'pinterest' | 'klaviyo' | 'omnisend' | 'omnisend-viewed-product' | 'mailchimp' | 'goaffpro' | 'profitmetrics' | 'pixi' | 'flow' | 'sendcloud' | 'shipstation' | 'shiprocket' | 'shipbob' | 'printful' | 'ahamove' | 'amazon-mcf' | 'skydropx' | 'royal-mail' | 'sevdesk' | 'shopify-ajax';
+interface DestinationValue {
+  readonly value: number | string;
+  readonly currency: string;
+}
+/**
+ * `m` as `dest` wants it: major units at the display digits (half-up) as a number or text per
+ * destination (`as` overrides), or integer "cents" for Shopify AJAX and Omnisend `viewed product`;
+ * the currency upper- or lower-case per destination. Undefined when the destination must not get
+ * this amount (Meta: not positive; GA4, Google Ads, TikTok, Snapchat, Pinterest and marketing:
+ * negative). Throws `wire_unsupported` for a currency the destination's unit is not defined for.
+ */
+declare function destinationAmount(dest: DestinationId, m: Money, options?: {
+  as?: 'number' | 'string';
+}): DestinationValue | undefined;
+/** A shopping-feed price: `'12.345 KWD'`, `'1200 JPY'`, `'19.99 USD'` (display digits, half-up). */
+declare function feedPrice(m: Money): string;
+/** Google micros (major x 10^6) as integer text, exactly: USD 1999 gives `'19990000'`. */
+declare function googleMicros(m: Money): string;
+interface EventMoney {
+  readonly value: number;
+  readonly currency: string;
+}
+/** First-party analytics money: the stored integer and the lower-case code (the ClickHouse `Int64` contract). */
+declare function eventMoney(m: Money): EventMoney;
+interface LegacyFloatRefundInput {
+  /** What Medusa records as captured on the payment. */
+  captured: Money | FractionalMoney;
+  /** What Medusa has refunded of that capture so far (a zero amount when nothing). */
+  refunded: Money | FractionalMoney;
+  /** The refund Medusa is about to send. */
+  refund: Money | FractionalMoney;
+  /** The capture as the PSP reports it, wire value as read (`'10.72'`). */
+  capturedWire: unknown;
+  /** What the PSP reports as already refunded of that capture, wire value as read (`'0.00'` or 0 when nothing). */
+  refundedWire: unknown;
+}
+interface LegacyFloatRefund {
+  /** What to send instead of `encodeWire(psp, refund)`. */
+  readonly wire: number | string;
+  /** The same amount as Money: what Medusa records on the refund row. */
+  readonly money: Money;
+}
+/**
+ * The PSP's remaining amount, to refund instead of `refund`, when the PSP holds the capture only
+ * in Medusa's pre-0.2.0 float spelling (`legacyFloatToFixed` PSPs: USD 1072.5 captured as
+ * `'10.72'`, where today's spelling is `'10.73'`) and `refund` is Medusa's whole remaining amount
+ * (`captured - refunded`, exactly). Medusa's remaining then encodes one wire unit above what the
+ * PSP still holds (after a `'0.72'` refund, Medusa's 1000.5 is `'10.01'` against the PSP's
+ * `'10.00'`), and the PSP refuses it (NOT_ALLOWED), so the refund could never complete.
+ * Returns `{ wire, money }` for the PSP's remaining (`'10.00'`, USD 1000), never more than it and
+ * never more than one legacy rounding below what `refund` encodes to. Null (send `refund` as
+ * is) for every other case: a PSP that never encoded in floating point, a capture that matches
+ * today's spelling or no spelling, a partial refund, a refund that already fits, mixed
+ * currencies, and any amount or PSP fact that cannot be read. Never throws.
+ */
+declare function legacyFloatRefundClamp(psp: PspId, input: LegacyFloatRefundInput): LegacyFloatRefund | null;
+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 account countries the PSP onboards, where each charges its own list (Paystack): what an
+   * account there always presents, and what it presents only once enabled on the account (Paystack
+   * USD on NG and KE accounts). Empty for every PSP without per-country lists.
+   */
+  readonly accountCountries: ReadonlyMap<string, PspAccountCountry>;
+  /**
+   * Per account currency that names one account country, the opt-in currencies an account in
+   * that country can add (Paystack NGN and KES: USD). Only currencies with a companion are keys.
+   */
+  readonly optInCompanions: ReadonlyMap<CurrencyCode, ReadonlySet<CurrencyCode>>;
+}
+interface PspAccountCountry {
+  /** What every account registered in the country presents. */
+  readonly currencies: ReadonlySet<CurrencyCode>;
+  /** What it presents only once the merchant has enabled it on the account (no API reports it). */
+  readonly optIn: 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 account country a currency names for `psp`: the one country whose accounts present it
+ * (Paystack NGN: `'NG'`, XOF: `'CI'`, the only XOF country Paystack onboards). Null when several
+ * countries' accounts can present it (Paystack USD, on NG and KE accounts), when the PSP has no
+ * per-country lists, or for an unknown code. Never throws for a bad code; an unknown PSP throws
+ * `wire_unsupported`.
+ */
+declare function pspAccountCountryForCurrency(psp: PspId, currency: unknown): string | null;
+interface PresentmentOptions {
+  /** ISO 3166 alpha-2, any case: only what an account registered there can present. */
+  accountCountry?: string;
+  /** With `accountCountry`, add the country's opt-in currencies (the merchant enabled them). Default false. */
+  includeOptIn?: boolean;
+}
+/**
+ * The currencies `psp` lets an account present (charge buyers in). Without `accountCountry`, the
+ * union over every account country, opt-in currencies included; 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, a Paystack account its country's currency (plus USD
+ * on NG and KE with `includeOptIn`, and nothing for a country Paystack does not onboard). 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?: PresentmentOptions): ReadonlySet<CurrencyCode>;
+interface ProviderAmountOptions {
+  /** Accept a negative amount (refunds, credits). Default false. */
+  allowNegative?: boolean;
+  /** Default `'.'`; `'auto'` decides from the text (see the core separator engine). */
+  decimalSeparator?: '.' | ',' | 'auto';
+  /** Read the first number and ignore the rest (`'22.67 + KDV'`). Default false. */
+  allowTrailingText?: boolean;
+  /** Rounding to the currency's storage digits (and the 'auto' whole-unit rounding). Default `'half-up'`. */
+  rounding?: RoundingMode;
+}
+/**
+ * A provider's major-unit amount (finite number, or text read by the separator engine, which
+ * strips the currency's symbol and code) as Money, rounded once to the storage digits. Null on
+ * anything invalid (empty, unparseable, non-finite, negative without `allowNegative`, too large,
+ * unknown currency), never 0.
+ */
+declare function parseProviderAmount(value: unknown, currency: string, options?: ProviderAmountOptions): Money | null;
+/** RBI e-mandate cap Razorpay token registrations carry as `max_amount`: INR 15,000 (1,500,000 paise = stored). */
+declare const RAZORPAY_AFA_FREE_CAP: Money;
+type VerificationPsp = 'paystack' | 'razorpay' | 'mollie' | 'adyen';
+/** The verification PSPs with a documented currency (`VERIFICATION_CURRENCY`): the charge may omit it. */
+type VerificationDefaultPsp = 'razorpay' | 'mollie';
+/**
+ * The symbolic charge a saved-card setup makes: Paystack one major unit, Razorpay one INR (any
+ * other currency is `wire_unsupported`), Mollie one smallest wire unit (`'0.01'`, `'1'` for ISK
+ * and JPY), Adyen zero. Vault charges are always new, so the iso-minor-v2 convention applies.
+ * `currency` may be left out (undefined only; `''` and null still throw `currency_missing`) for
+ * the PSPs that document a currency every account takes: Razorpay INR (recurring is INR only),
+ * Mollie EUR (every Mollie card method takes it). Adyen and Paystack have none, so their
+ * callers pass one: an Adyen fallback is the caller's policy (any currency the merchant account
+ * processes verifies a zero amount), not an Adyen fact.
+ */
+declare function verificationCharge(psp: VerificationDefaultPsp, currency?: string): {
+  wire: number | string;
+  money: Money;
+};
+declare function verificationCharge(psp: VerificationPsp, currency: string): {
+  wire: number | string;
+  money: Money;
+};
+/**
+ * iyzico's price spelling, on the text (no float): canonical decimal (no trailing fraction zeros),
+ * then `'.0'` when there is no `.` (`'10.50'` gives `'10.5'`, `'10.00'` gives `'10.0'`). Text that
+ * is not a plain decimal throws `parse`.
+ */
+declare function iyzicoPrice(wire: string): string;
+interface SlotMoney {
+  readonly amount: StoredAmount;
+  /** Lower-case, as Medusa spells it. */
+  readonly currency_code: string;
+}
+/** `m` for a slot context's `money` key. */
+declare function slotMoney(m: Money): SlotMoney;
+/**
+ * The money a slot context carries: `context.money` when it is valid, else the legacy
+ * `total ?? price` with the first known of `currency_code`, `currency`, read leniently (numbers, numeric text,
+ * Medusa BigNumber shapes). Undefined when the amount or the currency is missing or unreadable.
+ */
+declare function readSlotMoney(context: unknown): SlotMoney | undefined;
+export { WIRE_SCALE_ISO_MINOR_V2 as $, wireKeyPart as A, pspHomeCurrency as B, eventMoney as C, SameWireAmountOptions as D, DestinationId as E, decodeWire as F, wireFactor as G, pspSupportsCurrency as H, encodeWire as I, ISO_MINOR_V2 as J, wireBreakdown as K, pspCurrencies as L, EncodeWireOptions as M, TryDecodeWireOptions as N, oneWireUnit as O, assertPspCurrency as P, WIRE_ROUNDING_MARKER as Q, pspDefaultCurrency as R, destinationAmount as S, googleMicros as T, pspWireDigits as U, pspMinimumAmount as V, tryDecodeWire as W, WIRE_ROUNDING_EXACT as X, PRE_CUTOVER as Y, WIRE_ROUNDING_KEY as Z, LegacyFloatRefund as _, AuthorizeNetAmounts as _t, VerificationDefaultPsp as a, EncodeGatedPsp as at, DestinationValue as b, PAYSTACK_CURRENCIES as bt, verificationCharge as c, IyzicoCurrency as ct, PresentmentOptions as d, PSP_IDS as dt, WIRE_SCALE_KEY as et, PspAccountCountry as f, PaystackCurrency as ft, pspPresentmentCurrencies as g, WireAmount as gt, pspPresentment as h, VndOnlyPsp as ht, RAZORPAY_AFA_FREE_CAP as i, AuthorizeNetCurrency as it, DecodeWireOptions as j, sameWireAmount as k, ProviderAmountOptions as l, MajorNumberPsp as lt, pspAccountCountryForCurrency as m, PspId as mt, readSlotMoney as n, conventionOf as nt, VerificationPsp as o, GatedPsp as ot, PspPresentment as p, PspCurrency as pt, Convention as q, slotMoney as r, mayHoldLegacyFloatRounding as rt, iyzicoPrice as s, IsoMinorPsp as st, SlotMoney as t, WIRE_SCALE_MARKER as tt, parseProviderAmount as u, MajorStringPsp as ut, LegacyFloatRefundInput as v, authorizeNetReversibleAmount as vt, feedPrice as w, EventMoney as x, legacyFloatRefundClamp as y, jsonDecimalLiteral as yt, pspHomeCountry as z };