@uengage.io/platform-sdk 2.2.0 → 2.3.0

package/README.md

@@ -33,6 +33,7 @@ const { balance, balanceMinor, currency } = await wallet.getBalance();
 // wallet.debit({ referenceId, amountMinor, service: Services.FLASH_DELIVERY, description }) — idempotent on referenceId
 // wallet.credit({ ..., reversalOf }) refund capped by that debit; ({ ..., isRefund: true }) uncapped
 // wallet.listTransactions({...}); wallet.getTransaction(id)
+// wallet.getOverview() — wallet balance or credit line? See Wallet client below.
 // Legacy-ledger passthroughs, written as top-level ledger fields:
 //   taskId, rto (debit), units, serviceBaseCost, paymentId (credit), updatedBy,
 //   occurredAt — IST 'YYYY-MM-DD HH:mm:ss', dates the CHARGE not the write
@@ -229,6 +230,158 @@ const many = await client.business.bulk([123, 124], { groups: ['profile'] });
 - The `profile` group (just `name`) is public; other groups need
   matching `business.<group>:read` capability for the calling service id.
 
+## Wallet client
+
+`getWallet(...)` is a lightweight handle — no I/O. The wallet is resolved
+server-side on the first operation, so a routing miss surfaces from the
+operation, not from `getWallet()`.
+
+### Which billing model? — start here
+
+Prepaid wallets and merchant credit lines coexist, and which one a
+merchant is on decides what a dashboard renders and which calls are even
+legal. `getOverview()` settles it with a discriminated union:
+
+```ts
+const o = await wallet.getOverview();
+
+if (o.mode === 'credit') {
+  o.creditLine.limit; // { amount, amountMinor } — net of GST
+  o.creditLine.band; // 'normal' | 'warning' | 'critical' | 'blocked'
+} else {
+  o.balance.balanceMinor; // prepaid: the wallet balance
+}
+```
+
+- `balance` is on **both** arms and means the same thing either way: what
+  the merchant can still spend. Available credit on the credit arm.
+- One request for a prepaid merchant, two for a credit one, and never a
+  404 on the happy path — it reads `getBalance().source` rather than
+  calling `getCreditLine()` and catching its 404, which would make the
+  normal state of a prepaid merchant an error on every page load.
+- A wallet service older than the credit line (no `source`) reads as
+  prepaid rather than throwing.
+- **The credit arm needs `wallet.credit:read` on top of
+  `wallet.balance:read`.** A token with only the latter gets a
+  `WalletApiError` with `status === 403` from the second call — not a
+  fallback to `prepaid`, which would render the frozen `wallet_balance`
+  these merchants no longer spend from.
+- Not a guaranteed 200: `WalletNotFoundError` (no wallet document for the
+  resolved identity) and `UnresolvableWalletError` (routing cannot name
+  one) both propagate, because both mean there is nothing to render.
+
+### Credit line
+
+The ceiling is per **merchant**, not per wallet, so an outlet's id and its
+parent's id return the same line.
+
+```ts
+const line = await wallet.getCreditLine(); // 404 CreditLineNotFoundError if prepaid
+line.consumed; //  net, UNPAID — spans months, not a calendar figure
+line.available; //  limit − consumed
+line.estimatedInvoice.total; //  exact, from recorded GST — not consumed × 1.18
+
+await wallet.setCreditLimit({
+  referenceId: 'admin:limit:1200:2026-09-02', // idempotency key
+  limitMinor: 10_000_000, // ₹1,00,000, NET of GST; 0 blocks
+  onBehalfOf: 'user:4471', // required — the trail names the human
+  reason: 'Q3 volume increase',
+  // enabled: false → take them off the credit line
+});
+
+await wallet.settleInvoice({
+  invoiceRef: 'invoice:2026-04:88213', // idempotency key
+  netMinor: 500_000, // the NET figure — what frees credit
+  gstMinor: 90_000, // recorded, not released
+  onBehalfOf: 'user:9',
+});
+await wallet.reverseSettlement({ invoiceRef: '…', onBehalfOf: 'user:9' });
+// Correcting a settled amount: reverse, then settle again with the right
+// figures AND a `reason` — different figures on a reversed invoice
+// release against the merchant's whole outstanding consumption, so the
+// service requires the correction to say what it is correcting.
+
+await wallet.listCreditEvents(); // limit changes + settlements, newest first
+await wallet.listCreditEvents({ limit: 200 }); // the service defaults to 50
+await client.wallet.getCreditUtilisation({ band: 'warning' }); // cross-merchant
+```
+
+- **Charges on a credit-line merchant must carry `breakup`** — consumption
+  is tracked net of GST, so a missing split is
+  `CreditBreakupRequiredError` rather than a guessed rate. `allowNegative`
+  is refused (`CreditOverrideRefusedError`): it disables the balance guard
+  for migration paths, and on a credit line it would disable the limit.
+- **The merchant pays gross; settlement releases net.** A ₹5,900 invoice
+  on ₹5,000 of consumption frees ₹5,000. Passing gross hands back 18% too
+  much — and it looks right in a test, since both figures sit on the same
+  invoice row.
+- **Setting a limit never touches consumption**, so raising one hands back
+  exactly the difference. Lowering below what is consumed blocks charges
+  immediately.
+- **`enabled: false` is refused while the merchant owes** —
+  `CreditLineHasOutstandingError`, carrying `consumedMinor` so you can say
+  how much to settle. Disabling moves them back to a wallet balance, which
+  with a balance owed abandons it. To _stop_ a merchant trading use
+  `limitMinor: 0`; to move them _off_, settle first.
+- Reusing an idempotency key with **different** figures is
+  `CreditIdempotencyConflictError`, not a silent replay. To correct a
+  settled amount, reverse it and settle again rather than inventing a new
+  ref — a new ref leaves the original settlement standing.
+- **A plain `credit()` is refused** — `CreditTopUpRefusedError`. These
+  merchants have no balance to top up: `wallet_balance` is the fiction the
+  line replaces and is frozen, so the write would move nothing while
+  answering 201. Credit comes back through `settleInvoice`. A genuine
+  refund is accepted — send `reversalOf` or `isRefund` and it releases
+  what the original charge consumed.
+- `getCreditUtilisation` hangs off the **client**, not a wallet handle: it
+  is the one wallet call not scoped to a business.
+
+### Errors
+
+All extend `WalletApiError` (`.status`, `.body`).
+
+`CreditLimitReachedError` carries `limitMinor` / `consumedMinor` /
+`availableMinor` / `requestedMinor`, and that is the point of it — three
+situations share the code and need different merchant copy:
+
+```ts
+if (e instanceof CreditLimitReachedError) {
+  if (e.availableMinor === undefined) {
+    // No figures in the response (trimmed or proxied body) — generic
+    // copy. Not the same as 0, which is the "used up" sentinel below.
+  } else if (e.availableMinor > 0) {
+    // Limit NOT used up — this one charge is larger than what is left.
+    // A smaller order would go through; do not send them to their KAM.
+  }
+  // Otherwise the ceiling is reached — which can be unpaid invoices
+  // rather than this month's spend. getCreditLine() tells you which.
+}
+```
+
+The figures are optional for that reason: coercing an absent
+`availableMinor` to `0` would silently claim the limit is used up.
+
+Also: `CreditLineNotFoundError` (404 — a prepaid merchant, not a
+failure), `CreditBreakupRequiredError`, `CreditOverrideRefusedError`,
+`CreditTopUpRefusedError`, `CreditIdempotencyConflictError`,
+`CreditCorrectionReasonRequiredError` (400 — a reversed invoice is being
+re-settled for different figures; pass `reason`),
+`CreditCurrencyConflictError` and `CreditCurrencyMismatchError` (409 —
+neither is caller-retryable; see their docblocks),
+`SettlementNotFoundError`, plus the
+pre-existing `InsufficientBalanceError`, `OverRefundError`,
+`InvalidReversalError`, `IdempotencyConflictError`,
+`WalletIdentityMismatchError`, `UnresolvableWalletError`,
+`WalletNotFoundError`.
+
+### Money
+
+Every figure is `{ amount, amountMinor }`. **Compute in `amountMinor`**
+(integer paise); `amount` is for display. On a ledger row `amount` is
+**gross** and `breakup.subTotalMinor` is what consumed the ceiling —
+`creditMerchantId` present means the row's `balanceBefore`/`balanceAfter`
+are available credit rather than a wallet balance.
+
 ## Auth helpers
 
 ```ts

package/dist/version.d.ts

@@ -13,4 +13,4 @@
  * namespace suite, so a later split or trim of one namespace cannot take
  * the release guard with it.
  */
-export declare const SDK_VERSION = "2.2.0";
+export declare const SDK_VERSION = "2.3.0";

package/dist/version.js

@@ -16,5 +16,5 @@ exports.SDK_VERSION = void 0;
  * namespace suite, so a later split or trim of one namespace cannot take
  * the release guard with it.
  */
-exports.SDK_VERSION = '2.2.0';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBQ1UsUUFBQSxXQUFXLEdBQUcsT0FBTyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBNYW51YWxseS1tYWludGFpbmVkIHZlcnNpb24gc3RyaW5nIHN1cmZhY2VkIHZpYSB0aGUgYFVzZXItQWdlbnRgXG4gKiBoZWFkZXIuIEtlcHQgaW4gc3luYyB3aXRoIGBwYWNrYWdlLmpzb25gIGJ5IGhhbmQgYmVjYXVzZSBwdWxsaW5nIHRoZVxuICogdmFsdWUgZnJvbSBwYWNrYWdlLmpzb24gYXQgcnVudGltZSB3b3VsZCByZXF1aXJlIGVpdGhlciBhIEpTT04gaW1wb3J0XG4gKiAoVFMgbGliIHNldHRpbmdzIGRlcGVuZGVudCkgb3IgYSBidWlsZC10aW1lIHJlcGxhY2VtZW50LCBhbmQgdGhlXG4gKiBjb3N0IG9mIG9uZSBidW1wLWluLXR3by1wbGFjZXMgcGVyIHJlbGVhc2UgaXMgc21hbGwuXG4gKlxuICogVGhhdCBjb3N0IHdhcyB1bmRlcmVzdGltYXRlZCBvbmNlOiB0aGUgcHVibGlzaCBqb2IgdmVyaWZpZXNcbiAqIHBhY2thZ2UuanNvbiBhZ2FpbnN0IHRoZSByZWxlYXNlIHRhZyBidXQgbmV2ZXIgcmVhZHMgdGhpcyBmaWxlLCBzbyB0aGVcbiAqIHR3byBkcmlmdGVkIGFuZCAxLjAuMCBzaGlwcGVkIHJlcG9ydGluZyAwLjkuMS4gQSB0ZXN0IG5vdyBwaW5zIHRoZW1cbiAqIHRvZ2V0aGVyIChgdGVzdC92ZXJzaW9uLnRlc3QudHNgKSwgc28gZm9yZ2V0dGluZyB0aGlzIGJ1bXAgZmFpbHMgdGhlXG4gKiBidWlsZCBpbnN0ZWFkIG9mIHRoZSBVc2VyLUFnZW50LiBJdCBsaXZlcyBhdCB0aGUgdG9wIGxldmVsLCBub3QgdW5kZXIgYVxuICogbmFtZXNwYWNlIHN1aXRlLCBzbyBhIGxhdGVyIHNwbGl0IG9yIHRyaW0gb2Ygb25lIG5hbWVzcGFjZSBjYW5ub3QgdGFrZVxuICogdGhlIHJlbGVhc2UgZ3VhcmQgd2l0aCBpdC5cbiAqL1xuZXhwb3J0IGNvbnN0IFNES19WRVJTSU9OID0gJzIuMi4wJztcbiJdfQ==
+exports.SDK_VERSION = '2.3.0';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBQ1UsUUFBQSxXQUFXLEdBQUcsT0FBTyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBNYW51YWxseS1tYWludGFpbmVkIHZlcnNpb24gc3RyaW5nIHN1cmZhY2VkIHZpYSB0aGUgYFVzZXItQWdlbnRgXG4gKiBoZWFkZXIuIEtlcHQgaW4gc3luYyB3aXRoIGBwYWNrYWdlLmpzb25gIGJ5IGhhbmQgYmVjYXVzZSBwdWxsaW5nIHRoZVxuICogdmFsdWUgZnJvbSBwYWNrYWdlLmpzb24gYXQgcnVudGltZSB3b3VsZCByZXF1aXJlIGVpdGhlciBhIEpTT04gaW1wb3J0XG4gKiAoVFMgbGliIHNldHRpbmdzIGRlcGVuZGVudCkgb3IgYSBidWlsZC10aW1lIHJlcGxhY2VtZW50LCBhbmQgdGhlXG4gKiBjb3N0IG9mIG9uZSBidW1wLWluLXR3by1wbGFjZXMgcGVyIHJlbGVhc2UgaXMgc21hbGwuXG4gKlxuICogVGhhdCBjb3N0IHdhcyB1bmRlcmVzdGltYXRlZCBvbmNlOiB0aGUgcHVibGlzaCBqb2IgdmVyaWZpZXNcbiAqIHBhY2thZ2UuanNvbiBhZ2FpbnN0IHRoZSByZWxlYXNlIHRhZyBidXQgbmV2ZXIgcmVhZHMgdGhpcyBmaWxlLCBzbyB0aGVcbiAqIHR3byBkcmlmdGVkIGFuZCAxLjAuMCBzaGlwcGVkIHJlcG9ydGluZyAwLjkuMS4gQSB0ZXN0IG5vdyBwaW5zIHRoZW1cbiAqIHRvZ2V0aGVyIChgdGVzdC92ZXJzaW9uLnRlc3QudHNgKSwgc28gZm9yZ2V0dGluZyB0aGlzIGJ1bXAgZmFpbHMgdGhlXG4gKiBidWlsZCBpbnN0ZWFkIG9mIHRoZSBVc2VyLUFnZW50LiBJdCBsaXZlcyBhdCB0aGUgdG9wIGxldmVsLCBub3QgdW5kZXIgYVxuICogbmFtZXNwYWNlIHN1aXRlLCBzbyBhIGxhdGVyIHNwbGl0IG9yIHRyaW0gb2Ygb25lIG5hbWVzcGFjZSBjYW5ub3QgdGFrZVxuICogdGhlIHJlbGVhc2UgZ3VhcmQgd2l0aCBpdC5cbiAqL1xuZXhwb3J0IGNvbnN0IFNES19WRVJTSU9OID0gJzIuMy4wJztcbiJdfQ==

package/dist/wallet/client.d.ts

@@ -1,5 +1,5 @@
 import { type PlatformAuth, type PlatformAuthInput, type PlatformConfigInput } from '../config';
-import type { CreditInput, Currency, DebitInput, GetWalletOptions, ListTransactionsFilter, TransactionPage, TransactionResult, WalletBalance, WalletInstance, WalletTransaction } from './schema';
+import type { CreditEvent, CreditInput, CreditLine, CreditUtilisationFilter, CreditUtilisationPage, Currency, DebitInput, GetWalletOptions, ListCreditEventsFilter, ListTransactionsFilter, ReverseSettlementInput, SetCreditLimitInput, SetCreditLimitResult, SettleInvoiceInput, SettleInvoiceResult, TransactionPage, TransactionResult, WalletBalance, WalletInstance, WalletOverview, WalletTransaction } from './schema';
 /**
  * A handle to one business wallet. Cheap to create — `getWallet(...)`
  * does no I/O. The wallet is resolved server-side on the first
@@ -7,6 +7,23 @@ import type { CreditInput, Currency, DebitInput, GetWalletOptions, ListTransacti
  * surface from the operation, not from `getWallet()`.
  */
 export interface Wallet {
+    /**
+     * WHICH MODEL IS THIS MERCHANT ON — call this first.
+     *
+     * Returns a discriminated union on `mode`, so a dashboard settles
+     * "wallet balance or credit line?" from a value rather than by
+     * catching a 404, and TypeScript narrows the rest for you:
+     *
+     * ```ts
+     * const o = await wallet.getOverview();
+     * if (o.mode === 'credit') renderCreditWidget(o.creditLine);
+     * else renderWalletPanel(o.balance);
+     * ```
+     *
+     * One request for a prepaid merchant, two for a credit one, and never
+     * a 404 on the happy path — see the implementation for why that order.
+     */
+    getOverview(): Promise<WalletOverview>;
     /** GET /v1/wallet/balance — resolves the wallet and returns its balance + currency. */
     getBalance(): Promise<WalletBalance>;
     /** GET /v1/wallet/instance — wallet identity + currency, without the balance. */
@@ -29,6 +46,39 @@ export interface Wallet {
     listTransactions(filter?: ListTransactionsFilter): Promise<TransactionPage>;
     /** GET /v1/wallet/transactions/:id — scoped to this wallet. */
     getTransaction(id: string): Promise<WalletTransaction>;
+    /**
+     * GET /v1/wallet/credit — everything the merchant widget renders.
+     * Throws `CreditLineNotFoundError` (404) when the merchant is not on
+     * the credit line, which is the normal state for a prepaid merchant.
+     * Requires `wallet.credit:read`.
+     */
+    getCreditLine(): Promise<CreditLine>;
+    /**
+     * GET /v1/wallet/credit/events — the limit-change and settlement
+     * trail, newest first. Requires `wallet.credit:read`.
+     *
+     * Pass a `limit` to widen the page: the service defaults to 50, which
+     * a merchant on the line for a year will have outgrown.
+     */
+    listCreditEvents(filter?: ListCreditEventsFilter): Promise<CreditEvent[]>;
+    /**
+     * PUT /v1/wallet/credit/limit — set the limit, creating the credit
+     * line on first use. Consumption is never touched, so raising a limit
+     * hands back exactly the difference. Requires `wallet.credit:write`.
+     */
+    setCreditLimit(input: SetCreditLimitInput): Promise<SetCreditLimitResult>;
+    /**
+     * POST /v1/wallet/credit/settlements — release the credit an invoice
+     * was holding, on payment IN FULL. Releases the invoice's net figure;
+     * see `SettleInvoiceInput.netMinor`. Requires `wallet.credit:settle`.
+     */
+    settleInvoice(input: SettleInvoiceInput): Promise<SettleInvoiceResult>;
+    /**
+     * POST /v1/wallet/credit/settlements/reversal — undo a settlement
+     * recorded in error, re-holding exactly what it released. Requires
+     * `wallet.credit:settle`.
+     */
+    reverseSettlement(input: ReverseSettlementInput): Promise<SettleInvoiceResult>;
 }
 export interface WalletClient {
     config(input: PlatformConfigInput): WalletClient;
@@ -39,6 +89,16 @@ export interface WalletClient {
      * `wallet.*` scope for the operations on the returned handle.
      */
     getWallet(opts: GetWalletOptions): Wallet;
+    /**
+     * GET /v1/wallet/credit/utilisation — every merchant on the credit
+     * line, most-utilised first.
+     *
+     * On the client rather than on a wallet handle because it is the one
+     * wallet operation that is not scoped to a business, and it carries
+     * its own capability (`wallet.credit:list`) for the same reason: it is
+     * a materially broader grant than reading one merchant's line.
+     */
+    getCreditUtilisation(filter?: CreditUtilisationFilter): Promise<CreditUtilisationPage>;
 }
 export declare class WalletApiError extends Error {
     readonly status: number;
@@ -79,4 +139,148 @@ export declare class UnresolvableWalletError extends WalletApiError {
 export declare class WalletNotFoundError extends WalletApiError {
     constructor(body: string);
 }
+/**
+ * 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.
+ */
+export declare class CreditLimitReachedError extends WalletApiError {
+    readonly limitMinor?: number;
+    readonly consumedMinor?: number;
+    readonly availableMinor?: number;
+    readonly requestedMinor?: number;
+    constructor(figures: {
+        limitMinor?: number;
+        consumedMinor?: number;
+        availableMinor?: number;
+        requestedMinor?: number;
+    }, body: string);
+}
+/**
+ * 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.
+ */
+export declare class CreditBreakupRequiredError extends WalletApiError {
+    constructor(body: string);
+}
+/** `allowNegative` was passed for a credit-line merchant (HTTP 400). */
+export declare class CreditOverrideRefusedError extends WalletApiError {
+    constructor(body: string);
+}
+/**
+ * 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.
+ */
+export declare class CreditCorrectionReasonRequiredError extends WalletApiError {
+    /** What the invoice was previously settled for, in minor units. */
+    readonly previousNetMinor: number | undefined;
+    constructor(
+    /** What the invoice was previously settled for, in minor units. */
+    previousNetMinor: number | undefined, body: string);
+}
+/**
+ * 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.
+ */
+export declare class CreditCurrencyConflictError extends WalletApiError {
+    readonly storedCurrency: string | undefined;
+    readonly requestedCurrency: string | undefined;
+    constructor(storedCurrency: string | undefined, requestedCurrency: string | undefined, body: string);
+}
+/**
+ * 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.
+ */
+export declare class CreditCurrencyMismatchError extends WalletApiError {
+    constructor(body: string);
+}
+/**
+ * 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.
+ */
+export declare class CreditTopUpRefusedError extends WalletApiError {
+    constructor(body: string);
+}
+/**
+ * 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.
+ */
+export declare class CreditLineNotFoundError extends WalletApiError {
+    constructor(body: string);
+}
+/**
+ * `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.
+ */
+export declare class CreditLineHasOutstandingError extends WalletApiError {
+    readonly consumedMinor: number;
+    readonly gstAccruedMinor: number;
+    constructor(consumedMinor: number, gstAccruedMinor: number, body: string);
+}
+/** A limit `referenceId` or an invoice was reused for different figures (HTTP 409). */
+export declare class CreditIdempotencyConflictError extends WalletApiError {
+    constructor(body: string);
+}
+/** No settlement to reverse for that invoice (HTTP 404). */
+export declare class SettlementNotFoundError extends WalletApiError {
+    constructor(body: string);
+}
 export declare function createWalletClient(input?: PlatformConfigInput): WalletClient;