@uengage.io/platform-sdk 2.2.0 → 2.4.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/upsell/index.d.ts

@@ -1,2 +1,2 @@
 export { upsell, createUpsellClient, UpsellApiError, type UpsellClient, type UpsellClientOptions, type UpsellEnv, } from './client';
-export type { Cart, CartItem, Channel, KnownLayout, LadderRung, Layout, Placement, PlacementDeleteInput, PlacementDisplay, PlacementRecord, PlacementScope, PlacementUpsertInput, PlacementsQuery, ReasonCode, StrategyParams, SuggestionsInput, SuggestionsResult, Tenant, Touchpoint, UpsellEvent, UpsellEventType, UpsellEventsInput, UpsellItem, UpsellStrategy, } from './schema';
+export type { Cart, CartItem, Channel, ItemSource, KnownLayout, LadderRung, Layout, Placement, PlacementDeleteInput, PlacementDisplay, PlacementRecord, PlacementScope, PlacementUpsertInput, PlacementsQuery, ReasonCode, StrategyParams, SuggestionsInput, SuggestionsResult, Tenant, Touchpoint, UpsellEvent, UpsellEventType, UpsellEventsInput, UpsellItem, UpsellStrategy, } from './schema';

package/dist/upsell/index.js

@@ -5,4 +5,4 @@ var client_1 = require("./client");
 Object.defineProperty(exports, "upsell", { enumerable: true, get: function () { return client_1.upsell; } });
 Object.defineProperty(exports, "createUpsellClient", { enumerable: true, get: function () { return client_1.createUpsellClient; } });
 Object.defineProperty(exports, "UpsellApiError", { enumerable: true, get: function () { return client_1.UpsellApiError; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXBzZWxsL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLG1DQU9rQjtBQU5oQixnR0FBQSxNQUFNLE9BQUE7QUFDTiw0R0FBQSxrQkFBa0IsT0FBQTtBQUNsQix3R0FBQSxjQUFjLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge1xuICB1cHNlbGwsXG4gIGNyZWF0ZVVwc2VsbENsaWVudCxcbiAgVXBzZWxsQXBpRXJyb3IsXG4gIHR5cGUgVXBzZWxsQ2xpZW50LFxuICB0eXBlIFVwc2VsbENsaWVudE9wdGlvbnMsXG4gIHR5cGUgVXBzZWxsRW52LFxufSBmcm9tICcuL2NsaWVudCc7XG5leHBvcnQgdHlwZSB7XG4gIENhcnQsXG4gIENhcnRJdGVtLFxuICBDaGFubmVsLFxuICBLbm93bkxheW91dCxcbiAgTGFkZGVyUnVuZyxcbiAgTGF5b3V0LFxuICBQbGFjZW1lbnQsXG4gIFBsYWNlbWVudERlbGV0ZUlucHV0LFxuICBQbGFjZW1lbnREaXNwbGF5LFxuICBQbGFjZW1lbnRSZWNvcmQsXG4gIFBsYWNlbWVudFNjb3BlLFxuICBQbGFjZW1lbnRVcHNlcnRJbnB1dCxcbiAgUGxhY2VtZW50c1F1ZXJ5LFxuICBSZWFzb25Db2RlLFxuICBTdHJhdGVneVBhcmFtcyxcbiAgU3VnZ2VzdGlvbnNJbnB1dCxcbiAgU3VnZ2VzdGlvbnNSZXN1bHQsXG4gIFRlbmFudCxcbiAgVG91Y2hwb2ludCxcbiAgVXBzZWxsRXZlbnQsXG4gIFVwc2VsbEV2ZW50VHlwZSxcbiAgVXBzZWxsRXZlbnRzSW5wdXQsXG4gIFVwc2VsbEl0ZW0sXG4gIFVwc2VsbFN0cmF0ZWd5LFxufSBmcm9tICcuL3NjaGVtYSc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXBzZWxsL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLG1DQU9rQjtBQU5oQixnR0FBQSxNQUFNLE9BQUE7QUFDTiw0R0FBQSxrQkFBa0IsT0FBQTtBQUNsQix3R0FBQSxjQUFjLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQge1xuICB1cHNlbGwsXG4gIGNyZWF0ZVVwc2VsbENsaWVudCxcbiAgVXBzZWxsQXBpRXJyb3IsXG4gIHR5cGUgVXBzZWxsQ2xpZW50LFxuICB0eXBlIFVwc2VsbENsaWVudE9wdGlvbnMsXG4gIHR5cGUgVXBzZWxsRW52LFxufSBmcm9tICcuL2NsaWVudCc7XG5leHBvcnQgdHlwZSB7XG4gIENhcnQsXG4gIENhcnRJdGVtLFxuICBDaGFubmVsLFxuICBJdGVtU291cmNlLFxuICBLbm93bkxheW91dCxcbiAgTGFkZGVyUnVuZyxcbiAgTGF5b3V0LFxuICBQbGFjZW1lbnQsXG4gIFBsYWNlbWVudERlbGV0ZUlucHV0LFxuICBQbGFjZW1lbnREaXNwbGF5LFxuICBQbGFjZW1lbnRSZWNvcmQsXG4gIFBsYWNlbWVudFNjb3BlLFxuICBQbGFjZW1lbnRVcHNlcnRJbnB1dCxcbiAgUGxhY2VtZW50c1F1ZXJ5LFxuICBSZWFzb25Db2RlLFxuICBTdHJhdGVneVBhcmFtcyxcbiAgU3VnZ2VzdGlvbnNJbnB1dCxcbiAgU3VnZ2VzdGlvbnNSZXN1bHQsXG4gIFRlbmFudCxcbiAgVG91Y2hwb2ludCxcbiAgVXBzZWxsRXZlbnQsXG4gIFVwc2VsbEV2ZW50VHlwZSxcbiAgVXBzZWxsRXZlbnRzSW5wdXQsXG4gIFVwc2VsbEl0ZW0sXG4gIFVwc2VsbFN0cmF0ZWd5LFxufSBmcm9tICcuL3NjaGVtYSc7XG4iXX0=

package/dist/upsell/schema.d.ts

@@ -23,9 +23,28 @@ export type KnownLayout = 'carousel_2up' | 'horizontal_carousel' | 'grid_2xn_mod
 export type Layout = KnownLayout | (string & {});
 /** Why an item was recommended. Channels render these in customer language. */
 export type ReasonCode = 'popular_now' | 'completes_meal' | 'often_ordered_together' | 'your_usual' | 'chefs_pick';
+/**
+ * Which layer produced an item.
+ *
+ * Separate from `reasonCode` on purpose: `reasonCode` is customer-facing
+ * copy the channel renders ("Popular right now"), so overloading it with
+ * provenance would change the customer's visible label whenever the
+ * source changed.
+ *
+ *   algorithm     — scored by the engine, priority pins included
+ *   merchant_list — the merchant's own list replaced the algorithm
+ *   fallback      — topped up from the backup list, safety rules only
+ */
+export type ItemSource = 'algorithm' | 'merchant_list' | 'fallback';
 /** Which rung of the resolution ladder answered the request. */
 export type LadderRung = 'full_engine' | 'band_relaxation' | 'popularity_floor' | 'backup_suggestions' | 'empty_degraded';
-export type UpsellStrategy = 'menu-order-popularity' | 'legacy-catalog-sample';
+export type UpsellStrategy = 'menu-order-popularity' | 'legacy-catalog-sample'
+/**
+ * The merchant's own list replaces the algorithm at this placement.
+ * Requires `strategyParams.merchantListItemSlugs`; an empty list falls
+ * back to `menu-order-popularity` rather than serving nothing.
+ */
+ | 'merchant-list';
 export interface PlacementDisplay {
     title: string;
     /** Requested count. Touchpoint policy may cap it lower — see `meta.maxItems`. */
@@ -96,6 +115,16 @@ export interface UpsellItem {
     veg: number | null;
     brandId: number | null;
     reasonCode: ReasonCode;
+    /**
+     * Which layer produced this item.
+     *
+     * Optional on purpose, and it stays optional. The service always sets
+     * it, but an SDK is routinely newer than the deployment it talks to —
+     * typing it as required would let TypeScript promise a string that is
+     * `undefined` at runtime against any service older than the release
+     * that added it. Narrow it yourself if you have pinned both.
+     */
+    source?: ItemSource;
 }
 export interface SuggestionsResult {
     placement: string;
@@ -105,8 +134,21 @@ export interface SuggestionsResult {
         enabled: boolean;
         strategy: UpsellStrategy;
         configVersion: string;
-        /** Which ladder rung produced these items. */
+        /**
+         * The step that PRIMARILY answered — the first one to contribute.
+         *
+         * Since the ladder became a fill loop, several steps can contribute
+         * to one response; `rung` names the one that answered first, so a
+         * healthy card that merely topped up its last slot does not read as
+         * fully degraded. Read `steps` for how far down it went.
+         */
         rung: LadderRung;
+        /**
+         * Every step that contributed at least one item, in the order they
+         * ran. Optional for the same reason as `UpsellItem.source`: an older
+         * service does not send it.
+         */
+        steps?: LadderRung[];
         /** Effective cap applied: min(display.maxItems, touchpoint policy). */
         maxItems: number;
         /** How long the client may reuse this response, in seconds. */
@@ -124,8 +166,25 @@ export interface StrategyParams {
     neverSuggestItemSlugs?: string[];
     /** "My Priority Items" — occupy reserved slots ahead of scored items. */
     priorityItemSlugs?: string[];
-    /** "Backup Suggestions" — 2-6 items, served when everything else is empty. */
+    /**
+     * "Backup Suggestions" — up to 6 items. Skips the price band (the band
+     * is usually what emptied the pool) but still respects stock, cart,
+     * exclusions, diet and `maxPrice`. It TOPS UP a short list rather than
+     * only firing when everything else returned nothing, so one scored
+     * item plus two backup items is a valid response.
+     */
     backupItemSlugs?: string[];
+    /**
+     * The merchant's own list for this placement, up to 12 items. Only read
+     * when `strategy` is `merchant-list`.
+     *
+     * Distinct from `includedItemSlugs`, which is a FILTER over the whole
+     * menu — items still get ranked by the strategy and still report as
+     * `source: 'algorithm'`. This REPLACES the pool, rotates within it so a
+     * 10-item list on a 3-slot card shows all ten over time, and reports as
+     * `source: 'merchant_list'`.
+     */
+    merchantListItemSlugs?: string[];
     excludeCartItems?: boolean;
     maxPrice?: number;
 }
@@ -187,6 +246,12 @@ export interface PlacementsQuery {
 export type UpsellEventType = 'shown' | 'added' | 'ignored';
 export interface UpsellEvent {
     type: UpsellEventType;
+    /**
+     * Echo the item's `source`. This is what makes "is my list performing
+     * better than your algorithm?" answerable — attach rate is only
+     * comparable by layer if the layer is recorded on the event.
+     */
+    source?: ItemSource;
     itemId: number;
     reasonCode?: ReasonCode;
     /** ISO-8601. Defaults to server receive time when omitted. */

package/dist/upsell/schema.js

@@ -9,4 +9,4 @@
  * admin methods.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/upsell/schema.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG","sourcesContent":["/**\n * Type surface for the platform Upsell API.\n *\n * Two consumer-facing calls: `placements(...)` (which upsell surfaces a\n * channel should render for a tenant) and `suggest(...)` (items for one\n * placement given the live cart). `reportEvents(...)` feeds attach-rate\n * telemetry. Placement config is managed via the service-actor-only\n * admin methods.\n */\n\nexport type Channel = 'mobile_app' | 'kiosk' | 'whitelabel_web' | 'whatsapp' | 'voice';\n\n/**\n * A moment in the customer journey — the unit of platform policy\n * (price band, max items, and later the signal weight profile). A\n * placement is a channel's journey label pointing at one of these.\n */\nexport type Touchpoint =\n  | 'home'\n  | 'menu_browsing'\n  | 'menu_composing'\n  | 'search_no_result'\n  | 'cart'\n  | 'pre_checkout'\n  | 'post_order';\n\n/**\n * Rendering hint, owned by the channel frontend — the platform never\n * interprets it. Known values are listed for editor completion, but any\n * lowercase identifier is valid so new layouts need no SDK release.\n */\nexport type KnownLayout =\n  | 'carousel_2up'\n  | 'horizontal_carousel'\n  | 'grid_2xn_modal'\n  | 'carousel_1up'\n  | 'vertical_list'\n  | 'grid_3xn'\n  | 'compact_list'\n  | 'hero_banner';\n\nexport type Layout = KnownLayout | (string & {});\n\n/** Why an item was recommended. Channels render these in customer language. */\nexport type ReasonCode =\n  | 'popular_now'\n  | 'completes_meal'\n  | 'often_ordered_together'\n  | 'your_usual'\n  | 'chefs_pick';\n\n/** Which rung of the resolution ladder answered the request. */\nexport type LadderRung =\n  | 'full_engine'\n  | 'band_relaxation'\n  | 'popularity_floor'\n  | 'backup_suggestions'\n  | 'empty_degraded';\n\nexport type UpsellStrategy = 'menu-order-popularity' | 'legacy-catalog-sample';\n\nexport interface PlacementDisplay {\n  title: string;\n  /** Requested count. Touchpoint policy may cap it lower — see `meta.maxItems`. */\n  maxItems: number;\n  layout: Layout;\n}\n\n/** Resolved public placement (business override > brand > platform default). */\nexport interface Placement {\n  key: string;\n  channel: Channel;\n  touchpoint: Touchpoint;\n  enabled: boolean;\n  display: PlacementDisplay;\n  configVersion: string;\n}\n\nexport interface Tenant {\n  parentId: number;\n  businessId: number;\n}\n\nexport interface CartItem {\n  itemId: number;\n  qty: number;\n  unitPrice: number;\n  /** Optional; lets the dietary gate and category no-repeat see cart contents. */\n  itemSlug?: string;\n  sectionName?: string;\n  /** Legacy vegNonvegBoth flag: 1 veg, 2 non-veg, 3 both/egg. */\n  veg?: number;\n}\n\nexport interface Cart {\n  items: CartItem[];\n  subtotal: number;\n}\n\nexport interface SuggestionsInput {\n  channel: Channel;\n  placement: string;\n  tenant: Tenant;\n  context: {\n    cart: Cart;\n    fulfilmentMode?: 'delivery' | 'pickup' | 'dine_in';\n    /**\n     * Optional; unused by the v1 scorers. In the contract from day one\n     * so personalization lands without a break. `id` MUST be the opaque\n     * platform customer id, never a mobile number.\n     */\n    customer?: { id: string };\n    /**\n     * Optional; not yet acted on. Impression fatigue is session-scoped\n     * and shared across touchpoints — send it now so channels\n     * instrument once rather than twice.\n     */\n    sessionId?: string;\n  };\n}\n\nexport interface UpsellItem {\n  itemId: number;\n  itemName: string;\n  itemSlug: string | null;\n  description: string | null;\n  sectionId: number | null;\n  sectionName: string | null;\n  /** Selling price (INR). */\n  price: number;\n  image: string | null;\n  /** Raw legacy `vegNonvegBoth` flag, passed through untranslated. */\n  veg: number | null;\n  brandId: number | null;\n  reasonCode: ReasonCode;\n}\n\nexport interface SuggestionsResult {\n  placement: string;\n  touchpoint: Touchpoint;\n  items: UpsellItem[];\n  meta: {\n    enabled: boolean;\n    strategy: UpsellStrategy;\n    configVersion: string;\n    /** Which ladder rung produced these items. */\n    rung: LadderRung;\n    /** Effective cap applied: min(display.maxItems, touchpoint policy). */\n    maxItems: number;\n    /** How long the client may reuse this response, in seconds. */\n    ttlSeconds: number;\n    /** True when the candidate source failed and the service degraded to empty. */\n    degraded?: boolean;\n  };\n}\n\n/** Merchant-controlled selection inputs. */\nexport interface StrategyParams {\n  includedItemSlugs?: string[];\n  includedSections?: string[];\n  excludedSections?: string[];\n  /** \"Never Suggest These\" — absolute, overrides the priority list. */\n  neverSuggestItemSlugs?: string[];\n  /** \"My Priority Items\" — occupy reserved slots ahead of scored items. */\n  priorityItemSlugs?: string[];\n  /** \"Backup Suggestions\" — 2-6 items, served when everything else is empty. */\n  backupItemSlugs?: string[];\n  excludeCartItems?: boolean;\n  maxPrice?: number;\n}\n\nexport type PlacementScope = 'default' | 'tenant' | 'business';\n\n/** Raw admin-plane config row (no precedence merge applied). */\nexport interface PlacementRecord {\n  scope: PlacementScope;\n  parentId?: number;\n  businessId?: number;\n  channel: Channel;\n  key: string;\n  touchpoint: Touchpoint;\n  enabled: boolean;\n  display: PlacementDisplay;\n  strategy: UpsellStrategy;\n  strategyParams: StrategyParams;\n  configVersion: string;\n  updatedAt: string;\n  updatedBy: string;\n}\n\n/**\n * Admin upsert. Scope is derived: no parentId → platform default;\n * parentId only → brand row; parentId + businessId → business override.\n */\nexport interface PlacementUpsertInput {\n  parentId?: number;\n  businessId?: number;\n  channel: Channel;\n  key: string;\n  touchpoint: Touchpoint;\n  enabled: boolean;\n  display: PlacementDisplay;\n  strategy?: UpsellStrategy;\n  strategyParams?: StrategyParams;\n}\n\nexport interface PlacementDeleteInput {\n  parentId?: number;\n  businessId?: number;\n  channel: Channel;\n  key: string;\n  /**\n   * Required by the server when `parentId` is omitted, because that call\n   * targets the PLATFORM DEFAULT row and so removes the placement for\n   * every tenant that has not overridden it. Without this the server\n   * rejects the request with 400 rather than guessing that a missing\n   * parentId was deliberate.\n   *\n   * Deliberately not defaulted to `true` here: the whole point of the\n   * flag is that deleting a default must be stated, not inferred from\n   * the shape of the call.\n   */\n  confirmDeleteDefault?: boolean;\n}\n\nexport interface PlacementsQuery {\n  channel: Channel;\n  parentId: number;\n  businessId: number;\n}\n\n// ─── Attach-rate telemetry ─────────────────────────────────────────────────\n\nexport type UpsellEventType = 'shown' | 'added' | 'ignored';\n\nexport interface UpsellEvent {\n  type: UpsellEventType;\n  itemId: number;\n  reasonCode?: ReasonCode;\n  /** ISO-8601. Defaults to server receive time when omitted. */\n  occurredAt?: string;\n}\n\nexport interface UpsellEventsInput {\n  channel: Channel;\n  placement: string;\n  tenant: Tenant;\n  sessionId?: string;\n  /** Echo `meta.configVersion` from the response being reported on. */\n  configVersion?: string;\n  events: UpsellEvent[];\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/upsell/schema.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG","sourcesContent":["/**\n * Type surface for the platform Upsell API.\n *\n * Two consumer-facing calls: `placements(...)` (which upsell surfaces a\n * channel should render for a tenant) and `suggest(...)` (items for one\n * placement given the live cart). `reportEvents(...)` feeds attach-rate\n * telemetry. Placement config is managed via the service-actor-only\n * admin methods.\n */\n\nexport type Channel = 'mobile_app' | 'kiosk' | 'whitelabel_web' | 'whatsapp' | 'voice';\n\n/**\n * A moment in the customer journey — the unit of platform policy\n * (price band, max items, and later the signal weight profile). A\n * placement is a channel's journey label pointing at one of these.\n */\nexport type Touchpoint =\n  | 'home'\n  | 'menu_browsing'\n  | 'menu_composing'\n  | 'search_no_result'\n  | 'cart'\n  | 'pre_checkout'\n  | 'post_order';\n\n/**\n * Rendering hint, owned by the channel frontend — the platform never\n * interprets it. Known values are listed for editor completion, but any\n * lowercase identifier is valid so new layouts need no SDK release.\n */\nexport type KnownLayout =\n  | 'carousel_2up'\n  | 'horizontal_carousel'\n  | 'grid_2xn_modal'\n  | 'carousel_1up'\n  | 'vertical_list'\n  | 'grid_3xn'\n  | 'compact_list'\n  | 'hero_banner';\n\nexport type Layout = KnownLayout | (string & {});\n\n/** Why an item was recommended. Channels render these in customer language. */\nexport type ReasonCode =\n  | 'popular_now'\n  | 'completes_meal'\n  | 'often_ordered_together'\n  | 'your_usual'\n  | 'chefs_pick';\n\n/**\n * Which layer produced an item.\n *\n * Separate from `reasonCode` on purpose: `reasonCode` is customer-facing\n * copy the channel renders (\"Popular right now\"), so overloading it with\n * provenance would change the customer's visible label whenever the\n * source changed.\n *\n *   algorithm     — scored by the engine, priority pins included\n *   merchant_list — the merchant's own list replaced the algorithm\n *   fallback      — topped up from the backup list, safety rules only\n */\nexport type ItemSource = 'algorithm' | 'merchant_list' | 'fallback';\n\n/** Which rung of the resolution ladder answered the request. */\nexport type LadderRung =\n  | 'full_engine'\n  | 'band_relaxation'\n  | 'popularity_floor'\n  | 'backup_suggestions'\n  | 'empty_degraded';\n\nexport type UpsellStrategy =\n  | 'menu-order-popularity'\n  | 'legacy-catalog-sample'\n  /**\n   * The merchant's own list replaces the algorithm at this placement.\n   * Requires `strategyParams.merchantListItemSlugs`; an empty list falls\n   * back to `menu-order-popularity` rather than serving nothing.\n   */\n  | 'merchant-list';\n\nexport interface PlacementDisplay {\n  title: string;\n  /** Requested count. Touchpoint policy may cap it lower — see `meta.maxItems`. */\n  maxItems: number;\n  layout: Layout;\n}\n\n/** Resolved public placement (business override > brand > platform default). */\nexport interface Placement {\n  key: string;\n  channel: Channel;\n  touchpoint: Touchpoint;\n  enabled: boolean;\n  display: PlacementDisplay;\n  configVersion: string;\n}\n\nexport interface Tenant {\n  parentId: number;\n  businessId: number;\n}\n\nexport interface CartItem {\n  itemId: number;\n  qty: number;\n  unitPrice: number;\n  /** Optional; lets the dietary gate and category no-repeat see cart contents. */\n  itemSlug?: string;\n  sectionName?: string;\n  /** Legacy vegNonvegBoth flag: 1 veg, 2 non-veg, 3 both/egg. */\n  veg?: number;\n}\n\nexport interface Cart {\n  items: CartItem[];\n  subtotal: number;\n}\n\nexport interface SuggestionsInput {\n  channel: Channel;\n  placement: string;\n  tenant: Tenant;\n  context: {\n    cart: Cart;\n    fulfilmentMode?: 'delivery' | 'pickup' | 'dine_in';\n    /**\n     * Optional; unused by the v1 scorers. In the contract from day one\n     * so personalization lands without a break. `id` MUST be the opaque\n     * platform customer id, never a mobile number.\n     */\n    customer?: { id: string };\n    /**\n     * Optional; not yet acted on. Impression fatigue is session-scoped\n     * and shared across touchpoints — send it now so channels\n     * instrument once rather than twice.\n     */\n    sessionId?: string;\n  };\n}\n\nexport interface UpsellItem {\n  itemId: number;\n  itemName: string;\n  itemSlug: string | null;\n  description: string | null;\n  sectionId: number | null;\n  sectionName: string | null;\n  /** Selling price (INR). */\n  price: number;\n  image: string | null;\n  /** Raw legacy `vegNonvegBoth` flag, passed through untranslated. */\n  veg: number | null;\n  brandId: number | null;\n  reasonCode: ReasonCode;\n  /**\n   * Which layer produced this item.\n   *\n   * Optional on purpose, and it stays optional. The service always sets\n   * it, but an SDK is routinely newer than the deployment it talks to —\n   * typing it as required would let TypeScript promise a string that is\n   * `undefined` at runtime against any service older than the release\n   * that added it. Narrow it yourself if you have pinned both.\n   */\n  source?: ItemSource;\n}\n\nexport interface SuggestionsResult {\n  placement: string;\n  touchpoint: Touchpoint;\n  items: UpsellItem[];\n  meta: {\n    enabled: boolean;\n    strategy: UpsellStrategy;\n    configVersion: string;\n    /**\n     * The step that PRIMARILY answered — the first one to contribute.\n     *\n     * Since the ladder became a fill loop, several steps can contribute\n     * to one response; `rung` names the one that answered first, so a\n     * healthy card that merely topped up its last slot does not read as\n     * fully degraded. Read `steps` for how far down it went.\n     */\n    rung: LadderRung;\n    /**\n     * Every step that contributed at least one item, in the order they\n     * ran. Optional for the same reason as `UpsellItem.source`: an older\n     * service does not send it.\n     */\n    steps?: LadderRung[];\n    /** Effective cap applied: min(display.maxItems, touchpoint policy). */\n    maxItems: number;\n    /** How long the client may reuse this response, in seconds. */\n    ttlSeconds: number;\n    /** True when the candidate source failed and the service degraded to empty. */\n    degraded?: boolean;\n  };\n}\n\n/** Merchant-controlled selection inputs. */\nexport interface StrategyParams {\n  includedItemSlugs?: string[];\n  includedSections?: string[];\n  excludedSections?: string[];\n  /** \"Never Suggest These\" — absolute, overrides the priority list. */\n  neverSuggestItemSlugs?: string[];\n  /** \"My Priority Items\" — occupy reserved slots ahead of scored items. */\n  priorityItemSlugs?: string[];\n  /**\n   * \"Backup Suggestions\" — up to 6 items. Skips the price band (the band\n   * is usually what emptied the pool) but still respects stock, cart,\n   * exclusions, diet and `maxPrice`. It TOPS UP a short list rather than\n   * only firing when everything else returned nothing, so one scored\n   * item plus two backup items is a valid response.\n   */\n  backupItemSlugs?: string[];\n  /**\n   * The merchant's own list for this placement, up to 12 items. Only read\n   * when `strategy` is `merchant-list`.\n   *\n   * Distinct from `includedItemSlugs`, which is a FILTER over the whole\n   * menu — items still get ranked by the strategy and still report as\n   * `source: 'algorithm'`. This REPLACES the pool, rotates within it so a\n   * 10-item list on a 3-slot card shows all ten over time, and reports as\n   * `source: 'merchant_list'`.\n   */\n  merchantListItemSlugs?: string[];\n  excludeCartItems?: boolean;\n  maxPrice?: number;\n}\n\nexport type PlacementScope = 'default' | 'tenant' | 'business';\n\n/** Raw admin-plane config row (no precedence merge applied). */\nexport interface PlacementRecord {\n  scope: PlacementScope;\n  parentId?: number;\n  businessId?: number;\n  channel: Channel;\n  key: string;\n  touchpoint: Touchpoint;\n  enabled: boolean;\n  display: PlacementDisplay;\n  strategy: UpsellStrategy;\n  strategyParams: StrategyParams;\n  configVersion: string;\n  updatedAt: string;\n  updatedBy: string;\n}\n\n/**\n * Admin upsert. Scope is derived: no parentId → platform default;\n * parentId only → brand row; parentId + businessId → business override.\n */\nexport interface PlacementUpsertInput {\n  parentId?: number;\n  businessId?: number;\n  channel: Channel;\n  key: string;\n  touchpoint: Touchpoint;\n  enabled: boolean;\n  display: PlacementDisplay;\n  strategy?: UpsellStrategy;\n  strategyParams?: StrategyParams;\n}\n\nexport interface PlacementDeleteInput {\n  parentId?: number;\n  businessId?: number;\n  channel: Channel;\n  key: string;\n  /**\n   * Required by the server when `parentId` is omitted, because that call\n   * targets the PLATFORM DEFAULT row and so removes the placement for\n   * every tenant that has not overridden it. Without this the server\n   * rejects the request with 400 rather than guessing that a missing\n   * parentId was deliberate.\n   *\n   * Deliberately not defaulted to `true` here: the whole point of the\n   * flag is that deleting a default must be stated, not inferred from\n   * the shape of the call.\n   */\n  confirmDeleteDefault?: boolean;\n}\n\nexport interface PlacementsQuery {\n  channel: Channel;\n  parentId: number;\n  businessId: number;\n}\n\n// ─── Attach-rate telemetry ─────────────────────────────────────────────────\n\nexport type UpsellEventType = 'shown' | 'added' | 'ignored';\n\nexport interface UpsellEvent {\n  type: UpsellEventType;\n  /**\n   * Echo the item's `source`. This is what makes \"is my list performing\n   * better than your algorithm?\" answerable — attach rate is only\n   * comparable by layer if the layer is recorded on the event.\n   */\n  source?: ItemSource;\n  itemId: number;\n  reasonCode?: ReasonCode;\n  /** ISO-8601. Defaults to server receive time when omitted. */\n  occurredAt?: string;\n}\n\nexport interface UpsellEventsInput {\n  channel: Channel;\n  placement: string;\n  tenant: Tenant;\n  sessionId?: string;\n  /** Echo `meta.configVersion` from the response being reported on. */\n  configVersion?: string;\n  events: UpsellEvent[];\n}\n"]}

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.4.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.4.0';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBQ1UsUUFBQSxXQUFXLEdBQUcsT0FBTyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBNYW51YWxseS1tYWludGFpbmVkIHZlcnNpb24gc3RyaW5nIHN1cmZhY2VkIHZpYSB0aGUgYFVzZXItQWdlbnRgXG4gKiBoZWFkZXIuIEtlcHQgaW4gc3luYyB3aXRoIGBwYWNrYWdlLmpzb25gIGJ5IGhhbmQgYmVjYXVzZSBwdWxsaW5nIHRoZVxuICogdmFsdWUgZnJvbSBwYWNrYWdlLmpzb24gYXQgcnVudGltZSB3b3VsZCByZXF1aXJlIGVpdGhlciBhIEpTT04gaW1wb3J0XG4gKiAoVFMgbGliIHNldHRpbmdzIGRlcGVuZGVudCkgb3IgYSBidWlsZC10aW1lIHJlcGxhY2VtZW50LCBhbmQgdGhlXG4gKiBjb3N0IG9mIG9uZSBidW1wLWluLXR3by1wbGFjZXMgcGVyIHJlbGVhc2UgaXMgc21hbGwuXG4gKlxuICogVGhhdCBjb3N0IHdhcyB1bmRlcmVzdGltYXRlZCBvbmNlOiB0aGUgcHVibGlzaCBqb2IgdmVyaWZpZXNcbiAqIHBhY2thZ2UuanNvbiBhZ2FpbnN0IHRoZSByZWxlYXNlIHRhZyBidXQgbmV2ZXIgcmVhZHMgdGhpcyBmaWxlLCBzbyB0aGVcbiAqIHR3byBkcmlmdGVkIGFuZCAxLjAuMCBzaGlwcGVkIHJlcG9ydGluZyAwLjkuMS4gQSB0ZXN0IG5vdyBwaW5zIHRoZW1cbiAqIHRvZ2V0aGVyIChgdGVzdC92ZXJzaW9uLnRlc3QudHNgKSwgc28gZm9yZ2V0dGluZyB0aGlzIGJ1bXAgZmFpbHMgdGhlXG4gKiBidWlsZCBpbnN0ZWFkIG9mIHRoZSBVc2VyLUFnZW50LiBJdCBsaXZlcyBhdCB0aGUgdG9wIGxldmVsLCBub3QgdW5kZXIgYVxuICogbmFtZXNwYWNlIHN1aXRlLCBzbyBhIGxhdGVyIHNwbGl0IG9yIHRyaW0gb2Ygb25lIG5hbWVzcGFjZSBjYW5ub3QgdGFrZVxuICogdGhlIHJlbGVhc2UgZ3VhcmQgd2l0aCBpdC5cbiAqL1xuZXhwb3J0IGNvbnN0IFNES19WRVJTSU9OID0gJzIuNC4wJztcbiJdfQ==

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;