@settlemint/dalp-sdk 3.1.18-main.33808370488 → 3.1.18

package/dist/generated/response-scalars.d.ts

@@ -1,9 +0,0 @@
-/**
- * Response-side scalar paths, loaded only by a consumer that decodes them.
- *
- * Generated from the DALP v2 declaration. Do not edit.
- *
- * @module
- */
-import type { ResponseScalarTable } from "../routes/types.ts";
-export declare const data: ResponseScalarTable;

package/dist/generated/routes.d.ts

@@ -1,12 +0,0 @@
-/**
- * Every v2 route's identity, shape, traits and request-side scalars.
- *
- * Generated from the DALP v2 declaration. Do not edit.
- *
- * @module
- */
-import type { RouteTable, RouteRow } from "../routes/types.ts";
-import type { DalpRouteId } from "./api-types.d.ts";
-export declare const data: Omit<RouteTable, "routes"> & {
-    readonly routes: Readonly<Record<DalpRouteId, RouteRow>>;
-};

package/dist/proxy/builder.d.ts

@@ -1,47 +0,0 @@
-/**
- * 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;
-    /** Bounds a queue-backed wait. 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

@@ -1,32 +0,0 @@
-/**
- * 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

@@ -1,28 +0,0 @@
-/**
- * The promise interpreter's executor.
- *
- * Sends the prepared request and resolves the decoded body. A queue-backed
- * route resolves settled or fails: no 202 handle reaches a caller, because a
- * handle is a transport detail the SDK can follow itself and every caller
- * would otherwise re-implement the same poll.
- *
- * 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

@@ -1,51 +0,0 @@
-/**
- * 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. The remaining keys form
- * the JSON body when the declaration carries a payload and the query string
- * when it does not. 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/settlement.d.ts

@@ -1,67 +0,0 @@
-/**
- * Turn a 202 settlement handle into the settled result.
- *
- * A queue-backed route answers one of two ways: a settled 200 when the work
- * finishes inside the `Prefer: wait` window, or a 202 carrying
- * `transactionId`, `status` and `statusUrl` when the wait elapses. Both are the
- * platform's contract, and the handle is the durable one. What every caller
- * would otherwise write is the same poll loop, so the SDK owns it and a
- * mutation resolves settled or fails.
- *
- * The one thing a caller must not lose is the handle. A wait that runs out is
- * not a failed mutation, and reporting it as one would tell a caller their
- * write was rejected when it is still queued. `SettlementTimeoutError` carries
- * `transactionId` and `statusUrl` so the caller can resume the wait through
- * `../wait-for-transaction` or read the status route directly.
- *
- * The bound measures the platform's progress, not the calendar. A write the
- * funding gate has parked on an operator payment is stopped, not slow: the
- * status row reports the open ask as `activeRequirement` on every read, and no
- * progress is expected until the ask is paid. Every read that reports one
- * restarts the bound, so a parked write is never reported as a timeout and a
- * resumed write gets its whole budget back. What ends a pause is the payment
- * arriving or the platform failing the request when the ask lapses, and both
- * reach this loop as status. A caller that cannot wait that long ends the
- * wait through its `signal`. While the write is parked the reads slow down,
- * because the gate resumes it at its own cadence and the status route pays
- * for every read.
- *
- * @module
- */
-import { DalpSdkError } from "../errors/sdk-error.ts";
-import type { CallOptions } from "./builder.ts";
-import { type Transport } from "./transport.ts";
-/**
- * Default bound on how long the SDK follows a handle while the platform is
- * making progress. Time the write spends parked on a funding ask does not
- * count against it.
- */
-export declare const DEFAULT_SETTLEMENT_TIMEOUT_MS = 120000;
-/** Raised when the wait runs out while the work is still queued. */
-export declare class SettlementTimeoutError extends DalpSdkError {
-    readonly transactionId: string;
-    readonly statusUrl: string;
-    constructor(transactionId: string, statusUrl: string, timeoutMs: number);
-}
-/** Raised when the queued work reached a terminal failure. */
-export declare class SettlementFailedError extends DalpSdkError {
-    readonly transactionId: string;
-    constructor(transactionId: string, state: string, reason: string | undefined);
-}
-/** The 202 body, when the payload is one. */
-export interface SettlementHandle {
-    readonly transactionId: string;
-    readonly status: string;
-    readonly statusUrl: string;
-}
-export declare function readHandle(payload: unknown): SettlementHandle | undefined;
-/**
- * Follow a settlement handle to a terminal state.
- *
- * Returns the settled payload the status route reports. Raises
- * {@link SettlementFailedError} on a terminal failure and
- * {@link SettlementTimeoutError} when the bound elapses first. The bound
- * restarts on every status read that reports an open funding ask, so it never
- * elapses while the write is parked on a payment.
- */
-export declare function resolveSettlement(transport: Transport, payload: unknown, options: CallOptions | undefined, now?: () => number, sleep?: (ms: number) => Promise<void>): Promise<unknown>;

package/dist/proxy/sse.d.ts

@@ -1,54 +0,0 @@
-/**
- * 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.
- *
- * @yields Each frame the route emits, in order.
- */
-export declare function streamRequest(transport: Transport, route: RouteRow, input: unknown, options: CallOptions | undefined): AsyncGenerator<unknown>;

package/dist/proxy/tanstack.d.ts

@@ -1,27 +0,0 @@
-/**
- * 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

@@ -1,73 +0,0 @@
-/**
- * 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;
-    /** Default bound on a queue-backed wait. 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;
-    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

@@ -1,16 +0,0 @@
-/**
- * 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

@@ -1,13 +0,0 @@
-import {
-  UI_SETTLEMENT_TIMEOUT_MS,
-  canonicalize,
-  queryKeyFor
-} from "./chunk-def7rqy6.js";
-import"./chunk-fjnq61hj.js";
-import"./chunk-h12fatty.js";
-import"./chunk-y0d2c7kp.js";
-export {
-  UI_SETTLEMENT_TIMEOUT_MS,
-  canonicalize,
-  queryKeyFor
-};

package/dist/readonly-deep.d.ts

@@ -1,12 +0,0 @@
-/**
- * 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

@@ -1,20 +0,0 @@
-/**
- * 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/routes/index.d.ts

@@ -1,20 +0,0 @@
-/**
- * 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

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

package/dist/routes/types.d.ts

@@ -1,51 +0,0 @@
-/**
- * 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>;
-    /** 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

@@ -1,20 +0,0 @@
-/**
- * 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; that empty file is valid ESM, so ensure-dist accepts size 0 here.
- */
-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

@@ -1,16 +0,0 @@
-// 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

@@ -1,16 +0,0 @@
-/**
- * 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

@@ -1,20 +0,0 @@
-/**
- * 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;