@settlemint/dalp-sdk 3.1.25 → 3.1.26-main.37116470199

package/dist/routes/index.d.ts

@@ -0,0 +1,4 @@
+import { data as routeTable } from "../generated/routes.ts";
+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 {
+  data2
+} from "../chunk-hqz56e6q.js";
+
+// src/routes/index.ts
+var routeIds = Object.keys(data2.routes).sort();
+export {
+  routeIds,
+  data2 as routeTable
+};

package/dist/routes/types.d.ts

@@ -0,0 +1,72 @@
+export interface RouteRow {
+    readonly method: string;
+    readonly path: string;
+    readonly params: ReadonlyArray<string>;
+    readonly successStatuses: ReadonlyArray<number>;
+    readonly errorStatuses: ReadonlyArray<number>;
+    readonly queueBacked: boolean;
+    readonly settlementTrait: string;
+    readonly serializer: string;
+    readonly auth: string;
+    readonly access: string;
+    readonly idempotency: boolean;
+    readonly hasPayload: boolean;
+    readonly bodyParams: ReadonlyArray<string>;
+    readonly queryParams: ReadonlyArray<string>;
+    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 ErrorCodeTable {
+    readonly version: 1;
+    readonly codes: ReadonlyArray<string>;
+}
+export interface ErrorCatalogEntry {
+    readonly id: string;
+    readonly status: number;
+}
+export interface ErrorCatalogTable {
+    readonly version: 1;
+    readonly entries: Readonly<Record<string, ErrorCatalogEntry>>;
+}
+export interface RouteErrorCodeTable {
+    readonly version: 1;
+    readonly routes: Readonly<Record<string, ReadonlyArray<number> | undefined>>;
+}
+export interface JsonSchemaNode {
+    readonly $ref?: string;
+    readonly type?: string | ReadonlyArray<string>;
+    readonly properties?: Readonly<Record<string, JsonSchemaNode>>;
+    readonly required?: ReadonlyArray<string>;
+    readonly additionalProperties?: boolean | JsonSchemaNode;
+    readonly propertyNames?: JsonSchemaNode;
+    readonly items?: JsonSchemaNode;
+    readonly prefixItems?: ReadonlyArray<JsonSchemaNode>;
+    readonly anyOf?: ReadonlyArray<JsonSchemaNode>;
+    readonly oneOf?: ReadonlyArray<JsonSchemaNode>;
+    readonly allOf?: ReadonlyArray<JsonSchemaNode>;
+    readonly enum?: ReadonlyArray<unknown>;
+    readonly const?: unknown;
+    readonly pattern?: string;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly exclusiveMinimum?: number;
+    readonly exclusiveMaximum?: number;
+    readonly multipleOf?: number;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+}
+export interface ResponseSchemaTable {
+    readonly version: 1;
+    readonly definitions: Readonly<Record<string, JsonSchemaNode>>;
+    readonly routes: Readonly<Record<string, Readonly<Record<string, JsonSchemaNode | null>> | undefined>>;
+}
+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,4 @@
+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"];
+export declare const SDK_TYPE_ONLY_EXPORT_RELATIVE_PATHS: readonly ["dist/types.js"];
+export type SdkRuntimeExportRelativePath = (typeof SDK_RUNTIME_EXPORT_RELATIVE_PATHS)[number];
+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/runtime.d.ts

@@ -0,0 +1,11 @@
+export type DalpRuntime = "browser" | "server" | "react-native";
+/** @internal */
+export declare function detectDalpRuntime(): DalpRuntime;
+/** @internal */
+export declare function runtimeCredentials(runtime: DalpRuntime): RequestCredentials;
+/** @internal */
+export declare function isBufferingFetch(fetchImpl: unknown): boolean;
+/** @internal */
+export declare function keepBufferingMarker<Wrapper extends object>(wrapped: unknown, wrapper: Wrapper): Wrapper;
+/** @internal */
+export declare function refuseBundledApiKey(runtime: DalpRuntime): void;

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

@@ -0,0 +1,4 @@
+import type { Dnum } from "dnum";
+export type BigDecimalValue = Dnum;
+export declare function decodeBigDecimal(wire: string): BigDecimalValue;
+export declare const encodeBigDecimal: (value: Dnum) => string;

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

@@ -0,0 +1,5 @@
+export type EthereumAddressValue = string & {
+    readonly __brand: "EthereumAddress";
+};
+export declare function decodeEthereumAddress(wire: string): EthereumAddressValue;
+export declare function tryDecodeEthereumAddress(wire: unknown): EthereumAddressValue | undefined;

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

@@ -0,0 +1,13 @@
+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;
+}
+export declare function decodeExchangeRatesListResponse(payload: unknown): ExchangeRatesListResponse;
+export declare const exchangeRatesListTransformer: (data: unknown) => Promise<ExchangeRatesListResponse>;

package/dist/scalars/index.d.ts

@@ -0,0 +1,10 @@
+export { decodeBigDecimal, encodeBigDecimal } from "./big-decimal.ts";
+export type { BigDecimalValue } from "./big-decimal.ts";
+export { decodeTokenDecimals } from "./token-decimals.ts";
+export type { TokenDecimals } from "./token-decimals.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";

package/dist/scalars/index.js

@@ -0,0 +1,102 @@
+import {
+  DalpSdkError2
+} from "../chunk-k3ntysxx.js";
+
+// src/scalars/big-decimal.ts
+import * as dn from "dnum";
+var DECIMAL_WIRE = /^-?\d+(?:\.\d+)?$/u;
+function decodeBigDecimal(wire) {
+  if (!DECIMAL_WIRE.test(wire)) {
+    throw new DalpSdkError2({
+      code: "sdk.scalar.BIG_DECIMAL_INVALID",
+      category: "sdk.configuration",
+      retryable: false,
+      message: `\`${wire}\` is not a plain decimal string.`,
+      why: "A BigDecimal field carries an unscaled decimal, with no exponent and no separators.",
+      fix: "Pass the value exactly as the API returned it."
+    });
+  }
+  return dn.from(wire);
+}
+var encodeBigDecimal = (value) => dn.toString(value);
+// src/scalars/token-decimals.ts
+function decodeTokenDecimals(wire) {
+  const value = typeof wire === "string" && /^\d+$/u.test(wire) ? Number(wire) : wire;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 18) {
+    throw new DalpSdkError2({
+      code: "sdk.scalar.TOKEN_DECIMALS_INVALID",
+      category: "sdk.configuration",
+      retryable: false,
+      message: "Token decimals are missing or outside the range 0–18.",
+      why: "An ERC-20 token scale is a whole number from 0 through 18.",
+      fix: "Pass the decimals field exactly as the API returned it."
+    });
+  }
+  return value;
+}
+// src/scalars/ethereum-address.ts
+import { getAddress, isAddress } from "viem/utils";
+function decodeEthereumAddress(wire) {
+  if (!isAddress(wire, { strict: false })) {
+    throw new DalpSdkError2({
+      code: "sdk.scalar.EVM_ADDRESS_INVALID",
+      category: "sdk.configuration",
+      retryable: false,
+      message: `\`${wire}\` is not an EVM address.`,
+      why: "An EVM address is 42 characters starting with 0x.",
+      fix: "Pass the address exactly as the API returned it."
+    });
+  }
+  return getAddress(wire);
+}
+function tryDecodeEthereumAddress(wire) {
+  if (typeof wire !== "string" || !isAddress(wire, { strict: false })) {
+    return;
+  }
+  return getAddress(wire);
+}
+// src/scalars/organization-id.ts
+function decodeOrganizationId(wire) {
+  if (wire.length === 0) {
+    throw new DalpSdkError2({
+      code: "sdk.scalar.ORGANIZATION_ID_INVALID",
+      category: "sdk.configuration",
+      retryable: false,
+      message: "An organization id cannot be empty.",
+      why: "The organization id scopes every tenant-owned request.",
+      fix: "Pass the id the platform returned for the active organization."
+    });
+  }
+  return wire;
+}
+function tryDecodeOrganizationId(wire) {
+  return typeof wire === "string" && wire.length > 0 ? wire : undefined;
+}
+// src/scalars/exchange-rates.ts
+function decodeRow(row) {
+  const source = row !== null && typeof row === "object" ? row : { rate: null, feedAddress: null };
+  const rate = Reflect.get(source, "rate");
+  const feedAddress = Reflect.get(source, "feedAddress");
+  return {
+    ...source,
+    rate: typeof rate === "string" ? decodeBigDecimal(rate) : null,
+    feedAddress: typeof feedAddress === "string" ? decodeEthereumAddress(feedAddress) : null
+  };
+}
+function decodeExchangeRatesListResponse(payload) {
+  const source = payload !== null && typeof payload === "object" ? payload : { data: [] };
+  const rows = Reflect.get(source, "data");
+  return { ...source, data: Array.isArray(rows) ? rows.map(decodeRow) : [] };
+}
+var exchangeRatesListTransformer = async (data) => decodeExchangeRatesListResponse(data);
+export {
+  decodeBigDecimal,
+  decodeEthereumAddress,
+  decodeExchangeRatesListResponse,
+  decodeOrganizationId,
+  decodeTokenDecimals,
+  encodeBigDecimal,
+  exchangeRatesListTransformer,
+  tryDecodeEthereumAddress,
+  tryDecodeOrganizationId
+};

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

@@ -0,0 +1,5 @@
+export type OrganizationIdValue = string & {
+    readonly __brand: "OrganizationId";
+};
+export declare function decodeOrganizationId(wire: string): OrganizationIdValue;
+export declare function tryDecodeOrganizationId(wire: unknown): OrganizationIdValue | undefined;

package/dist/scalars/token-decimals.d.ts

@@ -0,0 +1,4 @@
+export type TokenDecimals = number & {
+    readonly __brand: "TokenDecimals";
+};
+export declare function decodeTokenDecimals(wire: string | number | undefined): TokenDecimals;

package/dist/secret.d.ts

@@ -0,0 +1,12 @@
+export declare const SECRET_REDACTION_MARKER = "[REDACTED]";
+declare const inspectSymbol: unique symbol;
+export declare class Secret {
+    private constructor();
+    static from(value: string): Secret;
+    toString(): string;
+    toJSON(): string;
+    [inspectSymbol](): string;
+}
+export declare const secret: (value: string) => Secret;
+export declare const unwrapSecret: (value: Secret) => string;
+export {};

package/dist/sign-webhook-receipt.d.ts

@@ -0,0 +1,16 @@
+export declare const RECEIPT_SIGNING_SCHEME = "dalp.whr.v1";
+export interface ReceiptSigningTuple {
+    deliveryId: string;
+    endpointId: string;
+    evtId: string;
+    innerEventHash: string;
+}
+export interface SignWebhookReceiptInput extends ReceiptSigningTuple {
+    secret: string;
+}
+export declare function buildReceiptSigningString(tuple: Readonly<ReceiptSigningTuple>): string;
+export declare function signWebhookReceipt({ secret, ...tuple }: Readonly<SignWebhookReceiptInput>): string;
+export interface VerifyWebhookReceiptInput extends SignWebhookReceiptInput {
+    readonly signature: string;
+}
+export declare function verifyWebhookReceipt({ signature, ...input }: Readonly<VerifyWebhookReceiptInput>): boolean;

package/dist/sign-webhook-receipt.js

@@ -0,0 +1,26 @@
+import {
+  toStandardWebhookSecret2
+} from "./chunk-qvtjb3dz.js";
+
+// src/sign-webhook-receipt.ts
+import { createHmac, timingSafeEqual } from "node:crypto";
+var RECEIPT_SIGNING_SCHEME = "dalp.whr.v1";
+function buildReceiptSigningString(tuple) {
+  return [RECEIPT_SIGNING_SCHEME, tuple.deliveryId, tuple.endpointId, tuple.evtId, tuple.innerEventHash].join(`
+`);
+}
+function signWebhookReceipt({ secret, ...tuple }) {
+  const key = Buffer.from(toStandardWebhookSecret2(secret), "base64");
+  return createHmac("sha256", key).update(buildReceiptSigningString(tuple), "utf8").digest("hex");
+}
+function verifyWebhookReceipt({ signature, ...input }) {
+  const expected = Buffer.from(signWebhookReceipt(input), "hex");
+  const received = Buffer.from(signature, "hex");
+  return expected.length === received.length && timingSafeEqual(expected, received);
+}
+export {
+  RECEIPT_SIGNING_SCHEME,
+  buildReceiptSigningString,
+  signWebhookReceipt,
+  verifyWebhookReceipt
+};

package/dist/transport/cookie-store.d.ts

@@ -0,0 +1,9 @@
+export type CookieStoreFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface CookieStoreShape {
+    readonly header: () => string;
+    readonly isEmpty: () => boolean;
+    readonly setCookieHeader: (header: string) => void;
+    readonly storeSetCookieHeaders: (headers: ReadonlyArray<string>) => void;
+}
+export declare function makeCookieStore(initialHeader?: string): CookieStoreShape;
+export declare function createCookieStoreFetch(cookieStore: CookieStoreShape, fetchImpl?: CookieStoreFetch): CookieStoreFetch;

package/dist/transport/sse-lifecycle.d.ts

@@ -0,0 +1,24 @@
+export type SseEventDisposition = "continue" | "success" | "failure";
+export interface SseStreamResult<T> {
+    readonly stream: AsyncIterable<T>;
+}
+export interface SseLifecycleOptions<T> {
+    readonly connect: (signal: AbortSignal) => Promise<SseStreamResult<T>>;
+    readonly classify: (event: T) => SseEventDisposition;
+    readonly signal?: AbortSignal;
+    readonly onEvent?: (event: T) => void;
+    readonly maxReconnects?: number;
+    readonly reconnectWindowMs?: number;
+    readonly healthyConnectionMs?: number;
+    readonly initialBackoffMs?: number;
+    readonly maxBackoffMs?: number;
+    readonly sleep?: (milliseconds: number) => Promise<void>;
+    readonly now?: () => number;
+}
+export type SseLifecycleFailureReason = "aborted" | "terminal-failure" | "transport-failure";
+export declare class SseLifecycleError<T = unknown> extends Error {
+    readonly reason: SseLifecycleFailureReason;
+    readonly lastEvent?: T;
+    constructor(reason: SseLifecycleFailureReason, lastEvent?: T, options?: ErrorOptions);
+}
+export declare function consumeSseUntilTerminal<T>(options: SseLifecycleOptions<T>): Promise<T>;

package/dist/types.d.ts

@@ -1,115 +1,38 @@
-/**
- * Type-only exports for the DALP SDK.
- *
- * Import from `@settlemint/dalp-sdk/types` when you only need types
- * (e.g., for function signatures) without pulling in runtime code.
- *
- * Related: kit/sdk/src/client.ts
- *
- * @module
- */
-import type { DalpApi } from "./api-types.generated.js";
-/**
- * Fully typed DALP API client.
- *
- * The shapes come from `./api-types.generated.ts` rather than from the contract
- * router's inferred type. A declaration that names the contract cannot be
- * published: `@dalp/api-contract` is private, and the inferred type does not
- * survive declaration emit at all (`TS7056` on the larger route files). See
- * `./contract.ts`.
- *
- * Response values carry the wire representation, so a `bigint` field reads as a
- * decimal string and a timestamp as an ISO string. The client serializes on the
- * way out but does not decode on the way back, so a request may pass either the
- * native value or its string form.
- *
- * Provides auto-completed access to all v2 API namespaces:
- * `account`, `actions`, `addons`, `admin`, `contacts`, `exchangeRates`,
- * `externalToken`, `identityRecovery`, `monitoring`, `search`,
- * `settings`, `system`, `token`, `transaction`, `user`.
- */
-export type DalpClient = DalpApi;
-/**
- * Per-call client context threaded into individual SDK operations as the second
- * argument, e.g. `client.token.create(input, { context: { idempotencyKey } })`.
- * Every field is optional and scoped to the single call, unlike the client-level
- * {@link BaseDalpClientConfig.idempotencyKey} which applies to every request.
- */
-export interface DalpClientCallContext {
-    /**
-     * Idempotency key sent as the `Idempotency-Key` header for this call only,
-     * overriding any client-level key. Use a fresh value per genuine retry of a
-     * failed mutation: dapi burns the key of a failed transaction, so re-sending
-     * under the same key is rejected ("previously failed. Use a new idempotency
-     * key to retry"). A stable value within one logical attempt keeps network-level
-     * fetch retries deduplicated.
-     */
-    idempotencyKey?: string;
-    /**
-     * oRPC error codes the caller treats as expected for this call and does not
-     * want surfaced by its own error logging (e.g. an existence probe that accepts
-     * `NOT_FOUND`). A client-side hint scoped to the single call; it is not sent to
-     * the server.
-     */
-    skipLoggingFor?: readonly string[];
+import type { AssumableParticipant, JoinableParticipant, JoinableProvider, EvmAddress, TokenTopicScheme, TokenTrustedIssuer, EvmUserEventV2Item, UserEventV2Item, UserMe, party_multisigDrafts_issueInvite_Response, party_topicSchemes_addForToken_Request, party_trustedIssuers_addForToken_Request, party_users_events_Response, platform_settings_settingsThemeUploadLogo_Request, token_create_Request, token_documents_getUploadUrl_Request, token_features_list_Response, system_feeds_issuerSigned_create_Request } from "./generated/api-types.d.ts";
+export type ParticipantKind = "person" | "company" | "fund" | "spv" | "department" | "joint_account" | "asset" | "organisation" | "claim_issuer" | "addon";
+export type ParticipantAddressPurpose = "transfer" | "identity" | "participant";
+export interface EligibleForTokenFilter {
+    readonly tokenAddress: EvmAddress;
+    readonly action: "mint" | "transfer" | "burn";
+    readonly reveal?: boolean;
 }
-interface BaseDalpClientConfig {
-    /** Base URL of the DALP API (e.g., `"https://dalp.example.com"`). */
-    url: string;
-    /**
-     * Organization ID for multi-tenant setups.
-     * Required when the API key is scoped to multiple organizations.
-     */
-    organizationId?: string;
-    /**
-     * Additional headers merged into every request.
-     * Accepts a static object or a (possibly async) function for dynamic headers.
-     * Can override defaults like `User-Agent` but cannot override security headers (`x-api-key`, `x-organization-id`).
-     */
-    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
-    /**
-     * Validate outgoing requests against the contract before sending.
-     * Catches schema violations client-side for faster feedback.
-     * @defaultValue false
-     */
-    requestValidation?: boolean;
-    /**
-     * Validate incoming responses against the contract.
-     * Useful during development to catch API drift.
-     * @defaultValue false
-     */
-    responseValidation?: boolean;
-    /**
-     * Custom `fetch` implementation.
-     * Use this to inject logging, proxy configuration, or test doubles.
-     */
-    fetch?: typeof globalThis.fetch;
-    /**
-     * Idempotency key sent as the `Idempotency-Key` header on every request.
-     *
-     * **Warning:** This value is sent on _every_ request made by the client.
-     * If you reuse the same client instance for multiple mutations, the server
-     * will deduplicate all but the first — subsequent mutations silently return
-     * the first response. Only set this when the client is used for a single
-     * mutation (e.g., a one-shot script). For multi-mutation workflows, set the
-     * header per-request via the `headers` callback instead.
-     *
-     * When omitted, no idempotency key header is sent.
-     */
-    idempotencyKey?: string;
-}
-/**
- * Configuration for creating an authenticated DALP API client.
- */
-export interface DalpClientConfig extends BaseDalpClientConfig {
-    /** API key for authenticated routes (issued via the DALP dashboard or CLI). */
-    apiKey: string;
-}
-/**
- * Configuration for creating a public DALP API client.
- */
-export interface PublicDalpClientConfig extends BaseDalpClientConfig {
-    apiKey?: undefined;
-}
-export type { WalletAuthEndpointPath } from "./auth-wallet-plugins.js";
-//# sourceMappingURL=types.d.ts.map
+export type JoinableParticipantOption = JoinableParticipant;
+export type JoinableProviderOption = JoinableProvider;
+export type ActAvailability = AssumableParticipant["actAvailability"];
+export type OnboardingState = UserMe["onboardingState"];
+export type UserEvent = UserEventV2Item;
+export type EvmUserEvent = EvmUserEventV2Item;
+export type UserEventCollectionResponse = party_users_events_Response;
+export type UserEventValue = NonNullable<EvmUserEvent["values"]>[number];
+export type TokenTopicSchemeInheritanceLevel = TokenTopicScheme["inheritanceLevel"];
+export type TokenTrustedIssuerInheritanceLevel = TokenTrustedIssuer["inheritanceLevel"];
+export type TokenTopicSchemeCreateInput = party_topicSchemes_addForToken_Request;
+export type TokenTrustedIssuerCreateInput = party_trustedIssuers_addForToken_Request;
+export type MultisigDraftCreateInviteOutput = party_multisigDrafts_issueInvite_Response;
+export type IssuerSignedCreateInput = system_feeds_issuerSigned_create_Request;
+export type ThemeLogoMode = platform_settings_settingsThemeUploadLogo_Request["mode"];
+type AttachedTokenFeature = token_features_list_Response["data"][number];
+type AttachedTokenFeatureConfig<Name extends AttachedTokenFeature["name"]> = NonNullable<Extract<AttachedTokenFeature, {
+    readonly name: Name;
+}>["config"]>;
+export type TokenFeatureHistoricalBalancesConfig = AttachedTokenFeatureConfig<"historical-balances">;
+export type TokenFeatureMaturityRedemptionConfig = AttachedTokenFeatureConfig<"maturity-redemption">;
+export type TokenFeatureFixedTreasuryYieldConfig = AttachedTokenFeatureConfig<"fixed-treasury-yield">;
+export type TokenFeatureDividendYieldConfig = AttachedTokenFeatureConfig<"dividend-yield">;
+export type TokenFeatureInterestYieldConfig = AttachedTokenFeatureConfig<"interest-yield">;
+export type TokenFeatureTransactionFeeConfig = AttachedTokenFeatureConfig<"transaction-fee">;
+export type TokenFeatureTransactionFeeAccountingConfig = AttachedTokenFeatureConfig<"transaction-fee-accounting">;
+export type TokenFeatureExternalTransactionFeeConfig = AttachedTokenFeatureConfig<"external-transaction-fee">;
+export type TokenDocumentMimeType = token_documents_getUploadUrl_Request["mimeType"];
+export type TokenCreateInput = token_create_Request;
+export type * from "./generated/api-types.d.ts";

package/dist/url.d.ts

@@ -1,2 +1 @@
 export declare function normalizeDalpBaseUrl(url: string): string;
-//# sourceMappingURL=url.d.ts.map

package/dist/verify-webhook.d.ts

@@ -1,34 +1,23 @@
-import type { Webhook } from "./webhook-events.js";
-export type WebhookVerificationFailure = "TIMESTAMP_SKEW" | "SECRET_MISMATCH" | "BODY_HASH_MISMATCH";
+import type { Webhook } from "./webhook-events.ts";
+export type WebhookVerificationFailure = "TIMESTAMP_SKEW" | "SECRET_MISMATCH" | "BODY_HASH_MISMATCH" | "REPLAYED_EVENT" | "MALFORMED_BODY" | "REPLAY_STORE_FAILURE";
 export type WebhookVerificationResult = {
-    ok: true;
-    event: Webhook.Event;
+    readonly ok: true;
+    readonly event: Webhook.Event;
 } | {
-    ok: false;
-    code: WebhookVerificationFailure;
+    readonly ok: false;
+    readonly code: WebhookVerificationFailure;
 };
+export interface WebhookReplayStore {
+    readonly has: (eventId: string) => boolean | Promise<boolean>;
+    readonly add: (eventId: string) => void | Promise<void>;
+}
 export interface VerifyWebhookInput {
-    rawBody: string | Uint8Array;
-    headers: Headers | Record<string, string | string[] | undefined>;
-    secret: string | readonly string[];
+    readonly rawBody: string | Uint8Array;
+    readonly headers: Headers | Record<string, string | ReadonlyArray<string> | undefined>;
+    readonly secret: string | ReadonlyArray<string>;
+    readonly replayStore?: WebhookReplayStore;
+    readonly now?: number | Date;
+    readonly timestampToleranceSeconds?: number;
 }
-/**
- * Strip the `dalp_whsk_` family prefix from a DALP signing secret.
- *
- * The Standard Webhooks library expects the bare secret material; DALP
- * adds the prefix for parity with the `sm_dalp_` API-key family. Both
- * the dispatcher (DALP-side) and any verifier (DALP or consumer) must
- * call this before constructing a `new Webhook(...)` instance, otherwise
- * the HMAC inputs differ on the two ends and every signature mismatches.
- */
 export declare function toStandardWebhookSecret(secret: string): string;
-/**
- * Verifies a DALP webhook signature and returns the typed event union.
- *
- * Use the returned lifecycle state and `supersedes` accessor to reconcile
- * cached DAPI mutation responses with later on-chain outcomes.
- *
- * @see ../../kit/docs/content/events/idempotency-and-on-chain-outcome.mdx
- */
-export declare function verifyWebhook({ rawBody, headers, secret }: VerifyWebhookInput): WebhookVerificationResult;
-//# sourceMappingURL=verify-webhook.d.ts.map
+export declare function verifyWebhook(input: VerifyWebhookInput): Promise<WebhookVerificationResult>;

package/dist/verify-webhook.js

@@ -0,0 +1,8 @@
+import {
+  toStandardWebhookSecret2,
+  verifyWebhook2
+} from "./chunk-qvtjb3dz.js";
+export {
+  toStandardWebhookSecret2 as toStandardWebhookSecret,
+  verifyWebhook2 as verifyWebhook
+};

package/dist/version.d.ts

@@ -1,5 +1,2 @@
-/** Semver version of the published SDK package. */
 export declare const SDK_VERSION: string;
-/** Default User-Agent header sent with every SDK request. */
 export declare const SDK_USER_AGENT: string;
-//# sourceMappingURL=version.d.ts.map