@settlemint/dalp-sdk 3.1.10 → 3.1.11-main.33556892334

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/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; 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

@@ -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.
+ *
+ * Declared as a codec so both directions live in one place: `BigDecimal.parse`
+ * (or `z.decode`) reads a wire string into a `Dnum`, and `z.encode` writes it
+ * back. `encodeBigDecimal` stays as the named encoder callers already use.
+ *
+ * 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"`.
+ */
+import type { Dnum } from "dnum";
+import * as z from "zod";
+export declare const BigDecimal: z.ZodCodec<z.ZodString, z.ZodCustom<Dnum, Dnum>>;
+export type BigDecimalValue = z.output<typeof BigDecimal>;
+export declare const encodeBigDecimal: (value: Dnum) => string;

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

@@ -0,0 +1,8 @@
+/**
+ * EVM address scalar: accepts checksummed or lowercase wire forms, normalizes
+ * to the EIP-55 checksum via viem, and brands the result so plain strings do
+ * not pass as validated addresses at the type level.
+ */
+import * as z from "zod";
+export declare const EthereumAddress: z.core.$ZodBranded<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>, "EthereumAddress", "out">;
+export type EthereumAddressValue = z.output<typeof EthereumAddress>;

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

@@ -0,0 +1,36 @@
+/**
+ * Reference scalar wrapper: composes the rich scalars onto the generated
+ * exchange-rates list response by extending the generated zod constants —
+ * generated files are never edited. The exported transformer is the KTD6
+ * injection mechanism: pass it as a per-call `responseTransformer` to the
+ * generated operation function or TanStack factory (caller options spread
+ * after the generated transformer, so the override wins; `createQueryKey`
+ * ignores it, so query keys stay stable).
+ */
+import * as z from "zod";
+export declare const ExchangeRatesListResponse: z.ZodObject<{
+    meta: z.ZodObject<{
+        total: z.ZodInt;
+        facets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            count: z.ZodInt;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>;
+    links: z.ZodObject<{
+        self: z.ZodString;
+        first: z.ZodString;
+        prev: z.ZodNullable<z.ZodString>;
+        next: z.ZodNullable<z.ZodString>;
+        last: z.ZodString;
+    }, z.core.$strict>;
+    data: z.ZodArray<z.ZodObject<{
+        baseCurrency: z.ZodString;
+        quoteCurrency: z.ZodString;
+        effectiveAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodString, z.ZodNumber]>>;
+        updatedAt: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodString, z.ZodNumber]>>;
+        rate: z.ZodNullable<z.ZodCodec<z.ZodString, z.ZodCustom<import("dnum").Dnum, import("dnum").Dnum>>>;
+        feedAddress: z.ZodNullable<z.core.$ZodBranded<z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>, "EthereumAddress", "out">>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ExchangeRatesListResponse = z.output<typeof ExchangeRatesListResponse>;
+export declare const exchangeRatesListTransformer: (data: unknown) => Promise<ExchangeRatesListResponse>;

package/dist/scalars/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Rich-scalar seam: zod schemas that decode the contract-faithful wire strings
+ * the generated core returns into `dnum` amounts, checksummed addresses, and
+ * branded entity ids. Composed onto the generated zod constants, never by
+ * editing generated files.
+ *
+ * @module
+ */
+export { BigDecimal, encodeBigDecimal } from "./big-decimal.ts";
+export type { BigDecimalValue } from "./big-decimal.ts";
+export { EthereumAddress } from "./ethereum-address.ts";
+export type { EthereumAddressValue } from "./ethereum-address.ts";
+export { OrganizationId } from "./organization-id.ts";
+export type { OrganizationIdValue } from "./organization-id.ts";
+export { ExchangeRatesListResponse, exchangeRatesListTransformer } from "./exchange-rates.ts";

package/dist/scalars/index.js

@@ -0,0 +1,39 @@
+import {
+  zV2ExchangeRatesListResponse
+} from "../chunk-63xjs3xe.js";
+
+// src/scalars/big-decimal.ts
+import * as dn from "dnum";
+import * as z from "zod";
+var decimalWire = /^-?\d+(?:\.\d+)?$/;
+var dnum = z.custom((value) => Array.isArray(value) && value.length === 2, "must be a dnum value");
+var BigDecimal = z.codec(z.string().regex(decimalWire, "must be a plain decimal string"), dnum, {
+  decode: (wire) => dn.from(wire),
+  encode: (value) => dn.toString(value)
+});
+var encodeBigDecimal = (value) => z.encode(BigDecimal, value);
+// src/scalars/ethereum-address.ts
+import { getAddress, isAddress } from "viem";
+import * as z2 from "zod";
+var EthereumAddress = z2.string().refine((value) => isAddress(value, { strict: false }), "must be an EVM address").transform((value) => getAddress(value)).brand();
+// src/scalars/organization-id.ts
+import * as z3 from "zod";
+var OrganizationId = z3.string().min(1).brand();
+// src/scalars/exchange-rates.ts
+import * as z4 from "zod";
+var row = zV2ExchangeRatesListResponse.shape.data.element.extend({
+  rate: BigDecimal.nullable(),
+  feedAddress: EthereumAddress.nullable()
+});
+var ExchangeRatesListResponse = zV2ExchangeRatesListResponse.extend({
+  data: z4.array(row)
+});
+var exchangeRatesListTransformer = async (data) => ExchangeRatesListResponse.parse(data);
+export {
+  BigDecimal,
+  EthereumAddress,
+  ExchangeRatesListResponse,
+  OrganizationId,
+  encodeBigDecimal,
+  exchangeRatesListTransformer
+};

package/dist/scalars/organization-id.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Branded organization id: the only entity id branded end-to-end across the
+ * platform. Runtime validation is minimal (non-empty); the brand is the
+ * type-level contract.
+ */
+import * as z from "zod";
+export declare const OrganizationId: z.core.$ZodBranded<z.ZodString, "OrganizationId", "out">;
+export type OrganizationIdValue = z.output<typeof OrganizationId>;

package/dist/schemas.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Generated zod v4 schemas for the v2 surface — the same schemas the generated
+ * SDK uses as its response validator.
+ *
+ * Custom scalars (BigDecimal, addresses, branded ids) are not applied here;
+ * those live on `@settlemint/dalp-sdk/scalars`, which composes onto these.
+ *
+ * @module
+ */
+export * from "./generated/zod.gen.ts";