@uengage.io/platform-sdk 2.2.0 → 2.3.0

package/dist/wallet/client.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WalletNotFoundError = exports.UnresolvableWalletError = exports.WalletIdentityMismatchError = exports.IdempotencyConflictError = exports.InvalidReversalError = exports.OverRefundError = exports.InsufficientBalanceError = exports.WalletApiError = void 0;
+exports.SettlementNotFoundError = exports.CreditIdempotencyConflictError = exports.CreditLineHasOutstandingError = exports.CreditLineNotFoundError = exports.CreditTopUpRefusedError = exports.CreditCurrencyMismatchError = exports.CreditCurrencyConflictError = exports.CreditCorrectionReasonRequiredError = exports.CreditOverrideRefusedError = exports.CreditBreakupRequiredError = exports.CreditLimitReachedError = exports.WalletNotFoundError = exports.UnresolvableWalletError = exports.WalletIdentityMismatchError = exports.IdempotencyConflictError = exports.InvalidReversalError = exports.OverRefundError = exports.InsufficientBalanceError = exports.WalletApiError = void 0;
 exports.createWalletClient = createWalletClient;
 const config_1 = require("../config");
 const http_1 = require("../http");
@@ -78,6 +78,197 @@ class WalletNotFoundError extends WalletApiError {
     }
 }
 exports.WalletNotFoundError = WalletNotFoundError;
+/**
+ * The charge would exceed the merchant's credit limit; nothing was moved
+ * (HTTP 409).
+ *
+ * Distinct from `InsufficientBalanceError` because the merchant's next
+ * step is different — settle an invoice or talk to their account
+ * manager, not top up. The figures also separate two cases that share
+ * this error and need different copy:
+ *
+ *   - `availableMinor === 0` — the limit is used up.
+ *   - `availableMinor > 0` — this one charge is larger than what is
+ *     left, which can happen at any utilisation. Telling that merchant
+ *     their "credit limit is reached" would be wrong.
+ *   - `availableMinor === undefined` — the response carried no figures
+ *     (a trimmed or proxied body). Fall back to generic copy; do not
+ *     read it as zero, which is the sentinel above.
+ *
+ * And a third the fields cannot distinguish on their own: consumption
+ * spans months, so a merchant can be at their ceiling purely because
+ * older invoices are unpaid. `getCreditLine()` tells you which.
+ */
+class CreditLimitReachedError extends WalletApiError {
+    limitMinor;
+    consumedMinor;
+    availableMinor;
+    requestedMinor;
+    constructor(figures, body) {
+        super(409, body);
+        this.name = 'CreditLimitReachedError';
+        this.limitMinor = figures.limitMinor;
+        this.consumedMinor = figures.consumedMinor;
+        this.availableMinor = figures.availableMinor;
+        this.requestedMinor = figures.requestedMinor;
+    }
+}
+exports.CreditLimitReachedError = CreditLimitReachedError;
+/**
+ * A charge on a credit-line merchant arrived without its GST split
+ * (HTTP 400).
+ *
+ * Consumption is tracked net of GST, so `breakup` is required rather
+ * than a rate being inferred. If you hit this, the caller is sending
+ * gross-only amounts and needs to send `breakup` — the same split it
+ * almost certainly already computes.
+ */
+class CreditBreakupRequiredError extends WalletApiError {
+    constructor(body) {
+        super(400, body);
+        this.name = 'CreditBreakupRequiredError';
+    }
+}
+exports.CreditBreakupRequiredError = CreditBreakupRequiredError;
+/** `allowNegative` was passed for a credit-line merchant (HTTP 400). */
+class CreditOverrideRefusedError extends WalletApiError {
+    constructor(body) {
+        super(400, body);
+        this.name = 'CreditOverrideRefusedError';
+    }
+}
+exports.CreditOverrideRefusedError = CreditOverrideRefusedError;
+/**
+ * A re-settlement changed an invoice's figures without saying why
+ * (HTTP 400).
+ *
+ * Re-settling a REVERSED invoice with different figures is how a settled
+ * amount is corrected, so the service does not refuse it the way it
+ * refuses a conflicting first settlement. But it releases against the
+ * merchant's whole outstanding consumption rather than the invoice's own
+ * amount, so a mistyped figure can hand back far more than the invoice
+ * held — and a deliberate correction can say what it is correcting where
+ * a replayed webhook cannot. Pass `reason` and retry. Re-settling with
+ * the SAME figures needs none.
+ */
+class CreditCorrectionReasonRequiredError extends WalletApiError {
+    previousNetMinor;
+    constructor(
+    /** What the invoice was previously settled for, in minor units. */
+    previousNetMinor, body) {
+        super(400, body);
+        this.previousNetMinor = previousNetMinor;
+        this.name = 'CreditCorrectionReasonRequiredError';
+    }
+}
+exports.CreditCorrectionReasonRequiredError = CreditCorrectionReasonRequiredError;
+/**
+ * A limit change named a currency the credit line is not denominated in
+ * (HTTP 409).
+ *
+ * The line's currency is fixed when it is created, because it sets the
+ * exponent every stored figure is already scaled by — changing it would
+ * re-denominate the limit and the consumption without touching either
+ * number. Re-denominating a live line is a migration, not a field
+ * update, so this is not something a caller can retry past: send the
+ * currency the line already carries.
+ */
+class CreditCurrencyConflictError extends WalletApiError {
+    storedCurrency;
+    requestedCurrency;
+    constructor(storedCurrency, requestedCurrency, body) {
+        super(409, body);
+        this.storedCurrency = storedCurrency;
+        this.requestedCurrency = requestedCurrency;
+        this.name = 'CreditCurrencyConflictError';
+    }
+}
+exports.CreditCurrencyConflictError = CreditCurrencyConflictError;
+/**
+ * The merchant's credit line and the wallet the charge routed to are in
+ * different currencies (HTTP 409).
+ *
+ * `amountMinor` and `breakup` carry no currency of their own — they are
+ * read with the exponent of the resolved wallet — so when the two
+ * disagree there is no reading of them that is right for both, and the
+ * service refuses rather than mis-scaling by a factor of ten or a
+ * hundred. Not caller-fixable: it means the merchant's routing and their
+ * credit line disagree, which is an ops/data problem.
+ */
+class CreditCurrencyMismatchError extends WalletApiError {
+    constructor(body) {
+        super(409, body);
+        this.name = 'CreditCurrencyMismatchError';
+    }
+}
+exports.CreditCurrencyMismatchError = CreditCurrencyMismatchError;
+/**
+ * A plain top-up was sent for a credit-line merchant (HTTP 400).
+ *
+ * These merchants have no balance to top up: `wallet_balance` is the
+ * fiction the credit line replaces and is deliberately frozen, so the
+ * write would move nothing while appearing to succeed. Credit is handed
+ * back by settling an invoice (`settleInvoice`), never by crediting the
+ * wallet. A genuine refund is accepted — send it as `reversalOf` or
+ * `isRefund` and it releases the credit the original charge consumed.
+ */
+class CreditTopUpRefusedError extends WalletApiError {
+    constructor(body) {
+        super(400, body);
+        this.name = 'CreditTopUpRefusedError';
+    }
+}
+exports.CreditTopUpRefusedError = CreditTopUpRefusedError;
+/**
+ * The merchant is not on the credit line (HTTP 404).
+ *
+ * The normal state for a prepaid merchant, so a widget should treat it
+ * as "show the wallet balance instead", not as an error.
+ */
+class CreditLineNotFoundError extends WalletApiError {
+    constructor(body) {
+        super(404, body);
+        this.name = 'CreditLineNotFoundError';
+    }
+}
+exports.CreditLineNotFoundError = CreditLineNotFoundError;
+/**
+ * `enabled: false` was refused because the merchant still owes for the
+ * credit line (HTTP 409).
+ *
+ * Disabling moves a merchant back to a wallet balance, and doing that
+ * with consumption outstanding abandons it. Show `consumedMinor` and
+ * tell the operator to settle first — or, if the intent was to stop the
+ * merchant trading rather than to move them off the model, set
+ * `limitMinor: 0`, which blocks every charge and keeps the balance.
+ */
+class CreditLineHasOutstandingError extends WalletApiError {
+    consumedMinor;
+    gstAccruedMinor;
+    constructor(consumedMinor, gstAccruedMinor, body) {
+        super(409, body);
+        this.name = 'CreditLineHasOutstandingError';
+        this.consumedMinor = consumedMinor;
+        this.gstAccruedMinor = gstAccruedMinor;
+    }
+}
+exports.CreditLineHasOutstandingError = CreditLineHasOutstandingError;
+/** A limit `referenceId` or an invoice was reused for different figures (HTTP 409). */
+class CreditIdempotencyConflictError extends WalletApiError {
+    constructor(body) {
+        super(409, body);
+        this.name = 'CreditIdempotencyConflictError';
+    }
+}
+exports.CreditIdempotencyConflictError = CreditIdempotencyConflictError;
+/** No settlement to reverse for that invoice (HTTP 404). */
+class SettlementNotFoundError extends WalletApiError {
+    constructor(body) {
+        super(404, body);
+        this.name = 'SettlementNotFoundError';
+    }
+}
+exports.SettlementNotFoundError = SettlementNotFoundError;
 const BUSINESS_ID_RE = /^business:(\d+)$/;
 /** Parse a typed wallet id (`"business:8841"`) into the numeric business id. */
 function parseBusinessId(id) {
@@ -91,10 +282,16 @@ function parseBusinessId(id) {
 function walletError(status, body) {
     let code;
     let balanceMinor;
+    let credit = {};
+    let outstanding = {};
+    let correction = {};
     try {
         const parsed = JSON.parse(body);
         code = parsed.error;
         balanceMinor = parsed.balanceMinor;
+        credit = parsed;
+        outstanding = parsed;
+        correction = parsed;
     }
     catch {
         // non-JSON body — fall through to a generic error
@@ -102,6 +299,48 @@ function walletError(status, body) {
     if (status === 409 && code === 'insufficient_balance') {
         return new InsufficientBalanceError(balanceMinor ?? 0, body);
     }
+    if (status === 409 && code === 'credit_limit_reached') {
+        // NOT `?? 0`. `availableMinor === 0` is the documented sentinel for
+        // "the limit is used up", and defaulting to it made a trimmed or
+        // proxied body indistinguishable from that — producing exactly the
+        // wrong merchant copy in the one place this error type exists to get
+        // right. Absent stays absent, which also matches PHP's
+        // `creditFigures()`, so the two SDKs agree on the rule.
+        return new CreditLimitReachedError({
+            limitMinor: credit.limitMinor,
+            consumedMinor: credit.consumedMinor,
+            availableMinor: credit.availableMinor,
+            requestedMinor: credit.requestedMinor,
+        }, body);
+    }
+    if (status === 400 && code === 'credit_breakup_required') {
+        return new CreditBreakupRequiredError(body);
+    }
+    if (status === 400 && code === 'credit_override_refused') {
+        return new CreditOverrideRefusedError(body);
+    }
+    if (status === 400 && code === 'credit_top_up_refused') {
+        return new CreditTopUpRefusedError(body);
+    }
+    if (status === 400 && code === 'credit_correction_reason_required') {
+        return new CreditCorrectionReasonRequiredError(correction.previousNetMinor, body);
+    }
+    if (status === 409 && code === 'credit_currency_conflict') {
+        return new CreditCurrencyConflictError(correction.storedCurrency, correction.requestedCurrency, body);
+    }
+    if (status === 409 && code === 'credit_currency_mismatch') {
+        return new CreditCurrencyMismatchError(body);
+    }
+    if (status === 409 && code === 'credit_line_has_outstanding') {
+        return new CreditLineHasOutstandingError(outstanding.consumedMinor ?? 0, outstanding.gstAccruedMinor ?? 0, body);
+    }
+    if (status === 409 && code === 'credit_idempotency_conflict') {
+        return new CreditIdempotencyConflictError(body);
+    }
+    if (status === 404 && code === 'credit_line_not_found')
+        return new CreditLineNotFoundError(body);
+    if (status === 404 && code === 'settlement_not_found')
+        return new SettlementNotFoundError(body);
     if (status === 409 && code === 'over_refund')
         return new OverRefundError(body);
     if (status === 409 && code === 'idempotency_conflict')
@@ -129,6 +368,29 @@ function createWalletClient(input = {}) {
             state.setAuth(opts);
             return client;
         },
+        async getCreditUtilisation(filter = {}) {
+            const p = new URLSearchParams();
+            if (filter.minUtilisationBps !== undefined) {
+                p.set('minUtilisationBps', String(filter.minUtilisationBps));
+            }
+            if (filter.band)
+                p.set('band', filter.band);
+            if (filter.offset !== undefined)
+                p.set('offset', String(filter.offset));
+            if (filter.limit !== undefined)
+                p.set('limit', String(filter.limit));
+            const path = '/v1/wallet/credit/utilisation';
+            const config = state.resolve();
+            const query = p.toString();
+            const res = await (0, http_1.sendWithAuthRetry)(config, {
+                method: 'GET',
+                path,
+                url: `${config.baseUrl}${path}${query ? `?${query}` : ''}`,
+            });
+            if (!res.ok)
+                throw walletError(res.status, await res.text());
+            return (await res.json());
+        },
         getWallet(opts) {
             // Parse eagerly so a malformed id fails fast at the call site,
             // but do NOT resolve the wallet here — that happens on the first
@@ -141,6 +403,29 @@ function createWalletClient(input = {}) {
                     p.set('forceChildWallet', 'true');
                 return p;
             };
+            const getJson = async (path, params) => {
+                const config = state.resolve();
+                const res = await (0, http_1.sendWithAuthRetry)(config, {
+                    method: 'GET',
+                    path,
+                    url: `${config.baseUrl}${path}?${params.toString()}`,
+                });
+                if (!res.ok)
+                    throw walletError(res.status, await res.text());
+                return (await res.json());
+            };
+            const sendJson = async (method, path, payload) => {
+                const config = state.resolve();
+                const res = await (0, http_1.sendWithAuthRetry)(config, {
+                    method,
+                    path,
+                    url: `${config.baseUrl}${path}`,
+                    body: JSON.stringify(payload),
+                });
+                if (!res.ok)
+                    throw walletError(res.status, await res.text());
+                return (await res.json());
+            };
             const postTransaction = async (type, body) => {
                 const path = '/v1/wallet/transactions';
                 // The wallet identity is exactly-one-of server-side, so an explicit
@@ -159,6 +444,63 @@ function createWalletClient(input = {}) {
                 return (await res.json());
             };
             const wallet = {
+                /**
+                 * BALANCE FIRST, deliberately, and the order is the whole design.
+                 *
+                 * `getBalance()` carries `source`, so for any merchant who has a
+                 * wallet at all it settles prepaid-vs-credit without an
+                 * exception. The alternative — call `getCreditLine()` and catch
+                 * its 404 — makes the *normal* state of a prepaid merchant an
+                 * error: a 404 in the network tab and a throw in the logs on
+                 * every dashboard load, for nothing being wrong.
+                 *
+                 * It also costs less where it matters. Most merchants are
+                 * prepaid, and for them this is ONE request: the balance is both
+                 * the answer and the data. Only a credit merchant pays a second
+                 * round trip, and only because they have figures a balance cannot
+                 * carry.
+                 *
+                 * `source` absent means a wallet service older than the credit
+                 * line, which is prepaid by definition — so an old service reads
+                 * as prepaid rather than throwing.
+                 *
+                 * WHAT THIS DOES NOT SWALLOW. `getBalance()` is not a guaranteed
+                 * 200: it answers `WalletNotFoundError` when no wallet document
+                 * exists for the resolved identity, and `UnresolvableWalletError`
+                 * when routing cannot name one. Both propagate, because both mean
+                 * there is genuinely nothing to render — reporting `prepaid` with
+                 * a zero balance would invent a wallet.
+                 *
+                 * CAPABILITIES. `wallet.balance:read` covers a prepaid merchant.
+                 * A credit merchant needs `wallet.credit:read` as well, and a
+                 * token holding only the former gets a `WalletApiError` with
+                 * `status === 403` from the second call — every wallet method
+                 * throws from that one hierarchy, so branch on `.status` rather
+                 * than looking for the SDK's `AuthorizationError`, which this
+                 * namespace does not raise. It is deliberately not caught:
+                 * falling back to `prepaid` would hand the dashboard a
+                 * `wallet_balance` that is frozen for exactly these merchants, so
+                 * it would render a confident, stale, wrong number instead of an
+                 * error someone can fix by widening the grant.
+                 */
+                async getOverview() {
+                    const balance = await wallet.getBalance();
+                    if (balance.source !== 'credit_line') {
+                        return { mode: 'prepaid', balance };
+                    }
+                    try {
+                        return { mode: 'credit', balance, creditLine: await wallet.getCreditLine() };
+                    }
+                    catch (err) {
+                        // Ops can disable a credit line between the two calls. Rare,
+                        // but the honest answer is then "prepaid" rather than an
+                        // error a dashboard cannot act on.
+                        if (err instanceof CreditLineNotFoundError) {
+                            return { mode: 'prepaid', balance };
+                        }
+                        throw err;
+                    }
+                },
                 async getBalance() {
                     const path = '/v1/wallet/balance';
                     const config = state.resolve();
@@ -233,10 +575,56 @@ function createWalletClient(input = {}) {
                         throw walletError(res.status, await res.text());
                     return (await res.json());
                 },
+                // ── Credit line ──
+                //
+                // These send `businessId` alone, never `forceChildWallet`: the
+                // credit line is resolved to the merchant that owns the business,
+                // and which wallet would have paid is not part of that question.
+                //
+                // `businessId` is spread LAST so the handle's merchant wins. A
+                // caller who passes their own `businessId` is naming a different
+                // merchant, and honouring it would move a limit or settle an
+                // invoice against that one while every log line and error still
+                // named this handle's.
+                async getCreditLine() {
+                    return getJson('/v1/wallet/credit', new URLSearchParams({ businessId: String(businessId) }));
+                },
+                async listCreditEvents(filter = {}) {
+                    const p = new URLSearchParams({ businessId: String(businessId) });
+                    if (filter.limit !== undefined)
+                        p.set('limit', String(filter.limit));
+                    const page = await getJson('/v1/wallet/credit/events', p);
+                    // `?? []` rather than a bare `page.events`: the declared type
+                    // says the key is always there, but the type describes what the
+                    // service intends to send, not what a proxy, an older
+                    // deployment or a truncated body actually delivered. Returning
+                    // `undefined` from a method typed `CreditEvent[]` puts a lie in
+                    // the caller's hands, and it surfaces as `.map of undefined`
+                    // inside their render — far from the request that caused it.
+                    return page.events ?? [];
+                },
+                setCreditLimit(input) {
+                    return sendJson('PUT', '/v1/wallet/credit/limit', {
+                        ...input,
+                        businessId,
+                    });
+                },
+                settleInvoice(input) {
+                    return sendJson('POST', '/v1/wallet/credit/settlements', {
+                        ...input,
+                        businessId,
+                    });
+                },
+                reverseSettlement(input) {
+                    return sendJson('POST', '/v1/wallet/credit/settlements/reversal', {
+                        ...input,
+                        businessId,
+                    });
+                },
             };
             return wallet;
         },
     };
     return client;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/wallet/client.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ConfigState,\n  type PlatformAuth,\n  type PlatformAuthInput,\n  type PlatformConfigInput,\n} from '../config';\nimport { sendWithAuthRetry } from '../http';\nimport type {\n  CreditInput,\n  Currency,\n  DebitInput,\n  GetWalletOptions,\n  ListTransactionsFilter,\n  TransactionPage,\n  TransactionResult,\n  WalletBalance,\n  WalletInstance,\n  WalletTransaction,\n} from './schema';\n\n/**\n * A handle to one business wallet. Cheap to create — `getWallet(...)`\n * does no I/O. The wallet is resolved server-side on the first\n * operation, so `UnresolvableWalletError` / `WalletNotFoundError`\n * surface from the operation, not from `getWallet()`.\n */\nexport interface Wallet {\n  /** GET /v1/wallet/balance — resolves the wallet and returns its balance + currency. */\n  getBalance(): Promise<WalletBalance>;\n  /** GET /v1/wallet/instance — wallet identity + currency, without the balance. */\n  getInstance(): Promise<WalletInstance>;\n  /** The wallet's currency `{code, symbol}` (a slice of getInstance()). */\n  getCurrency(): Promise<Currency>;\n  /**\n   * POST /v1/wallet/transactions (type=debit). Idempotent on\n   * `referenceId`. Pass `wallet` to charge a wallet other than the one\n   * this handle routes to.\n   */\n  debit(input: DebitInput): Promise<TransactionResult>;\n  /**\n   * POST /v1/wallet/transactions (type=credit). Pass `reversalOf` for a\n   * refund capped by the original debit, or `isRefund` for one computed\n   * independently of it.\n   */\n  credit(input: CreditInput): Promise<TransactionResult>;\n  /** GET /v1/wallet/transactions — newest-first, keyset-paginated. */\n  listTransactions(filter?: ListTransactionsFilter): Promise<TransactionPage>;\n  /** GET /v1/wallet/transactions/:id — scoped to this wallet. */\n  getTransaction(id: string): Promise<WalletTransaction>;\n}\n\nexport interface WalletClient {\n  config(input: PlatformConfigInput): WalletClient;\n  auth(input: PlatformAuthInput | PlatformAuth): WalletClient;\n  /**\n   * Build a handle to a business wallet. Synchronous and I/O-free — it\n   * only parses `id`. Requires a service token carrying the relevant\n   * `wallet.*` scope for the operations on the returned handle.\n   */\n  getWallet(opts: GetWalletOptions): Wallet;\n}\n\nexport class WalletApiError extends Error {\n  readonly status: number;\n  readonly body: string;\n\n  constructor(status: number, body: string) {\n    super(`wallet API ${status}: ${body}`);\n    this.name = 'WalletApiError';\n    this.status = status;\n    this.body = body;\n  }\n}\n\n/** A debit would overdraw the wallet; nothing was moved (HTTP 409). */\nexport class InsufficientBalanceError extends WalletApiError {\n  readonly balanceMinor: number;\n  constructor(balanceMinor: number, body: string) {\n    super(409, body);\n    this.name = 'InsufficientBalanceError';\n    this.balanceMinor = balanceMinor;\n  }\n}\n\n/** A refund would push total reversals past the original debit (HTTP 409). */\nexport class OverRefundError extends WalletApiError {\n  constructor(body: string) {\n    super(409, body);\n    this.name = 'OverRefundError';\n  }\n}\n\n/** `reversalOf` doesn't reference a valid debit on this wallet (HTTP 422). */\nexport class InvalidReversalError extends WalletApiError {\n  constructor(body: string) {\n    super(422, body);\n    this.name = 'InvalidReversalError';\n  }\n}\n\n/** A `referenceId` was reused with a different amount/type/service (HTTP 409). */\nexport class IdempotencyConflictError extends WalletApiError {\n  constructor(body: string) {\n    super(409, body);\n    this.name = 'IdempotencyConflictError';\n  }\n}\n\n/**\n * A `wallet` override named a `parentBusinessId` the wallet document\n * contradicts (HTTP 409). Nothing was moved — the write is refused rather\n * than charging the right wallet under the wrong identity, which would\n * misattribute the ledger row and split its idempotency scope.\n */\nexport class WalletIdentityMismatchError extends WalletApiError {\n  constructor(body: string) {\n    super(409, body);\n    this.name = 'WalletIdentityMismatchError';\n  }\n}\n\n/** The business, or the business its `bId_deduction` points to, does not exist (HTTP 422). */\nexport class UnresolvableWalletError extends WalletApiError {\n  constructor(body: string) {\n    super(422, body);\n    this.name = 'UnresolvableWalletError';\n  }\n}\n\n/** No wallet document, or no such transaction on this wallet (HTTP 404). */\nexport class WalletNotFoundError extends WalletApiError {\n  constructor(body: string) {\n    super(404, body);\n    this.name = 'WalletNotFoundError';\n  }\n}\n\nconst BUSINESS_ID_RE = /^business:(\\d+)$/;\n\n/** Parse a typed wallet id (`\"business:8841\"`) into the numeric business id. */\nfunction parseBusinessId(id: string): number {\n  const match = BUSINESS_ID_RE.exec(id);\n  if (!match) {\n    throw new Error(\n      `wallet.getWallet: id must look like \"business:<positive integer>\" (got \"${id}\")`,\n    );\n  }\n  return Number.parseInt(match[1], 10);\n}\n\n/** Map a non-2xx wallet response to the most specific typed error. */\nfunction walletError(status: number, body: string): WalletApiError {\n  let code: string | undefined;\n  let balanceMinor: number | undefined;\n  try {\n    const parsed = JSON.parse(body) as { error?: string; balanceMinor?: number };\n    code = parsed.error;\n    balanceMinor = parsed.balanceMinor;\n  } catch {\n    // non-JSON body — fall through to a generic error\n  }\n  if (status === 409 && code === 'insufficient_balance') {\n    return new InsufficientBalanceError(balanceMinor ?? 0, body);\n  }\n  if (status === 409 && code === 'over_refund') return new OverRefundError(body);\n  if (status === 409 && code === 'idempotency_conflict') return new IdempotencyConflictError(body);\n  if (status === 409 && code === 'wallet_identity_mismatch') {\n    return new WalletIdentityMismatchError(body);\n  }\n  if (status === 422 && code === 'invalid_reversal') return new InvalidReversalError(body);\n  if (status === 422 && code === 'unresolvable_wallet') return new UnresolvableWalletError(body);\n  if (status === 404) return new WalletNotFoundError(body);\n  return new WalletApiError(status, body);\n}\n\nexport function createWalletClient(input: PlatformConfigInput = {}): WalletClient {\n  const state = new ConfigState();\n  state.apply(input);\n\n  const client: WalletClient = {\n    config(opts) {\n      state.apply(opts);\n      return client;\n    },\n    auth(opts) {\n      state.setAuth(opts);\n      return client;\n    },\n    getWallet(opts) {\n      // Parse eagerly so a malformed id fails fast at the call site,\n      // but do NOT resolve the wallet here — that happens on the first\n      // operation against the handle.\n      const businessId = parseBusinessId(opts.id);\n      const forceChildWallet = opts.forceChildWallet === true;\n\n      const baseParams = (): URLSearchParams => {\n        const p = new URLSearchParams({ businessId: String(businessId) });\n        if (forceChildWallet) p.set('forceChildWallet', 'true');\n        return p;\n      };\n\n      const postTransaction = async (\n        type: 'debit' | 'credit',\n        body: DebitInput | CreditInput,\n      ): Promise<TransactionResult> => {\n        const path = '/v1/wallet/transactions';\n        // The wallet identity is exactly-one-of server-side, so an explicit\n        // `wallet` override REPLACES this handle's businessId rather than\n        // travelling alongside it — sending both is a 400.\n        const payload = JSON.stringify(\n          body.wallet ? { type, ...body } : { businessId, forceChildWallet, type, ...body },\n        );\n        const config = state.resolve();\n        const res = await sendWithAuthRetry(config, {\n          method: 'POST',\n          path,\n          url: `${config.baseUrl}${path}`,\n          body: payload,\n        });\n        if (!res.ok) throw walletError(res.status, await res.text());\n        return (await res.json()) as TransactionResult;\n      };\n\n      const wallet: Wallet = {\n        async getBalance() {\n          const path = '/v1/wallet/balance';\n          const config = state.resolve();\n          const res = await sendWithAuthRetry(config, {\n            method: 'GET',\n            path,\n            url: `${config.baseUrl}${path}?${baseParams().toString()}`,\n          });\n          if (!res.ok) throw walletError(res.status, await res.text());\n          return (await res.json()) as WalletBalance;\n        },\n        async getInstance() {\n          const path = '/v1/wallet/instance';\n          const config = state.resolve();\n          const res = await sendWithAuthRetry(config, {\n            method: 'GET',\n            path,\n            url: `${config.baseUrl}${path}?${baseParams().toString()}`,\n          });\n          if (!res.ok) throw walletError(res.status, await res.text());\n          return (await res.json()) as WalletInstance;\n        },\n        async getCurrency() {\n          return (await wallet.getInstance()).currency;\n        },\n        debit(body) {\n          return postTransaction('debit', body);\n        },\n        credit(body) {\n          return postTransaction('credit', body);\n        },\n        async listTransactions(filter = {}) {\n          const p = baseParams();\n          if (filter.type) p.set('type', filter.type);\n          if (filter.from) p.set('from', filter.from);\n          if (filter.to) p.set('to', filter.to);\n          if (filter.service !== undefined) p.set('service', String(filter.service));\n          if (filter.referenceId) p.set('referenceId', filter.referenceId);\n          if (filter.tag) p.set('tag', filter.tag);\n          if (filter.cursor) p.set('cursor', filter.cursor);\n          if (filter.limit !== undefined) p.set('limit', String(filter.limit));\n          const path = '/v1/wallet/transactions';\n          const config = state.resolve();\n          const res = await sendWithAuthRetry(config, {\n            method: 'GET',\n            path,\n            url: `${config.baseUrl}${path}?${p.toString()}`,\n          });\n          if (!res.ok) throw walletError(res.status, await res.text());\n          return (await res.json()) as TransactionPage;\n        },\n        async getTransaction(id) {\n          const path = `/v1/wallet/transactions/${id}`;\n          const config = state.resolve();\n          const res = await sendWithAuthRetry(config, {\n            method: 'GET',\n            path,\n            url: `${config.baseUrl}${path}?${baseParams().toString()}`,\n          });\n          if (!res.ok) throw walletError(res.status, await res.text());\n          return (await res.json()) as WalletTransaction;\n        },\n      };\n      return wallet;\n    },\n  };\n\n  return client;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/wallet/client.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ConfigState,\n  type PlatformAuth,\n  type PlatformAuthInput,\n  type PlatformConfigInput,\n} from '../config';\nimport { sendWithAuthRetry } from '../http';\nimport type {\n  CreditEvent,\n  CreditInput,\n  CreditLine,\n  CreditUtilisationFilter,\n  CreditUtilisationPage,\n  Currency,\n  DebitInput,\n  GetWalletOptions,\n  ListCreditEventsFilter,\n  ListTransactionsFilter,\n  ReverseSettlementInput,\n  SetCreditLimitInput,\n  SetCreditLimitResult,\n  SettleInvoiceInput,\n  SettleInvoiceResult,\n  TransactionPage,\n  TransactionResult,\n  WalletBalance,\n  WalletInstance,\n  WalletOverview,\n  WalletTransaction,\n} from './schema';\n\n/**\n * A handle to one business wallet. Cheap to create — `getWallet(...)`\n * does no I/O. The wallet is resolved server-side on the first\n * operation, so `UnresolvableWalletError` / `WalletNotFoundError`\n * surface from the operation, not from `getWallet()`.\n */\nexport interface Wallet {\n  /**\n   * WHICH MODEL IS THIS MERCHANT ON — call this first.\n   *\n   * Returns a discriminated union on `mode`, so a dashboard settles\n   * \"wallet balance or credit line?\" from a value rather than by\n   * catching a 404, and TypeScript narrows the rest for you:\n   *\n   * ```ts\n   * const o = await wallet.getOverview();\n   * if (o.mode === 'credit') renderCreditWidget(o.creditLine);\n   * else renderWalletPanel(o.balance);\n   * ```\n   *\n   * One request for a prepaid merchant, two for a credit one, and never\n   * a 404 on the happy path — see the implementation for why that order.\n   */\n  getOverview(): Promise<WalletOverview>;\n  /** GET /v1/wallet/balance — resolves the wallet and returns its balance + currency. */\n  getBalance(): Promise<WalletBalance>;\n  /** GET /v1/wallet/instance — wallet identity + currency, without the balance. */\n  getInstance(): Promise<WalletInstance>;\n  /** The wallet's currency `{code, symbol}` (a slice of getInstance()). */\n  getCurrency(): Promise<Currency>;\n  /**\n   * POST /v1/wallet/transactions (type=debit). Idempotent on\n   * `referenceId`. Pass `wallet` to charge a wallet other than the one\n   * this handle routes to.\n   */\n  debit(input: DebitInput): Promise<TransactionResult>;\n  /**\n   * POST /v1/wallet/transactions (type=credit). Pass `reversalOf` for a\n   * refund capped by the original debit, or `isRefund` for one computed\n   * independently of it.\n   */\n  credit(input: CreditInput): Promise<TransactionResult>;\n  /** GET /v1/wallet/transactions — newest-first, keyset-paginated. */\n  listTransactions(filter?: ListTransactionsFilter): Promise<TransactionPage>;\n  /** GET /v1/wallet/transactions/:id — scoped to this wallet. */\n  getTransaction(id: string): Promise<WalletTransaction>;\n\n  // ── Credit line ──\n  //\n  // Resolved to the MERCHANT this wallet belongs to, not to the wallet:\n  // all of a merchant's outlets share one credit line, so calling these\n  // on an outlet handle and on its parent's handle is the same request.\n\n  /**\n   * GET /v1/wallet/credit — everything the merchant widget renders.\n   * Throws `CreditLineNotFoundError` (404) when the merchant is not on\n   * the credit line, which is the normal state for a prepaid merchant.\n   * Requires `wallet.credit:read`.\n   */\n  getCreditLine(): Promise<CreditLine>;\n  /**\n   * GET /v1/wallet/credit/events — the limit-change and settlement\n   * trail, newest first. Requires `wallet.credit:read`.\n   *\n   * Pass a `limit` to widen the page: the service defaults to 50, which\n   * a merchant on the line for a year will have outgrown.\n   */\n  listCreditEvents(filter?: ListCreditEventsFilter): Promise<CreditEvent[]>;\n  /**\n   * PUT /v1/wallet/credit/limit — set the limit, creating the credit\n   * line on first use. Consumption is never touched, so raising a limit\n   * hands back exactly the difference. Requires `wallet.credit:write`.\n   */\n  setCreditLimit(input: SetCreditLimitInput): Promise<SetCreditLimitResult>;\n  /**\n   * POST /v1/wallet/credit/settlements — release the credit an invoice\n   * was holding, on payment IN FULL. Releases the invoice's net figure;\n   * see `SettleInvoiceInput.netMinor`. Requires `wallet.credit:settle`.\n   */\n  settleInvoice(input: SettleInvoiceInput): Promise<SettleInvoiceResult>;\n  /**\n   * POST /v1/wallet/credit/settlements/reversal — undo a settlement\n   * recorded in error, re-holding exactly what it released. Requires\n   * `wallet.credit:settle`.\n   */\n  reverseSettlement(input: ReverseSettlementInput): Promise<SettleInvoiceResult>;\n}\n\nexport interface WalletClient {\n  config(input: PlatformConfigInput): WalletClient;\n  auth(input: PlatformAuthInput | PlatformAuth): WalletClient;\n  /**\n   * Build a handle to a business wallet. Synchronous and I/O-free — it\n   * only parses `id`. Requires a service token carrying the relevant\n   * `wallet.*` scope for the operations on the returned handle.\n   */\n  getWallet(opts: GetWalletOptions): Wallet;\n  /**\n   * GET /v1/wallet/credit/utilisation — every merchant on the credit\n   * line, most-utilised first.\n   *\n   * On the client rather than on a wallet handle because it is the one\n   * wallet operation that is not scoped to a business, and it carries\n   * its own capability (`wallet.credit:list`) for the same reason: it is\n   * a materially broader grant than reading one merchant's line.\n   */\n  getCreditUtilisation(filter?: CreditUtilisationFilter): Promise<CreditUtilisationPage>;\n}\n\nexport class WalletApiError extends Error {\n  readonly status: number;\n  readonly body: string;\n\n  constructor(status: number, body: string) {\n    super(`wallet API ${status}: ${body}`);\n    this.name = 'WalletApiError';\n    this.status = status;\n    this.body = body;\n  }\n}\n\n/** A debit would overdraw the wallet; nothing was moved (HTTP 409). */\nexport class InsufficientBalanceError extends WalletApiError {\n  readonly balanceMinor: number;\n  constructor(balanceMinor: number, body: string) {\n    super(409, body);\n    this.name = 'InsufficientBalanceError';\n    this.balanceMinor = balanceMinor;\n  }\n}\n\n/** A refund would push total reversals past the original debit (HTTP 409). */\nexport class OverRefundError extends WalletApiError {\n  constructor(body: string) {\n    super(409, body);\n    this.name = 'OverRefundError';\n  }\n}\n\n/** `reversalOf` doesn't reference a valid debit on this wallet (HTTP 422). */\nexport class InvalidReversalError extends WalletApiError {\n  constructor(body: string) {\n    super(422, body);\n    this.name = 'InvalidReversalError';\n  }\n}\n\n/** A `referenceId` was reused with a different amount/type/service (HTTP 409). */\nexport class IdempotencyConflictError extends WalletApiError {\n  constructor(body: string) {\n    super(409, body);\n    this.name = 'IdempotencyConflictError';\n  }\n}\n\n/**\n * A `wallet` override named a `parentBusinessId` the wallet document\n * contradicts (HTTP 409). Nothing was moved — the write is refused rather\n * than charging the right wallet under the wrong identity, which would\n * misattribute the ledger row and split its idempotency scope.\n */\nexport class WalletIdentityMismatchError extends WalletApiError {\n  constructor(body: string) {\n    super(409, body);\n    this.name = 'WalletIdentityMismatchError';\n  }\n}\n\n/** The business, or the business its `bId_deduction` points to, does not exist (HTTP 422). */\nexport class UnresolvableWalletError extends WalletApiError {\n  constructor(body: string) {\n    super(422, body);\n    this.name = 'UnresolvableWalletError';\n  }\n}\n\n/** No wallet document, or no such transaction on this wallet (HTTP 404). */\nexport class WalletNotFoundError extends WalletApiError {\n  constructor(body: string) {\n    super(404, body);\n    this.name = 'WalletNotFoundError';\n  }\n}\n\n/**\n * The charge would exceed the merchant's credit limit; nothing was moved\n * (HTTP 409).\n *\n * Distinct from `InsufficientBalanceError` because the merchant's next\n * step is different — settle an invoice or talk to their account\n * manager, not top up. The figures also separate two cases that share\n * this error and need different copy:\n *\n *   - `availableMinor === 0` — the limit is used up.\n *   - `availableMinor > 0` — this one charge is larger than what is\n *     left, which can happen at any utilisation. Telling that merchant\n *     their \"credit limit is reached\" would be wrong.\n *   - `availableMinor === undefined` — the response carried no figures\n *     (a trimmed or proxied body). Fall back to generic copy; do not\n *     read it as zero, which is the sentinel above.\n *\n * And a third the fields cannot distinguish on their own: consumption\n * spans months, so a merchant can be at their ceiling purely because\n * older invoices are unpaid. `getCreditLine()` tells you which.\n */\nexport class CreditLimitReachedError extends WalletApiError {\n  readonly limitMinor?: number;\n  readonly consumedMinor?: number;\n  readonly availableMinor?: number;\n  readonly requestedMinor?: number;\n  constructor(\n    figures: {\n      limitMinor?: number;\n      consumedMinor?: number;\n      availableMinor?: number;\n      requestedMinor?: number;\n    },\n    body: string,\n  ) {\n    super(409, body);\n    this.name = 'CreditLimitReachedError';\n    this.limitMinor = figures.limitMinor;\n    this.consumedMinor = figures.consumedMinor;\n    this.availableMinor = figures.availableMinor;\n    this.requestedMinor = figures.requestedMinor;\n  }\n}\n\n/**\n * A charge on a credit-line merchant arrived without its GST split\n * (HTTP 400).\n *\n * Consumption is tracked net of GST, so `breakup` is required rather\n * than a rate being inferred. If you hit this, the caller is sending\n * gross-only amounts and needs to send `breakup` — the same split it\n * almost certainly already computes.\n */\nexport class CreditBreakupRequiredError extends WalletApiError {\n  constructor(body: string) {\n    super(400, body);\n    this.name = 'CreditBreakupRequiredError';\n  }\n}\n\n/** `allowNegative` was passed for a credit-line merchant (HTTP 400). */\nexport class CreditOverrideRefusedError extends WalletApiError {\n  constructor(body: string) {\n    super(400, body);\n    this.name = 'CreditOverrideRefusedError';\n  }\n}\n\n/**\n * A re-settlement changed an invoice's figures without saying why\n * (HTTP 400).\n *\n * Re-settling a REVERSED invoice with different figures is how a settled\n * amount is corrected, so the service does not refuse it the way it\n * refuses a conflicting first settlement. But it releases against the\n * merchant's whole outstanding consumption rather than the invoice's own\n * amount, so a mistyped figure can hand back far more than the invoice\n * held — and a deliberate correction can say what it is correcting where\n * a replayed webhook cannot. Pass `reason` and retry. Re-settling with\n * the SAME figures needs none.\n */\nexport class CreditCorrectionReasonRequiredError extends WalletApiError {\n  constructor(\n    /** What the invoice was previously settled for, in minor units. */\n    readonly previousNetMinor: number | undefined,\n    body: string,\n  ) {\n    super(400, body);\n    this.name = 'CreditCorrectionReasonRequiredError';\n  }\n}\n\n/**\n * A limit change named a currency the credit line is not denominated in\n * (HTTP 409).\n *\n * The line's currency is fixed when it is created, because it sets the\n * exponent every stored figure is already scaled by — changing it would\n * re-denominate the limit and the consumption without touching either\n * number. Re-denominating a live line is a migration, not a field\n * update, so this is not something a caller can retry past: send the\n * currency the line already carries.\n */\nexport class CreditCurrencyConflictError extends WalletApiError {\n  constructor(\n    readonly storedCurrency: string | undefined,\n    readonly requestedCurrency: string | undefined,\n    body: string,\n  ) {\n    super(409, body);\n    this.name = 'CreditCurrencyConflictError';\n  }\n}\n\n/**\n * The merchant's credit line and the wallet the charge routed to are in\n * different currencies (HTTP 409).\n *\n * `amountMinor` and `breakup` carry no currency of their own — they are\n * read with the exponent of the resolved wallet — so when the two\n * disagree there is no reading of them that is right for both, and the\n * service refuses rather than mis-scaling by a factor of ten or a\n * hundred. Not caller-fixable: it means the merchant's routing and their\n * credit line disagree, which is an ops/data problem.\n */\nexport class CreditCurrencyMismatchError extends WalletApiError {\n  constructor(body: string) {\n    super(409, body);\n    this.name = 'CreditCurrencyMismatchError';\n  }\n}\n\n/**\n * A plain top-up was sent for a credit-line merchant (HTTP 400).\n *\n * These merchants have no balance to top up: `wallet_balance` is the\n * fiction the credit line replaces and is deliberately frozen, so the\n * write would move nothing while appearing to succeed. Credit is handed\n * back by settling an invoice (`settleInvoice`), never by crediting the\n * wallet. A genuine refund is accepted — send it as `reversalOf` or\n * `isRefund` and it releases the credit the original charge consumed.\n */\nexport class CreditTopUpRefusedError extends WalletApiError {\n  constructor(body: string) {\n    super(400, body);\n    this.name = 'CreditTopUpRefusedError';\n  }\n}\n\n/**\n * The merchant is not on the credit line (HTTP 404).\n *\n * The normal state for a prepaid merchant, so a widget should treat it\n * as \"show the wallet balance instead\", not as an error.\n */\nexport class CreditLineNotFoundError extends WalletApiError {\n  constructor(body: string) {\n    super(404, body);\n    this.name = 'CreditLineNotFoundError';\n  }\n}\n\n/**\n * `enabled: false` was refused because the merchant still owes for the\n * credit line (HTTP 409).\n *\n * Disabling moves a merchant back to a wallet balance, and doing that\n * with consumption outstanding abandons it. Show `consumedMinor` and\n * tell the operator to settle first — or, if the intent was to stop the\n * merchant trading rather than to move them off the model, set\n * `limitMinor: 0`, which blocks every charge and keeps the balance.\n */\nexport class CreditLineHasOutstandingError extends WalletApiError {\n  readonly consumedMinor: number;\n  readonly gstAccruedMinor: number;\n  constructor(consumedMinor: number, gstAccruedMinor: number, body: string) {\n    super(409, body);\n    this.name = 'CreditLineHasOutstandingError';\n    this.consumedMinor = consumedMinor;\n    this.gstAccruedMinor = gstAccruedMinor;\n  }\n}\n\n/** A limit `referenceId` or an invoice was reused for different figures (HTTP 409). */\nexport class CreditIdempotencyConflictError extends WalletApiError {\n  constructor(body: string) {\n    super(409, body);\n    this.name = 'CreditIdempotencyConflictError';\n  }\n}\n\n/** No settlement to reverse for that invoice (HTTP 404). */\nexport class SettlementNotFoundError extends WalletApiError {\n  constructor(body: string) {\n    super(404, body);\n    this.name = 'SettlementNotFoundError';\n  }\n}\n\nconst BUSINESS_ID_RE = /^business:(\\d+)$/;\n\n/** Parse a typed wallet id (`\"business:8841\"`) into the numeric business id. */\nfunction parseBusinessId(id: string): number {\n  const match = BUSINESS_ID_RE.exec(id);\n  if (!match) {\n    throw new Error(\n      `wallet.getWallet: id must look like \"business:<positive integer>\" (got \"${id}\")`,\n    );\n  }\n  return Number.parseInt(match[1], 10);\n}\n\n/** Map a non-2xx wallet response to the most specific typed error. */\nfunction walletError(status: number, body: string): WalletApiError {\n  let code: string | undefined;\n  let balanceMinor: number | undefined;\n  let credit: {\n    limitMinor?: number;\n    consumedMinor?: number;\n    availableMinor?: number;\n    requestedMinor?: number;\n  } = {};\n  let outstanding: { consumedMinor?: number; gstAccruedMinor?: number } = {};\n  let correction: {\n    previousNetMinor?: number;\n    storedCurrency?: string;\n    requestedCurrency?: string;\n  } = {};\n  try {\n    const parsed = JSON.parse(body) as {\n      error?: string;\n      balanceMinor?: number;\n      limitMinor?: number;\n      consumedMinor?: number;\n      availableMinor?: number;\n      requestedMinor?: number;\n      gstAccruedMinor?: number;\n      previousNetMinor?: number;\n      storedCurrency?: string;\n      requestedCurrency?: string;\n    };\n    code = parsed.error;\n    balanceMinor = parsed.balanceMinor;\n    credit = parsed;\n    outstanding = parsed;\n    correction = parsed;\n  } catch {\n    // non-JSON body — fall through to a generic error\n  }\n  if (status === 409 && code === 'insufficient_balance') {\n    return new InsufficientBalanceError(balanceMinor ?? 0, body);\n  }\n  if (status === 409 && code === 'credit_limit_reached') {\n    // NOT `?? 0`. `availableMinor === 0` is the documented sentinel for\n    // \"the limit is used up\", and defaulting to it made a trimmed or\n    // proxied body indistinguishable from that — producing exactly the\n    // wrong merchant copy in the one place this error type exists to get\n    // right. Absent stays absent, which also matches PHP's\n    // `creditFigures()`, so the two SDKs agree on the rule.\n    return new CreditLimitReachedError(\n      {\n        limitMinor: credit.limitMinor,\n        consumedMinor: credit.consumedMinor,\n        availableMinor: credit.availableMinor,\n        requestedMinor: credit.requestedMinor,\n      },\n      body,\n    );\n  }\n  if (status === 400 && code === 'credit_breakup_required') {\n    return new CreditBreakupRequiredError(body);\n  }\n  if (status === 400 && code === 'credit_override_refused') {\n    return new CreditOverrideRefusedError(body);\n  }\n  if (status === 400 && code === 'credit_top_up_refused') {\n    return new CreditTopUpRefusedError(body);\n  }\n  if (status === 400 && code === 'credit_correction_reason_required') {\n    return new CreditCorrectionReasonRequiredError(correction.previousNetMinor, body);\n  }\n  if (status === 409 && code === 'credit_currency_conflict') {\n    return new CreditCurrencyConflictError(\n      correction.storedCurrency,\n      correction.requestedCurrency,\n      body,\n    );\n  }\n  if (status === 409 && code === 'credit_currency_mismatch') {\n    return new CreditCurrencyMismatchError(body);\n  }\n  if (status === 409 && code === 'credit_line_has_outstanding') {\n    return new CreditLineHasOutstandingError(\n      outstanding.consumedMinor ?? 0,\n      outstanding.gstAccruedMinor ?? 0,\n      body,\n    );\n  }\n  if (status === 409 && code === 'credit_idempotency_conflict') {\n    return new CreditIdempotencyConflictError(body);\n  }\n  if (status === 404 && code === 'credit_line_not_found') return new CreditLineNotFoundError(body);\n  if (status === 404 && code === 'settlement_not_found') return new SettlementNotFoundError(body);\n  if (status === 409 && code === 'over_refund') return new OverRefundError(body);\n  if (status === 409 && code === 'idempotency_conflict') return new IdempotencyConflictError(body);\n  if (status === 409 && code === 'wallet_identity_mismatch') {\n    return new WalletIdentityMismatchError(body);\n  }\n  if (status === 422 && code === 'invalid_reversal') return new InvalidReversalError(body);\n  if (status === 422 && code === 'unresolvable_wallet') return new UnresolvableWalletError(body);\n  if (status === 404) return new WalletNotFoundError(body);\n  return new WalletApiError(status, body);\n}\n\nexport function createWalletClient(input: PlatformConfigInput = {}): WalletClient {\n  const state = new ConfigState();\n  state.apply(input);\n\n  const client: WalletClient = {\n    config(opts) {\n      state.apply(opts);\n      return client;\n    },\n    auth(opts) {\n      state.setAuth(opts);\n      return client;\n    },\n    async getCreditUtilisation(filter = {}) {\n      const p = new URLSearchParams();\n      if (filter.minUtilisationBps !== undefined) {\n        p.set('minUtilisationBps', String(filter.minUtilisationBps));\n      }\n      if (filter.band) p.set('band', filter.band);\n      if (filter.offset !== undefined) p.set('offset', String(filter.offset));\n      if (filter.limit !== undefined) p.set('limit', String(filter.limit));\n      const path = '/v1/wallet/credit/utilisation';\n      const config = state.resolve();\n      const query = p.toString();\n      const res = await sendWithAuthRetry(config, {\n        method: 'GET',\n        path,\n        url: `${config.baseUrl}${path}${query ? `?${query}` : ''}`,\n      });\n      if (!res.ok) throw walletError(res.status, await res.text());\n      return (await res.json()) as CreditUtilisationPage;\n    },\n    getWallet(opts) {\n      // Parse eagerly so a malformed id fails fast at the call site,\n      // but do NOT resolve the wallet here — that happens on the first\n      // operation against the handle.\n      const businessId = parseBusinessId(opts.id);\n      const forceChildWallet = opts.forceChildWallet === true;\n\n      const baseParams = (): URLSearchParams => {\n        const p = new URLSearchParams({ businessId: String(businessId) });\n        if (forceChildWallet) p.set('forceChildWallet', 'true');\n        return p;\n      };\n\n      const getJson = async <T>(path: string, params: URLSearchParams): Promise<T> => {\n        const config = state.resolve();\n        const res = await sendWithAuthRetry(config, {\n          method: 'GET',\n          path,\n          url: `${config.baseUrl}${path}?${params.toString()}`,\n        });\n        if (!res.ok) throw walletError(res.status, await res.text());\n        return (await res.json()) as T;\n      };\n\n      const sendJson = async <T>(\n        method: 'POST' | 'PUT',\n        path: string,\n        payload: unknown,\n      ): Promise<T> => {\n        const config = state.resolve();\n        const res = await sendWithAuthRetry(config, {\n          method,\n          path,\n          url: `${config.baseUrl}${path}`,\n          body: JSON.stringify(payload),\n        });\n        if (!res.ok) throw walletError(res.status, await res.text());\n        return (await res.json()) as T;\n      };\n\n      const postTransaction = async (\n        type: 'debit' | 'credit',\n        body: DebitInput | CreditInput,\n      ): Promise<TransactionResult> => {\n        const path = '/v1/wallet/transactions';\n        // The wallet identity is exactly-one-of server-side, so an explicit\n        // `wallet` override REPLACES this handle's businessId rather than\n        // travelling alongside it — sending both is a 400.\n        const payload = JSON.stringify(\n          body.wallet ? { type, ...body } : { businessId, forceChildWallet, type, ...body },\n        );\n        const config = state.resolve();\n        const res = await sendWithAuthRetry(config, {\n          method: 'POST',\n          path,\n          url: `${config.baseUrl}${path}`,\n          body: payload,\n        });\n        if (!res.ok) throw walletError(res.status, await res.text());\n        return (await res.json()) as TransactionResult;\n      };\n\n      const wallet: Wallet = {\n        /**\n         * BALANCE FIRST, deliberately, and the order is the whole design.\n         *\n         * `getBalance()` carries `source`, so for any merchant who has a\n         * wallet at all it settles prepaid-vs-credit without an\n         * exception. The alternative — call `getCreditLine()` and catch\n         * its 404 — makes the *normal* state of a prepaid merchant an\n         * error: a 404 in the network tab and a throw in the logs on\n         * every dashboard load, for nothing being wrong.\n         *\n         * It also costs less where it matters. Most merchants are\n         * prepaid, and for them this is ONE request: the balance is both\n         * the answer and the data. Only a credit merchant pays a second\n         * round trip, and only because they have figures a balance cannot\n         * carry.\n         *\n         * `source` absent means a wallet service older than the credit\n         * line, which is prepaid by definition — so an old service reads\n         * as prepaid rather than throwing.\n         *\n         * WHAT THIS DOES NOT SWALLOW. `getBalance()` is not a guaranteed\n         * 200: it answers `WalletNotFoundError` when no wallet document\n         * exists for the resolved identity, and `UnresolvableWalletError`\n         * when routing cannot name one. Both propagate, because both mean\n         * there is genuinely nothing to render — reporting `prepaid` with\n         * a zero balance would invent a wallet.\n         *\n         * CAPABILITIES. `wallet.balance:read` covers a prepaid merchant.\n         * A credit merchant needs `wallet.credit:read` as well, and a\n         * token holding only the former gets a `WalletApiError` with\n         * `status === 403` from the second call — every wallet method\n         * throws from that one hierarchy, so branch on `.status` rather\n         * than looking for the SDK's `AuthorizationError`, which this\n         * namespace does not raise. It is deliberately not caught:\n         * falling back to `prepaid` would hand the dashboard a\n         * `wallet_balance` that is frozen for exactly these merchants, so\n         * it would render a confident, stale, wrong number instead of an\n         * error someone can fix by widening the grant.\n         */\n        async getOverview() {\n          const balance = await wallet.getBalance();\n          if (balance.source !== 'credit_line') {\n            return { mode: 'prepaid', balance };\n          }\n          try {\n            return { mode: 'credit', balance, creditLine: await wallet.getCreditLine() };\n          } catch (err) {\n            // Ops can disable a credit line between the two calls. Rare,\n            // but the honest answer is then \"prepaid\" rather than an\n            // error a dashboard cannot act on.\n            if (err instanceof CreditLineNotFoundError) {\n              return { mode: 'prepaid', balance };\n            }\n            throw err;\n          }\n        },\n        async getBalance() {\n          const path = '/v1/wallet/balance';\n          const config = state.resolve();\n          const res = await sendWithAuthRetry(config, {\n            method: 'GET',\n            path,\n            url: `${config.baseUrl}${path}?${baseParams().toString()}`,\n          });\n          if (!res.ok) throw walletError(res.status, await res.text());\n          return (await res.json()) as WalletBalance;\n        },\n        async getInstance() {\n          const path = '/v1/wallet/instance';\n          const config = state.resolve();\n          const res = await sendWithAuthRetry(config, {\n            method: 'GET',\n            path,\n            url: `${config.baseUrl}${path}?${baseParams().toString()}`,\n          });\n          if (!res.ok) throw walletError(res.status, await res.text());\n          return (await res.json()) as WalletInstance;\n        },\n        async getCurrency() {\n          return (await wallet.getInstance()).currency;\n        },\n        debit(body) {\n          return postTransaction('debit', body);\n        },\n        credit(body) {\n          return postTransaction('credit', body);\n        },\n        async listTransactions(filter = {}) {\n          const p = baseParams();\n          if (filter.type) p.set('type', filter.type);\n          if (filter.from) p.set('from', filter.from);\n          if (filter.to) p.set('to', filter.to);\n          if (filter.service !== undefined) p.set('service', String(filter.service));\n          if (filter.referenceId) p.set('referenceId', filter.referenceId);\n          if (filter.tag) p.set('tag', filter.tag);\n          if (filter.cursor) p.set('cursor', filter.cursor);\n          if (filter.limit !== undefined) p.set('limit', String(filter.limit));\n          const path = '/v1/wallet/transactions';\n          const config = state.resolve();\n          const res = await sendWithAuthRetry(config, {\n            method: 'GET',\n            path,\n            url: `${config.baseUrl}${path}?${p.toString()}`,\n          });\n          if (!res.ok) throw walletError(res.status, await res.text());\n          return (await res.json()) as TransactionPage;\n        },\n        async getTransaction(id) {\n          const path = `/v1/wallet/transactions/${id}`;\n          const config = state.resolve();\n          const res = await sendWithAuthRetry(config, {\n            method: 'GET',\n            path,\n            url: `${config.baseUrl}${path}?${baseParams().toString()}`,\n          });\n          if (!res.ok) throw walletError(res.status, await res.text());\n          return (await res.json()) as WalletTransaction;\n        },\n\n        // ── Credit line ──\n        //\n        // These send `businessId` alone, never `forceChildWallet`: the\n        // credit line is resolved to the merchant that owns the business,\n        // and which wallet would have paid is not part of that question.\n        //\n        // `businessId` is spread LAST so the handle's merchant wins. A\n        // caller who passes their own `businessId` is naming a different\n        // merchant, and honouring it would move a limit or settle an\n        // invoice against that one while every log line and error still\n        // named this handle's.\n\n        async getCreditLine() {\n          return getJson<CreditLine>(\n            '/v1/wallet/credit',\n            new URLSearchParams({ businessId: String(businessId) }),\n          );\n        },\n        async listCreditEvents(filter = {}) {\n          const p = new URLSearchParams({ businessId: String(businessId) });\n          if (filter.limit !== undefined) p.set('limit', String(filter.limit));\n          const page = await getJson<{ events?: CreditEvent[] }>('/v1/wallet/credit/events', p);\n          // `?? []` rather than a bare `page.events`: the declared type\n          // says the key is always there, but the type describes what the\n          // service intends to send, not what a proxy, an older\n          // deployment or a truncated body actually delivered. Returning\n          // `undefined` from a method typed `CreditEvent[]` puts a lie in\n          // the caller's hands, and it surfaces as `.map of undefined`\n          // inside their render — far from the request that caused it.\n          return page.events ?? [];\n        },\n        setCreditLimit(input) {\n          return sendJson<SetCreditLimitResult>('PUT', '/v1/wallet/credit/limit', {\n            ...input,\n            businessId,\n          });\n        },\n        settleInvoice(input) {\n          return sendJson<SettleInvoiceResult>('POST', '/v1/wallet/credit/settlements', {\n            ...input,\n            businessId,\n          });\n        },\n        reverseSettlement(input) {\n          return sendJson<SettleInvoiceResult>('POST', '/v1/wallet/credit/settlements/reversal', {\n            ...input,\n            businessId,\n          });\n        },\n      };\n      return wallet;\n    },\n  };\n\n  return client;\n}\n"]}