@settlemint/dalp-sdk 3.1.18 → 3.1.19-main.34482536277

package/dist/proxy/builder.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Build the namespaced call surface from the route table.
+ *
+ * The tree is not emitted as 759 functions. It is a `Proxy` that resolves a
+ * node on first access and caches it, so the runtime cost is one closure per
+ * route a caller actually touches, and the module stays a few hundred lines
+ * regardless of how many routes the platform grows.
+ *
+ * This module is executor-agnostic on purpose: it imports neither `fetch` nor
+ * `effect`. The promise entry and the Effect entry pass their own executor and
+ * get the same tree, which is what keeps route behavior from diverging between
+ * the two surfaces.
+ *
+ * @module
+ */
+import type { RouteRow, RouteTable } from "../routes/types.ts";
+/** Per-call overrides a caller may pass alongside the request. */
+export interface CallOptions {
+    readonly signal?: AbortSignal;
+    /** How long the platform holds this write before it answers 202. Ignored on an immediate route. */
+    readonly settlementTimeoutMs?: number;
+    /**
+     * Extra headers for this call. A function is evaluated per request, which is
+     * what a retryable write needs: `Idempotency-Key` must be fresh per attempt,
+     * and a TanStack mutation binds its options once but fires many times.
+     */
+    readonly headers?: Readonly<Record<string, string>> | (() => Readonly<Record<string, string>>);
+}
+/** What an interpreter supplies: how to turn a resolved route call into a result. */
+export type Executor = (route: RouteRow, id: string, input: unknown, options: CallOptions | undefined) => unknown;
+/**
+ * Members attached to every leaf beside the call itself. A route segment may
+ * never take one of these names; the emitter refuses such a declaration.
+ */
+export interface LeafExtras {
+    readonly queryOptions: (input?: unknown, options?: CallOptions) => unknown;
+    readonly mutationOptions: (options?: CallOptions) => unknown;
+}
+/** How an interpreter builds the TanStack factories for one route. */
+export interface LeafFactories {
+    readonly queryOptions: (route: RouteRow, id: string, input: unknown, options: CallOptions | undefined) => unknown;
+    readonly mutationOptions: (route: RouteRow, id: string, options: CallOptions | undefined) => unknown;
+}
+/** Build the call surface for one executor. */
+export declare function buildProxy(table: RouteTable, executor: Executor, factories: LeafFactories): unknown;
+/** Look one route up by id, for a caller that builds its own command surface. */
+export declare function findRoute(table: RouteTable, id: string): RouteRow | undefined;

package/dist/proxy/client.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The promise call surface.
+ *
+ * @module
+ */
+import type { DalpApi, DalpRouteId, DalpRouteTypes } from "../generated/api-types.d.ts";
+import { type CallOptions } from "./builder.ts";
+import { type CreateDalpClientOptions } from "./transport.ts";
+/** Execute a route by its id, for a caller that builds its own command surface. */
+export interface DalpClient {
+    readonly api: DalpApi;
+    /** Held conditional-GET bodies. Clear on sign-out and organization switch. */
+    readonly conditionalRequests: {
+        readonly clear: () => void;
+    };
+    /**
+     * Dispatch by route id. Resolves the decoded body, or, for a
+     * `text/event-stream` route, the frame sequence the proxy leaf also returns.
+     *
+     * Typed against the id, so a command surface built from route ids keeps the
+     * request and response types the namespaced tree gives a call site.
+     */
+    readonly execute: <Id extends DalpRouteId>(routeId: Id, input?: DalpRouteTypes[Id]["request"], options?: CallOptions) => Promise<DalpRouteTypes[Id]["response"]>;
+}
+/**
+ * Create the namespaced client.
+ *
+ * `api` is the proxy tree. `execute` is the same dispatch reached by route id,
+ * which is what `kit/cli` uses: its command tree is kubectl-shaped, derived
+ * from URL segments, so it never wants the JavaScript namespace tree.
+ */
+export declare function createDalpClient(options: CreateDalpClientOptions): DalpClient;

package/dist/proxy/fetch-executor.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The promise interpreter's executor.
+ *
+ * Sends the prepared request and resolves the decoded body. A 202 handle is
+ * the declared response, so it is handed back rather than followed: its status
+ * URL reports lifecycle state, not the route-specific 200 resource, and a
+ * caller that swaps one for the other has lost the durable identifier its
+ * write is addressed by. How long the platform holds the response before it
+ * answers 202 is the caller's to set, through `settlementTimeoutMs`.
+ *
+ * No response validation. The emitted declarations describe the response and
+ * the platform validated it on the way out, so re-checking it here would ship
+ * a second copy of every schema to every consumer for no added guarantee.
+ *
+ * @module
+ */
+import type { CallOptions, Executor } from "./builder.ts";
+import { type Transport } from "./transport.ts";
+import type { RouteRow } from "../routes/types.ts";
+/** Send one prepared request. */
+export declare function sendRequest(transport: Transport, route: RouteRow, input: unknown, options: CallOptions | undefined): Promise<unknown>;
+/**
+ * Build the executor the proxy calls for every leaf.
+ *
+ * An SSE route returns its async iterable directly rather than a promise of
+ * one, so `for await (const frame of dalp.transaction.statusStream(input))`
+ * reads without an intervening await. Awaiting it first is also valid, because
+ * awaiting a non-promise is a no-op.
+ */
+export declare function createFetchExecutor(transport: Transport): Executor;

package/dist/proxy/flat-args.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Split one flat argument object into the parts an HTTP request needs.
+ *
+ * The call site names what it means and nothing else:
+ *
+ *     dalp.api.token.transfer({ tokenAddress, transfers })
+ *
+ * rather than restating the transport at every site as
+ * `{ client, path: { tokenAddress }, body: { to, amount } }`. The route table
+ * carries the path template's parameter names, so the split is a lookup, and
+ * the build refuses any route whose path parameter would collide with a body or
+ * query key, which is what makes merging them safe.
+ *
+ * @module
+ */
+import type { RouteRow } from "../routes/types.ts";
+/**
+ * One flat call argument, before the route table says which key goes where.
+ * Named rather than `Record<string, unknown>` so the unstructured boundary is
+ * explicit: this is caller input, not a decoded domain shape.
+ */
+/** A JSON value a caller may pass in a flat call argument. */
+export type FlatCallValue = null | boolean | number | string | ReadonlyArray<FlatCallValue> | FlatCallObject;
+/** A nested object inside a flat call argument. */
+export interface FlatCallObject {
+    readonly [key: string]: FlatCallValue;
+}
+/**
+ * One flat call argument, before the route table says which key goes where.
+ * Named rather than left as a bare record so the unstructured boundary is
+ * explicit: this is caller input, not a decoded domain shape.
+ */
+export type FlatCallInput = FlatCallObject;
+/** The request parts, ready for a URL and a body. */
+export interface SplitArgs {
+    readonly path: FlatCallInput;
+    readonly query: FlatCallInput;
+    readonly body: FlatCallInput | undefined;
+}
+/**
+ * Divide `input` into path, query and body according to `route`.
+ *
+ * A key named in the path template goes to the path. When the declaration
+ * carries a payload, a key the route declares as a query parameter goes to the
+ * query string and the remaining keys form the JSON body; without a payload
+ * every remaining key is a query parameter. The method is not the signal: a
+ * DELETE that declares a payload reads it from the body exactly as a POST does,
+ * and a GET never declares one.
+ */
+export declare function splitFlatArgs(route: RouteRow, input: unknown): SplitArgs;
+/** Substitute path parameters into the route's template. */
+export declare function buildPath(route: RouteRow, path: FlatCallInput): string;

package/dist/proxy/sse.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Read a `text/event-stream` route as an async iterable of decoded frames.
+ *
+ * Ten v2 routes answer with SSE rather than a body, and the route table names
+ * them with `serializer: "sse"`. They are the same declaration, the same path
+ * builder and the same auth as every other route, so they resolve through the
+ * same proxy leaf; only what comes back differs. A caller writes
+ * `for await (const frame of dalp.transaction.statusStream({ transactionId }))`.
+ *
+ * The parser is the wire format and nothing more: `data:` lines accumulate,
+ * a blank line dispatches the event, and a comment keeps the connection warm.
+ * Retry, backoff and reconnection are deliberately absent. A stream that ends
+ * before its terminal frame is a fact the caller has to see, and a reconnect
+ * hidden here would replace that fact with a silent gap in the sequence.
+ *
+ * One event name is not a frame. When a route's stream fails, the server ends
+ * it with a block whose `event:` line is the reserved failure name, and whose
+ * `data:` line is a serialized description of the failure. The reader raises it
+ * as a `DalpApiError`, so a caller sees the failure rather than a frame that
+ * looks like a payload and is not one.
+ *
+ * @module
+ */
+import type { CallOptions } from "./builder.ts";
+import type { RouteRow } from "../routes/types.ts";
+import { type Transport } from "./transport.ts";
+/**
+ * The event name the Effect HTTP API server writes when a route's stream fails.
+ *
+ * `HttpApiBuilder` owns the name and keeps it private, so the value is repeated
+ * here rather than imported. `tests/unit/effect-client.test.ts` pins it against
+ * the literal Effect publishes on its OpenAPI stream metadata.
+ */
+export declare const RESERVED_STREAM_FAILURE_EVENT = "effect/httpapi/stream/failure";
+/**
+ * The stable code raised when a route ends its stream with the reserved event.
+ *
+ * Consumers classify on this code, so it lives beside the throw rather than
+ * being copied into every reader of the error.
+ */
+export declare const STREAM_FAILED_ERROR_CODE = "sdk.stream.FAILED";
+/**
+ * Decode a byte stream into dispatched SSE events.
+ *
+ * @yields Each dispatched event, parsed as JSON when it is JSON.
+ * @throws A `DalpApiError` when the route ends the stream with its reserved failure event.
+ */
+export declare function decodeEventStream(body: ReadableStream<Uint8Array>): AsyncGenerator<unknown>;
+/**
+ * Open one SSE route and yield its frames.
+ *
+ * The frames come from a generator this function wraps rather than from this
+ * function itself, because closing an async generator does not reach its body
+ * while a read is in flight. A `return()` on a generator suspended inside
+ * `await reader.read()` is QUEUED behind that read, and a route that holds its
+ * stream open with nothing left to say never settles it. The close then waits
+ * for a frame the route has no reason to send, and it waits forever.
+ *
+ * That is not a corner case. A consumer stops reading exactly when it has seen
+ * what it came for, which is usually before the run it is watching finishes:
+ * a screen the operator navigates away from, and a caller that stops at a
+ * funding ask it cannot pay. Measured on the gas drill (`aa-subjects` AE5): the
+ * lane stopped at the smart-account ask, which by design leaves the token
+ * create parked on that ask, and every assertion passed. The scope holding the
+ * stream then called `return()`, the parked stream never sent another frame,
+ * and the lane failed on its 600 s timeout with the work already done.
+ *
+ * So the request carries an abort signal this function owns, and the wrapper
+ * fires it BEFORE forwarding the close. The read in flight then ends, the
+ * generator body runs its own cleanup, and the close resolves. The caller's own
+ * signal still aborts the request; it is forwarded into the same controller.
+ *
+ * @returns The route's frame sequence, in order, closable at any frame.
+ */
+export declare function streamRequest(transport: Transport, route: RouteRow, input: unknown, options: CallOptions | undefined): AsyncGenerator<unknown>;

package/dist/proxy/tanstack.d.ts

@@ -0,0 +1,27 @@
+/**
+ * TanStack option factories, on the same proxy nodes as the calls.
+ *
+ * `dalp.api.token.list.queryOptions({ limit: 25 })` rather than a parallel module of
+ * `v2TokenListOptions` functions. The key carries route identity plus
+ * canonicalized input, so two callers passing equivalent input in different key
+ * order produce the same key and share a cache entry.
+ *
+ * This module imports no React and no TanStack: it returns plain objects
+ * matching the shapes `queryOptions` and `mutationOptions` expect, which keeps
+ * `@tanstack/react-query` an optional peer that a non-React consumer never
+ * resolves.
+ *
+ * @module
+ */
+import type { LeafFactories } from "./builder.ts";
+import type { Transport } from "./transport.ts";
+/** Sort object keys recursively so equivalent input hashes to one key. */
+export declare function canonicalize(value: unknown): unknown;
+/** The cache key for one call: route identity, then canonical input. */
+export declare function queryKeyFor(id: string, input: unknown): ReadonlyArray<unknown>;
+/**
+ * A UI wait shorter than the batch default: a mutation hook holds a spinner for
+ * the whole settlement, and two minutes of spinner is not a UI.
+ */
+export declare const UI_SETTLEMENT_TIMEOUT_MS = 30000;
+export declare function createTanstackFactories(transport: Transport): LeafFactories;

package/dist/proxy/transport.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The request path shared by both interpreters.
+ *
+ * Everything here already existed as hand-written transport policy around the
+ * generated client: body compression, SSR cookie forwarding, the query
+ * serializer, the acting-context headers, and the API-key rule. Only the
+ * dispatch changed, from 759 emitted functions to one route lookup, so this
+ * module composes the same pieces rather than reimplementing them.
+ *
+ * @module
+ */
+import { Secret } from "../secret.ts";
+import { type DalpFetch } from "../client/ssr-fetch.ts";
+import { type ConditionalRequestStore } from "../client/conditional-request.ts";
+import type { RouteRow } from "../routes/types.ts";
+import type { CallOptions } from "./builder.ts";
+export interface DalpClientContext {
+    readonly organizationId?: string;
+    readonly participant?: string;
+    readonly executor?: "eoa" | "smart-wallet";
+    readonly chainId?: number | string;
+    readonly selectedSigners?: ReadonlyArray<string>;
+    readonly idempotencyKey?: string;
+}
+export interface DalpSsrOptions {
+    readonly requestHeaders: HeadersInit;
+    readonly allowedOrigins?: ReadonlyArray<string | URL>;
+}
+export interface CreateDalpClientOptions {
+    readonly baseUrl: string | URL;
+    readonly apiKey?: string | Secret;
+    readonly context?: DalpClientContext;
+    readonly fetch?: DalpFetch;
+    readonly runtime?: "browser" | "server";
+    readonly ssr?: DalpSsrOptions;
+    /** How long the platform holds a queue-backed write before it answers 202. A call may override it. */
+    readonly settlementTimeoutMs?: number;
+}
+/** Build per-operation headers which override an instance's default acting context. */
+export declare function createDalpContextHeaders(context: DalpClientContext): Headers;
+/** A prepared request, before it is sent. Both interpreters build the same one. */
+export interface PreparedRequest {
+    readonly url: string;
+    readonly method: string;
+    readonly headers: Headers;
+    readonly body: string | undefined;
+}
+/** Everything a request needs that does not come from the call itself. */
+export interface Transport {
+    readonly baseUrl: string;
+    readonly fetch: DalpFetch;
+    readonly credentials: RequestCredentials;
+    readonly apiKey: Secret | undefined;
+    readonly contextHeaders: Headers;
+    /** The wait a queue-backed write asks the platform for, in milliseconds. */
+    readonly settlementTimeoutMs: number | undefined;
+    /** Held ETag bodies. Clear on sign-out and organization switch. */
+    readonly conditionalRequests: ConditionalRequestStore;
+}
+/** Default wait a caller asks the platform to hold before it answers 202. */
+export declare const DEFAULT_PREFER_WAIT_SECONDS = 15;
+export declare function createTransport(options: CreateDalpClientOptions): Transport;
+/**
+ * The headers every request of one call carries: the JSON accept, the API key,
+ * the acting-context headers, and the caller's own headers on top. The
+ * settlement poll that follows a 202 sends the same set, because the status
+ * route authenticates exactly like the write that produced the handle; a poll
+ * that dropped the caller's session or API key answered 401 mid-settlement.
+ */
+export declare function callHeaders(transport: Transport, options: CallOptions | undefined): Headers;
+/** Turn a flat call into the request the route describes. */
+export declare function prepareRequest(transport: Transport, route: RouteRow, input: unknown, options: CallOptions | undefined): PreparedRequest;
+/** Read a response, raising `DalpApiError` on a non-2xx. */
+export declare function readResponse(response: Response): Promise<unknown>;

package/dist/react-query.d.ts

@@ -0,0 +1,16 @@
+/**
+ * TanStack Query helpers.
+ *
+ * The option factories live on the proxy nodes themselves
+ * (`dalp.api.token.list.queryOptions({ limit: 25 })`), so this subpath no longer
+ * re-exports a parallel module of generated `*Options` functions. What remains
+ * is the key derivation, which a consumer needs to invalidate by hand.
+ *
+ * Nothing here imports `@tanstack/react-query`: the factories return plain
+ * objects matching the shapes it expects, which keeps that peer dependency
+ * optional for a non-React consumer.
+ *
+ * @module
+ */
+export { canonicalize, queryKeyFor, UI_SETTLEMENT_TIMEOUT_MS } from "./proxy/tanstack.ts";
+export type { CallOptions } from "./proxy/builder.ts";

package/dist/react-query.js

@@ -0,0 +1,12 @@
+import"./chunk-j4sxrfzz.js";
+import {
+  canonicalize2,
+  queryKeyFor2,
+  UI_SETTLEMENT_TIMEOUT_MS2
+} from "./chunk-shp8v4ws.js";
+import"./chunk-xp3fx2yt.js";
+export {
+  UI_SETTLEMENT_TIMEOUT_MS2 as UI_SETTLEMENT_TIMEOUT_MS,
+  canonicalize2 as canonicalize,
+  queryKeyFor2 as queryKeyFor
+};

package/dist/readonly-deep.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A local deep-readonly, exported as a module rather than declared ambiently.
+ *
+ * An ambient `.d.ts` global compiles inside this workspace but never reaches the
+ * tarball, so every emitted declaration that named it referenced a type the
+ * consumer could not resolve. Exporting it makes the published declarations
+ * self-contained. The repository copy at `@core/schema/deep-readonly` is a
+ * private workspace package and must not be imported here.
+ */
+export type ReadonlyDeep<T> = T extends string | number | bigint | boolean | symbol | null | undefined | Date | RegExp | Map<unknown, unknown> | Set<unknown> | Promise<unknown> ? T : T extends CallableFunction ? T : T extends object ? {
+    readonly [Key in keyof T]: ReadonlyDeep<T[Key]>;
+} : T;

package/dist/reads-as-funding-paused.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Whether a transaction status row says the write is parked on an operator's
+ * gas funding payment.
+ *
+ * The funding gate holds the queue state of a write it pauses, so `status`
+ * does not move while the operator is being asked for money. The open ask,
+ * published as `activeRequirement` on the status route and its stream, is the
+ * only field that says the write is waiting on a payment rather than on the
+ * chain. The wire declares it absent or null when there is no ask.
+ */
+export declare function readsAsFundingPaused(status: unknown): boolean;
+/**
+ * Longest gap between two status reads of a parked write.
+ *
+ * A write waiting on a payment moves at the funding gate's own cadence, which
+ * grows to minutes, so reading it faster than this learns nothing and costs
+ * the status route a request for every parked write on every second of a pause
+ * that can last a day.
+ */
+export declare const PAUSED_POLL_INTERVAL_MAX_MS = 30000;

package/dist/reads-as-indexer-rebuild.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Whether a transaction status row says the platform is rebuilding its index
+ * of the chain the write landed on.
+ *
+ * A rebuild replays a chain's whole history, so a write that is already mined
+ * cannot be read back until the replay reaches its block. The queue state does
+ * not move while that runs, so `indexerRebuild`, published on the status route
+ * and its stream, is the only field that says the wait is on the replay rather
+ * than on the chain. The wire declares it absent or null when no rebuild runs.
+ *
+ * A rebuild takes hours, against minutes for a funding pause, so a caller that
+ * reads this must widen its own patience rather than report a timeout.
+ */
+export declare function readsAsIndexerRebuild(status: unknown): boolean;

package/dist/routes/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The declaration-derived route table, as data.
+ *
+ * Published beside its types so a consumer that builds its own command surface
+ * can resolve a route id without reaching for an interpreter. `kit/cli` walks
+ * it to build commands; the dapp facade uses it to prove a facade path names a
+ * real route at construction time rather than at the first call.
+ *
+ * @module
+ */
+import { data as routeTable } from "../generated/routes.ts";
+/**
+ * Every declared route id, in a stable order.
+ *
+ * The generated table is keyed by route id, so `keyof` is already the union and
+ * no literal assertion is invented here.
+ */
+export declare const routeIds: ReadonlyArray<keyof typeof routeTable.routes>;
+export { routeTable };
+export type { ResponseScalarTable, RouteRow, RouteTable } from "./types.ts";

package/dist/routes/index.js

@@ -0,0 +1,10 @@
+import {
+  data
+} from "../chunk-09prmw53.js";
+
+// src/routes/index.ts
+var routeIds = Object.keys(data.routes).sort();
+export {
+  routeIds,
+  data as routeTable
+};

package/dist/routes/types.d.ts

@@ -0,0 +1,57 @@
+/**
+ * The shape of the declaration-derived route table.
+ *
+ * Mirrors what `packages/dapi/server/tools/route-table.ts` emits. It is
+ * restated here rather than imported because the SDK is published and
+ * `check-dts-portability` proves the packed declarations reference no private
+ * workspace package.
+ *
+ * @module
+ */
+/** One route, as the declaration describes it. */
+export interface RouteRow {
+    readonly method: string;
+    /** Path template with `:param` segments, unprefixed by the API mount. */
+    readonly path: string;
+    readonly params: ReadonlyArray<string>;
+    readonly successStatuses: ReadonlyArray<number>;
+    readonly errorStatuses: ReadonlyArray<number>;
+    /**
+     * Whether the route can answer with a settlement handle, derived from the
+     * declared success statuses rather than from the `settlement` trait.
+     */
+    readonly queueBacked: boolean;
+    readonly settlementTrait: string;
+    readonly serializer: string;
+    readonly auth: string;
+    readonly access: string;
+    readonly idempotency: boolean;
+    /**
+     * Whether the declaration carries a request payload. Non-path keys of a flat
+     * call become the JSON body when it does and query parameters when it does
+     * not, whatever the method: a DELETE with a payload reads a body.
+     */
+    readonly hasPayload: boolean;
+    /**
+     * Path parameters the payload declares again. The flat call names the field
+     * once; the split puts it in the path and repeats it in the body.
+     */
+    readonly bodyParams: ReadonlyArray<string>;
+    /**
+     * Top-level query parameter names the declaration carries. On a route with a
+     * payload the split lifts these keys into the query string before the rest
+     * becomes the body; without them every non-path key would be sent as body.
+     */
+    readonly queryParams: ReadonlyArray<string>;
+    /** Request-side scalars, keyed by dotted field path. */
+    readonly scalars: Readonly<Record<string, string | undefined>>;
+}
+export interface RouteTable {
+    readonly version: 1;
+    readonly routes: Readonly<Record<string, RouteRow | undefined>>;
+    readonly settlementDisagreements: ReadonlyArray<string>;
+}
+export interface ResponseScalarTable {
+    readonly version: 1;
+    readonly routes: Readonly<Record<string, Readonly<Record<string, string>> | undefined>>;
+}

package/dist/runtime-exports.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Runtime dist files probed by Console `/readyz`.
+ *
+ * Completeness of the published package is the export graph walked by
+ * `kit/sdk/scripts/sdk-dist-artifact-graph.ts`. This list is the smaller boot
+ * probe subset. Keep in sync with `kit/dapp/server/sdk-runtime-export-paths.ts`
+ * (probe boot must not resolve this package at module evaluation).
+ *
+ * @module
+ */
+/** Relative paths under the `@settlemint/dalp-sdk` package root. */
+export declare const SDK_RUNTIME_EXPORT_RELATIVE_PATHS: readonly ["dist/index.js", "dist/operations.js", "dist/types.js", "dist/index.d.ts", "dist/runtime-exports.js", "dist/runtime-exports.d.ts"];
+/**
+ * Type-only published entries. Bun emits a 0-byte JS file for `export type *`
+ * modules; the artifact graph accepts it beside a non-empty declaration file.
+ */
+export declare const SDK_TYPE_ONLY_EXPORT_RELATIVE_PATHS: readonly ["dist/types.js"];
+export type SdkRuntimeExportRelativePath = (typeof SDK_RUNTIME_EXPORT_RELATIVE_PATHS)[number];
+/** First runtime export — historical single-sentinel alias. */
+export declare const SDK_BUILD_SENTINEL_RELATIVE_PATH: "dist/index.js";

package/dist/runtime-exports.js

@@ -0,0 +1,16 @@
+// src/runtime-exports.ts
+var SDK_RUNTIME_EXPORT_RELATIVE_PATHS = [
+  "dist/index.js",
+  "dist/operations.js",
+  "dist/types.js",
+  "dist/index.d.ts",
+  "dist/runtime-exports.js",
+  "dist/runtime-exports.d.ts"
+];
+var SDK_TYPE_ONLY_EXPORT_RELATIVE_PATHS = ["dist/types.js"];
+var [SDK_BUILD_SENTINEL_RELATIVE_PATH] = SDK_RUNTIME_EXPORT_RELATIVE_PATHS;
+export {
+  SDK_BUILD_SENTINEL_RELATIVE_PATH,
+  SDK_RUNTIME_EXPORT_RELATIVE_PATHS,
+  SDK_TYPE_ONLY_EXPORT_RELATIVE_PATHS
+};

package/dist/scalars/big-decimal.d.ts

@@ -0,0 +1,16 @@
+/**
+ * BigDecimal wire scalar: the API encodes arbitrary-precision decimals as plain
+ * decimal strings; consumers work with `dnum` values.
+ *
+ * Both directions live here. Encoding normalizes: `dnum` does not preserve
+ * trailing fractional zeros, so `"1.100"` decodes to the same value as `"1.1"`
+ * and re-encodes as `"1.1"`.
+ *
+ * @module
+ */
+import type { Dnum } from "dnum";
+export type BigDecimalValue = Dnum;
+/** Read a wire decimal string into a `dnum` value. */
+export declare function decodeBigDecimal(wire: string): BigDecimalValue;
+/** Write a `dnum` value back to its wire form. */
+export declare const encodeBigDecimal: (value: Dnum) => string;

package/dist/scalars/ethereum-address.d.ts

@@ -0,0 +1,20 @@
+/**
+ * EVM address scalar: accepts checksummed or lowercase wire forms and
+ * normalizes to the EIP-55 checksum. The branded type keeps a plain string from
+ * passing as a validated address.
+ *
+ * @module
+ */
+export type EthereumAddressValue = string & {
+    readonly __brand: "EthereumAddress";
+};
+/** Normalize a wire address to its EIP-55 checksum. */
+export declare function decodeEthereumAddress(wire: string): EthereumAddressValue;
+/**
+ * Normalize a wire address, or return nothing when it is not one.
+ *
+ * UI code frequently reads an address out of unvalidated state and needs a
+ * verdict rather than an exception, which is what zod's `safeParse` gave the
+ * previous schema-shaped surface.
+ */
+export declare function tryDecodeEthereumAddress(wire: unknown): EthereumAddressValue | undefined;

package/dist/scalars/exchange-rates.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Rich-scalar decoding for the exchange-rates list response.
+ *
+ * The wire carries a contract-faithful decimal string and a lowercase address.
+ * This turns them into a `dnum` amount and a checksummed address. It reads the
+ * shape structurally rather than through a schema library: the SDK ships no
+ * runtime validator, because the platform validated the body on the way out and
+ * a second copy of every schema would reach every consumer for no added
+ * guarantee.
+ *
+ * @module
+ */
+import { type BigDecimalValue } from "./big-decimal.ts";
+import { type EthereumAddressValue } from "./ethereum-address.ts";
+export interface ExchangeRateRow {
+    readonly rate: BigDecimalValue | null;
+    readonly feedAddress: EthereumAddressValue | null;
+    readonly [key: string]: unknown;
+}
+export interface ExchangeRatesListResponse {
+    readonly data: ReadonlyArray<ExchangeRateRow>;
+    readonly [key: string]: unknown;
+}
+/** Decode a list response, converting its scalar columns. */
+export declare function decodeExchangeRatesListResponse(payload: unknown): ExchangeRatesListResponse;
+/** Kept for callers that spread this as a response transformer. */
+export declare const exchangeRatesListTransformer: (data: unknown) => Promise<ExchangeRatesListResponse>;

package/dist/scalars/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Rich-scalar decoders.
+ *
+ * The route table names which fields carry a scalar, keyed by dotted path, so a
+ * caller applies these where the declaration says a scalar lives rather than
+ * guessing from a field name. They are plain functions: the SDK ships no
+ * runtime schema library, because the platform validates on the way out.
+ *
+ * @module
+ */
+export { decodeBigDecimal, encodeBigDecimal } from "./big-decimal.ts";
+export type { BigDecimalValue } from "./big-decimal.ts";
+export { decodeEthereumAddress, tryDecodeEthereumAddress } from "./ethereum-address.ts";
+export type { EthereumAddressValue } from "./ethereum-address.ts";
+export { decodeOrganizationId, tryDecodeOrganizationId } from "./organization-id.ts";
+export type { OrganizationIdValue } from "./organization-id.ts";
+export { decodeExchangeRatesListResponse, exchangeRatesListTransformer } from "./exchange-rates.ts";
+export type { ExchangeRateRow, ExchangeRatesListResponse } from "./exchange-rates.ts";