@uengage.io/platform-sdk 0.9.1 → 0.14.0

package/dist/wallet/client.d.ts

@@ -0,0 +1,65 @@
+import { type PlatformAuth, type PlatformAuthInput, type PlatformConfigInput } from '../config';
+import type { CreditInput, Currency, DebitInput, GetWalletOptions, ListTransactionsFilter, TransactionPage, TransactionResult, WalletBalance, WalletInstance, 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
+ * operation, so `UnresolvableWalletError` / `WalletNotFoundError`
+ * surface from the operation, not from `getWallet()`.
+ */
+export interface Wallet {
+    /** 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. */
+    getInstance(): Promise<WalletInstance>;
+    /** The wallet's currency `{code, symbol}` (a slice of getInstance()). */
+    getCurrency(): Promise<Currency>;
+    /** POST /v1/wallet/transactions (type=debit). Idempotent on `referenceId`. */
+    debit(input: DebitInput): Promise<TransactionResult>;
+    /** POST /v1/wallet/transactions (type=credit). Pass `reversalOf` for a refund. */
+    credit(input: CreditInput): Promise<TransactionResult>;
+    /** GET /v1/wallet/transactions — newest-first, keyset-paginated. */
+    listTransactions(filter?: ListTransactionsFilter): Promise<TransactionPage>;
+    /** GET /v1/wallet/transactions/:id — scoped to this wallet. */
+    getTransaction(id: string): Promise<WalletTransaction>;
+}
+export interface WalletClient {
+    config(input: PlatformConfigInput): WalletClient;
+    auth(input: PlatformAuthInput | PlatformAuth): WalletClient;
+    /**
+     * Build a handle to a business wallet. Synchronous and I/O-free — it
+     * only parses `id`. Requires a service token carrying the relevant
+     * `wallet.*` scope for the operations on the returned handle.
+     */
+    getWallet(opts: GetWalletOptions): Wallet;
+}
+export declare class WalletApiError extends Error {
+    readonly status: number;
+    readonly body: string;
+    constructor(status: number, body: string);
+}
+/** A debit would overdraw the wallet; nothing was moved (HTTP 409). */
+export declare class InsufficientBalanceError extends WalletApiError {
+    readonly balanceMinor: number;
+    constructor(balanceMinor: number, body: string);
+}
+/** A refund would push total reversals past the original debit (HTTP 409). */
+export declare class OverRefundError extends WalletApiError {
+    constructor(body: string);
+}
+/** `reversalOf` doesn't reference a valid debit on this wallet (HTTP 422). */
+export declare class InvalidReversalError extends WalletApiError {
+    constructor(body: string);
+}
+/** A `referenceId` was reused with a different amount/type/service (HTTP 409). */
+export declare class IdempotencyConflictError extends WalletApiError {
+    constructor(body: string);
+}
+/** The business, or the business its `bId_deduction` points to, does not exist (HTTP 422). */
+export declare class UnresolvableWalletError extends WalletApiError {
+    constructor(body: string);
+}
+/** No wallet document, or no such transaction on this wallet (HTTP 404). */
+export declare class WalletNotFoundError extends WalletApiError {
+    constructor(body: string);
+}
+export declare function createWalletClient(input?: PlatformConfigInput): WalletClient;

package/dist/wallet/client.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletNotFoundError = exports.UnresolvableWalletError = exports.IdempotencyConflictError = exports.InvalidReversalError = exports.OverRefundError = exports.InsufficientBalanceError = exports.WalletApiError = void 0;
+exports.createWalletClient = createWalletClient;
+const config_1 = require("../config");
+const http_1 = require("../http");
+class WalletApiError extends Error {
+    status;
+    body;
+    constructor(status, body) {
+        super(`wallet API ${status}: ${body}`);
+        this.name = 'WalletApiError';
+        this.status = status;
+        this.body = body;
+    }
+}
+exports.WalletApiError = WalletApiError;
+/** A debit would overdraw the wallet; nothing was moved (HTTP 409). */
+class InsufficientBalanceError extends WalletApiError {
+    balanceMinor;
+    constructor(balanceMinor, body) {
+        super(409, body);
+        this.name = 'InsufficientBalanceError';
+        this.balanceMinor = balanceMinor;
+    }
+}
+exports.InsufficientBalanceError = InsufficientBalanceError;
+/** A refund would push total reversals past the original debit (HTTP 409). */
+class OverRefundError extends WalletApiError {
+    constructor(body) {
+        super(409, body);
+        this.name = 'OverRefundError';
+    }
+}
+exports.OverRefundError = OverRefundError;
+/** `reversalOf` doesn't reference a valid debit on this wallet (HTTP 422). */
+class InvalidReversalError extends WalletApiError {
+    constructor(body) {
+        super(422, body);
+        this.name = 'InvalidReversalError';
+    }
+}
+exports.InvalidReversalError = InvalidReversalError;
+/** A `referenceId` was reused with a different amount/type/service (HTTP 409). */
+class IdempotencyConflictError extends WalletApiError {
+    constructor(body) {
+        super(409, body);
+        this.name = 'IdempotencyConflictError';
+    }
+}
+exports.IdempotencyConflictError = IdempotencyConflictError;
+/** The business, or the business its `bId_deduction` points to, does not exist (HTTP 422). */
+class UnresolvableWalletError extends WalletApiError {
+    constructor(body) {
+        super(422, body);
+        this.name = 'UnresolvableWalletError';
+    }
+}
+exports.UnresolvableWalletError = UnresolvableWalletError;
+/** No wallet document, or no such transaction on this wallet (HTTP 404). */
+class WalletNotFoundError extends WalletApiError {
+    constructor(body) {
+        super(404, body);
+        this.name = 'WalletNotFoundError';
+    }
+}
+exports.WalletNotFoundError = WalletNotFoundError;
+const BUSINESS_ID_RE = /^business:(\d+)$/;
+/** Parse a typed wallet id (`"business:8841"`) into the numeric business id. */
+function parseBusinessId(id) {
+    const match = BUSINESS_ID_RE.exec(id);
+    if (!match) {
+        throw new Error(`wallet.getWallet: id must look like "business:<positive integer>" (got "${id}")`);
+    }
+    return Number.parseInt(match[1], 10);
+}
+/** Map a non-2xx wallet response to the most specific typed error. */
+function walletError(status, body) {
+    let code;
+    let balanceMinor;
+    try {
+        const parsed = JSON.parse(body);
+        code = parsed.error;
+        balanceMinor = parsed.balanceMinor;
+    }
+    catch {
+        // non-JSON body — fall through to a generic error
+    }
+    if (status === 409 && code === 'insufficient_balance') {
+        return new InsufficientBalanceError(balanceMinor ?? 0, body);
+    }
+    if (status === 409 && code === 'over_refund')
+        return new OverRefundError(body);
+    if (status === 409 && code === 'idempotency_conflict')
+        return new IdempotencyConflictError(body);
+    if (status === 422 && code === 'invalid_reversal')
+        return new InvalidReversalError(body);
+    if (status === 422 && code === 'unresolvable_wallet')
+        return new UnresolvableWalletError(body);
+    if (status === 404)
+        return new WalletNotFoundError(body);
+    return new WalletApiError(status, body);
+}
+function createWalletClient(input = {}) {
+    const state = new config_1.ConfigState();
+    state.apply(input);
+    const client = {
+        config(opts) {
+            state.apply(opts);
+            return client;
+        },
+        auth(opts) {
+            state.setAuth(opts);
+            return client;
+        },
+        getWallet(opts) {
+            // Parse eagerly so a malformed id fails fast at the call site,
+            // but do NOT resolve the wallet here — that happens on the first
+            // operation against the handle.
+            const businessId = parseBusinessId(opts.id);
+            const forceChildWallet = opts.forceChildWallet === true;
+            const baseParams = () => {
+                const p = new URLSearchParams({ businessId: String(businessId) });
+                if (forceChildWallet)
+                    p.set('forceChildWallet', 'true');
+                return p;
+            };
+            const postTransaction = async (type, body) => {
+                const path = '/v1/wallet/transactions';
+                const payload = JSON.stringify({ businessId, forceChildWallet, type, ...body });
+                const config = state.resolve();
+                const res = await (0, http_1.sendWithAuthRetry)(config, {
+                    method: 'POST',
+                    path,
+                    url: `${config.baseUrl}${path}`,
+                    body: payload,
+                });
+                if (!res.ok)
+                    throw walletError(res.status, await res.text());
+                return (await res.json());
+            };
+            const wallet = {
+                async getBalance() {
+                    const path = '/v1/wallet/balance';
+                    const config = state.resolve();
+                    const res = await (0, http_1.sendWithAuthRetry)(config, {
+                        method: 'GET',
+                        path,
+                        url: `${config.baseUrl}${path}?${baseParams().toString()}`,
+                    });
+                    if (!res.ok)
+                        throw walletError(res.status, await res.text());
+                    return (await res.json());
+                },
+                async getInstance() {
+                    const path = '/v1/wallet/instance';
+                    const config = state.resolve();
+                    const res = await (0, http_1.sendWithAuthRetry)(config, {
+                        method: 'GET',
+                        path,
+                        url: `${config.baseUrl}${path}?${baseParams().toString()}`,
+                    });
+                    if (!res.ok)
+                        throw walletError(res.status, await res.text());
+                    return (await res.json());
+                },
+                async getCurrency() {
+                    return (await wallet.getInstance()).currency;
+                },
+                debit(body) {
+                    return postTransaction('debit', body);
+                },
+                credit(body) {
+                    return postTransaction('credit', body);
+                },
+                async listTransactions(filter = {}) {
+                    const p = baseParams();
+                    if (filter.type)
+                        p.set('type', filter.type);
+                    if (filter.from)
+                        p.set('from', filter.from);
+                    if (filter.to)
+                        p.set('to', filter.to);
+                    if (filter.service !== undefined)
+                        p.set('service', String(filter.service));
+                    if (filter.referenceId)
+                        p.set('referenceId', filter.referenceId);
+                    if (filter.tag)
+                        p.set('tag', filter.tag);
+                    if (filter.cursor)
+                        p.set('cursor', filter.cursor);
+                    if (filter.limit !== undefined)
+                        p.set('limit', String(filter.limit));
+                    const path = '/v1/wallet/transactions';
+                    const config = state.resolve();
+                    const res = await (0, http_1.sendWithAuthRetry)(config, {
+                        method: 'GET',
+                        path,
+                        url: `${config.baseUrl}${path}?${p.toString()}`,
+                    });
+                    if (!res.ok)
+                        throw walletError(res.status, await res.text());
+                    return (await res.json());
+                },
+                async getTransaction(id) {
+                    const path = `/v1/wallet/transactions/${id}`;
+                    const config = state.resolve();
+                    const res = await (0, http_1.sendWithAuthRetry)(config, {
+                        method: 'GET',
+                        path,
+                        url: `${config.baseUrl}${path}?${baseParams().toString()}`,
+                    });
+                    if (!res.ok)
+                        throw walletError(res.status, await res.text());
+                    return (await res.json());
+                },
+            };
+            return wallet;
+        },
+    };
+    return client;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/wallet/client.ts"],"names":[],"mappings":";;;AAuJA,gDAgHC;AAvQD,sCAKmB;AACnB,kCAA4C;AAgD5C,MAAa,cAAe,SAAQ,KAAK;IAC9B,MAAM,CAAS;IACf,IAAI,CAAS;IAEtB,YAAY,MAAc,EAAE,IAAY;QACtC,KAAK,CAAC,cAAc,MAAM,KAAK,IAAI,EAAE,CAAC,CAAC;QACvC,IAAI,CAAC,IAAI,GAAG,gBAAgB,CAAC;QAC7B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AAVD,wCAUC;AAED,uEAAuE;AACvE,MAAa,wBAAyB,SAAQ,cAAc;IACjD,YAAY,CAAS;IAC9B,YAAY,YAAoB,EAAE,IAAY;QAC5C,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAC;QACvC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IACnC,CAAC;CACF;AAPD,4DAOC;AAED,8EAA8E;AAC9E,MAAa,eAAgB,SAAQ,cAAc;IACjD,YAAY,IAAY;QACtB,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;IAChC,CAAC;CACF;AALD,0CAKC;AAED,8EAA8E;AAC9E,MAAa,oBAAqB,SAAQ,cAAc;IACtD,YAAY,IAAY;QACtB,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;IACrC,CAAC;CACF;AALD,oDAKC;AAED,kFAAkF;AAClF,MAAa,wBAAyB,SAAQ,cAAc;IAC1D,YAAY,IAAY;QACtB,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAC;IACzC,CAAC;CACF;AALD,4DAKC;AAED,8FAA8F;AAC9F,MAAa,uBAAwB,SAAQ,cAAc;IACzD,YAAY,IAAY;QACtB,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC;IACxC,CAAC;CACF;AALD,0DAKC;AAED,4EAA4E;AAC5E,MAAa,mBAAoB,SAAQ,cAAc;IACrD,YAAY,IAAY;QACtB,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;IACpC,CAAC;CACF;AALD,kDAKC;AAED,MAAM,cAAc,GAAG,kBAAkB,CAAC;AAE1C,gFAAgF;AAChF,SAAS,eAAe,CAAC,EAAU;IACjC,MAAM,KAAK,GAAG,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACtC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CACb,2EAA2E,EAAE,IAAI,CAClF,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AACvC,CAAC;AAED,sEAAsE;AACtE,SAAS,WAAW,CAAC,MAAc,EAAE,IAAY;IAC/C,IAAI,IAAwB,CAAC;IAC7B,IAAI,YAAgC,CAAC;IACrC,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAA8C,CAAC;QAC7E,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC;QACpB,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;IACrC,CAAC;IAAC,MAAM,CAAC;QACP,kDAAkD;IACpD,CAAC;IACD,IAAI,MAAM,KAAK,GAAG,IAAI,IAAI,KAAK,sBAAsB,EAAE,CAAC;QACtD,OAAO,IAAI,wBAAwB,CAAC,YAAY,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;IAC/D,CAAC;IACD,IAAI,MAAM,KAAK,GAAG,IAAI,IAAI,KAAK,aAAa;QAAE,OAAO,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC;IAC/E,IAAI,MAAM,KAAK,GAAG,IAAI,IAAI,KAAK,sBAAsB;QAAE,OAAO,IAAI,wBAAwB,CAAC,IAAI,CAAC,CAAC;IACjG,IAAI,MAAM,KAAK,GAAG,IAAI,IAAI,KAAK,kBAAkB;QAAE,OAAO,IAAI,oBAAoB,CAAC,IAAI,CAAC,CAAC;IACzF,IAAI,MAAM,KAAK,GAAG,IAAI,IAAI,KAAK,qBAAqB;QAAE,OAAO,IAAI,uBAAuB,CAAC,IAAI,CAAC,CAAC;IAC/F,IAAI,MAAM,KAAK,GAAG;QAAE,OAAO,IAAI,mBAAmB,CAAC,IAAI,CAAC,CAAC;IACzD,OAAO,IAAI,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAC1C,CAAC;AAED,SAAgB,kBAAkB,CAAC,QAA6B,EAAE;IAChE,MAAM,KAAK,GAAG,IAAI,oBAAW,EAAE,CAAC;IAChC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAEnB,MAAM,MAAM,GAAiB;QAC3B,MAAM,CAAC,IAAI;YACT,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAClB,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,IAAI,CAAC,IAAI;YACP,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YACpB,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,SAAS,CAAC,IAAI;YACZ,+DAA+D;YAC/D,iEAAiE;YACjE,gCAAgC;YAChC,MAAM,UAAU,GAAG,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC5C,MAAM,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,KAAK,IAAI,CAAC;YAExD,MAAM,UAAU,GAAG,GAAoB,EAAE;gBACvC,MAAM,CAAC,GAAG,IAAI,eAAe,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;gBAClE,IAAI,gBAAgB;oBAAE,CAAC,CAAC,GAAG,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC;gBACxD,OAAO,CAAC,CAAC;YACX,CAAC,CAAC;YAEF,MAAM,eAAe,GAAG,KAAK,EAC3B,IAAwB,EACxB,IAA8B,EACF,EAAE;gBAC9B,MAAM,IAAI,GAAG,yBAAyB,CAAC;gBACvC,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,UAAU,EAAE,gBAAgB,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC;gBAChF,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;gBAC/B,MAAM,GAAG,GAAG,MAAM,IAAA,wBAAiB,EAAC,MAAM,EAAE;oBAC1C,MAAM,EAAE,MAAM;oBACd,IAAI;oBACJ,GAAG,EAAE,GAAG,MAAM,CAAC,OAAO,GAAG,IAAI,EAAE;oBAC/B,IAAI,EAAE,OAAO;iBACd,CAAC,CAAC;gBACH,IAAI,CAAC,GAAG,CAAC,EAAE;oBAAE,MAAM,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;gBAC7D,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,CAAsB,CAAC;YACjD,CAAC,CAAC;YAEF,MAAM,MAAM,GAAW;gBACrB,KAAK,CAAC,UAAU;oBACd,MAAM,IAAI,GAAG,oBAAoB,CAAC;oBAClC,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;oBAC/B,MAAM,GAAG,GAAG,MAAM,IAAA,wBAAiB,EAAC,MAAM,EAAE;wBAC1C,MAAM,EAAE,KAAK;wBACb,IAAI;wBACJ,GAAG,EAAE,GAAG,MAAM,CAAC,OAAO,GAAG,IAAI,IAAI,UAAU,EAAE,CAAC,QAAQ,EAAE,EAAE;qBAC3D,CAAC,CAAC;oBACH,IAAI,CAAC,GAAG,CAAC,EAAE;wBAAE,MAAM,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;oBAC7D,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,CAAkB,CAAC;gBAC7C,CAAC;gBACD,KAAK,CAAC,WAAW;oBACf,MAAM,IAAI,GAAG,qBAAqB,CAAC;oBACnC,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;oBAC/B,MAAM,GAAG,GAAG,MAAM,IAAA,wBAAiB,EAAC,MAAM,EAAE;wBAC1C,MAAM,EAAE,KAAK;wBACb,IAAI;wBACJ,GAAG,EAAE,GAAG,MAAM,CAAC,OAAO,GAAG,IAAI,IAAI,UAAU,EAAE,CAAC,QAAQ,EAAE,EAAE;qBAC3D,CAAC,CAAC;oBACH,IAAI,CAAC,GAAG,CAAC,EAAE;wBAAE,MAAM,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;oBAC7D,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,CAAmB,CAAC;gBAC9C,CAAC;gBACD,KAAK,CAAC,WAAW;oBACf,OAAO,CAAC,MAAM,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,QAAQ,CAAC;gBAC/C,CAAC;gBACD,KAAK,CAAC,IAAI;oBACR,OAAO,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;gBACxC,CAAC;gBACD,MAAM,CAAC,IAAI;oBACT,OAAO,eAAe,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;gBACzC,CAAC;gBACD,KAAK,CAAC,gBAAgB,CAAC,MAAM,GAAG,EAAE;oBAChC,MAAM,CAAC,GAAG,UAAU,EAAE,CAAC;oBACvB,IAAI,MAAM,CAAC,IAAI;wBAAE,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;oBAC5C,IAAI,MAAM,CAAC,IAAI;wBAAE,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;oBAC5C,IAAI,MAAM,CAAC,EAAE;wBAAE,CAAC,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;oBACtC,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS;wBAAE,CAAC,CAAC,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;oBAC3E,IAAI,MAAM,CAAC,WAAW;wBAAE,CAAC,CAAC,GAAG,CAAC,aAAa,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;oBACjE,IAAI,MAAM,CAAC,GAAG;wBAAE,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;oBACzC,IAAI,MAAM,CAAC,MAAM;wBAAE,CAAC,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;oBAClD,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS;wBAAE,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;oBACrE,MAAM,IAAI,GAAG,yBAAyB,CAAC;oBACvC,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;oBAC/B,MAAM,GAAG,GAAG,MAAM,IAAA,wBAAiB,EAAC,MAAM,EAAE;wBAC1C,MAAM,EAAE,KAAK;wBACb,IAAI;wBACJ,GAAG,EAAE,GAAG,MAAM,CAAC,OAAO,GAAG,IAAI,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE;qBAChD,CAAC,CAAC;oBACH,IAAI,CAAC,GAAG,CAAC,EAAE;wBAAE,MAAM,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;oBAC7D,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,CAAoB,CAAC;gBAC/C,CAAC;gBACD,KAAK,CAAC,cAAc,CAAC,EAAE;oBACrB,MAAM,IAAI,GAAG,2BAA2B,EAAE,EAAE,CAAC;oBAC7C,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC;oBAC/B,MAAM,GAAG,GAAG,MAAM,IAAA,wBAAiB,EAAC,MAAM,EAAE;wBAC1C,MAAM,EAAE,KAAK;wBACb,IAAI;wBACJ,GAAG,EAAE,GAAG,MAAM,CAAC,OAAO,GAAG,IAAI,IAAI,UAAU,EAAE,CAAC,QAAQ,EAAE,EAAE;qBAC3D,CAAC,CAAC;oBACH,IAAI,CAAC,GAAG,CAAC,EAAE;wBAAE,MAAM,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;oBAC7D,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,CAAsB,CAAC;gBACjD,CAAC;aACF,CAAC;YACF,OAAO,MAAM,CAAC;QAChB,CAAC;KACF,CAAC;IAEF,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["import {\n  ConfigState,\n  type PlatformAuth,\n  type PlatformAuthInput,\n  type PlatformConfigInput,\n} from '../config';\nimport { sendWithAuthRetry } from '../http';\nimport type {\n  CreditInput,\n  Currency,\n  DebitInput,\n  GetWalletOptions,\n  ListTransactionsFilter,\n  TransactionPage,\n  TransactionResult,\n  WalletBalance,\n  WalletInstance,\n  WalletTransaction,\n} from './schema';\n\n/**\n * A handle to one business wallet. Cheap to create — `getWallet(...)`\n * does no I/O. The wallet is resolved server-side on the first\n * operation, so `UnresolvableWalletError` / `WalletNotFoundError`\n * surface from the operation, not from `getWallet()`.\n */\nexport interface Wallet {\n  /** GET /v1/wallet/balance — resolves the wallet and returns its balance + currency. */\n  getBalance(): Promise<WalletBalance>;\n  /** GET /v1/wallet/instance — wallet identity + currency, without the balance. */\n  getInstance(): Promise<WalletInstance>;\n  /** The wallet's currency `{code, symbol}` (a slice of getInstance()). */\n  getCurrency(): Promise<Currency>;\n  /** POST /v1/wallet/transactions (type=debit). Idempotent on `referenceId`. */\n  debit(input: DebitInput): Promise<TransactionResult>;\n  /** POST /v1/wallet/transactions (type=credit). Pass `reversalOf` for a refund. */\n  credit(input: CreditInput): Promise<TransactionResult>;\n  /** GET /v1/wallet/transactions — newest-first, keyset-paginated. */\n  listTransactions(filter?: ListTransactionsFilter): Promise<TransactionPage>;\n  /** GET /v1/wallet/transactions/:id — scoped to this wallet. */\n  getTransaction(id: string): Promise<WalletTransaction>;\n}\n\nexport interface WalletClient {\n  config(input: PlatformConfigInput): WalletClient;\n  auth(input: PlatformAuthInput | PlatformAuth): WalletClient;\n  /**\n   * Build a handle to a business wallet. Synchronous and I/O-free — it\n   * only parses `id`. Requires a service token carrying the relevant\n   * `wallet.*` scope for the operations on the returned handle.\n   */\n  getWallet(opts: GetWalletOptions): Wallet;\n}\n\nexport class WalletApiError extends Error {\n  readonly status: number;\n  readonly body: string;\n\n  constructor(status: number, body: string) {\n    super(`wallet API ${status}: ${body}`);\n    this.name = 'WalletApiError';\n    this.status = status;\n    this.body = body;\n  }\n}\n\n/** A debit would overdraw the wallet; nothing was moved (HTTP 409). */\nexport class InsufficientBalanceError extends WalletApiError {\n  readonly balanceMinor: number;\n  constructor(balanceMinor: number, body: string) {\n    super(409, body);\n    this.name = 'InsufficientBalanceError';\n    this.balanceMinor = balanceMinor;\n  }\n}\n\n/** A refund would push total reversals past the original debit (HTTP 409). */\nexport class OverRefundError extends WalletApiError {\n  constructor(body: string) {\n    super(409, body);\n    this.name = 'OverRefundError';\n  }\n}\n\n/** `reversalOf` doesn't reference a valid debit on this wallet (HTTP 422). */\nexport class InvalidReversalError extends WalletApiError {\n  constructor(body: string) {\n    super(422, body);\n    this.name = 'InvalidReversalError';\n  }\n}\n\n/** A `referenceId` was reused with a different amount/type/service (HTTP 409). */\nexport class IdempotencyConflictError extends WalletApiError {\n  constructor(body: string) {\n    super(409, body);\n    this.name = 'IdempotencyConflictError';\n  }\n}\n\n/** The business, or the business its `bId_deduction` points to, does not exist (HTTP 422). */\nexport class UnresolvableWalletError extends WalletApiError {\n  constructor(body: string) {\n    super(422, body);\n    this.name = 'UnresolvableWalletError';\n  }\n}\n\n/** No wallet document, or no such transaction on this wallet (HTTP 404). */\nexport class WalletNotFoundError extends WalletApiError {\n  constructor(body: string) {\n    super(404, body);\n    this.name = 'WalletNotFoundError';\n  }\n}\n\nconst BUSINESS_ID_RE = /^business:(\\d+)$/;\n\n/** Parse a typed wallet id (`\"business:8841\"`) into the numeric business id. */\nfunction parseBusinessId(id: string): number {\n  const match = BUSINESS_ID_RE.exec(id);\n  if (!match) {\n    throw new Error(\n      `wallet.getWallet: id must look like \"business:<positive integer>\" (got \"${id}\")`,\n    );\n  }\n  return Number.parseInt(match[1], 10);\n}\n\n/** Map a non-2xx wallet response to the most specific typed error. */\nfunction walletError(status: number, body: string): WalletApiError {\n  let code: string | undefined;\n  let balanceMinor: number | undefined;\n  try {\n    const parsed = JSON.parse(body) as { error?: string; balanceMinor?: number };\n    code = parsed.error;\n    balanceMinor = parsed.balanceMinor;\n  } catch {\n    // non-JSON body — fall through to a generic error\n  }\n  if (status === 409 && code === 'insufficient_balance') {\n    return new InsufficientBalanceError(balanceMinor ?? 0, body);\n  }\n  if (status === 409 && code === 'over_refund') return new OverRefundError(body);\n  if (status === 409 && code === 'idempotency_conflict') return new IdempotencyConflictError(body);\n  if (status === 422 && code === 'invalid_reversal') return new InvalidReversalError(body);\n  if (status === 422 && code === 'unresolvable_wallet') return new UnresolvableWalletError(body);\n  if (status === 404) return new WalletNotFoundError(body);\n  return new WalletApiError(status, body);\n}\n\nexport function createWalletClient(input: PlatformConfigInput = {}): WalletClient {\n  const state = new ConfigState();\n  state.apply(input);\n\n  const client: WalletClient = {\n    config(opts) {\n      state.apply(opts);\n      return client;\n    },\n    auth(opts) {\n      state.setAuth(opts);\n      return client;\n    },\n    getWallet(opts) {\n      // Parse eagerly so a malformed id fails fast at the call site,\n      // but do NOT resolve the wallet here — that happens on the first\n      // operation against the handle.\n      const businessId = parseBusinessId(opts.id);\n      const forceChildWallet = opts.forceChildWallet === true;\n\n      const baseParams = (): URLSearchParams => {\n        const p = new URLSearchParams({ businessId: String(businessId) });\n        if (forceChildWallet) p.set('forceChildWallet', 'true');\n        return p;\n      };\n\n      const postTransaction = async (\n        type: 'debit' | 'credit',\n        body: DebitInput | CreditInput,\n      ): Promise<TransactionResult> => {\n        const path = '/v1/wallet/transactions';\n        const payload = JSON.stringify({ businessId, forceChildWallet, type, ...body });\n        const config = state.resolve();\n        const res = await sendWithAuthRetry(config, {\n          method: 'POST',\n          path,\n          url: `${config.baseUrl}${path}`,\n          body: payload,\n        });\n        if (!res.ok) throw walletError(res.status, await res.text());\n        return (await res.json()) as TransactionResult;\n      };\n\n      const wallet: Wallet = {\n        async getBalance() {\n          const path = '/v1/wallet/balance';\n          const config = state.resolve();\n          const res = await sendWithAuthRetry(config, {\n            method: 'GET',\n            path,\n            url: `${config.baseUrl}${path}?${baseParams().toString()}`,\n          });\n          if (!res.ok) throw walletError(res.status, await res.text());\n          return (await res.json()) as WalletBalance;\n        },\n        async getInstance() {\n          const path = '/v1/wallet/instance';\n          const config = state.resolve();\n          const res = await sendWithAuthRetry(config, {\n            method: 'GET',\n            path,\n            url: `${config.baseUrl}${path}?${baseParams().toString()}`,\n          });\n          if (!res.ok) throw walletError(res.status, await res.text());\n          return (await res.json()) as WalletInstance;\n        },\n        async getCurrency() {\n          return (await wallet.getInstance()).currency;\n        },\n        debit(body) {\n          return postTransaction('debit', body);\n        },\n        credit(body) {\n          return postTransaction('credit', body);\n        },\n        async listTransactions(filter = {}) {\n          const p = baseParams();\n          if (filter.type) p.set('type', filter.type);\n          if (filter.from) p.set('from', filter.from);\n          if (filter.to) p.set('to', filter.to);\n          if (filter.service !== undefined) p.set('service', String(filter.service));\n          if (filter.referenceId) p.set('referenceId', filter.referenceId);\n          if (filter.tag) p.set('tag', filter.tag);\n          if (filter.cursor) p.set('cursor', filter.cursor);\n          if (filter.limit !== undefined) p.set('limit', String(filter.limit));\n          const path = '/v1/wallet/transactions';\n          const config = state.resolve();\n          const res = await sendWithAuthRetry(config, {\n            method: 'GET',\n            path,\n            url: `${config.baseUrl}${path}?${p.toString()}`,\n          });\n          if (!res.ok) throw walletError(res.status, await res.text());\n          return (await res.json()) as TransactionPage;\n        },\n        async getTransaction(id) {\n          const path = `/v1/wallet/transactions/${id}`;\n          const config = state.resolve();\n          const res = await sendWithAuthRetry(config, {\n            method: 'GET',\n            path,\n            url: `${config.baseUrl}${path}?${baseParams().toString()}`,\n          });\n          if (!res.ok) throw walletError(res.status, await res.text());\n          return (await res.json()) as WalletTransaction;\n        },\n      };\n      return wallet;\n    },\n  };\n\n  return client;\n}\n"]}

package/dist/wallet/index.d.ts

@@ -0,0 +1,3 @@
+export type { WalletRef, WalletBalance, WalletInstance, Currency, Amount, Balance, ServiceRef, GetWalletOptions, Breakup, WalletTags, DebitInput, CreditInput, TransactionResult, WalletTransaction, ListTransactionsFilter, TransactionPage, } from './schema';
+export { Services, type Service } from './services';
+export { createWalletClient, WalletApiError, InsufficientBalanceError, OverRefundError, InvalidReversalError, IdempotencyConflictError, UnresolvableWalletError, WalletNotFoundError, type WalletClient, type Wallet, } from './client';

package/dist/wallet/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletNotFoundError = exports.UnresolvableWalletError = 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");
+Object.defineProperty(exports, "createWalletClient", { enumerable: true, get: function () { return client_1.createWalletClient; } });
+Object.defineProperty(exports, "WalletApiError", { enumerable: true, get: function () { return client_1.WalletApiError; } });
+Object.defineProperty(exports, "InsufficientBalanceError", { enumerable: true, get: function () { return client_1.InsufficientBalanceError; } });
+Object.defineProperty(exports, "OverRefundError", { enumerable: true, get: function () { return client_1.OverRefundError; } });
+Object.defineProperty(exports, "InvalidReversalError", { enumerable: true, get: function () { return client_1.InvalidReversalError; } });
+Object.defineProperty(exports, "IdempotencyConflictError", { enumerable: true, get: function () { return client_1.IdempotencyConflictError; } });
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd2FsbGV0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQWtCQSx1Q0FBb0Q7QUFBM0Msb0dBQUEsUUFBUSxPQUFBO0FBQ2pCLG1DQVdrQjtBQVZoQiw0R0FBQSxrQkFBa0IsT0FBQTtBQUNsQix3R0FBQSxjQUFjLE9BQUE7QUFDZCxrSEFBQSx3QkFBd0IsT0FBQTtBQUN4Qix5R0FBQSxlQUFlLE9BQUE7QUFDZiw4R0FBQSxvQkFBb0IsT0FBQTtBQUNwQixrSEFBQSx3QkFBd0IsT0FBQTtBQUN4QixpSEFBQSx1QkFBdUIsT0FBQTtBQUN2Qiw2R0FBQSxtQkFBbUIsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIHtcbiAgV2FsbGV0UmVmLFxuICBXYWxsZXRCYWxhbmNlLFxuICBXYWxsZXRJbnN0YW5jZSxcbiAgQ3VycmVuY3ksXG4gIEFtb3VudCxcbiAgQmFsYW5jZSxcbiAgU2VydmljZVJlZixcbiAgR2V0V2FsbGV0T3B0aW9ucyxcbiAgQnJlYWt1cCxcbiAgV2FsbGV0VGFncyxcbiAgRGViaXRJbnB1dCxcbiAgQ3JlZGl0SW5wdXQsXG4gIFRyYW5zYWN0aW9uUmVzdWx0LFxuICBXYWxsZXRUcmFuc2FjdGlvbixcbiAgTGlzdFRyYW5zYWN0aW9uc0ZpbHRlcixcbiAgVHJhbnNhY3Rpb25QYWdlLFxufSBmcm9tICcuL3NjaGVtYSc7XG5leHBvcnQgeyBTZXJ2aWNlcywgdHlwZSBTZXJ2aWNlIH0gZnJvbSAnLi9zZXJ2aWNlcyc7XG5leHBvcnQge1xuICBjcmVhdGVXYWxsZXRDbGllbnQsXG4gIFdhbGxldEFwaUVycm9yLFxuICBJbnN1ZmZpY2llbnRCYWxhbmNlRXJyb3IsXG4gIE92ZXJSZWZ1bmRFcnJvcixcbiAgSW52YWxpZFJldmVyc2FsRXJyb3IsXG4gIElkZW1wb3RlbmN5Q29uZmxpY3RFcnJvcixcbiAgVW5yZXNvbHZhYmxlV2FsbGV0RXJyb3IsXG4gIFdhbGxldE5vdEZvdW5kRXJyb3IsXG4gIHR5cGUgV2FsbGV0Q2xpZW50LFxuICB0eXBlIFdhbGxldCxcbn0gZnJvbSAnLi9jbGllbnQnO1xuIl19

package/dist/wallet/schema.d.ts

@@ -0,0 +1,132 @@
+import type { Service } from './services';
+/**
+ * Wallet identity inside the platform wallet service. `childBusinessId`
+ * is `"0"` when the parent business's own wallet answered (parent-chain
+ * billing resolved on the outlet's behalf).
+ */
+export interface WalletRef {
+    parentBusinessId: string;
+    childBusinessId: string;
+}
+/** Currency descriptor for a wallet. */
+export interface Currency {
+    /** ISO code, e.g. `"INR"`. */
+    code: string;
+    /** Display symbol, e.g. `"₹"`. */
+    symbol: string;
+}
+/** A transaction amount in major + integer minor units. */
+export interface Amount {
+    amount: number;
+    amountMinor: number;
+}
+/** A balance in major + integer minor units. */
+export interface Balance {
+    balance: number;
+    balanceMinor: number;
+}
+/** A chargeable service, as returned on a transaction. */
+export interface ServiceRef {
+    id: number;
+    name: string;
+}
+export interface WalletBalance {
+    /** Balance in major units. */
+    balance: number;
+    /** Balance in integer minor units, per the wallet's currency. */
+    balanceMinor: number;
+    currency: Currency;
+}
+/** Wallet details (identity + currency), without the balance. */
+export interface WalletInstance {
+    wallet: WalletRef;
+    currency: Currency;
+}
+/**
+ * Options for `wallet.getWallet(...)`.
+ *
+ * `id` is a typed entity reference, e.g. `"business:8841"` (same
+ * prefixed shape the platform uses for JWT subjects). Today only the
+ * `business:` prefix is supported.
+ */
+export interface GetWalletOptions {
+    id: string;
+    /**
+     * Force the business's own (child) wallet, bypassing parent-funding
+     * routing (`flash_configuration.bId_deduction`). Default `false` — the
+     * service resolves child-vs-parent automatically. No effect for a root
+     * business, which only has its own wallet.
+     */
+    forceChildWallet?: boolean;
+}
+/** The GST split on a charge. Recorded on the ledger; the service does not compute GST. */
+export interface Breakup {
+    subTotalMinor: number;
+    gstMinor: number;
+    gstRate: number;
+}
+/** Searchable key/value metadata attached to a transaction. */
+export type WalletTags = Record<string, string>;
+/** Fields common to a debit and a credit. */
+interface TransactionInputBase {
+    /** Deterministic id of the business event — the idempotency key. */
+    referenceId: string;
+    /** Amount in integer minor units of the wallet's currency. */
+    amountMinor: number;
+    service: Service;
+    description: string;
+    breakup?: Breakup;
+    tags?: WalletTags;
+}
+export interface DebitInput extends TransactionInputBase {
+    /** Allow the balance to go negative (flash migration only — needs sign-off). */
+    allowNegative?: boolean;
+}
+export interface CreditInput extends TransactionInputBase {
+    /** Link a refund to the original debit's `id`; subject to the over-refund guard. */
+    reversalOf?: string;
+}
+/** What `debit()` / `credit()` return. */
+export interface TransactionResult {
+    /** The wallet_transactions record id. Persist this; use as `reversalOf` for a refund. */
+    id: string;
+    /** `true` = a replay of an earlier identical referenceId; no money moved now. */
+    idempotent: boolean;
+    type: 'debit' | 'credit';
+    amount: Amount;
+    balanceBefore: Balance;
+    balanceAfter: Balance;
+    currency: Currency;
+    wallet: WalletRef;
+}
+/** A transaction as returned by `listTransactions()` / `getTransaction()`. */
+export interface WalletTransaction {
+    id: string;
+    type: string;
+    amount: Amount;
+    service: ServiceRef;
+    description: string;
+    tags?: WalletTags;
+    reversalOf?: string;
+    balanceBefore: Balance;
+    balanceAfter: Balance;
+    timestamp: string;
+    currency: Currency;
+    wallet: WalletRef;
+}
+export interface ListTransactionsFilter {
+    type?: 'debit' | 'credit' | 'all';
+    from?: string;
+    to?: string;
+    service?: Service;
+    referenceId?: string;
+    /** Single tag filter as `key:value`. */
+    tag?: string;
+    cursor?: string;
+    limit?: number;
+}
+export interface TransactionPage {
+    transactions: WalletTransaction[];
+    nextCursor?: string;
+}
+export {};

package/dist/wallet/schema.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/wallet/services.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Chargeable services. The value is the legacy `service_id` stored on
+ * every ledger entry (so existing reports/invoicing keep working);
+ * callers reference the named constant instead of hardcoding the
+ * number. Extend as new chargeable services are added.
+ */
+export declare const Services: {
+    readonly RECHARGE: 0;
+    readonly SMS: 1;
+    readonly WHATSAPP: 4;
+    readonly FLASH_DELIVERY: 5;
+    readonly EMAIL: 10;
+    readonly ALERT: 40;
+};
+export type Service = (typeof Services)[keyof typeof Services];

package/dist/wallet/services.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Services = void 0;
+/**
+ * Chargeable services. The value is the legacy `service_id` stored on
+ * every ledger entry (so existing reports/invoicing keep working);
+ * callers reference the named constant instead of hardcoding the
+ * number. Extend as new chargeable services are added.
+ */
+exports.Services = {
+    RECHARGE: 0,
+    SMS: 1,
+    WHATSAPP: 4,
+    FLASH_DELIVERY: 5,
+    EMAIL: 10,
+    ALERT: 40,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd2FsbGV0L3NlcnZpY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOzs7OztHQUtHO0FBQ1UsUUFBQSxRQUFRLEdBQUc7SUFDdEIsUUFBUSxFQUFFLENBQUM7SUFDWCxHQUFHLEVBQUUsQ0FBQztJQUNOLFFBQVEsRUFBRSxDQUFDO0lBQ1gsY0FBYyxFQUFFLENBQUM7SUFDakIsS0FBSyxFQUFFLEVBQUU7SUFDVCxLQUFLLEVBQUUsRUFBRTtDQUNELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENoYXJnZWFibGUgc2VydmljZXMuIFRoZSB2YWx1ZSBpcyB0aGUgbGVnYWN5IGBzZXJ2aWNlX2lkYCBzdG9yZWQgb25cbiAqIGV2ZXJ5IGxlZGdlciBlbnRyeSAoc28gZXhpc3RpbmcgcmVwb3J0cy9pbnZvaWNpbmcga2VlcCB3b3JraW5nKTtcbiAqIGNhbGxlcnMgcmVmZXJlbmNlIHRoZSBuYW1lZCBjb25zdGFudCBpbnN0ZWFkIG9mIGhhcmRjb2RpbmcgdGhlXG4gKiBudW1iZXIuIEV4dGVuZCBhcyBuZXcgY2hhcmdlYWJsZSBzZXJ2aWNlcyBhcmUgYWRkZWQuXG4gKi9cbmV4cG9ydCBjb25zdCBTZXJ2aWNlcyA9IHtcbiAgUkVDSEFSR0U6IDAsXG4gIFNNUzogMSxcbiAgV0hBVFNBUFA6IDQsXG4gIEZMQVNIX0RFTElWRVJZOiA1LFxuICBFTUFJTDogMTAsXG4gIEFMRVJUOiA0MCxcbn0gYXMgY29uc3Q7XG5cbmV4cG9ydCB0eXBlIFNlcnZpY2UgPSAodHlwZW9mIFNlcnZpY2VzKVtrZXlvZiB0eXBlb2YgU2VydmljZXNdO1xuIl19

package/dist/zones/client.d.ts

@@ -0,0 +1,51 @@
+import { type PlatformAuth, type PlatformAuthInput, type PlatformConfigInput } from '../config';
+import type { ContainingInput, Zone, ZoneCreateInput, ZoneCreateResult, ZoneListOptions, ZoneListPage, ZonePatchInput, ZoneReplaceInput, ZoneSummary } from './schema';
+export interface ZonesClient {
+    config(input: PlatformConfigInput): ZonesClient;
+    auth(input: PlatformAuthInput | PlatformAuth): ZonesClient;
+    /** POST /v1/zones - create a single zone. */
+    create(input: ZoneCreateInput): Promise<ZoneCreateResult>;
+    /** GET /v1/zones/{zid} - returns the full zone or throws ZonesApiError(404). */
+    get(zid: string): Promise<Zone>;
+    /** PATCH /v1/zones/{zid} - shallow tag merge; null deletes a key. */
+    update(zid: string, input: ZonePatchInput): Promise<Zone>;
+    /** PUT /v1/zones/{zid} - full replace of geometry + tags. */
+    replace(zid: string, input: ZoneReplaceInput): Promise<Zone>;
+    /** DELETE /v1/zones/{zid} - 404 if not present. */
+    delete(zid: string): Promise<void>;
+    /** GET /v1/zones?tags=... - tag-filtered, keyset-paginated listing. */
+    list(opts?: ZoneListOptions): Promise<ZoneListPage>;
+    /** POST /v1/zones/batch/create - bounded array; returned in input order. */
+    createMany(zones: readonly ZoneCreateInput[]): Promise<{
+        zones: Array<{
+            zid: string;
+        }>;
+    }>;
+    /** POST /v1/zones/batch/delete - returns the count actually deleted. */
+    deleteMany(zids: readonly string[]): Promise<{
+        deleted: number;
+    }>;
+    /** POST /v1/zones/containing - the spatial primitive. */
+    containing(input: ContainingInput): Promise<ZoneSummary[]>;
+    /** Sugar over containing({ point, ids: [zid] }). True iff the zone contains the point. */
+    contains(zid: string, point: ContainingInput['point']): Promise<boolean>;
+}
+export declare class ZonesApiError extends Error {
+    readonly status: number;
+    readonly body: string;
+    constructor(status: number, body: string);
+}
+/**
+ * Build the `zones` namespace.
+ *
+ * Shape and contract mirror {@link createBusinessClient} - lazy config
+ * resolution via {@link ConfigState}, shared 401-retry via
+ * {@link sendWithAuthRetry}, immutable per-call config; no globals.
+ *
+ * Writes (`create`, `update`, `replace`, `delete`, batch ops) require a
+ * service-actor token. Reads (`get`, `list`, `containing`, `contains`)
+ * accept either a service-actor or a user-actor token. The SDK does not
+ * enforce this - the server returns 401/403 and we surface it as
+ * {@link ZonesApiError}.
+ */
+export declare function createZonesClient(input?: PlatformConfigInput): ZonesClient;