@amboras-dev/money 0.2.0 → 0.4.0

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

@@ -1,5 +1,9 @@
-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
+import { b as FractionDigits, g as CurrencyCode, i as Money, o as StoredAmount, t as FractionalMoney, z as RoundingMode } from "./money-BkMeYDEW.js";
+/** 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
@@ -17,8 +21,6 @@ interface AuthorizeNetAmounts {
   authAmount?: string | null;
 }
 declare function authorizeNetReversibleAmount(details: AuthorizeNetAmounts): string | undefined;
-//#endregion
-//#region src/wire/descriptors.d.ts
 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';
@@ -29,10 +31,19 @@ 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[];
-//#endregion
-//#region src/wire/marker.d.ts
 declare const WIRE_SCALE_KEY = "amboras_wire_scale";
 declare const WIRE_SCALE_ISO_MINOR_V2 = "iso-minor-v2";
 declare const WIRE_SCALE_MARKER: Readonly<{
@@ -52,8 +63,18 @@ declare const PRE_CUTOVER: Convention;
  * fetched records only: it never queries (FORCE RLS would hide the row and the marker with it).
  */
 declare function conventionOf(...records: unknown[]): Convention;
-//#endregion
-//#region src/wire/breakdown.d.ts
+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
@@ -64,8 +85,6 @@ declare function wireBreakdown(psp: IsoMinorPsp, total: Money, parts: Readonly<R
   total: number;
   parts: Record<string, number>;
 };
-//#endregion
-//#region src/wire/codec.d.ts
 /** Whether `psp` takes `currency` (any case, historic codes included). Never throws for a bad code. */
 declare function pspSupportsCurrency(psp: PspId, currency: string): boolean;
 /**
@@ -76,11 +95,29 @@ 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.
+ * `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(psp: PspId, currency: unknown): CurrencyCode;
+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
@@ -125,25 +162,38 @@ declare function encodeWire<P extends EncodeGatedPsp>(psp: P, m: Money | Fractio
   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`.
- * Signed, except VNPay, where anything but a positive whole number is no amount (`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, convention: Convention): Money;
-declare function decodeWire<P extends Exclude<PspId, GatedPsp>>(psp: P, wire: unknown, currency: string): Money;
-interface TryDecodeWireOptions {
-  /** Required for gated PSPs (Stripe, Adyen, Razorpay, Paystack, MoMo): without it the result is undefined. */
-  convention?: Convention;
-  /** Accept a negative wire amount (balance transactions, reversals). Default false; never for VNPay. */
-  allowNegative?: boolean;
-}
+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
@@ -151,8 +201,6 @@ interface TryDecodeWireOptions {
  * `convention`: no hidden default) and for a negative amount unless `allowNegative`.
  */
 declare function tryDecodeWire(psp: PspId, wire: unknown, currency: unknown, options?: TryDecodeWireOptions): Money | undefined;
-//#endregion
-//#region src/wire/compare.d.ts
 interface SameWireAmountOptions {
   /** Required for gated PSPs (Stripe, Adyen, Razorpay, Paystack, MoMo); without it the answer is false. */
   convention?: Convention;
@@ -162,6 +210,15 @@ interface SameWireAmountOptions {
    * 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.
@@ -194,11 +251,7 @@ declare function sameWireAmount(psp: PspId, reported: unknown, expected: Money |
 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;
-//#endregion
-//#region src/data/destinations.d.ts
 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';
-//#endregion
-//#region src/wire/destinations.d.ts
 interface DestinationValue {
   readonly value: number | string;
   readonly currency: string;
@@ -223,8 +276,38 @@ 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 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>;
@@ -232,6 +315,23 @@ interface PspPresentment {
   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
@@ -242,18 +342,30 @@ interface PspPresentment {
  */
 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).
+ * 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 pspPresentmentCurrencies(psp: PspId, options?: {
+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;
-}): ReadonlySet<CurrencyCode>;
-//#endregion
-//#region src/wire/provider-amount.d.ts
+  /** 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;
@@ -271,16 +383,26 @@ interface ProviderAmountOptions {
  * unknown currency), never 0.
  */
 declare function parseProviderAmount(value: unknown, currency: string, options?: ProviderAmountOptions): Money | null;
-//#endregion
-//#region src/wire/providers.d.ts
 /** 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: 'paystack' | 'razorpay' | 'mollie' | 'adyen', currency: string): {
+declare function verificationCharge(psp: VerificationDefaultPsp, currency?: string): {
+  wire: number | string;
+  money: Money;
+};
+declare function verificationCharge(psp: VerificationPsp, currency: string): {
   wire: number | string;
   money: Money;
 };
@@ -290,8 +412,6 @@ declare function verificationCharge(psp: 'paystack' | 'razorpay' | 'mollie' | 'a
  * is not a plain decimal throws `parse`.
  */
 declare function iyzicoPrice(wire: string): string;
-//#endregion
-//#region src/wire/slot.d.ts
 interface SlotMoney {
   readonly amount: StoredAmount;
   /** Lower-case, as Medusa spells it. */
@@ -305,5 +425,4 @@ declare function slotMoney(m: Money): SlotMoney;
  * Medusa BigNumber shapes). Undefined when the amount or the currency is missing or unreadable.
  */
 declare function readSlotMoney(context: unknown): SlotMoney | undefined;
-//#endregion
-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 };
+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 };