@uengage.io/platform-sdk 2.2.0 → 2.4.0

package/dist/wallet/index.d.ts

@@ -1,3 +1,3 @@
-export type { WalletRef, WalletBalance, WalletInstance, Currency, Amount, Balance, ServiceRef, GetWalletOptions, Breakup, WalletTags, WalletOverride, DebitInput, CreditInput, TransactionResult, WalletTransaction, ListTransactionsFilter, TransactionPage, } from './schema';
+export type { WalletRef, WalletBalance, WalletInstance, WalletOverview, Currency, Amount, Balance, ServiceRef, GetWalletOptions, Breakup, WalletTags, WalletOverride, DebitInput, CreditInput, TransactionResult, WalletTransaction, ListTransactionsFilter, TransactionPage, CreditAmount, CreditBand, CreditLine, SetCreditLimitInput, SetCreditLimitResult, SettleInvoiceInput, SettleInvoiceResult, ReverseSettlementInput, CreditEvent, ListCreditEventsFilter, CreditUtilisationFilter, CreditUtilisationPage, } from './schema';
 export { Services, type Service } from './services';
-export { createWalletClient, WalletApiError, InsufficientBalanceError, OverRefundError, InvalidReversalError, IdempotencyConflictError, WalletIdentityMismatchError, UnresolvableWalletError, WalletNotFoundError, type WalletClient, type Wallet, } from './client';
+export { createWalletClient, WalletApiError, InsufficientBalanceError, OverRefundError, InvalidReversalError, IdempotencyConflictError, WalletIdentityMismatchError, UnresolvableWalletError, WalletNotFoundError, CreditLimitReachedError, CreditBreakupRequiredError, CreditOverrideRefusedError, CreditTopUpRefusedError, CreditCorrectionReasonRequiredError, CreditCurrencyConflictError, CreditCurrencyMismatchError, CreditLineNotFoundError, CreditIdempotencyConflictError, CreditLineHasOutstandingError, SettlementNotFoundError, type WalletClient, type Wallet, } from './client';

package/dist/wallet/index.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 = exports.createWalletClient = exports.Services = void 0;
+exports.SettlementNotFoundError = exports.CreditLineHasOutstandingError = exports.CreditIdempotencyConflictError = exports.CreditLineNotFoundError = exports.CreditCurrencyMismatchError = exports.CreditCurrencyConflictError = exports.CreditCorrectionReasonRequiredError = exports.CreditTopUpRefusedError = exports.CreditOverrideRefusedError = exports.CreditBreakupRequiredError = exports.CreditLimitReachedError = exports.WalletNotFoundError = exports.UnresolvableWalletError = exports.WalletIdentityMismatchError = exports.IdempotencyConflictError = exports.InvalidReversalError = exports.OverRefundError = exports.InsufficientBalanceError = exports.WalletApiError = exports.createWalletClient = exports.Services = void 0;
 var services_1 = require("./services");
 Object.defineProperty(exports, "Services", { enumerable: true, get: function () { return services_1.Services; } });
 var client_1 = require("./client");
@@ -13,4 +13,15 @@ Object.defineProperty(exports, "IdempotencyConflictError", { enumerable: true, g
 Object.defineProperty(exports, "WalletIdentityMismatchError", { enumerable: true, get: function () { return client_1.WalletIdentityMismatchError; } });
 Object.defineProperty(exports, "UnresolvableWalletError", { enumerable: true, get: function () { return client_1.UnresolvableWalletError; } });
 Object.defineProperty(exports, "WalletNotFoundError", { enumerable: true, get: function () { return client_1.WalletNotFoundError; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd2FsbGV0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQW1CQSx1Q0FBb0Q7QUFBM0Msb0dBQUEsUUFBUSxPQUFBO0FBQ2pCLG1DQVlrQjtBQVhoQiw0R0FBQSxrQkFBa0IsT0FBQTtBQUNsQix3R0FBQSxjQUFjLE9BQUE7QUFDZCxrSEFBQSx3QkFBd0IsT0FBQTtBQUN4Qix5R0FBQSxlQUFlLE9BQUE7QUFDZiw4R0FBQSxvQkFBb0IsT0FBQTtBQUNwQixrSEFBQSx3QkFBd0IsT0FBQTtBQUN4QixxSEFBQSwyQkFBMkIsT0FBQTtBQUMzQixpSEFBQSx1QkFBdUIsT0FBQTtBQUN2Qiw2R0FBQSxtQkFBbUIsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIHtcbiAgV2FsbGV0UmVmLFxuICBXYWxsZXRCYWxhbmNlLFxuICBXYWxsZXRJbnN0YW5jZSxcbiAgQ3VycmVuY3ksXG4gIEFtb3VudCxcbiAgQmFsYW5jZSxcbiAgU2VydmljZVJlZixcbiAgR2V0V2FsbGV0T3B0aW9ucyxcbiAgQnJlYWt1cCxcbiAgV2FsbGV0VGFncyxcbiAgV2FsbGV0T3ZlcnJpZGUsXG4gIERlYml0SW5wdXQsXG4gIENyZWRpdElucHV0LFxuICBUcmFuc2FjdGlvblJlc3VsdCxcbiAgV2FsbGV0VHJhbnNhY3Rpb24sXG4gIExpc3RUcmFuc2FjdGlvbnNGaWx0ZXIsXG4gIFRyYW5zYWN0aW9uUGFnZSxcbn0gZnJvbSAnLi9zY2hlbWEnO1xuZXhwb3J0IHsgU2VydmljZXMsIHR5cGUgU2VydmljZSB9IGZyb20gJy4vc2VydmljZXMnO1xuZXhwb3J0IHtcbiAgY3JlYXRlV2FsbGV0Q2xpZW50LFxuICBXYWxsZXRBcGlFcnJvcixcbiAgSW5zdWZmaWNpZW50QmFsYW5jZUVycm9yLFxuICBPdmVyUmVmdW5kRXJyb3IsXG4gIEludmFsaWRSZXZlcnNhbEVycm9yLFxuICBJZGVtcG90ZW5jeUNvbmZsaWN0RXJyb3IsXG4gIFdhbGxldElkZW50aXR5TWlzbWF0Y2hFcnJvcixcbiAgVW5yZXNvbHZhYmxlV2FsbGV0RXJyb3IsXG4gIFdhbGxldE5vdEZvdW5kRXJyb3IsXG4gIHR5cGUgV2FsbGV0Q2xpZW50LFxuICB0eXBlIFdhbGxldCxcbn0gZnJvbSAnLi9jbGllbnQnO1xuIl19
+Object.defineProperty(exports, "CreditLimitReachedError", { enumerable: true, get: function () { return client_1.CreditLimitReachedError; } });
+Object.defineProperty(exports, "CreditBreakupRequiredError", { enumerable: true, get: function () { return client_1.CreditBreakupRequiredError; } });
+Object.defineProperty(exports, "CreditOverrideRefusedError", { enumerable: true, get: function () { return client_1.CreditOverrideRefusedError; } });
+Object.defineProperty(exports, "CreditTopUpRefusedError", { enumerable: true, get: function () { return client_1.CreditTopUpRefusedError; } });
+Object.defineProperty(exports, "CreditCorrectionReasonRequiredError", { enumerable: true, get: function () { return client_1.CreditCorrectionReasonRequiredError; } });
+Object.defineProperty(exports, "CreditCurrencyConflictError", { enumerable: true, get: function () { return client_1.CreditCurrencyConflictError; } });
+Object.defineProperty(exports, "CreditCurrencyMismatchError", { enumerable: true, get: function () { return client_1.CreditCurrencyMismatchError; } });
+Object.defineProperty(exports, "CreditLineNotFoundError", { enumerable: true, get: function () { return client_1.CreditLineNotFoundError; } });
+Object.defineProperty(exports, "CreditIdempotencyConflictError", { enumerable: true, get: function () { return client_1.CreditIdempotencyConflictError; } });
+Object.defineProperty(exports, "CreditLineHasOutstandingError", { enumerable: true, get: function () { return client_1.CreditLineHasOutstandingError; } });
+Object.defineProperty(exports, "SettlementNotFoundError", { enumerable: true, get: function () { return client_1.SettlementNotFoundError; } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/wallet/schema.d.ts

@@ -31,11 +31,201 @@ export interface ServiceRef {
     name: string;
 }
 export interface WalletBalance {
-    /** Balance in major units. */
+    /**
+     * What the business can still spend, in major units.
+     *
+     * For a prepaid wallet this is its balance. For a merchant on the
+     * credit line it is their AVAILABLE CREDIT, net of GST — one number
+     * either way, so a caller that pre-checks a balance before allowing a
+     * charge needs no change. `source` says which it is.
+     */
     balance: number;
-    /** Balance in integer minor units, per the wallet's currency. */
+    /** The same figure in integer minor units, per the wallet's currency. */
     balanceMinor: number;
     currency: Currency;
+    /**
+     * Which ceiling the figure came from. Additive — absent on responses
+     * from a wallet service deployed before the credit line, so treat
+     * `undefined` as `'wallet_balance'`.
+     */
+    source?: 'wallet_balance' | 'credit_line';
+}
+/** A credit-line figure in major + minor units. */
+export interface CreditAmount {
+    amount: number;
+    amountMinor: number;
+}
+/**
+ * Where a merchant sits against their limit.
+ *
+ * `normal` below 80%, `warning` 80–94%, `critical` 95–99%, `blocked` at
+ * 100% and above. Drives the widget's bar colour (U3) and which alerts
+ * have fired.
+ */
+export type CreditBand = 'normal' | 'warning' | 'critical' | 'blocked';
+/**
+ * A merchant's credit line — everything the merchant widget renders,
+ * from one call.
+ *
+ * The ceiling is per MERCHANT, not per wallet: all of a merchant's
+ * outlets consume one line, so passing an outlet's id and passing its
+ * parent's return the same figures.
+ */
+export interface CreditLine {
+    merchantId: string;
+    enabled: boolean;
+    /** Net of GST. */
+    limit: CreditAmount;
+    /**
+     * Net, unpaid consumption. SPANS MONTHS — this is not a
+     * calendar-month figure. It accumulates as charges land and falls only
+     * when an invoice is settled, so a merchant with old unpaid invoices
+     * carries them here.
+     */
+    consumed: CreditAmount;
+    available: CreditAmount;
+    utilisationPercent: number;
+    band: CreditBand;
+    /**
+     * `consumed + gstAccrued`, from the GST recorded on each charge — not
+     * `consumed × 1.18`, so a zero-rated merchant is right too.
+     */
+    estimatedInvoice: {
+        net: CreditAmount;
+        gst: CreditAmount;
+        total: CreditAmount;
+    };
+    currency: Currency;
+    updatedAt: string;
+}
+/**
+ * What a dashboard needs at page load, in one shape.
+ *
+ * A DISCRIMINATED UNION on `mode`, so `if (o.mode === 'credit')` narrows
+ * to the credit-line fields and a prepaid branch cannot reach them. That
+ * is the point: which model a merchant is on decides which panels the
+ * dashboard renders and which calls are even legal, so it has to be
+ * settled before anything else runs — and settled by a value, not by
+ * catching a 404.
+ *
+ * `balance` is present on BOTH arms and always means the same thing:
+ * what the merchant can still spend. On the credit arm it is available
+ * credit, on the prepaid arm it is the wallet balance.
+ */
+export type WalletOverview = {
+    mode: 'prepaid';
+    balance: WalletBalance;
+} | {
+    mode: 'credit';
+    balance: WalletBalance;
+    creditLine: CreditLine;
+};
+export interface SetCreditLimitInput {
+    /** Idempotency key: a retried admin click applies the change once. */
+    referenceId: string;
+    /** The new limit in minor units, NET of GST. `0` blocks without removing the line. */
+    limitMinor: number;
+    /** Absent means enable — setting a limit is what puts a merchant on the credit line. */
+    enabled?: boolean;
+    /**
+     * The human whose decision this is, e.g. `"user:4471"`. REQUIRED: the
+     * caller's own service identity is recorded separately, and a trail
+     * that named only the admin panel would be useless.
+     */
+    onBehalfOf: string;
+    reason?: string;
+}
+export interface SetCreditLimitResult {
+    creditLine: CreditLine;
+    /** True when this call replayed an earlier one with the same `referenceId`. */
+    idempotent: boolean;
+}
+export interface SettleInvoiceInput {
+    /** The invoice being settled; the idempotency key for the release. */
+    invoiceRef: string;
+    /**
+     * The invoice's NET figure, minor units — NOT the gross the merchant
+     * paid. A ₹5,900 invoice on ₹5,000 of consumption releases ₹5,000,
+     * because the limit and consumption are denominated net of GST.
+     */
+    netMinor: number;
+    /** The invoice's GST figure, minor units. Recorded, not released. */
+    gstMinor: number;
+    onBehalfOf: string;
+    /**
+     * Optional in general, REQUIRED when re-settling a reversed invoice
+     * with figures that differ from the original — that is a correction,
+     * and it releases against the merchant's whole outstanding consumption
+     * rather than this invoice's amount, so it has to say what it is
+     * correcting. Without it the call is
+     * `CreditCorrectionReasonRequiredError`. Re-settling with the same
+     * figures needs none.
+     */
+    reason?: string;
+}
+export interface SettleInvoiceResult {
+    creditLine: CreditLine;
+    releasedNetMinor: number;
+    releasedGstMinor: number;
+    idempotent: boolean;
+}
+export interface ReverseSettlementInput {
+    invoiceRef: string;
+    onBehalfOf: string;
+    reason?: string;
+}
+/** One entry in a merchant's limit-change and settlement trail. */
+export interface CreditEvent {
+    /**
+     * A reversal is its own row rather than an edit to the settlement it
+     * undoes, so the trail stays append-only and each row names its own
+     * actor and reason.
+     */
+    kind: 'limit_changed' | 'settled' | 'settlement_reversed';
+    ref: string;
+    limitBeforeMinor?: number;
+    limitAfterMinor?: number;
+    enabledBefore?: boolean;
+    enabledAfter?: boolean;
+    netMinor?: number;
+    gstMinor?: number;
+    releasedNetMinor?: number;
+    /** GST released alongside `releasedNetMinor`; recorded, not credited. */
+    releasedGstMinor?: number;
+    /**
+     * Which reversal of this settlement, from 1. On reversal rows only: an
+     * invoice can be settled, reversed, re-settled and reversed again, and
+     * each reversal is a separate row.
+     */
+    cycle?: number;
+    /** Set on a `settled` row when it was reversed; cleared if re-settled. */
+    reversedAt?: string;
+    /** The OAuth client that called. */
+    actor: string;
+    /** The human the caller was acting for. */
+    onBehalfOf?: string;
+    reason?: string;
+    recordedAt: string;
+}
+export interface ListCreditEventsFilter {
+    /**
+     * How many events to return, newest first. The service defaults to 50
+     * — enough for a recent-activity panel, not for a merchant's whole
+     * history on the line.
+     */
+    limit?: number;
+}
+export interface CreditUtilisationFilter {
+    /** Only merchants at or above this utilisation, in basis points (8000 = 80%). */
+    minUtilisationBps?: number;
+    band?: CreditBand;
+    offset?: number;
+    limit?: number;
+}
+export interface CreditUtilisationPage {
+    merchants: CreditLine[];
+    /** Matching merchants before paging, for the dashboard's count. */
+    total: number;
 }
 /** Wallet details (identity + currency), without the balance. */
 export interface WalletInstance {
@@ -196,6 +386,26 @@ export interface WalletTransaction {
     /** True when the entry is marked a refund (reversal-linked or standalone). */
     refund?: boolean;
     updatedBy?: string;
+    /**
+     * The GST split recorded on the charge, in minor units.
+     *
+     * `amount` is the GROSS figure. On a credit-line row it is NOT what
+     * moved against the ceiling — `subTotalMinor` is, and it is what an
+     * invoice is built from. Absent on rows written without a split (every
+     * legacy row); guaranteed on a credit-line row, because the split is
+     * mandatory there.
+     */
+    breakup?: {
+        subTotalMinor: number;
+        gstMinor: number;
+        gstRate: number;
+    };
+    /**
+     * Set when the charge consumed a credit line. Its presence also means
+     * `balanceBefore`/`balanceAfter` on this row are AVAILABLE CREDIT
+     * rather than a wallet balance.
+     */
+    creditMerchantId?: string;
 }
 export interface ListTransactionsFilter {
     type?: 'debit' | 'credit' | 'all';

package/dist/wallet/schema.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/wallet/schema.ts"],"names":[],"mappings":"","sourcesContent":["import type { Service } from './services';\n\n/**\n * Wallet identity inside the platform wallet service. `childBusinessId`\n * is `\"0\"` when the parent business's own wallet answered (parent-chain\n * billing resolved on the outlet's behalf).\n */\nexport interface WalletRef {\n  parentBusinessId: string;\n  childBusinessId: string;\n}\n\n/** Currency descriptor for a wallet. */\nexport interface Currency {\n  /** ISO code, e.g. `\"INR\"`. */\n  code: string;\n  /** Display symbol, e.g. `\"₹\"`. */\n  symbol: string;\n}\n\n/** A transaction amount in major + integer minor units. */\nexport interface Amount {\n  amount: number;\n  amountMinor: number;\n}\n\n/** A balance in major + integer minor units. */\nexport interface Balance {\n  balance: number;\n  balanceMinor: number;\n}\n\n/** A chargeable service, as returned on a transaction. */\nexport interface ServiceRef {\n  id: number;\n  name: string;\n}\n\nexport interface WalletBalance {\n  /** Balance in major units. */\n  balance: number;\n  /** Balance in integer minor units, per the wallet's currency. */\n  balanceMinor: number;\n  currency: Currency;\n}\n\n/** Wallet details (identity + currency), without the balance. */\nexport interface WalletInstance {\n  wallet: WalletRef;\n  currency: Currency;\n}\n\n/**\n * Options for `wallet.getWallet(...)`.\n *\n * `id` is a typed entity reference, e.g. `\"business:8841\"` (same\n * prefixed shape the platform uses for JWT subjects). Today only the\n * `business:` prefix is supported.\n */\nexport interface GetWalletOptions {\n  id: string;\n  /**\n   * Force the business's own (child) wallet, bypassing parent-funding\n   * routing (`flash_configuration.bId_deduction`). Default `false` — the\n   * service resolves child-vs-parent automatically. No effect for a root\n   * business, which only has its own wallet.\n   */\n  forceChildWallet?: boolean;\n}\n\n/** The GST split on a charge. Recorded on the ledger; the service does not compute GST. */\nexport interface Breakup {\n  subTotalMinor: number;\n  gstMinor: number;\n  gstRate: number;\n}\n\n/** Searchable key/value metadata attached to a transaction. */\nexport type WalletTags = Record<string, string>;\n\n/**\n * An explicit wallet identity that REPLACES `bId_deduction` routing for\n * one write. For callers that already know which wallet pays (admin\n * tools, uengage-crm) or want to assert an identity the routing tables\n * might disagree with.\n *\n * The currency is NOT part of this — the service still takes it from the\n * business that owns the wallet, so a named wallet cannot be charged at\n * the wrong minor-unit scale.\n */\nexport interface WalletOverride {\n  parentBusinessId: string;\n  /** `\"0\"` for the parent business's own wallet. */\n  childBusinessId: string;\n}\n\n/** Fields common to a debit and a credit. */\ninterface TransactionInputBase {\n  /** Deterministic id of the business event — the idempotency key. */\n  referenceId: string;\n  /** Amount in integer minor units of the wallet's currency. */\n  amountMinor: number;\n  service: Service;\n  description: string;\n  breakup?: Breakup;\n  tags?: WalletTags;\n\n  /**\n   * Charge this wallet instead of the one this handle's business id\n   * routes to — for THIS call only. Bypasses\n   * `flash_configuration.bId_deduction` entirely, and cannot be combined\n   * with a handle built with `forceChildWallet`.\n   */\n  wallet?: WalletOverride;\n  // Note: for a child wallet the service asserts `parentBusinessId`\n  // against the wallet document rather than filtering on it, so a wrong\n  // one is a 409 `wallet_identity_mismatch` rather than a silent charge to\n  // the right wallet under the wrong identity.\n\n  // ── legacy-ledger passthroughs ──\n  // Written as TOP-LEVEL fields on the ledger document because flash's\n  // own code and finance reporting query them there. They are not `tags`:\n  // `tags` is Record<string, string> (so `rto` and `units` would not fit)\n  // and would nest them under `tags.*`, breaking those queries.\n  /**\n   * Flash's natural key for the delivery task. Stored as both `task_id`\n   * and `transaction_order_id`. NOT an idempotency key — `referenceId`\n   * is; this is the key flash's own pre-check filters on.\n   */\n  taskId?: string;\n  /**\n   * Chargeable units on this line. Defaults to 1 on a DEBIT when `taskId`\n   * is set (the legacy writer's credit row carries no `units` key, so\n   * credits are not defaulted); an explicit value is honoured on either.\n   */\n  units?: number;\n  /**\n   * Tariff base cost in MAJOR units (not minor, unlike `amountMinor`),\n   * caller-denominated and stored unconverted.\n   */\n  serviceBaseCost?: number;\n  /**\n   * When the charge actually OCCURRED, IST `YYYY-MM-DD HH:mm:ss`. Sets\n   * the ledger's `inserted_date` — what finance reporting and the\n   * `from`/`to` history filter range on — so a backfill or a replay is\n   * dated at the event, not at the write. The wall-clock write time is\n   * recorded separately as `recordedAt`. Defaults to now; may not be in\n   * the future or backdated more than 90 days.\n   */\n  occurredAt?: string;\n  /**\n   * The originating actor, stored as `updated_by` ('PetPooja', a rider\n   * id, 'Reconcile'). The OAuth client that authenticated the call is\n   * recorded separately and is unaffected.\n   */\n  updatedBy?: string;\n}\n\nexport interface DebitInput extends TransactionInputBase {\n  /** Allow the balance to go negative (flash migration only — needs sign-off). */\n  allowNegative?: boolean;\n  /** Return-to-origin leg. Debits only; part of flash's dedupe key. */\n  rto?: boolean;\n}\n\nexport interface CreditInput extends TransactionInputBase {\n  /** Link a refund to the original debit's `id`; subject to the over-refund guard. */\n  reversalOf?: string;\n  /**\n   * Mark this credit as a refund WITHOUT linking it to an original debit,\n   * and so without the over-refund guard. For refunds computed\n   * independently of the debit — a partial (buffer-only) refund that can\n   * legitimately exceed it. Use `reversalOf` instead when the refund\n   * genuinely reverses one known debit and should be capped by it.\n   */\n  isRefund?: boolean;\n  /**\n   * Payment reference. Credits only. The empty string is meaningful and\n   * is sent through as-is.\n   */\n  paymentId?: string;\n}\n\n/** What `debit()` / `credit()` return. */\nexport interface TransactionResult {\n  /** The wallet_transactions record id. Persist this; use as `reversalOf` for a refund. */\n  id: string;\n  /** `true` = a replay of an earlier identical referenceId; no money moved now. */\n  idempotent: boolean;\n  type: 'debit' | 'credit';\n  amount: Amount;\n  balanceBefore: Balance;\n  balanceAfter: Balance;\n  currency: Currency;\n  wallet: WalletRef;\n}\n\n/** A transaction as returned by `listTransactions()` / `getTransaction()`. */\nexport interface WalletTransaction {\n  id: string;\n  type: string;\n  amount: Amount;\n  service: ServiceRef;\n  description: string;\n  tags?: WalletTags;\n  reversalOf?: string;\n  balanceBefore: Balance;\n  balanceAfter: Balance;\n  /** When the charge occurred, IST. A backdated write (`occurredAt`) sets it. */\n  timestamp: string;\n  /**\n   * Wall-clock write time, IST. Absent on transactions written before\n   * this field existed, where `timestamp` is also the write time.\n   */\n  recordedAt?: string;\n  currency: Currency;\n  wallet: WalletRef;\n\n  // ── legacy-ledger passthroughs, echoed back ──\n  taskId?: string;\n  rto?: boolean;\n  units?: number;\n  serviceBaseCost?: number;\n  paymentId?: string;\n  /** True when the entry is marked a refund (reversal-linked or standalone). */\n  refund?: boolean;\n  updatedBy?: string;\n}\n\nexport interface ListTransactionsFilter {\n  type?: 'debit' | 'credit' | 'all';\n  from?: string;\n  to?: string;\n  service?: Service;\n  referenceId?: string;\n  /** Single tag filter as `key:value`. */\n  tag?: string;\n  cursor?: string;\n  limit?: number;\n}\n\nexport interface TransactionPage {\n  transactions: WalletTransaction[];\n  nextCursor?: string;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/wallet/schema.ts"],"names":[],"mappings":"","sourcesContent":["import type { Service } from './services';\n\n/**\n * Wallet identity inside the platform wallet service. `childBusinessId`\n * is `\"0\"` when the parent business's own wallet answered (parent-chain\n * billing resolved on the outlet's behalf).\n */\nexport interface WalletRef {\n  parentBusinessId: string;\n  childBusinessId: string;\n}\n\n/** Currency descriptor for a wallet. */\nexport interface Currency {\n  /** ISO code, e.g. `\"INR\"`. */\n  code: string;\n  /** Display symbol, e.g. `\"₹\"`. */\n  symbol: string;\n}\n\n/** A transaction amount in major + integer minor units. */\nexport interface Amount {\n  amount: number;\n  amountMinor: number;\n}\n\n/** A balance in major + integer minor units. */\nexport interface Balance {\n  balance: number;\n  balanceMinor: number;\n}\n\n/** A chargeable service, as returned on a transaction. */\nexport interface ServiceRef {\n  id: number;\n  name: string;\n}\n\nexport interface WalletBalance {\n  /**\n   * What the business can still spend, in major units.\n   *\n   * For a prepaid wallet this is its balance. For a merchant on the\n   * credit line it is their AVAILABLE CREDIT, net of GST — one number\n   * either way, so a caller that pre-checks a balance before allowing a\n   * charge needs no change. `source` says which it is.\n   */\n  balance: number;\n  /** The same figure in integer minor units, per the wallet's currency. */\n  balanceMinor: number;\n  currency: Currency;\n  /**\n   * Which ceiling the figure came from. Additive — absent on responses\n   * from a wallet service deployed before the credit line, so treat\n   * `undefined` as `'wallet_balance'`.\n   */\n  source?: 'wallet_balance' | 'credit_line';\n}\n\n// ─── Credit line ────────────────────────────────────────────────────────────\n\n/** A credit-line figure in major + minor units. */\nexport interface CreditAmount {\n  amount: number;\n  amountMinor: number;\n}\n\n/**\n * Where a merchant sits against their limit.\n *\n * `normal` below 80%, `warning` 80–94%, `critical` 95–99%, `blocked` at\n * 100% and above. Drives the widget's bar colour (U3) and which alerts\n * have fired.\n */\nexport type CreditBand = 'normal' | 'warning' | 'critical' | 'blocked';\n\n/**\n * A merchant's credit line — everything the merchant widget renders,\n * from one call.\n *\n * The ceiling is per MERCHANT, not per wallet: all of a merchant's\n * outlets consume one line, so passing an outlet's id and passing its\n * parent's return the same figures.\n */\nexport interface CreditLine {\n  merchantId: string;\n  enabled: boolean;\n  /** Net of GST. */\n  limit: CreditAmount;\n  /**\n   * Net, unpaid consumption. SPANS MONTHS — this is not a\n   * calendar-month figure. It accumulates as charges land and falls only\n   * when an invoice is settled, so a merchant with old unpaid invoices\n   * carries them here.\n   */\n  consumed: CreditAmount;\n  available: CreditAmount;\n  utilisationPercent: number;\n  band: CreditBand;\n  /**\n   * `consumed + gstAccrued`, from the GST recorded on each charge — not\n   * `consumed × 1.18`, so a zero-rated merchant is right too.\n   */\n  estimatedInvoice: { net: CreditAmount; gst: CreditAmount; total: CreditAmount };\n  currency: Currency;\n  updatedAt: string;\n}\n\n/**\n * What a dashboard needs at page load, in one shape.\n *\n * A DISCRIMINATED UNION on `mode`, so `if (o.mode === 'credit')` narrows\n * to the credit-line fields and a prepaid branch cannot reach them. That\n * is the point: which model a merchant is on decides which panels the\n * dashboard renders and which calls are even legal, so it has to be\n * settled before anything else runs — and settled by a value, not by\n * catching a 404.\n *\n * `balance` is present on BOTH arms and always means the same thing:\n * what the merchant can still spend. On the credit arm it is available\n * credit, on the prepaid arm it is the wallet balance.\n */\nexport type WalletOverview =\n  | { mode: 'prepaid'; balance: WalletBalance }\n  | { mode: 'credit'; balance: WalletBalance; creditLine: CreditLine };\n\nexport interface SetCreditLimitInput {\n  /** Idempotency key: a retried admin click applies the change once. */\n  referenceId: string;\n  /** The new limit in minor units, NET of GST. `0` blocks without removing the line. */\n  limitMinor: number;\n  /** Absent means enable — setting a limit is what puts a merchant on the credit line. */\n  enabled?: boolean;\n  /**\n   * The human whose decision this is, e.g. `\"user:4471\"`. REQUIRED: the\n   * caller's own service identity is recorded separately, and a trail\n   * that named only the admin panel would be useless.\n   */\n  onBehalfOf: string;\n  reason?: string;\n}\n\nexport interface SetCreditLimitResult {\n  creditLine: CreditLine;\n  /** True when this call replayed an earlier one with the same `referenceId`. */\n  idempotent: boolean;\n}\n\nexport interface SettleInvoiceInput {\n  /** The invoice being settled; the idempotency key for the release. */\n  invoiceRef: string;\n  /**\n   * The invoice's NET figure, minor units — NOT the gross the merchant\n   * paid. A ₹5,900 invoice on ₹5,000 of consumption releases ₹5,000,\n   * because the limit and consumption are denominated net of GST.\n   */\n  netMinor: number;\n  /** The invoice's GST figure, minor units. Recorded, not released. */\n  gstMinor: number;\n  onBehalfOf: string;\n  /**\n   * Optional in general, REQUIRED when re-settling a reversed invoice\n   * with figures that differ from the original — that is a correction,\n   * and it releases against the merchant's whole outstanding consumption\n   * rather than this invoice's amount, so it has to say what it is\n   * correcting. Without it the call is\n   * `CreditCorrectionReasonRequiredError`. Re-settling with the same\n   * figures needs none.\n   */\n  reason?: string;\n}\n\nexport interface SettleInvoiceResult {\n  creditLine: CreditLine;\n  releasedNetMinor: number;\n  releasedGstMinor: number;\n  idempotent: boolean;\n}\n\nexport interface ReverseSettlementInput {\n  invoiceRef: string;\n  onBehalfOf: string;\n  reason?: string;\n}\n\n/** One entry in a merchant's limit-change and settlement trail. */\nexport interface CreditEvent {\n  /**\n   * A reversal is its own row rather than an edit to the settlement it\n   * undoes, so the trail stays append-only and each row names its own\n   * actor and reason.\n   */\n  kind: 'limit_changed' | 'settled' | 'settlement_reversed';\n  ref: string;\n  limitBeforeMinor?: number;\n  limitAfterMinor?: number;\n  enabledBefore?: boolean;\n  enabledAfter?: boolean;\n  netMinor?: number;\n  gstMinor?: number;\n  releasedNetMinor?: number;\n  /** GST released alongside `releasedNetMinor`; recorded, not credited. */\n  releasedGstMinor?: number;\n  /**\n   * Which reversal of this settlement, from 1. On reversal rows only: an\n   * invoice can be settled, reversed, re-settled and reversed again, and\n   * each reversal is a separate row.\n   */\n  cycle?: number;\n  /** Set on a `settled` row when it was reversed; cleared if re-settled. */\n  reversedAt?: string;\n  /** The OAuth client that called. */\n  actor: string;\n  /** The human the caller was acting for. */\n  onBehalfOf?: string;\n  reason?: string;\n  recordedAt: string;\n}\n\nexport interface ListCreditEventsFilter {\n  /**\n   * How many events to return, newest first. The service defaults to 50\n   * — enough for a recent-activity panel, not for a merchant's whole\n   * history on the line.\n   */\n  limit?: number;\n}\n\nexport interface CreditUtilisationFilter {\n  /** Only merchants at or above this utilisation, in basis points (8000 = 80%). */\n  minUtilisationBps?: number;\n  band?: CreditBand;\n  offset?: number;\n  limit?: number;\n}\n\nexport interface CreditUtilisationPage {\n  merchants: CreditLine[];\n  /** Matching merchants before paging, for the dashboard's count. */\n  total: number;\n}\n\n/** Wallet details (identity + currency), without the balance. */\nexport interface WalletInstance {\n  wallet: WalletRef;\n  currency: Currency;\n}\n\n/**\n * Options for `wallet.getWallet(...)`.\n *\n * `id` is a typed entity reference, e.g. `\"business:8841\"` (same\n * prefixed shape the platform uses for JWT subjects). Today only the\n * `business:` prefix is supported.\n */\nexport interface GetWalletOptions {\n  id: string;\n  /**\n   * Force the business's own (child) wallet, bypassing parent-funding\n   * routing (`flash_configuration.bId_deduction`). Default `false` — the\n   * service resolves child-vs-parent automatically. No effect for a root\n   * business, which only has its own wallet.\n   */\n  forceChildWallet?: boolean;\n}\n\n/** The GST split on a charge. Recorded on the ledger; the service does not compute GST. */\nexport interface Breakup {\n  subTotalMinor: number;\n  gstMinor: number;\n  gstRate: number;\n}\n\n/** Searchable key/value metadata attached to a transaction. */\nexport type WalletTags = Record<string, string>;\n\n/**\n * An explicit wallet identity that REPLACES `bId_deduction` routing for\n * one write. For callers that already know which wallet pays (admin\n * tools, uengage-crm) or want to assert an identity the routing tables\n * might disagree with.\n *\n * The currency is NOT part of this — the service still takes it from the\n * business that owns the wallet, so a named wallet cannot be charged at\n * the wrong minor-unit scale.\n */\nexport interface WalletOverride {\n  parentBusinessId: string;\n  /** `\"0\"` for the parent business's own wallet. */\n  childBusinessId: string;\n}\n\n/** Fields common to a debit and a credit. */\ninterface TransactionInputBase {\n  /** Deterministic id of the business event — the idempotency key. */\n  referenceId: string;\n  /** Amount in integer minor units of the wallet's currency. */\n  amountMinor: number;\n  service: Service;\n  description: string;\n  breakup?: Breakup;\n  tags?: WalletTags;\n\n  /**\n   * Charge this wallet instead of the one this handle's business id\n   * routes to — for THIS call only. Bypasses\n   * `flash_configuration.bId_deduction` entirely, and cannot be combined\n   * with a handle built with `forceChildWallet`.\n   */\n  wallet?: WalletOverride;\n  // Note: for a child wallet the service asserts `parentBusinessId`\n  // against the wallet document rather than filtering on it, so a wrong\n  // one is a 409 `wallet_identity_mismatch` rather than a silent charge to\n  // the right wallet under the wrong identity.\n\n  // ── legacy-ledger passthroughs ──\n  // Written as TOP-LEVEL fields on the ledger document because flash's\n  // own code and finance reporting query them there. They are not `tags`:\n  // `tags` is Record<string, string> (so `rto` and `units` would not fit)\n  // and would nest them under `tags.*`, breaking those queries.\n  /**\n   * Flash's natural key for the delivery task. Stored as both `task_id`\n   * and `transaction_order_id`. NOT an idempotency key — `referenceId`\n   * is; this is the key flash's own pre-check filters on.\n   */\n  taskId?: string;\n  /**\n   * Chargeable units on this line. Defaults to 1 on a DEBIT when `taskId`\n   * is set (the legacy writer's credit row carries no `units` key, so\n   * credits are not defaulted); an explicit value is honoured on either.\n   */\n  units?: number;\n  /**\n   * Tariff base cost in MAJOR units (not minor, unlike `amountMinor`),\n   * caller-denominated and stored unconverted.\n   */\n  serviceBaseCost?: number;\n  /**\n   * When the charge actually OCCURRED, IST `YYYY-MM-DD HH:mm:ss`. Sets\n   * the ledger's `inserted_date` — what finance reporting and the\n   * `from`/`to` history filter range on — so a backfill or a replay is\n   * dated at the event, not at the write. The wall-clock write time is\n   * recorded separately as `recordedAt`. Defaults to now; may not be in\n   * the future or backdated more than 90 days.\n   */\n  occurredAt?: string;\n  /**\n   * The originating actor, stored as `updated_by` ('PetPooja', a rider\n   * id, 'Reconcile'). The OAuth client that authenticated the call is\n   * recorded separately and is unaffected.\n   */\n  updatedBy?: string;\n}\n\nexport interface DebitInput extends TransactionInputBase {\n  /** Allow the balance to go negative (flash migration only — needs sign-off). */\n  allowNegative?: boolean;\n  /** Return-to-origin leg. Debits only; part of flash's dedupe key. */\n  rto?: boolean;\n}\n\nexport interface CreditInput extends TransactionInputBase {\n  /** Link a refund to the original debit's `id`; subject to the over-refund guard. */\n  reversalOf?: string;\n  /**\n   * Mark this credit as a refund WITHOUT linking it to an original debit,\n   * and so without the over-refund guard. For refunds computed\n   * independently of the debit — a partial (buffer-only) refund that can\n   * legitimately exceed it. Use `reversalOf` instead when the refund\n   * genuinely reverses one known debit and should be capped by it.\n   */\n  isRefund?: boolean;\n  /**\n   * Payment reference. Credits only. The empty string is meaningful and\n   * is sent through as-is.\n   */\n  paymentId?: string;\n}\n\n/** What `debit()` / `credit()` return. */\nexport interface TransactionResult {\n  /** The wallet_transactions record id. Persist this; use as `reversalOf` for a refund. */\n  id: string;\n  /** `true` = a replay of an earlier identical referenceId; no money moved now. */\n  idempotent: boolean;\n  type: 'debit' | 'credit';\n  amount: Amount;\n  balanceBefore: Balance;\n  balanceAfter: Balance;\n  currency: Currency;\n  wallet: WalletRef;\n}\n\n/** A transaction as returned by `listTransactions()` / `getTransaction()`. */\nexport interface WalletTransaction {\n  id: string;\n  type: string;\n  amount: Amount;\n  service: ServiceRef;\n  description: string;\n  tags?: WalletTags;\n  reversalOf?: string;\n  balanceBefore: Balance;\n  balanceAfter: Balance;\n  /** When the charge occurred, IST. A backdated write (`occurredAt`) sets it. */\n  timestamp: string;\n  /**\n   * Wall-clock write time, IST. Absent on transactions written before\n   * this field existed, where `timestamp` is also the write time.\n   */\n  recordedAt?: string;\n  currency: Currency;\n  wallet: WalletRef;\n\n  // ── legacy-ledger passthroughs, echoed back ──\n  taskId?: string;\n  rto?: boolean;\n  units?: number;\n  serviceBaseCost?: number;\n  paymentId?: string;\n  /** True when the entry is marked a refund (reversal-linked or standalone). */\n  refund?: boolean;\n  updatedBy?: string;\n  /**\n   * The GST split recorded on the charge, in minor units.\n   *\n   * `amount` is the GROSS figure. On a credit-line row it is NOT what\n   * moved against the ceiling — `subTotalMinor` is, and it is what an\n   * invoice is built from. Absent on rows written without a split (every\n   * legacy row); guaranteed on a credit-line row, because the split is\n   * mandatory there.\n   */\n  breakup?: { subTotalMinor: number; gstMinor: number; gstRate: number };\n  /**\n   * Set when the charge consumed a credit line. Its presence also means\n   * `balanceBefore`/`balanceAfter` on this row are AVAILABLE CREDIT\n   * rather than a wallet balance.\n   */\n  creditMerchantId?: string;\n}\n\nexport interface ListTransactionsFilter {\n  type?: 'debit' | 'credit' | 'all';\n  from?: string;\n  to?: string;\n  service?: Service;\n  referenceId?: string;\n  /** Single tag filter as `key:value`. */\n  tag?: string;\n  cursor?: string;\n  limit?: number;\n}\n\nexport interface TransactionPage {\n  transactions: WalletTransaction[];\n  nextCursor?: string;\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uengage.io/platform-sdk",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "Client SDK for the uEngage platform API (audit, business, zones, wallet, upsell, auth, events). Single createClient(...) factory; OAuth2 client_credentials, static Bearer, or legacy session-token auth modes. Browser-safe realtime client at the /realtime subpath.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",