@settlemint/dalp-sdk 2.1.7-main.26370298202 → 2.1.7-main.26370663399

package/dist/index.js

@@ -29755,7 +29755,7 @@ var tokenV2MutationsContract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.reads.contract.ts
-import { z as z445 } from "zod";
+import { z as z448 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/token/routes/token.features.schema.ts
 import { z as z422 } from "zod";
@@ -30358,6 +30358,75 @@ var ConversionRecordV2ItemSchema = z429.object({
 });
 var ConversionRecordsV2OutputSchema = createPaginatedResponse(ConversionRecordV2ItemSchema);
 
+// ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.conversion-trigger-events.schema.ts
+import { z as z430 } from "zod";
+var CONVERSION_TRIGGER_EVENT_KIND_OPTIONS = ["published", "disabled", "republished"];
+var CONVERSION_TRIGGER_EVENTS_COLLECTION_FIELDS = {
+  kind: enumField(CONVERSION_TRIGGER_EVENT_KIND_OPTIONS, { facetable: true }),
+  blockTimestamp: dateField()
+};
+var ConversionTriggerEventsV2InputSchema = createCollectionInputSchema(CONVERSION_TRIGGER_EVENTS_COLLECTION_FIELDS, {
+  defaultSort: "-blockTimestamp",
+  globalSearch: false
+});
+var ConversionTriggerEventV2ItemSchema = z430.object({
+  triggerId: z430.string(),
+  kind: z430.enum(CONVERSION_TRIGGER_EVENT_KIND_OPTIONS),
+  eventIndex: z430.number().int().nonnegative(),
+  denominationAsset: ethereumAddress.nullable(),
+  roundPricePerShareWad: bigDecimal().nullable(),
+  roundPricePerShareWadExact: apiBigInt.nullable(),
+  expiresAt: timestamp().nullable(),
+  metadataHash: z430.string().nullable(),
+  blockNumber: apiBigInt,
+  blockTimestamp: timestamp(),
+  txHash: z430.string(),
+  logIndex: z430.number().int().nonnegative()
+});
+var ConversionTriggerEventsV2OutputSchema = createPaginatedResponse(ConversionTriggerEventV2ItemSchema);
+
+// ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.converts-to.schema.ts
+import { z as z431 } from "zod";
+var CONVERTS_TO_COLLECTION_FIELDS = {
+  isAuthorized: booleanField({ facetable: true }),
+  authorizedAt: dateField()
+};
+var ConvertsToV2InputSchema = createCollectionInputSchema(CONVERTS_TO_COLLECTION_FIELDS, {
+  defaultSort: "-authorizedAt",
+  globalSearch: false
+});
+var ConvertsToV2ItemSchema = z431.object({
+  targetTokenAddress: ethereumAddress,
+  conversionFeatureAddress: ethereumAddress.nullable(),
+  minterFeatureAddress: ethereumAddress.nullable(),
+  isAuthorized: z431.boolean(),
+  authorizedAt: timestamp(),
+  revokedAt: timestamp().nullable(),
+  updatedAt: timestamp()
+});
+var ConvertsToV2OutputSchema = createPaginatedResponse(ConvertsToV2ItemSchema);
+
+// ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.converted-from.schema.ts
+import { z as z432 } from "zod";
+var CONVERTED_FROM_COLLECTION_FIELDS = {
+  isAuthorized: booleanField({ facetable: true }),
+  authorizedAt: dateField()
+};
+var ConvertedFromV2InputSchema = createCollectionInputSchema(CONVERTED_FROM_COLLECTION_FIELDS, {
+  defaultSort: "-authorizedAt",
+  globalSearch: false
+});
+var ConvertedFromV2ItemSchema = z432.object({
+  sourceTokenAddress: ethereumAddress,
+  conversionFeatureAddress: ethereumAddress.nullable(),
+  minterFeatureAddress: ethereumAddress.nullable(),
+  isAuthorized: z432.boolean(),
+  authorizedAt: timestamp(),
+  revokedAt: timestamp().nullable(),
+  updatedAt: timestamp()
+});
+var ConvertedFromV2OutputSchema = createPaginatedResponse(ConvertedFromV2ItemSchema);
+
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.denomination-assets.schema.ts
 var DenominationAssetV2ItemSchema = DenominationAssetListSchema.element;
 var DENOMINATION_ASSETS_COLLECTION_FIELDS = {
@@ -30373,26 +30442,26 @@ var DenominationAssetsV2InputSchema = createCollectionInputSchema(DENOMINATION_A
 var DenominationAssetsV2OutputSchema = createPaginatedResponse(DenominationAssetV2ItemSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.events.schema.ts
-import { z as z430 } from "zod";
-var TokenEventV2ValueSchema = z430.object({
-  id: z430.string().meta({ description: "Unique identifier for the parameter value", examples: ["evt_val_123"] }),
-  name: z430.string().meta({ description: "Name of the event parameter", examples: ["from", "to", "amount"] }),
-  value: z430.string().meta({
+import { z as z433 } from "zod";
+var TokenEventV2ValueSchema = z433.object({
+  id: z433.string().meta({ description: "Unique identifier for the parameter value", examples: ["evt_val_123"] }),
+  name: z433.string().meta({ description: "Name of the event parameter", examples: ["from", "to", "amount"] }),
+  value: z433.string().meta({
     description: "Value of the event parameter (address, hex hash, decimal-string number, or arbitrary text)",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F", "1000000000000000000"]
   })
 });
-var TokenEventV2ItemSchema = z430.object({
-  id: z430.string().meta({ description: "Unique identifier for the event", examples: ["evt_123abc"] }),
-  eventName: z430.string().meta({
+var TokenEventV2ItemSchema = z433.object({
+  id: z433.string().meta({ description: "Unique identifier for the event", examples: ["evt_123abc"] }),
+  eventName: z433.string().meta({
     description: "The event name",
     examples: ["TransferCompleted", "MintCompleted", "BurnCompleted"]
   }),
-  txIndex: z430.string().meta({
+  txIndex: z433.string().meta({
     description: "Log index within the transaction (string for parity with v1)",
     examples: ["0", "1", "5"]
   }),
-  blockNumber: z430.string().meta({
+  blockNumber: z433.string().meta({
     description: "Block number when the event occurred (decimal string for bigint precision)",
     examples: ["12345678", "20000000"]
   }),
@@ -30404,19 +30473,19 @@ var TokenEventV2ItemSchema = z430.object({
     description: "Transaction hash",
     examples: ["0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"]
   }),
-  emitter: z430.object({
+  emitter: z433.object({
     id: ethereumAddress.meta({
       description: "Address of the contract that emitted the event",
       examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
     })
   }),
-  sender: z430.object({
+  sender: z433.object({
     id: ethereumAddress.meta({
       description: "Address that triggered the event (account or sender, falling back to the contract address)",
       examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
     })
   }),
-  values: z430.array(TokenEventV2ValueSchema).meta({
+  values: z433.array(TokenEventV2ValueSchema).meta({
     description: "Event parameter values",
     examples: []
   })
@@ -30437,15 +30506,15 @@ var TokenEventsV2InputSchema = createCollectionInputSchema(TOKEN_EVENTS_COLLECTI
 var TokenEventsV2OutputSchema = createPaginatedResponse(TokenEventV2ItemSchema);
 
 // ../../packages/dalp/api-contract/src/routes/token/routes/token.transfer-approvals.schema.ts
-import { z as z431 } from "zod";
-var TransferApprovalSchema = z431.object({
-  id: z431.string().meta({
+import { z as z434 } from "zod";
+var TransferApprovalSchema = z434.object({
+  id: z434.string().meta({
     description: "Unique approval ID: {moduleAddress}-{token}-{fromIdentity}-{toIdentity}-{value}",
     examples: ["0xabc...-0xtoken...-0xfrom...-0xto...-1000000000000000000"]
   }),
-  token: z431.object({ id: ethereumAddress }),
-  fromIdentity: z431.object({ id: ethereumAddress }),
-  toIdentity: z431.object({ id: ethereumAddress }),
+  token: z434.object({ id: ethereumAddress }),
+  fromIdentity: z434.object({ id: ethereumAddress }),
+  toIdentity: z434.object({ id: ethereumAddress }),
   value: assetAmount.meta({
     description: "Approved transfer amount in base units",
     examples: ["1000000000000000000"]
@@ -30455,7 +30524,7 @@ var TransferApprovalSchema = z431.object({
     description: "Timestamp when approval expires. Epoch zero means no expiry.",
     examples: ["0", "1893456000"]
   }),
-  status: z431.enum(["pending", "consumed", "revoked"]).meta({
+  status: z434.enum(["pending", "consumed", "revoked"]).meta({
     description: "Current status of the approval",
     examples: ["pending"]
   }),
@@ -30468,17 +30537,17 @@ var TransferApprovalSchema = z431.object({
     examples: ["2023-11-14T12:05:00.000Z"]
   })
 });
-var TransferApprovalsResponseSchema = z431.object({
-  transferApprovals: z431.array(TransferApprovalSchema).meta({
+var TransferApprovalsResponseSchema = z434.object({
+  transferApprovals: z434.array(TransferApprovalSchema).meta({
     description: "List of transfer approvals ordered by creation time descending",
     examples: []
   }),
-  totalCount: z431.number().int().nonnegative().meta({
+  totalCount: z434.number().int().nonnegative().meta({
     description: "Total number of transfer approvals for this token",
     examples: [3]
   })
 });
-var TransferApprovalsInputSchema = z431.object({
+var TransferApprovalsInputSchema = z434.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -30486,20 +30555,20 @@ var TransferApprovalsInputSchema = z431.object({
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.price.schema.ts
-import { z as z432 } from "zod";
-var TokenPriceInputParamsSchema = z432.object({
+import { z as z435 } from "zod";
+var TokenPriceInputParamsSchema = z435.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   })
 });
-var TokenPriceInputQuerySchema = z432.object({
+var TokenPriceInputQuerySchema = z435.object({
   currency: fiatCurrency().default("USD").meta({
     description: "Target ISO 4217 currency code for price conversion",
     examples: ["USD", "EUR", "GBP", "AED"]
   })
 });
-var ConversionHopSchema = z432.object({
+var ConversionHopSchema = z435.object({
   from: fiatCurrency().meta({
     description: "Source currency of this hop",
     examples: ["AED"]
@@ -30508,7 +30577,7 @@ var ConversionHopSchema = z432.object({
     description: "Target currency of this hop",
     examples: ["USD"]
   }),
-  rate: z432.string().meta({
+  rate: z435.string().meta({
     description: "Exchange rate (18-decimal string)",
     examples: ["272300000000000000"]
   }),
@@ -30520,17 +30589,17 @@ var ConversionHopSchema = z432.object({
     description: "When the feed was last updated",
     examples: ["2024-03-22T12:00:00.000Z"]
   }),
-  inverse: z432.boolean().meta({
+  inverse: z435.boolean().meta({
     description: "Whether this hop uses an inverse rate (1/rate of the registered feed)",
     examples: [false]
   })
 });
-var TokenPriceResponseSchema = z432.object({
+var TokenPriceResponseSchema = z435.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  price: z432.string().meta({
+  price: z435.string().meta({
     description: "The resolved price as a decimal string (18-decimal normalized)",
     examples: ["27230000000000000000"]
   }),
@@ -30538,11 +30607,11 @@ var TokenPriceResponseSchema = z432.object({
     description: "The currency of the returned price",
     examples: ["USD"]
   }),
-  decimals: z432.number().meta({
+  decimals: z435.number().meta({
     description: "Decimal precision of the price (always 18)",
     examples: [18]
   }),
-  source: z432.enum(["feed", "claim"]).meta({
+  source: z435.enum(["feed", "claim"]).meta({
     description: "Whether the base price came from a feed or identity claim",
     examples: ["feed"]
   }),
@@ -30550,7 +30619,7 @@ var TokenPriceResponseSchema = z432.object({
     description: "The native currency of the base price before conversion",
     examples: ["AED"]
   }),
-  convertible: z432.boolean().meta({
+  convertible: z435.boolean().meta({
     description: "Whether the price was successfully converted to the target currency",
     examples: [true]
   }),
@@ -30558,15 +30627,15 @@ var TokenPriceResponseSchema = z432.object({
     description: "The requested target currency (only present when convertible is false)",
     examples: ["USD"]
   }),
-  reason: z432.string().optional().meta({
+  reason: z435.string().optional().meta({
     description: "Reason for conversion failure (only present when convertible is false)",
     examples: ["no_fx_path"]
   }),
-  message: z432.string().optional().meta({
+  message: z435.string().optional().meta({
     description: "Human-readable explanation (only present when convertible is false)",
     examples: ["No conversion path from AED to USD. Register FX feeds for intermediate pairs."]
   }),
-  availableCurrencies: z432.array(fiatCurrency()).optional().meta({
+  availableCurrencies: z435.array(fiatCurrency()).optional().meta({
     description: "Currencies reachable from the source currency (only present when convertible is false)",
     examples: [["AED", "EUR"]]
   }),
@@ -30574,7 +30643,7 @@ var TokenPriceResponseSchema = z432.object({
     description: "When the price data was last updated (ISO 8601)",
     examples: ["2026-03-22T10:30:00.000Z"]
   }),
-  conversionPath: z432.array(ConversionHopSchema).meta({
+  conversionPath: z435.array(ConversionHopSchema).meta({
     description: "The FX conversion hops applied (empty if no conversion needed)",
     examples: [[]]
   })
@@ -30590,24 +30659,30 @@ var HOLDER_COLLECTION_FIELDS = {
 var HoldersV2InputSchema = createCollectionInputSchema(HOLDER_COLLECTION_FIELDS, {
   defaultSort: "-lastUpdatedAt"
 });
-var HoldersV2OutputSchema = createPaginatedResponse(assetBalance());
+var HoldersV2EntrySchema = assetBalance().extend({
+  transferableBalance: bigDecimal().meta({
+    description: "`balanceOf` minus principal already converted via a ConversionFeature. Equals `balanceOf` (i.e. `value`) when no conversion feature is attached or when no conversions have occurred for this holder.",
+    examples: ["1000000000000000000", "0"]
+  })
+});
+var HoldersV2OutputSchema = createPaginatedResponse(HoldersV2EntrySchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.participant-roles-view.contract.ts
-import { z as z434 } from "zod";
+import { z as z437 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.participant-roles-view.schema.ts
-import { z as z433 } from "zod";
-var TokenParticipantRolesViewItemSchema = z433.object({
-  participantId: z433.string().nullable(),
-  displayName: z433.string(),
+import { z as z436 } from "zod";
+var TokenParticipantRolesViewItemSchema = z436.object({
+  participantId: z436.string().nullable(),
+  displayName: z436.string(),
   signingAddress: ethereumAddress.nullable(),
   operationsAddress: ethereumAddress.nullable(),
   accountAddress: ethereumAddress.nullable(),
-  isContract: z433.boolean(),
-  eoaRoles: z433.array(assetAccessControlRole),
-  smartWalletRoles: z433.array(assetAccessControlRole),
-  missingRoles: z433.array(assetAccessControlRole),
-  drift: z433.boolean()
+  isContract: z436.boolean(),
+  eoaRoles: z436.array(assetAccessControlRole),
+  smartWalletRoles: z436.array(assetAccessControlRole),
+  missingRoles: z436.array(assetAccessControlRole),
+  drift: z436.boolean()
 });
 var TOKEN_PARTICIPANT_ROLES_VIEW_COLLECTION_FIELDS = {
   participantId: textField({ sortable: true, defaultOperator: "iLike" }),
@@ -30634,7 +30709,7 @@ var participantRolesView2 = v2Contract.route({
   description: "List participant role assignments for a token across signing and operations addresses.",
   successDescription: "Paginated token participant role assignments retrieved successfully.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z434.object({
+}).input(v2Input.paramsQuery(z437.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -30642,7 +30717,7 @@ var participantRolesView2 = v2Contract.route({
 }), TokenParticipantRolesViewV2InputSchema)).output(TokenParticipantRolesViewV2OutputSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.historical-balances.schema.ts
-import { z as z435 } from "zod";
+import { z as z438 } from "zod";
 var HISTORICAL_BALANCE_KIND_OPTIONS = ["account", "totalSupply"];
 var TOKEN_HISTORICAL_BALANCES_COLLECTION_FIELDS = {
   account: addressField({ defaultOperator: "eq" }),
@@ -30667,10 +30742,10 @@ var TokenHistoricalBalancesV2InputSchema = createCollectionInputSchema(TOKEN_HIS
     }
   }
 });
-var TokenHistoricalBalanceV2ItemSchema = z435.object({
-  id: z435.string().uuid(),
+var TokenHistoricalBalanceV2ItemSchema = z438.object({
+  id: z438.string().uuid(),
   account: ethereumAddress,
-  kind: z435.enum(HISTORICAL_BALANCE_KIND_OPTIONS),
+  kind: z438.enum(HISTORICAL_BALANCE_KIND_OPTIONS),
   sender: ethereumAddress,
   oldBalance: bigDecimal(),
   oldBalanceExact: apiBigInt,
@@ -30679,14 +30754,14 @@ var TokenHistoricalBalanceV2ItemSchema = z435.object({
   blockNumber: apiBigInt,
   blockTimestamp: timestamp(),
   txHash: ethereumHash,
-  logIndex: z435.number().int().nonnegative()
+  logIndex: z438.number().int().nonnegative()
 });
 var TokenHistoricalBalancesV2OutputSchema = createPaginatedResponse(TokenHistoricalBalanceV2ItemSchema);
-var strictHistoricalLookup = z435.union([z435.boolean(), z435.enum(["true", "false"]).transform((value3) => value3 === "true")]).optional().default(true);
+var strictHistoricalLookup = z438.union([z438.boolean(), z438.enum(["true", "false"]).transform((value3) => value3 === "true")]).optional().default(true);
 var historicalTimepoint = apiBigInt.refine((value3) => value3 >= 0n, {
   message: "timepoint must be greater than or equal to 0"
 });
-var TokenHistoricalBalanceAtBlockV2InputQuerySchema = z435.object({
+var TokenHistoricalBalanceAtBlockV2InputQuerySchema = z438.object({
   account: ethereumAddress.meta({
     description: "Holder account to read from the historical-balances feature",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -30700,7 +30775,7 @@ var TokenHistoricalBalanceAtBlockV2InputQuerySchema = z435.object({
     examples: [true]
   })
 });
-var TokenHistoricalBalanceAtBlockV2DataSchema = z435.object({
+var TokenHistoricalBalanceAtBlockV2DataSchema = z438.object({
   account: ethereumAddress,
   balance: bigDecimal(),
   balanceExact: apiBigInt,
@@ -30715,12 +30790,12 @@ var TOKEN_HISTORICAL_HOLDERS_AT_BLOCK_COLLECTION_FIELDS = {
   balance: bigintField({ filterable: false }),
   lastUpdatedAt: dateField({ filterable: false })
 };
-var TokenHistoricalHoldersAtBlockV2InputSchema = z435.object({
-  sortBy: z435.enum(["accountAddress", "balance", "lastUpdatedAt"]).default("balance"),
-  sortDirection: z435.enum(["asc", "desc"]).default("desc"),
-  offset: z435.coerce.number().int().nonnegative().default(0),
-  limit: z435.coerce.number().int().positive().max(200).default(50),
-  filters: z435.array(DataTableFilterSchema).default([]),
+var TokenHistoricalHoldersAtBlockV2InputSchema = z438.object({
+  sortBy: z438.enum(["accountAddress", "balance", "lastUpdatedAt"]).default("balance"),
+  sortDirection: z438.enum(["asc", "desc"]).default("desc"),
+  offset: z438.coerce.number().int().nonnegative().default(0),
+  limit: z438.coerce.number().int().positive().max(200).default(50),
+  filters: z438.array(DataTableFilterSchema).default([]),
   timepoint: historicalTimepoint.meta({
     description: "Historical feature clock timepoint, expressed as Unix seconds for timestamp-mode tokens",
     examples: ["1767225600"]
@@ -30733,8 +30808,8 @@ var TokenHistoricalHoldersAtBlockV2InputSchema = z435.object({
 var TokenHistoricalHoldersAtBlockV2OutputSchema = createPaginatedResponse(assetBalance());
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.historical-balance-at-block.schema.ts
-import { z as z436 } from "zod";
-var TokenHistoricalBalanceAtBlockByHolderV2InputParamsSchema = z436.object({
+import { z as z439 } from "zod";
+var TokenHistoricalBalanceAtBlockByHolderV2InputParamsSchema = z439.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -30744,13 +30819,13 @@ var TokenHistoricalBalanceAtBlockByHolderV2InputParamsSchema = z436.object({
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   })
 });
-var TokenHistoricalBalanceAtBlockByHolderV2InputQuerySchema = z436.object({
-  atBlock: z436.coerce.bigint().positive().meta({
+var TokenHistoricalBalanceAtBlockByHolderV2InputQuerySchema = z439.object({
+  atBlock: z439.coerce.bigint().positive().meta({
     description: "Positive integer block number to read the holder's balance at. Blocks are the canonical chain time unit; date pickers resolve date -> block via the indexer's block-time index before pushing this param.",
     examples: ["21040117"]
   })
 });
-var TokenHistoricalBalanceAtBlockByHolderV2DataSchema = z436.object({
+var TokenHistoricalBalanceAtBlockByHolderV2DataSchema = z439.object({
   tokenAddress: ethereumAddress,
   holderAddress: ethereumAddress,
   balance: bigDecimal(),
@@ -30758,13 +30833,13 @@ var TokenHistoricalBalanceAtBlockByHolderV2DataSchema = z436.object({
   asOfBlockNumber: apiBigInt,
   asOfBlockTimestamp: timestamp().nullable(),
   asOfTxHash: ethereumHash.nullable(),
-  asOfLogIndex: z436.number().int().nonnegative().nullable(),
+  asOfLogIndex: z439.number().int().nonnegative().nullable(),
   requestedBlock: apiBigInt
 });
 var TokenHistoricalBalanceAtBlockByHolderV2OutputSchema = createSingleResponse(TokenHistoricalBalanceAtBlockByHolderV2DataSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.transaction-fee-collections.list.schema.ts
-import { z as z437 } from "zod";
+import { z as z440 } from "zod";
 var OPERATION_TYPE_OPTIONS = ["mint", "burn", "transfer", "redeem"];
 var TOKEN_TRANSACTION_FEE_COLLECTIONS_COLLECTION_FIELDS = {
   collectedAt: dateField(),
@@ -30777,21 +30852,21 @@ var TokenTransactionFeeCollectionsV2InputSchema = createCollectionInputSchema(TO
   defaultSort: "-collectedAt",
   globalSearch: false
 });
-var TokenTransactionFeeCollectionV2ItemSchema = z437.object({
-  id: z437.string().uuid(),
+var TokenTransactionFeeCollectionV2ItemSchema = z440.object({
+  id: z440.string().uuid(),
   counterpartyAddress: ethereumAddress,
-  operationType: z437.enum(OPERATION_TYPE_OPTIONS),
+  operationType: z440.enum(OPERATION_TYPE_OPTIONS),
   feeAmount: bigDecimal(),
   feeAmountExact: apiBigInt,
   blockNumber: apiBigInt,
   blockTimestamp: timestamp(),
   txHash: ethereumHash,
-  logIndex: z437.number().int().nonnegative()
+  logIndex: z440.number().int().nonnegative()
 });
 var TokenTransactionFeeCollectionsV2OutputSchema = createPaginatedResponse(TokenTransactionFeeCollectionV2ItemSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.fee-accrual-events.list.schema.ts
-import { z as z438 } from "zod";
+import { z as z441 } from "zod";
 var FEE_ACCRUAL_OPERATION_TYPE_OPTIONS = [...OPERATION_TYPE_OPTIONS, "unknown"];
 var TOKEN_FEE_ACCRUAL_EVENTS_COLLECTION_FIELDS = {
   accruedAt: dateField(),
@@ -30807,56 +30882,56 @@ var TokenFeeAccrualEventsV2InputSchema = createCollectionInputSchema(TOKEN_FEE_A
   defaultSort: "-accruedAt",
   globalSearch: false
 });
-var TokenFeeAccrualEventV2ItemSchema = z438.object({
-  id: z438.uuid(),
+var TokenFeeAccrualEventV2ItemSchema = z441.object({
+  id: z441.uuid(),
   payer: ethereumAddress,
   fromAddress: ethereumAddress,
   toAddress: ethereumAddress,
-  operationType: z438.enum(FEE_ACCRUAL_OPERATION_TYPE_OPTIONS),
+  operationType: z441.enum(FEE_ACCRUAL_OPERATION_TYPE_OPTIONS),
   operationAmount: bigDecimal(),
   operationAmountExact: apiBigInt,
-  feeBps: z438.number().int().nonnegative(),
+  feeBps: z441.number().int().nonnegative(),
   feeAmount: bigDecimal(),
   feeAmountExact: apiBigInt,
   blockNumber: apiBigInt,
   blockTimestamp: timestamp(),
   eventTimestamp: timestamp(),
   txHash: ethereumHash,
-  logIndex: z438.number().int().nonnegative()
+  logIndex: z441.number().int().nonnegative()
 });
 var TokenFeeAccrualEventsV2OutputSchema = createPaginatedResponse(TokenFeeAccrualEventV2ItemSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.fee-accrual-payer.schema.ts
-import { z as z439 } from "zod";
-var TokenFeeAccrualPayerV2InputSchema = z439.object({
+import { z as z442 } from "zod";
+var TokenFeeAccrualPayerV2InputSchema = z442.object({
   payer: ethereumAddress.meta({
     description: "Payer address whose accrued fees to summarise.",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   })
 });
-var TokenFeeAccrualPayerBreakdownItemSchema = z439.object({
-  operationType: z439.enum(FEE_ACCRUAL_OPERATION_TYPE_OPTIONS),
-  eventCount: z439.number().int().nonnegative(),
+var TokenFeeAccrualPayerBreakdownItemSchema = z442.object({
+  operationType: z442.enum(FEE_ACCRUAL_OPERATION_TYPE_OPTIONS),
+  eventCount: z442.number().int().nonnegative(),
   totalOperationAmount: bigDecimal(),
   totalOperationAmountExact: apiBigInt,
   totalFeeAmount: bigDecimal(),
   totalFeeAmountExact: apiBigInt
 });
-var TokenFeeAccrualPayerV2OutputSchema = z439.object({
-  data: z439.object({
+var TokenFeeAccrualPayerV2OutputSchema = z442.object({
+  data: z442.object({
     payer: ethereumAddress,
-    totalEvents: z439.number().int().nonnegative(),
+    totalEvents: z442.number().int().nonnegative(),
     totalFeeAmount: bigDecimal(),
     totalFeeAmountExact: apiBigInt,
     totalOperationAmount: bigDecimal(),
     totalOperationAmountExact: apiBigInt,
-    breakdown: z439.array(TokenFeeAccrualPayerBreakdownItemSchema),
-    recentEvents: z439.array(TokenFeeAccrualEventV2ItemSchema)
+    breakdown: z442.array(TokenFeeAccrualPayerBreakdownItemSchema),
+    recentEvents: z442.array(TokenFeeAccrualEventV2ItemSchema)
   })
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.external-fee-collection-events.list.schema.ts
-import { z as z440 } from "zod";
+import { z as z443 } from "zod";
 var EXTERNAL_OPERATION_TYPE_OPTIONS = ["mint", "burn", "transfer", "unknown"];
 var TOKEN_EXTERNAL_FEE_COLLECTION_EVENTS_COLLECTION_FIELDS = {
   collectedAt: dateField(),
@@ -30870,22 +30945,22 @@ var TokenExternalFeeCollectionEventsV2InputSchema = createCollectionInputSchema(
   defaultSort: "-collectedAt",
   globalSearch: false
 });
-var TokenExternalFeeCollectionEventV2ItemSchema = z440.object({
-  id: z440.uuid(),
+var TokenExternalFeeCollectionEventV2ItemSchema = z443.object({
+  id: z443.uuid(),
   payer: ethereumAddress,
   feeToken: ethereumAddress,
-  operationType: z440.enum(EXTERNAL_OPERATION_TYPE_OPTIONS),
+  operationType: z443.enum(EXTERNAL_OPERATION_TYPE_OPTIONS),
   feeAmount: bigDecimal(),
   feeAmountExact: apiBigInt,
   blockNumber: apiBigInt,
   blockTimestamp: timestamp(),
   txHash: ethereumHash,
-  logIndex: z440.number().int().nonnegative()
+  logIndex: z443.number().int().nonnegative()
 });
 var TokenExternalFeeCollectionEventsV2OutputSchema = createPaginatedResponse(TokenExternalFeeCollectionEventV2ItemSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.feature-permit-replay-history.schema.ts
-import { z as z441 } from "zod";
+import { z as z444 } from "zod";
 var PERMIT_REPLAY_HISTORY_COLLECTION_FIELDS = {
   blockTime: dateField()
 };
@@ -30893,7 +30968,7 @@ var TokenFeaturePermitReplayHistoryV2InputSchema = createCollectionInputSchema(P
   defaultSort: "-blockTime",
   globalSearch: false
 });
-var TokenFeaturePermitReplayHistoryV2ItemSchema = z441.object({
+var TokenFeaturePermitReplayHistoryV2ItemSchema = z444.object({
   nonce: apiBigInt.meta({
     description: "Per-owner sequence number derived from the count of prior projection rows for the same (chainId, tokenAddress, owner) tuple.",
     examples: ["0"]
@@ -30925,10 +31000,10 @@ var TransferApprovalsV2InputSchema = createCollectionInputSchema(TRANSFER_APPROV
 var TransferApprovalsV2OutputSchema = createPaginatedResponse(TransferApprovalSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.treasury-health.schema.ts
-import { z as z442 } from "zod";
+import { z as z445 } from "zod";
 var TreasuryHealthInputSchema = TokenReadInputSchema;
-var TreasuryHealthApprovalSchema = z442.object({
-  kind: z442.enum(["maturity-redemption", "fixed-treasury-yield"]).meta({
+var TreasuryHealthApprovalSchema = z445.object({
+  kind: z445.enum(["maturity-redemption", "fixed-treasury-yield"]).meta({
     description: "Which feature this approval row gates.",
     examples: ["maturity-redemption"]
   }),
@@ -30952,21 +31027,21 @@ var TreasuryHealthApprovalSchema = z442.object({
     description: "Required allowance ceiling for the feature, scaled by denomination asset decimals.",
     examples: ["1000.00"]
   }),
-  satisfied: z442.boolean().meta({
+  satisfied: z445.boolean().meta({
     description: "True when the indexed allowance is greater than or equal to the required ceiling.",
     examples: [true, false]
   })
 });
-var TreasuryHealthImplementationSchema = z442.object({
-  treasuryIsContract: z442.boolean().nullable().meta({
+var TreasuryHealthImplementationSchema = z445.object({
+  treasuryIsContract: z445.boolean().nullable().meta({
     description: "Whether the configured treasury address is a contract (`true`), an EOA (`false`), or has not yet been classified by the indexer (`null`).",
     examples: [false, true, null]
   })
 }).nullable().meta({
   description: "Treasury implementation classification. `null` when no maturity / yield feature is attached."
 });
-var TreasuryHealthResponseSchema = z442.object({
-  approvals: z442.array(TreasuryHealthApprovalSchema).meta({
+var TreasuryHealthResponseSchema = z445.object({
+  approvals: z445.array(TreasuryHealthApprovalSchema).meta({
     description: "Per-feature approval rows. Empty when the token has neither a maturity-redemption nor a fixed-treasury-yield feature attached."
   }),
   implementation: TreasuryHealthImplementationSchema,
@@ -30978,11 +31053,11 @@ var TreasuryHealthResponseSchema = z442.object({
     description: "Projected next-period denomination need (next scheduled redemption / unclaimed yield), scaled by denomination asset decimals. Used to set the `yellow` threshold.",
     examples: ["1000.00"]
   }),
-  status: z442.enum(["green", "yellow", "red"]).meta({
+  status: z445.enum(["green", "yellow", "red"]).meta({
     description: "Badge status. `green` = approvals satisfy ceilings AND balance covers projected need. `yellow` = approvals satisfy but balance is below projected need. `red` = at least one approval is below its ceiling.",
     examples: ["green", "yellow", "red"]
   }),
-  reason: z442.string().nullable().meta({
+  reason: z445.string().nullable().meta({
     description: "Human-readable reason for the non-green status. `null` for `green`.",
     examples: ["balance below projected", "approval below ceiling", null]
   }),
@@ -30993,7 +31068,7 @@ var TreasuryHealthResponseSchema = z442.object({
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.voting-delegations.schema.ts
-import { z as z443 } from "zod";
+import { z as z446 } from "zod";
 var VOTING_DELEGATIONS_COLLECTION_FIELDS = {
   account: addressField({ defaultOperator: "iLike" }),
   delegate: addressField({ defaultOperator: "iLike" }),
@@ -31007,49 +31082,49 @@ var VotingDelegationsV2InputSchema = createCollectionInputSchema(VOTING_DELEGATI
   defaultSort: "-delegatedAt",
   globalSearch: false
 });
-var VotingDelegationV2ItemSchema = z443.object({
-  id: z443.string().uuid(),
+var VotingDelegationV2ItemSchema = z446.object({
+  id: z446.string().uuid(),
   delegator: ethereumAddress,
   fromDelegate: ethereumAddress.nullable(),
   toDelegate: ethereumAddress,
   delegatedAt: timestamp(),
   delegatedBlockNumber: apiBigInt,
   delegatedTxHash: ethereumHash,
-  delegatedLogIndex: z443.number().int().nonnegative(),
+  delegatedLogIndex: z446.number().int().nonnegative(),
   undelegatedAt: timestamp().nullable(),
   undelegatedBlockNumber: apiBigInt.nullable(),
   undelegatedTxHash: ethereumHash.nullable(),
-  undelegatedLogIndex: z443.number().int().nonnegative().nullable(),
-  isActive: z443.boolean()
+  undelegatedLogIndex: z446.number().int().nonnegative().nullable(),
+  isActive: z446.boolean()
 });
 var VotingDelegationsV2OutputSchema = createPaginatedResponse(VotingDelegationV2ItemSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.voting-power-distribution.schema.ts
-import { z as z444 } from "zod";
+import { z as z447 } from "zod";
 var DEFAULT_TOP_N = 50;
 var MAX_TOP_N = 200;
-var VotingPowerDistributionV2InputSchema = z444.object({
-  topN: z444.coerce.number().int().min(1).max(MAX_TOP_N).default(DEFAULT_TOP_N).meta({
+var VotingPowerDistributionV2InputSchema = z447.object({
+  topN: z447.coerce.number().int().min(1).max(MAX_TOP_N).default(DEFAULT_TOP_N).meta({
     description: `Number of top holders to return individually (1-${MAX_TOP_N}). Remaining holders aggregate into the "other" bucket.`,
     examples: [DEFAULT_TOP_N]
   })
 });
-var VotingPowerDistributionHolderSchema = z444.object({
+var VotingPowerDistributionHolderSchema = z447.object({
   account: ethereumAddress,
-  votes: z444.string(),
+  votes: z447.string(),
   votesExact: apiBigInt
 });
-var VotingPowerDistributionOtherSchema = z444.object({
-  holders: z444.number().int().nonnegative(),
-  votes: z444.string(),
+var VotingPowerDistributionOtherSchema = z447.object({
+  holders: z447.number().int().nonnegative(),
+  votes: z447.string(),
   votesExact: apiBigInt
 });
-var VotingPowerDistributionV2DataSchema = z444.object({
-  total: z444.number().int().nonnegative(),
-  topN: z444.number().int().nonnegative(),
-  totalVotes: z444.string(),
+var VotingPowerDistributionV2DataSchema = z447.object({
+  total: z447.number().int().nonnegative(),
+  topN: z447.number().int().nonnegative(),
+  totalVotes: z447.string(),
   totalVotesExact: apiBigInt,
-  holders: z444.array(VotingPowerDistributionHolderSchema),
+  holders: z447.array(VotingPowerDistributionHolderSchema),
   other: VotingPowerDistributionOtherSchema
 });
 var VotingPowerDistributionV2OutputSchema = createSingleResponse(VotingPowerDistributionV2DataSchema);
@@ -31068,21 +31143,21 @@ var allowance = v2Contract.route({
   description: "Get token allowance for a specific owner/spender pair.",
   successDescription: "Token allowance details retrieved successfully.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({ tokenAddress: TokenAllowanceInputSchema.shape.tokenAddress }), z445.object(TokenAllowanceInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(TokenAllowanceResponseSchema));
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenAllowanceInputSchema.shape.tokenAddress }), z448.object(TokenAllowanceInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(TokenAllowanceResponseSchema));
 var holder = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/holder-balances",
   description: "Get a specific token holder's balance information.",
   successDescription: "Token holder balance details retrieved successfully.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({ tokenAddress: TokenHolderInputSchema.shape.tokenAddress }), z445.object(TokenHolderInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(TokenHolderResponseSchema));
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenHolderInputSchema.shape.tokenAddress }), z448.object(TokenHolderInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(TokenHolderResponseSchema));
 var holders = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/holders",
   description: "Get token holders and their balances.",
   successDescription: "List of token holders with balance information.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({
+}).input(v2Input.paramsQuery(z448.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -31094,7 +31169,7 @@ var actions = v2Contract.route({
   description: "List actions targeting a specific token. Supports JSON:API pagination, sorting, filtering, and faceted counts.",
   successDescription: "Paginated list of actions targeting the specified token.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({
+}).input(v2Input.paramsQuery(z448.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address to filter actions by",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -31106,7 +31181,7 @@ var events2 = v2Contract.route({
   description: "List token events with pagination, filtering, sorting, and faceted counts.",
   successDescription: "Paginated list of token events with metadata and pagination links.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({
+}).input(v2Input.paramsQuery(z448.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -31118,7 +31193,7 @@ var denominationAssets = v2Contract.route({
   description: "List denomination asset(s) used by the specified bond. Supports JSON:API pagination, sorting, filtering, and faceted counts.",
   successDescription: "Paginated list of denomination assets used by the specified bond.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), DenominationAssetsV2InputSchema)).output(DenominationAssetsV2OutputSchema);
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), DenominationAssetsV2InputSchema)).output(DenominationAssetsV2OutputSchema);
 var compliance = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/compliance-modules",
@@ -31160,7 +31235,7 @@ var transferApprovals = v2Contract.route({
   description: "List transfer approvals created on the TransferApprovalComplianceModule for this token. Includes pending, consumed, and revoked approvals.",
   successDescription: "List of transfer approvals with their current status.",
   tags: [V2_TAG.compliance]
-}).input(v2Input.paramsQuery(z445.object({ tokenAddress: TransferApprovalsInputSchema.shape.tokenAddress }), TransferApprovalsV2InputSchema)).output(TransferApprovalsV2OutputSchema);
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TransferApprovalsInputSchema.shape.tokenAddress }), TransferApprovalsV2InputSchema)).output(TransferApprovalsV2OutputSchema);
 var price = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/price",
@@ -31174,49 +31249,70 @@ var conversionTriggers = v2Contract.route({
   description: "List conversion triggers for a token. Includes computed effective price (after discount and cap). Supports JSON:API pagination, sorting, filtering, and faceted counts.",
   successDescription: "Paginated list of conversion triggers with effective pricing.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), ConversionTriggersV2InputSchema)).output(ConversionTriggersV2OutputSchema);
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), ConversionTriggersV2InputSchema)).output(ConversionTriggersV2OutputSchema);
 var conversionRecords = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/conversion/records",
   description: "List conversion lifecycle records for a token. Includes conversion-minter issuance details when available. Supports JSON:API pagination, sorting, filtering, and faceted counts.",
   successDescription: "Paginated list of conversion records.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), ConversionRecordsV2InputSchema)).output(ConversionRecordsV2OutputSchema);
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), ConversionRecordsV2InputSchema)).output(ConversionRecordsV2OutputSchema);
+var conversionTriggerEvents = v2Contract.route({
+  method: "GET",
+  path: "/tokens/{tokenAddress}/conversion/events",
+  description: "List the append-only TriggerPublished / TriggerDisabled / republish lifecycle observations for a token's attached conversion feature. Supports JSON:API pagination, sorting, filtering, and faceted counts.",
+  successDescription: "Paginated list of conversion trigger lifecycle events.",
+  tags: [V2_TAG.token]
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), ConversionTriggerEventsV2InputSchema)).output(ConversionTriggerEventsV2OutputSchema);
+var convertsTo = v2Contract.route({
+  method: "GET",
+  path: "/tokens/{tokenAddress}/conversion/converts-to",
+  description: "List target tokens that this token has been authorized to convert into. Reads the forward direction of the bidirectional conversion authorization edges.",
+  successDescription: "Paginated list of forward conversion authorization edges.",
+  tags: [V2_TAG.token]
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), ConvertsToV2InputSchema)).output(ConvertsToV2OutputSchema);
+var convertedFrom = v2Contract.route({
+  method: "GET",
+  path: "/tokens/{tokenAddress}/conversion/converted-from",
+  description: "List source tokens that have been authorized to convert into this token. Reads the reverse direction of the bidirectional conversion authorization edges.",
+  successDescription: "Paginated list of reverse conversion authorization edges.",
+  tags: [V2_TAG.token]
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), ConvertedFromV2InputSchema)).output(ConvertedFromV2OutputSchema);
 var conversionHolderState = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/conversion/holder-state",
   description: "Read holder-specific conversion state from the token's attached conversion feature. Returns null when no conversion feature is attached.",
   successDescription: "Conversion holder state retrieved successfully.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({ tokenAddress: TokenConversionHolderStateInputSchema.shape.tokenAddress }), z445.object(TokenConversionHolderStateInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(TokenConversionHolderStateResponseSchema));
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenConversionHolderStateInputSchema.shape.tokenAddress }), z448.object(TokenConversionHolderStateInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(TokenConversionHolderStateResponseSchema));
 var votingDelegations = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/voting-delegations",
   description: "List voting delegation lifecycle rows for a token's voting-power feature. Supports JSON:API pagination, sorting, filtering, and faceted active counts.",
   successDescription: "Paginated list of voting delegation lifecycle rows.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), VotingDelegationsV2InputSchema)).output(VotingDelegationsV2OutputSchema);
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), VotingDelegationsV2InputSchema)).output(VotingDelegationsV2OutputSchema);
 var votingPowerDistribution = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/voting-power/distribution",
   description: "Histogram of current voting power per delegate for a token's voting-power feature. Returns the top-N holders by latest votes plus a single aggregated 'other' bucket covering remaining holders.",
   successDescription: "Voting-power distribution summary retrieved successfully.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), VotingPowerDistributionV2InputSchema)).output(VotingPowerDistributionV2OutputSchema);
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), VotingPowerDistributionV2InputSchema)).output(VotingPowerDistributionV2OutputSchema);
 var permitInfo = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/permit-info",
   description: "Read EIP-2612 permit metadata from the token's attached permit feature, including the domain separator and optional owner nonce.",
   successDescription: "Permit feature metadata retrieved successfully.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({ tokenAddress: TokenPermitInfoInputSchema.shape.tokenAddress }), z445.object(TokenPermitInfoInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(TokenPermitInfoResponseSchema));
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenPermitInfoInputSchema.shape.tokenAddress }), z448.object(TokenPermitInfoInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(TokenPermitInfoResponseSchema));
 var featurePermitReplayHistory = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/permit/replay-history/{owner}",
   description: "List relayed `permit()` calls scoped to a single holder for a token's attached Permit feature. Forensic/audit view derived from the indexer projection that filters Approval events on the EIP-2612 permit function selector. History begins at the U2 selector bump landing date — pre-bump events do not appear because their `selector` column is NULL. Permits routed through ERC-4337 `EntryPoint.handleOps` (smart-wallet / UserOp paths) are conservatively excluded in this backend slice because the outer transaction selector reflects the EntryPoint, not the EIP-2612 selector; promoting AA-routed permits requires inner-call decoding tracked as a follow-up.",
   successDescription: "Paginated list of permit replay events for the specified owner.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({
+}).input(v2Input.paramsQuery(z448.object({
   tokenAddress: TokenReadInputSchema.shape.tokenAddress,
   owner: ethereumAddress.meta({
     description: "Token holder whose permit replay history is being requested.",
@@ -31229,21 +31325,21 @@ var historicalBalances = v2Contract.route({
   description: "List historical balance checkpoints for a token's historical-balances feature. Account rows are returned by default; total-supply rows are reachable through filter[kind]=totalSupply or filter[account]=0x0000000000000000000000000000000000000000.",
   successDescription: "Paginated list of historical balance checkpoints.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenHistoricalBalancesV2InputSchema)).output(TokenHistoricalBalancesV2OutputSchema);
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenHistoricalBalancesV2InputSchema)).output(TokenHistoricalBalancesV2OutputSchema);
 var historicalBalanceAtBlock = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/historical-balances/balance-at-block",
   description: "Read a holder balance and total supply from the token's attached historical-balances feature at a specific feature clock timepoint.",
   successDescription: "Historical balance snapshot retrieved successfully.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenHistoricalBalanceAtBlockV2InputQuerySchema)).output(TokenHistoricalBalanceAtBlockV2OutputSchema);
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenHistoricalBalanceAtBlockV2InputQuerySchema)).output(TokenHistoricalBalanceAtBlockV2OutputSchema);
 var historicalHoldersAtBlock = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/historical-balances/holders-at-block",
   description: "List holder balances read from the token's attached historical-balances feature at a specific feature clock timepoint.",
   successDescription: "Paginated historical holder snapshot retrieved successfully.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenHistoricalHoldersAtBlockV2InputSchema)).output(TokenHistoricalHoldersAtBlockV2OutputSchema);
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenHistoricalHoldersAtBlockV2InputSchema)).output(TokenHistoricalHoldersAtBlockV2OutputSchema);
 var historicalBalanceAtBlockByHolder = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/historical-balances/{holderAddress}",
@@ -31257,28 +31353,28 @@ var transactionFeeCollections = v2Contract.route({
   description: "List transaction-fee collections for a token's transaction-fee feature. Supports JSON:API pagination, sorting, filtering, and faceted operation counts.",
   successDescription: "Paginated list of transaction-fee collections.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenTransactionFeeCollectionsV2InputSchema)).output(TokenTransactionFeeCollectionsV2OutputSchema);
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenTransactionFeeCollectionsV2InputSchema)).output(TokenTransactionFeeCollectionsV2OutputSchema);
 var feeAccrualEvents = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/transaction-fee-accounting/accrual-events",
   description: "List fee-accrual events for a token's transaction-fee-accounting feature. Each row captures the full FeeAccrued payload (payer, from, to, fee type, operation amount, fee bps, fee amount). Supports JSON:API pagination, sorting, filtering, and faceted operation counts.",
   successDescription: "Paginated list of fee-accrual events.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenFeeAccrualEventsV2InputSchema)).output(TokenFeeAccrualEventsV2OutputSchema);
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenFeeAccrualEventsV2InputSchema)).output(TokenFeeAccrualEventsV2OutputSchema);
 var feeAccrualPayer = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/transaction-fee-accounting/payers/{payer}",
   description: "Per-payer summary of accrued transaction fees on a token's transaction-fee-accounting feature — totals, per-operation-type breakdown, and the most recent accrual events for the payer.",
   successDescription: "Per-payer accrual summary.",
   tags: [V2_TAG.token]
-}).input(v2Input.params(z445.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }).extend(TokenFeeAccrualPayerV2InputSchema.shape))).output(TokenFeeAccrualPayerV2OutputSchema);
+}).input(v2Input.params(z448.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }).extend(TokenFeeAccrualPayerV2InputSchema.shape))).output(TokenFeeAccrualPayerV2OutputSchema);
 var externalFeeCollectionEvents = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/external-transaction-fee/collection-events",
   description: "List external-fee collection events for a token's external-transaction-fee feature. Each row captures the full ExternalFeeCollected payload (payer, fee token, operation type, fee amount). Supports JSON:API pagination, sorting, filtering, and faceted operation counts.",
   successDescription: "Paginated list of external-fee collection events.",
   tags: [V2_TAG.token]
-}).input(v2Input.paramsQuery(z445.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenExternalFeeCollectionEventsV2InputSchema)).output(TokenExternalFeeCollectionEventsV2OutputSchema);
+}).input(v2Input.paramsQuery(z448.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenExternalFeeCollectionEventsV2InputSchema)).output(TokenExternalFeeCollectionEventsV2OutputSchema);
 var treasuryHealth = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/treasury/health",
@@ -31302,6 +31398,9 @@ var tokenV2ReadsContract = {
   transferApprovals,
   conversionTriggers,
   conversionRecords,
+  conversionTriggerEvents,
+  convertsTo,
+  convertedFrom,
   conversionHolderState,
   votingDelegations,
   votingPowerDistribution,
@@ -31321,7 +31420,7 @@ var tokenV2ReadsContract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.stats.contract.ts
-import { z as z446 } from "zod";
+import { z as z449 } from "zod";
 var statsBondStatus = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/stats/bond-status",
@@ -31342,25 +31441,25 @@ var statsTotalSupply = v2Contract.route({
   description: "Get total supply history statistics for a specific token.",
   successDescription: "Token total supply history statistics.",
   tags: [V2_TAG.tokenStats]
-}).input(v2Input.paramsQuery(z446.object({
+}).input(v2Input.paramsQuery(z449.object({
   tokenAddress: StatsTotalSupplyInputSchema.shape.tokenAddress
-}), z446.object(StatsTotalSupplyInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(StatsTotalSupplyOutputSchema));
+}), z449.object(StatsTotalSupplyInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(StatsTotalSupplyOutputSchema));
 var statsSupplyChanges = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/stats/supply-changes",
   description: "Get supply changes history (minted/burned) statistics for a specific token.",
   successDescription: "Token supply changes history statistics.",
   tags: [V2_TAG.tokenStats]
-}).input(v2Input.paramsQuery(z446.object({
+}).input(v2Input.paramsQuery(z449.object({
   tokenAddress: StatsSupplyChangesInputSchema.shape.tokenAddress
-}), z446.object(StatsSupplyChangesInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(StatsSupplyChangesOutputSchema));
+}), z449.object(StatsSupplyChangesInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(StatsSupplyChangesOutputSchema));
 var statsVolume = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/stats/volume",
   description: "Get total volume history statistics for a specific token.",
   successDescription: "Token total volume history statistics.",
   tags: [V2_TAG.tokenStats]
-}).input(v2Input.paramsQuery(z446.object({ tokenAddress: StatsVolumeInputSchema.shape.tokenAddress }), z446.object(StatsVolumeInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(StatsVolumeOutputSchema));
+}).input(v2Input.paramsQuery(z449.object({ tokenAddress: StatsVolumeInputSchema.shape.tokenAddress }), z449.object(StatsVolumeInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(StatsVolumeOutputSchema));
 var statsWalletDistribution = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/stats/wallet-distribution",
@@ -31394,46 +31493,46 @@ var tokenV2StatsContract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/topic-schemes/topic-schemes.v2.contract.ts
-import { z as z450 } from "zod";
+import { z as z453 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/token/topic-schemes/routes/topic-scheme.list.schema.ts
-import { z as z447 } from "zod";
-var TokenTopicSchemeInheritanceLevelSchema = z447.enum(["token", "system", "global"]).meta({
+import { z as z450 } from "zod";
+var TokenTopicSchemeInheritanceLevelSchema = z450.enum(["token", "system", "global"]).meta({
   description: "Chain-of-trust tier that registered the scheme. `token` rows are token-specific and removable; `system` and `global` rows are inherited and read-only.",
   examples: ["token"]
 });
-var TokenTopicSchemeSchema = z447.object({
-  id: z447.string().meta({
+var TokenTopicSchemeSchema = z450.object({
+  id: z450.string().meta({
     description: "Synthetic identifier for the topic scheme row (registry + topicId).",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F#1"]
   }),
-  topicId: z447.string().meta({
+  topicId: z450.string().meta({
     description: "Numeric topic id as a decimal string (matches the on-chain uint256).",
     examples: ["1", "100"]
   }),
-  name: z447.string().meta({
+  name: z450.string().meta({
     description: "Human-readable topic-scheme name registered on the registry.",
     examples: ["Know Your Customer", "Accredited Investor"]
   }),
-  signature: z447.string().meta({
+  signature: z450.string().meta({
     description: "ABI signature describing the claim data shape verified by this scheme.",
     examples: ["(string)", "(uint256,bool)"]
   }),
-  registry: z447.object({
+  registry: z450.object({
     id: ethereumAddress.meta({
       description: "Topic Scheme Registry contract address that holds this row.",
       examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
     })
   }),
   inheritanceLevel: TokenTopicSchemeInheritanceLevelSchema,
-  isShadowed: z447.boolean().meta({
+  isShadowed: z450.boolean().meta({
     description: "TRUE when another registry in the resolved chain registered the same numeric topicId with a different signature. Surfaces inheritance shadowing before a token admin mutates the row.",
     examples: [false]
   })
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/topic-schemes/topic-schemes.v2.list.schema.ts
-import { z as z448 } from "zod";
+import { z as z451 } from "zod";
 var TOKEN_TOPIC_SCHEMES_COLLECTION_FIELDS = {
   topicId: bigintField({ defaultOperator: "eq" }),
   name: textField({ defaultOperator: "iLike" }),
@@ -31445,14 +31544,14 @@ var TokenTopicSchemesV2ListInputSchema = createCollectionInputSchema(TOKEN_TOPIC
   globalSearch: true
 });
 var TokenTopicSchemesV2ListOutputSchema = createPaginatedResponse(TokenTopicSchemeSchema, {
-  hasTokenRegistry: z448.boolean().meta({
+  hasTokenRegistry: z451.boolean().meta({
     description: "Whether the token has an attached token-level Topic Scheme Registry. " + "When false, only inherited system/global schemes resolve and no token-specific scheme can be added or removed."
   })
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/topic-schemes/topic-schemes.v2.mutations.schema.ts
 import { parseAbiParameters } from "viem";
-import { z as z449 } from "zod";
+import { z as z452 } from "zod";
 function normalizeClaimDataSignature(signature) {
   return `(${signature.trim()})`;
 }
@@ -31466,7 +31565,7 @@ function isAbiTypeList(typeList) {
     return false;
   }
 }
-var ClaimDataSignatureSchema = z449.string().min(1, "Signature is required").superRefine((value3, ctx) => {
+var ClaimDataSignatureSchema = z452.string().min(1, "Signature is required").superRefine((value3, ctx) => {
   if (value3.length === 0) {
     return;
   }
@@ -31479,7 +31578,7 @@ var ClaimDataSignatureSchema = z449.string().min(1, "Signature is required").sup
   }
 });
 var TokenTopicSchemeCreateInputSchema = MutationInputSchema.extend({
-  name: z449.string().min(1, "Topic scheme name is required").max(100, "Topic scheme name must be less than 100 characters").meta({
+  name: z452.string().min(1, "Topic scheme name is required").max(100, "Topic scheme name must be less than 100 characters").meta({
     description: "Human-readable name for the token-level topic scheme.",
     examples: ["Custom Compliance", "Asset Origin"]
   }),
@@ -31489,20 +31588,20 @@ var TokenTopicSchemeCreateInputSchema = MutationInputSchema.extend({
   })
 });
 var TokenTopicSchemeCreateOutputSchema = BaseMutationOutputSchema.extend({
-  name: z449.string().meta({
+  name: z452.string().meta({
     description: "Name of the created token-level topic scheme.",
     examples: ["Custom Compliance", "Asset Origin"]
   })
 });
-var TokenTopicSchemeDeleteParamsSchema = z449.object({
-  topicId: z449.string().min(1, "topicId is required").regex(/^\d+$/, "topicId must be a numeric decimal string").meta({
+var TokenTopicSchemeDeleteParamsSchema = z452.object({
+  topicId: z452.string().min(1, "topicId is required").regex(/^\d+$/, "topicId must be a numeric decimal string").meta({
     description: "Numeric topic id of the token-level scheme to remove (decimal string).",
     examples: ["1", "100"]
   })
 });
 var TokenTopicSchemeDeleteInputSchema = MutationInputSchema;
 var TokenTopicSchemeDeleteOutputSchema = BaseMutationOutputSchema.extend({
-  topicId: z449.string().meta({
+  topicId: z452.string().meta({
     description: "Numeric topic id of the removed token-level scheme.",
     examples: ["1", "100"]
   })
@@ -31531,7 +31630,7 @@ var del12 = v2Contract.route({
   description: "Remove a token-specific topic scheme from the token-level Topic Scheme Registry by topic id.",
   successDescription: "Token topic scheme removed successfully.",
   tags: [V2_TAG.claimTopics]
-}).meta({ contractErrors: [...TOKEN_TOPIC_SCHEME_DELETE_ERRORS] }).input(v2Input.paramsBody(z450.object({ ...TokenReadInputSchema.shape, ...TokenTopicSchemeDeleteParamsSchema.shape }), TokenTopicSchemeDeleteInputSchema)).output(createAsyncBlockchainMutationResponse(TokenTopicSchemeDeleteOutputSchema));
+}).meta({ contractErrors: [...TOKEN_TOPIC_SCHEME_DELETE_ERRORS] }).input(v2Input.paramsBody(z453.object({ ...TokenReadInputSchema.shape, ...TokenTopicSchemeDeleteParamsSchema.shape }), TokenTopicSchemeDeleteInputSchema)).output(createAsyncBlockchainMutationResponse(TokenTopicSchemeDeleteOutputSchema));
 var tokenV2TopicSchemesContract = {
   list: list40,
   create: create21,
@@ -31539,54 +31638,54 @@ var tokenV2TopicSchemesContract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/trusted-issuers/trusted-issuers.v2.contract.ts
-import { z as z454 } from "zod";
+import { z as z457 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/token/trusted-issuers/routes/trusted-issuer.list.schema.ts
-import { z as z451 } from "zod";
-var TokenTrustedIssuerInheritanceLevelSchema = z451.enum(["token", "system", "global"]).meta({
+import { z as z454 } from "zod";
+var TokenTrustedIssuerInheritanceLevelSchema = z454.enum(["token", "system", "global"]).meta({
   description: "Chain-of-trust tier that registered the issuer. `token` rows are token-specific and removable; `system` and `global` rows are inherited and read-only.",
   examples: ["token"]
 });
-var TokenTrustedIssuerClaimTopicSchema = z451.object({
-  topicId: z451.string().meta({
+var TokenTrustedIssuerClaimTopicSchema = z454.object({
+  topicId: z454.string().meta({
     description: "Numeric topic id as a decimal string (matches the on-chain uint256).",
     examples: ["1", "100"]
   }),
-  name: z451.string().meta({
+  name: z454.string().meta({
     description: "Human-readable topic-scheme name resolved from the token's topic-scheme registry chain.",
     examples: ["Know Your Customer", "Accredited Investor"]
   })
 });
-var TokenTrustedIssuerSchema = z451.object({
+var TokenTrustedIssuerSchema = z454.object({
   id: ethereumAddress.meta({
     description: "Issuer identity address — the on-chain key for the trusted issuer.",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  account: z451.object({
+  account: z454.object({
     id: ethereumAddress.meta({
       description: "Issuer wallet address.",
       examples: ["0x2546BcD3c84621e976D8185a91A922aE77ECEc30"]
     })
   }).nullable().optional().meta({ description: "Identity account associated with the issuer, when resolvable." }),
-  claimTopics: z451.array(TokenTrustedIssuerClaimTopicSchema).meta({
+  claimTopics: z454.array(TokenTrustedIssuerClaimTopicSchema).meta({
     description: "Claim topics this issuer is trusted for at its registry tier.",
     examples: [[]]
   }),
-  registry: z451.object({
+  registry: z454.object({
     id: ethereumAddress.meta({
       description: "Trusted Issuer Registry contract address that holds this row.",
       examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
     })
   }),
   inheritanceLevel: TokenTrustedIssuerInheritanceLevelSchema,
-  isInheritedElsewhere: z451.boolean().meta({
+  isInheritedElsewhere: z454.boolean().meta({
     description: "True when the same trusted issuer is also active in a parent-tier (system/global) registry of this token's resolved chain. " + "A `token`-tier row with this flag set keeps inherited trust after a token-level remove; `system`/`global` rows are always false.",
     examples: [false]
   })
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/trusted-issuers/trusted-issuers.v2.list.schema.ts
-import { z as z452 } from "zod";
+import { z as z455 } from "zod";
 var TOKEN_TRUSTED_ISSUERS_COLLECTION_FIELDS = {
   account: textField({ defaultOperator: "iLike" }),
   source: enumField(["token", "system", "global"], { sortable: false })
@@ -31596,18 +31695,18 @@ var TokenTrustedIssuersV2ListInputSchema = createCollectionInputSchema(TOKEN_TRU
   globalSearch: true
 });
 var TokenTrustedIssuersV2ListOutputSchema = createPaginatedResponse(TokenTrustedIssuerSchema, {
-  hasTrustedIssuersRegistry: z452.boolean().meta({
+  hasTrustedIssuersRegistry: z455.boolean().meta({
     description: "Whether the token has an attached token-level Trusted Issuer Registry. " + "When false, only inherited system/global issuers resolve and no token-specific issuer can be added or removed."
   })
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/trusted-issuers/trusted-issuers.v2.mutations.schema.ts
-import { z as z453 } from "zod";
+import { z as z456 } from "zod";
 var MAX_UINT2565 = 2n ** 256n - 1n;
 var MAX_CLAIM_TOPIC_IDS = 50;
 var CLAIM_TOPIC_ID_FORMAT_MESSAGE = "Each claim topic id must be a non-negative decimal integer.";
 var CLAIM_TOPIC_ID_RANGE_MESSAGE = "Each claim topic id must fit within uint256.";
-var ClaimTopicIdSchema = z453.string().min(1, "Claim topic id is required").superRefine((value3, ctx) => {
+var ClaimTopicIdSchema = z456.string().min(1, "Claim topic id is required").superRefine((value3, ctx) => {
   if (!/^\d+$/.test(value3)) {
     ctx.addIssue({ code: "custom", message: CLAIM_TOPIC_ID_FORMAT_MESSAGE });
     return;
@@ -31621,7 +31720,7 @@ var TokenTrustedIssuerCreateInputSchema = MutationInputSchema.extend({
     description: "Identity address of the trusted issuer to add to the token-level registry.",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  claimTopicIds: z453.array(ClaimTopicIdSchema).min(1, "At least one claim topic id is required").max(MAX_CLAIM_TOPIC_IDS, `A trusted issuer may be granted at most ${MAX_CLAIM_TOPIC_IDS} claim topics`).meta({
+  claimTopicIds: z456.array(ClaimTopicIdSchema).min(1, "At least one claim topic id is required").max(MAX_CLAIM_TOPIC_IDS, `A trusted issuer may be granted at most ${MAX_CLAIM_TOPIC_IDS} claim topics`).meta({
     description: "Decimal-string topic ids the issuer is trusted for, passed as the on-chain uint256[] argument.",
     examples: [["1", "2", "100"]]
   })
@@ -31632,7 +31731,7 @@ var TokenTrustedIssuerCreateOutputSchema = BaseMutationOutputSchema.extend({
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   })
 });
-var TokenTrustedIssuerDeleteParamsSchema = z453.object({
+var TokenTrustedIssuerDeleteParamsSchema = z456.object({
   issuerAddress: ethereumAddress.meta({
     description: "Identity address of the token-level trusted issuer to remove.",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -31669,7 +31768,7 @@ var del13 = v2Contract.route({
   description: "Remove a token-specific trusted issuer from the token-level Trusted Issuer Registry by issuer address.",
   successDescription: "Token trusted issuer removed successfully.",
   tags: [V2_TAG.trustedIssuers]
-}).meta({ contractErrors: [...TOKEN_TRUSTED_ISSUER_DELETE_ERRORS] }).input(v2Input.paramsBody(z454.object({ ...TokenReadInputSchema.shape, ...TokenTrustedIssuerDeleteParamsSchema.shape }), TokenTrustedIssuerDeleteInputSchema)).output(createAsyncBlockchainMutationResponse(TokenTrustedIssuerDeleteOutputSchema));
+}).meta({ contractErrors: [...TOKEN_TRUSTED_ISSUER_DELETE_ERRORS] }).input(v2Input.paramsBody(z457.object({ ...TokenReadInputSchema.shape, ...TokenTrustedIssuerDeleteParamsSchema.shape }), TokenTrustedIssuerDeleteInputSchema)).output(createAsyncBlockchainMutationResponse(TokenTrustedIssuerDeleteOutputSchema));
 var tokenV2TrustedIssuersContract = {
   list: list41,
   create: create22,
@@ -31695,7 +31794,7 @@ var tokenV2Contract = {
 };
 
 // ../../packages/core/validation/src/transaction-request-state.ts
-import { z as z455 } from "zod";
+import { z as z458 } from "zod";
 var transactionRequestStates = [
   "RECEIVED",
   "QUEUED",
@@ -31710,7 +31809,7 @@ var transactionRequestStates = [
   "CANCELLED"
 ];
 var TERMINAL_STATES = ["COMPLETED", "FAILED", "DEAD_LETTER", "CANCELLED"];
-var TransactionRequestStateSchema = z455.enum(transactionRequestStates).meta({
+var TransactionRequestStateSchema = z458.enum(transactionRequestStates).meta({
   description: "Current state in the transaction request lifecycle",
   examples: ["RECEIVED", "QUEUED", "BROADCASTING", "COMPLETED", "FAILED"]
 });
@@ -31752,96 +31851,96 @@ var transactionSubStatuses = [
   "WORKFLOW_BATCH_COMPLETED",
   "WORKFLOW_BATCH_FAILED"
 ];
-var TransactionSubStatusSchema = z455.enum(transactionSubStatuses).meta({
+var TransactionSubStatusSchema = z458.enum(transactionSubStatuses).meta({
   description: "Detailed sub-status for transaction failures",
   examples: ["REVERTED", "NONCE_CONFLICT", "INSUFFICIENT_BALANCE"]
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/transaction/transaction.v2.admin.schema.ts
-import { z as z456 } from "zod";
-var TransactionForceRetryInputSchema = z456.object({
-  transactionId: z456.uuid().meta({
+import { z as z459 } from "zod";
+var TransactionForceRetryInputSchema = z459.object({
+  transactionId: z459.uuid().meta({
     description: "Queue transaction identifier (UUIDv7) to retry",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   })
 });
-var TransactionForceRetryBodySchema = z456.object({
-  gasPrice: z456.string().optional().meta({
+var TransactionForceRetryBodySchema = z459.object({
+  gasPrice: z459.string().optional().meta({
     description: "Override gas price in wei (decimal string)",
     examples: ["20000000000"]
   }),
-  nonce: z456.number().int().nonnegative().optional().meta({
+  nonce: z459.number().int().nonnegative().optional().meta({
     description: "Override nonce for the retried transaction",
     examples: [42]
   })
 }).default({});
-var TransactionForceRetryResultSchema = z456.object({
-  transactionId: z456.uuid().meta({ description: "The requeued transaction ID" }),
+var TransactionForceRetryResultSchema = z459.object({
+  transactionId: z459.uuid().meta({ description: "The requeued transaction ID" }),
   previousStatus: transactionRequestState().meta({ description: "State before force retry" }),
   status: transactionRequestState().meta({ description: "New state after force retry (QUEUED)" })
 });
 var TransactionV2ForceRetryOutputSchema = createSingleResponse(TransactionForceRetryResultSchema);
-var TransactionForceFailInputSchema = z456.object({
-  transactionId: z456.uuid().meta({
+var TransactionForceFailInputSchema = z459.object({
+  transactionId: z459.uuid().meta({
     description: "Queue transaction identifier (UUIDv7) to force-fail",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   })
 });
-var TransactionForceFailBodySchema = z456.object({
-  reason: z456.string().min(1).max(1000).meta({
+var TransactionForceFailBodySchema = z459.object({
+  reason: z459.string().min(1).max(1000).meta({
     description: "Human-readable reason for forcing this transaction to failed state",
     examples: ["Manual intervention: stuck transaction after nonce conflict"]
   })
 });
-var TransactionForceFailResultSchema = z456.object({
-  transactionId: z456.uuid().meta({ description: "The force-failed transaction ID" }),
+var TransactionForceFailResultSchema = z459.object({
+  transactionId: z459.uuid().meta({ description: "The force-failed transaction ID" }),
   previousStatus: transactionRequestState().meta({ description: "State before force fail" }),
   status: transactionRequestState().meta({ description: "New state (FAILED)" }),
-  reason: z456.string().meta({ description: "The reason provided for the force-fail" })
+  reason: z459.string().meta({ description: "The reason provided for the force-fail" })
 });
 var TransactionV2ForceFailOutputSchema = createSingleResponse(TransactionForceFailResultSchema);
-var TransactionForceNonceInputSchema = z456.object({
-  transactionId: z456.uuid().meta({
+var TransactionForceNonceInputSchema = z459.object({
+  transactionId: z459.uuid().meta({
     description: "Queue transaction identifier — the nonce is forced on its sender wallet",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   })
 });
-var TransactionForceNonceBodySchema = z456.object({
-  nonce: z456.number().int().nonnegative().meta({
+var TransactionForceNonceBodySchema = z459.object({
+  nonce: z459.number().int().nonnegative().meta({
     description: "Nonce value to force-set on the sender's nonce tracker",
     examples: [42]
   })
 });
-var TransactionForceNonceResultSchema = z456.object({
-  previous: z456.number().nullable().meta({ description: "Previous nonce value (null if uninitialized)" }),
-  new: z456.number().meta({ description: "New nonce value after force-set" })
+var TransactionForceNonceResultSchema = z459.object({
+  previous: z459.number().nullable().meta({ description: "Previous nonce value (null if uninitialized)" }),
+  new: z459.number().meta({ description: "New nonce value after force-set" })
 });
 var TransactionV2ForceNonceOutputSchema = createSingleResponse(TransactionForceNonceResultSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/transaction/transaction.v2.cancel.schema.ts
-import { z as z457 } from "zod";
-var TransactionV2CancelInputSchema = z457.object({
-  transactionId: z457.uuid().meta({
+import { z as z460 } from "zod";
+var TransactionV2CancelInputSchema = z460.object({
+  transactionId: z460.uuid().meta({
     description: "Queue transaction identifier (UUIDv7) to cancel",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   })
 });
-var TransactionCancelResultSchema = z457.object({
-  status: z457.enum(["cancelled", "cancellation_pending", "error"]).meta({
+var TransactionCancelResultSchema = z460.object({
+  status: z460.enum(["cancelled", "cancellation_pending", "error"]).meta({
     description: "Cancel result: 'cancelled' for immediate cancel, " + "'cancellation_pending' for post-broadcast RBF cancel, 'error' if cancel failed",
     examples: ["cancelled", "cancellation_pending"]
   }),
-  cancelTransactionId: z457.string().optional().meta({
+  cancelTransactionId: z460.string().optional().meta({
     description: "RBF replacement transaction ID when cancellation is pending on-chain"
   }),
-  message: z457.string().optional().meta({
+  message: z460.string().optional().meta({
     description: "Human-readable error or status message"
   })
 });
 var TransactionV2CancelOutputSchema = createSingleResponse(TransactionCancelResultSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/transaction/transaction.v2.list.schema.ts
-import { z as z458 } from "zod";
+import { z as z461 } from "zod";
 var TRANSACTION_COLLECTION_FIELDS = {
   status: enumField([...transactionRequestStates]),
   operationType: textField(),
@@ -31854,12 +31953,12 @@ var TransactionV2ListInputSchema = createCollectionInputSchema(TRANSACTION_COLLE
   defaultSort: "createdAt",
   globalSearch: true
 });
-var TransactionListItemSchema = z458.object({
-  transactionId: z458.uuid().meta({
+var TransactionListItemSchema = z461.object({
+  transactionId: z461.uuid().meta({
     description: "Queue transaction identifier (UUIDv7)",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   }),
-  kind: z458.string().meta({
+  kind: z461.string().meta({
     description: "Mutation kind submitted to the queue",
     examples: ["token.create", "token.mint"]
   }),
@@ -31867,19 +31966,19 @@ var TransactionListItemSchema = z458.object({
     description: "Current transaction queue state",
     examples: ["QUEUED", "COMPLETED", "FAILED"]
   }),
-  subStatus: z458.string().nullable().meta({
+  subStatus: z461.string().nullable().meta({
     description: "Optional queue sub-status with finer-grained detail",
     examples: ["TIMEOUT", null]
   }),
-  fromAddress: z458.string().meta({
+  fromAddress: z461.string().meta({
     description: "Sender wallet address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  chainId: z458.number().int().meta({
+  chainId: z461.number().int().meta({
     description: "Target chain ID",
     examples: [1]
   }),
-  transactionHash: z458.string().nullable().meta({
+  transactionHash: z461.string().nullable().meta({
     description: "Primary transaction hash once broadcast",
     examples: ["0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef", null]
   }),
@@ -31899,19 +31998,19 @@ var TransactionV2ReadInputSchema = TransactionReadInputSchema;
 var TransactionV2ReadOutputSchema = createSingleResponse(TransactionReadOutputSchema);
 
 // ../../packages/dalp/api-contract/src/routes/transaction/routes/transaction.status.schema.ts
-import { z as z459 } from "zod";
-var TransactionStatusInputSchema = z459.object({
-  transactionId: z459.uuid().meta({
+import { z as z462 } from "zod";
+var TransactionStatusInputSchema = z462.object({
+  transactionId: z462.uuid().meta({
     description: "Queue transaction identifier (UUIDv7)",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   })
 });
-var TransactionStatusOutputSchema = z459.object({
-  transactionId: z459.uuid().meta({
+var TransactionStatusOutputSchema = z462.object({
+  transactionId: z462.uuid().meta({
     description: "Queue transaction identifier (UUIDv7)",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   }),
-  kind: z459.string().meta({
+  kind: z462.string().meta({
     description: "Mutation kind submitted to the queue",
     examples: ["token.create", "token.mint"]
   }),
@@ -31919,23 +32018,23 @@ var TransactionStatusOutputSchema = z459.object({
     description: "Current transaction queue state",
     examples: ["QUEUED", "PREPARING", "CONFIRMING", "COMPLETED", "FAILED"]
   }),
-  subStatus: z459.string().nullable().meta({
+  subStatus: z462.string().nullable().meta({
     description: "Optional queue sub-status with finer-grained progress or failure detail",
     examples: ["TIMEOUT", "WORKFLOW_GRANTING_PERMISSIONS", null]
   }),
-  transactionHash: z459.string().nullable().meta({
+  transactionHash: z462.string().nullable().meta({
     description: "Primary transaction hash once broadcast",
     examples: ["0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef", null]
   }),
-  transactionHashes: z459.array(z459.string()).optional().meta({
+  transactionHashes: z462.array(z462.string()).optional().meta({
     description: "All transaction hashes for batch operations. Only present when the operation produced multiple transactions.",
     examples: [["0xabc...", "0xdef..."]]
   }),
-  blockNumber: z459.string().nullable().meta({
+  blockNumber: z462.string().nullable().meta({
     description: "Confirmed block number when available",
     examples: ["12345678", null]
   }),
-  errorMessage: z459.string().nullable().meta({
+  errorMessage: z462.string().nullable().meta({
     description: "Human-readable error or timeout detail when available",
     examples: ["Execution reverted", "Receipt not found after repeated checks", null]
   }),
@@ -32014,12 +32113,12 @@ var transactionV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/user/user.v2.contract.ts
-import { z as z465 } from "zod";
+import { z as z468 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/user/routes/user.read-by-national-id.schema.ts
-import { z as z460 } from "zod";
-var UserReadByNationalIdInputSchema = z460.object({
-  nationalId: z460.string().min(1).max(50).trim().meta({ description: "The national ID to look up (exact match against approved KYC)", examples: ["AB123456"] })
+import { z as z463 } from "zod";
+var UserReadByNationalIdInputSchema = z463.object({
+  nationalId: z463.string().min(1).max(50).trim().meta({ description: "The national ID to look up (exact match against approved KYC)", examples: ["AB123456"] })
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/user/user.v2.admin-list.schema.ts
@@ -32037,13 +32136,13 @@ var UserAdminListV2InputSchema = createCollectionInputSchema(USER_ADMIN_LIST_COL
 var UserAdminListV2OutputSchema = createPaginatedResponse(UserListItemSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/user/user.v2.assets.schema.ts
-import { z as z461 } from "zod";
-var TokenAssetV2Schema = z461.object({
+import { z as z464 } from "zod";
+var TokenAssetV2Schema = z464.object({
   id: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  name: z461.string().meta({
+  name: z464.string().meta({
     description: "The token name",
     examples: ["Bond Token", "Equity Share"]
   }),
@@ -32063,19 +32162,19 @@ var TokenAssetV2Schema = z461.object({
     description: "The total supply of the token (raw on-chain uint256)",
     examples: ["1000000000000000000000", "101000000000000000000000000"]
   }),
-  bond: z461.object({
-    isMatured: z461.boolean().meta({
+  bond: z464.object({
+    isMatured: z464.boolean().meta({
       description: "Whether the bond is matured",
       examples: [true, false]
     })
   }).optional().nullable().meta({ description: "The bond details", examples: [] }),
-  yield: z461.object({
-    schedule: z461.object({
+  yield: z464.object({
+    schedule: z464.object({
       id: ethereumAddress.meta({
         description: "The yield schedule contract address",
         examples: ["0x8ba1f109551bD432803012645Ac136ddd64DBA72"]
       }),
-      denominationAsset: z461.object({
+      denominationAsset: z464.object({
         id: ethereumAddress.meta({
           description: "The denomination asset contract address",
           examples: ["0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"]
@@ -32095,8 +32194,8 @@ var TokenAssetV2Schema = z461.object({
     }).nullable().meta({ description: "The yield schedule details", examples: [] })
   }).nullable().meta({ description: "The yield details", examples: [] })
 });
-var UserAssetBalanceV2ItemSchema = z461.object({
-  id: z461.uuid().meta({
+var UserAssetBalanceV2ItemSchema = z464.object({
+  id: z464.uuid().meta({
     description: "The balance record ID (idxr_token_balances.id, UUIDv7).",
     examples: ["019283bc-7e0a-7c3d-9b1f-3f4d2c5e6a7b"]
   }),
@@ -32116,7 +32215,7 @@ var UserAssetBalanceV2ItemSchema = z461.object({
     description: "Balance multiplied by the token's resolved price, expressed in the organization's base currency. Null when no FX/price path is available for the token.",
     examples: ["5.00", null]
   }),
-  priceInBaseCurrencyReliable: z461.boolean().meta({
+  priceInBaseCurrencyReliable: z464.boolean().meta({
     description: "Whether the FX chain used to populate the token's resolved base-currency price was fully reliable (all hops via active feeds). False when no price is available or when any hop fell back to a stale/backfilled rate.",
     examples: [true, false]
   }),
@@ -32168,10 +32267,10 @@ var UserV2ListInputSchema = createCollectionInputSchema(USERS_COLLECTION_FIELDS,
 var UserV2ListOutputSchema = createPaginatedResponse(UserListItemSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/user/kyc/kyc.v2.contract.ts
-import { z as z464 } from "zod";
+import { z as z467 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/user/kyc/kyc-profile-version-documents.v2.list.schema.ts
-import { z as z462 } from "zod";
+import { z as z465 } from "zod";
 var KYC_PROFILE_VERSION_DOCUMENTS_COLLECTION_FIELDS = {
   fileName: textField(),
   documentType: enumField(kycDocumentTypes, { facetable: true }),
@@ -32182,19 +32281,19 @@ var KYC_PROFILE_VERSION_DOCUMENTS_COLLECTION_FIELDS = {
 var KycProfileVersionDocumentsV2ListInputSchema = createCollectionInputSchema(KYC_PROFILE_VERSION_DOCUMENTS_COLLECTION_FIELDS, {
   defaultSort: "uploadedAt"
 });
-var KycProfileVersionDocumentsV2ListItemSchema = z462.object({
-  id: z462.string(),
+var KycProfileVersionDocumentsV2ListItemSchema = z465.object({
+  id: z465.string(),
   documentType: kycDocumentType(),
-  fileName: z462.string(),
-  fileSize: z462.number(),
-  mimeType: z462.string(),
+  fileName: z465.string(),
+  fileSize: z465.number(),
+  mimeType: z465.string(),
   uploadedAt: timestamp(),
-  uploadedBy: z462.string().nullable()
+  uploadedBy: z465.string().nullable()
 });
 var KycProfileVersionDocumentsV2ListOutputSchema = createPaginatedResponse(KycProfileVersionDocumentsV2ListItemSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/user/kyc/kyc-profile-versions.v2.list.schema.ts
-import { z as z463 } from "zod";
+import { z as z466 } from "zod";
 var KYC_VERSION_STATUSES = ["draft", "submitted", "under_review", "approved", "rejected"];
 var KYC_REVIEW_OUTCOMES = ["approved", "rejected", "changes_requested"];
 var KYC_PROFILE_VERSIONS_COLLECTION_FIELDS = {
@@ -32207,21 +32306,21 @@ var KYC_PROFILE_VERSIONS_COLLECTION_FIELDS = {
 var KycProfileVersionsV2ListInputSchema = createCollectionInputSchema(KYC_PROFILE_VERSIONS_COLLECTION_FIELDS, {
   defaultSort: "versionNumber"
 });
-var KycProfileVersionsV2ListItemSchema = z463.object({
-  id: z463.string(),
-  versionNumber: z463.number(),
+var KycProfileVersionsV2ListItemSchema = z466.object({
+  id: z466.string(),
+  versionNumber: z466.number(),
   status: kycVersionStatus(),
   createdAt: timestamp(),
-  createdBy: z463.string().nullable(),
+  createdBy: z466.string().nullable(),
   submittedAt: timestamp().nullable(),
-  submittedBy: z463.string().nullable(),
+  submittedBy: z466.string().nullable(),
   reviewedAt: timestamp().nullable(),
-  reviewedBy: z463.string().nullable(),
-  reviewOutcome: z463.enum(KYC_REVIEW_OUTCOMES).nullable(),
-  isDraft: z463.boolean(),
-  isUnderReview: z463.boolean(),
-  isApproved: z463.boolean(),
-  isCurrent: z463.boolean()
+  reviewedBy: z466.string().nullable(),
+  reviewOutcome: z466.enum(KYC_REVIEW_OUTCOMES).nullable(),
+  isDraft: z466.boolean(),
+  isUnderReview: z466.boolean(),
+  isApproved: z466.boolean(),
+  isCurrent: z466.boolean()
 });
 var KycProfileVersionsV2ListOutputSchema = createPaginatedResponse(KycProfileVersionsV2ListItemSchema);
 
@@ -32239,14 +32338,14 @@ var versionsList = v2Contract.route({
   description: "List KYC profile versions for a user with pagination, sorting, and filtering. Sortable by versionNumber, status, createdAt, submittedAt, reviewedAt.",
   successDescription: "Paginated array of KYC profile versions with total count and faceted filter values.",
   tags: [V2_TAG.userKyc]
-}).input(v2Input.paramsQuery(z464.object({ userId: z464.string().min(1) }), KycProfileVersionsV2ListInputSchema)).output(KycProfileVersionsV2ListOutputSchema);
+}).input(v2Input.paramsQuery(z467.object({ userId: z467.string().min(1) }), KycProfileVersionsV2ListInputSchema)).output(KycProfileVersionsV2ListOutputSchema);
 var versionsCreate = v2Contract.route({
   method: "POST",
   path: "/kyc-profiles/{userId}/versions",
   description: "Create a new draft KYC profile version, optionally cloning from an existing version.",
   successDescription: "KYC profile version created successfully.",
   tags: [V2_TAG.userKyc]
-}).input(v2Input.paramsBody(z464.object({ userId: KycProfileVersionsCreateInputSchema.shape.userId }), KycProfileVersionsCreateInputSchema.omit({ userId: true }))).output(createSingleResponse(KycProfileVersionsCreateOutputSchema));
+}).input(v2Input.paramsBody(z467.object({ userId: KycProfileVersionsCreateInputSchema.shape.userId }), KycProfileVersionsCreateInputSchema.omit({ userId: true }))).output(createSingleResponse(KycProfileVersionsCreateOutputSchema));
 var versionRead = v2Contract.route({
   method: "GET",
   path: "/kyc-profile-versions/{versionId}",
@@ -32260,7 +32359,7 @@ var versionUpdate = v2Contract.route({
   description: "Update fields on a draft KYC profile version. Only draft versions can be edited.",
   successDescription: "KYC profile version updated successfully.",
   tags: [V2_TAG.userKyc]
-}).input(v2Input.paramsBody(z464.object({ versionId: KycProfileVersionUpdateInputSchema.shape.versionId }), KycProfileVersionUpdateInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionUpdateOutputSchema));
+}).input(v2Input.paramsBody(z467.object({ versionId: KycProfileVersionUpdateInputSchema.shape.versionId }), KycProfileVersionUpdateInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionUpdateOutputSchema));
 var versionSubmit = v2Contract.route({
   method: "POST",
   path: "/kyc-profile-versions/{versionId}/submissions",
@@ -32274,28 +32373,28 @@ var versionApprove = v2Contract.route({
   description: "Approve a KYC profile version that is under review. Requires KYC_REVIEWER role.",
   successDescription: "KYC profile version approved.",
   tags: [V2_TAG.userKyc]
-}).input(v2Input.paramsBody(z464.object({ versionId: KycProfileVersionApproveInputSchema.shape.versionId }), KycProfileVersionApproveInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionApproveOutputSchema));
+}).input(v2Input.paramsBody(z467.object({ versionId: KycProfileVersionApproveInputSchema.shape.versionId }), KycProfileVersionApproveInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionApproveOutputSchema));
 var versionReject = v2Contract.route({
   method: "POST",
   path: "/kyc-profile-versions/{versionId}/rejections",
   description: "Reject a KYC profile version that is under review. Requires KYC_REVIEWER role.",
   successDescription: "KYC profile version rejected.",
   tags: [V2_TAG.userKyc]
-}).input(v2Input.paramsBody(z464.object({ versionId: KycProfileVersionRejectInputSchema.shape.versionId }), KycProfileVersionRejectInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionRejectOutputSchema));
+}).input(v2Input.paramsBody(z467.object({ versionId: KycProfileVersionRejectInputSchema.shape.versionId }), KycProfileVersionRejectInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionRejectOutputSchema));
 var versionRequestUpdate = v2Contract.route({
   method: "POST",
   path: "/kyc-profile-versions/{versionId}/update-requests",
   description: "Request changes on a KYC version under review. Creates an action request for the user.",
   successDescription: "Update request created successfully.",
   tags: [V2_TAG.userKyc]
-}).input(v2Input.paramsBody(z464.object({ versionId: KycProfileVersionRequestUpdateInputSchema.shape.versionId }), KycProfileVersionRequestUpdateInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionRequestUpdateOutputSchema));
+}).input(v2Input.paramsBody(z467.object({ versionId: KycProfileVersionRequestUpdateInputSchema.shape.versionId }), KycProfileVersionRequestUpdateInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionRequestUpdateOutputSchema));
 var documentsList = v2Contract.route({
   method: "GET",
   path: "/kyc-profile-versions/{versionId}/documents",
   description: "List documents attached to a KYC profile version with pagination, sorting, and filtering. Sortable by fileName, documentType, fileSize, uploadedAt.",
   successDescription: "Paginated array of KYC documents with total count and faceted filter values.",
   tags: [V2_TAG.userKyc]
-}).input(v2Input.paramsQuery(z464.object({ versionId: z464.string().min(1) }), KycProfileVersionDocumentsV2ListInputSchema)).output(KycProfileVersionDocumentsV2ListOutputSchema);
+}).input(v2Input.paramsQuery(z467.object({ versionId: z467.string().min(1) }), KycProfileVersionDocumentsV2ListInputSchema)).output(KycProfileVersionDocumentsV2ListOutputSchema);
 var documentsDelete = v2Contract.route({
   method: "DELETE",
   path: "/kyc-profile-versions/{versionId}/documents/{documentId}",
@@ -32309,7 +32408,7 @@ var documentsConfirmUpload = v2Contract.route({
   description: "Upload a KYC document through DAPI so the payload is encrypted before object storage.",
   successDescription: "Document uploaded successfully.",
   tags: [V2_TAG.userKyc]
-}).input(v2Input.paramsBody(z464.object({ versionId: KycProfileVersionDocumentConfirmUploadV2InputSchema.shape.versionId }), KycProfileVersionDocumentConfirmUploadV2InputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionDocumentConfirmUploadOutputSchema));
+}).input(v2Input.paramsBody(z467.object({ versionId: KycProfileVersionDocumentConfirmUploadV2InputSchema.shape.versionId }), KycProfileVersionDocumentConfirmUploadV2InputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionDocumentConfirmUploadOutputSchema));
 var documentsGetDownloadUrl = v2Contract.route({
   method: "POST",
   path: "/kyc-profile-versions/{versionId}/documents/{documentId}/downloads",
@@ -32386,14 +32485,14 @@ var readByUserId2 = v2Contract.route({
   description: "Read a single user by their internal database ID.",
   successDescription: "User retrieved successfully.",
   tags: [V2_TAG.user]
-}).input(v2Input.params(z465.object({ userId: z465.string() }))).output(createSingleResponse(UserReadOutputSchema));
+}).input(v2Input.params(z468.object({ userId: z468.string() }))).output(createSingleResponse(UserReadOutputSchema));
 var readByWallet3 = v2Contract.route({
   method: "GET",
   path: "/wallets/{wallet}/user",
   description: "Read a single user by their Ethereum wallet address.",
   successDescription: "User retrieved successfully.",
   tags: [V2_TAG.user]
-}).input(v2Input.params(z465.object({ wallet: ethereumAddress }))).output(createSingleResponse(UserReadOutputSchema));
+}).input(v2Input.params(z468.object({ wallet: ethereumAddress }))).output(createSingleResponse(UserReadOutputSchema));
 var readByNationalId = v2Contract.route({
   method: "GET",
   path: "/national-ids/{nationalId}/user",
@@ -32502,30 +32601,30 @@ var userV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.chain-of-custody.schema.ts
-import { z as z466 } from "zod";
-var WebhooksV2ChainOfCustodyInputSchema = z466.object({
-  evtId: z466.string().trim().min(1)
-});
-var WebhooksV2ChainOfCustodyOutputSchema = createSingleResponse(z466.object({
-  evtId: z466.string(),
-  hops: z466.array(z466.object({
-    stage: z466.string(),
-    contentHash: z466.string(),
-    signedBy: z466.string().optional(),
-    recordedAt: z466.coerce.date()
+import { z as z469 } from "zod";
+var WebhooksV2ChainOfCustodyInputSchema = z469.object({
+  evtId: z469.string().trim().min(1)
+});
+var WebhooksV2ChainOfCustodyOutputSchema = createSingleResponse(z469.object({
+  evtId: z469.string(),
+  hops: z469.array(z469.object({
+    stage: z469.string(),
+    contentHash: z469.string(),
+    signedBy: z469.string().optional(),
+    recordedAt: z469.coerce.date()
   })),
-  merkleRoot: z466.string(),
-  platformSignature: z466.string()
+  merkleRoot: z469.string(),
+  platformSignature: z469.string()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.create.schema.ts
-import { z as z468 } from "zod";
+import { z as z471 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.list.schema.ts
-import { z as z467 } from "zod";
-var WebhookPayloadShapeSchema = z467.enum(["thin", "fat"]);
-var WebhookBreakerStateSchema = z467.enum(["closed", "half_open", "open"]);
-var WebhookDeliveryFailureClassSchema = z467.enum([
+import { z as z470 } from "zod";
+var WebhookPayloadShapeSchema = z470.enum(["thin", "fat"]);
+var WebhookBreakerStateSchema = z470.enum(["closed", "half_open", "open"]);
+var WebhookDeliveryFailureClassSchema = z470.enum([
   "DNS_FAIL",
   "TLS_FAIL",
   "CONNECT_TIMEOUT",
@@ -32537,35 +32636,35 @@ var WebhookDeliveryFailureClassSchema = z467.enum([
   "RECEIPT_INVALID_SIG",
   "RECEIPT_HASH_MISMATCH"
 ]);
-var WebhookFinalityStateSchema = z467.enum(["pending", "provisional", "final", "retracted", "recalled"]);
-var WebhookSigningSecretStatusSchema = z467.enum(["active", "previous", "revoked"]);
-var WebhookFatEventsAcknowledgmentSchema = z467.object({
-  acknowledgedAt: z467.coerce.date(),
-  acknowledgedByUserId: z467.string(),
-  fieldsAcknowledged: z467.array(z467.string())
-});
-var WebhookEndpointSchema = z467.object({
-  id: z467.uuid(),
-  tenantId: z467.string(),
-  systemId: z467.string(),
-  url: z467.url(),
-  displayName: z467.string().nullable(),
-  subscriptions: z467.array(z467.string()),
+var WebhookFinalityStateSchema = z470.enum(["pending", "provisional", "final", "retracted", "recalled"]);
+var WebhookSigningSecretStatusSchema = z470.enum(["active", "previous", "revoked"]);
+var WebhookFatEventsAcknowledgmentSchema = z470.object({
+  acknowledgedAt: z470.coerce.date(),
+  acknowledgedByUserId: z470.string(),
+  fieldsAcknowledged: z470.array(z470.string())
+});
+var WebhookEndpointSchema = z470.object({
+  id: z470.uuid(),
+  tenantId: z470.string(),
+  systemId: z470.string(),
+  url: z470.url(),
+  displayName: z470.string().nullable(),
+  subscriptions: z470.array(z470.string()),
   defaultPayloadShape: WebhookPayloadShapeSchema,
-  counterSignedReceipts: z467.boolean(),
+  counterSignedReceipts: z470.boolean(),
   breakerState: WebhookBreakerStateSchema,
-  disabledAt: z467.coerce.date().nullable(),
-  disabledReason: z467.string().nullable(),
+  disabledAt: z470.coerce.date().nullable(),
+  disabledReason: z470.string().nullable(),
   fatEventsAcknowledgment: WebhookFatEventsAcknowledgmentSchema.nullable(),
-  secret: z467.object({
-    activeVersion: z467.number().int().positive().nullable(),
-    previousVersion: z467.number().int().positive().nullable(),
-    previousRevokesAt: z467.coerce.date().nullable(),
-    lastUsedAt: z467.coerce.date().nullable()
+  secret: z470.object({
+    activeVersion: z470.number().int().positive().nullable(),
+    previousVersion: z470.number().int().positive().nullable(),
+    previousRevokesAt: z470.coerce.date().nullable(),
+    lastUsedAt: z470.coerce.date().nullable()
   }),
-  createdAt: z467.coerce.date(),
-  updatedAt: z467.coerce.date(),
-  createdByUserId: z467.string().nullable()
+  createdAt: z470.coerce.date(),
+  updatedAt: z470.coerce.date(),
+  createdByUserId: z470.string().nullable()
 });
 var WEBHOOKS_COLLECTION_FIELDS = {
   displayName: textField(),
@@ -32584,44 +32683,44 @@ var WebhooksV2ListInputSchema = createCollectionInputSchema(WEBHOOKS_COLLECTION_
 var WebhooksV2ListOutputSchema = createPaginatedResponse(WebhookEndpointSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.create.schema.ts
-var WebhooksV2CreateInputSchema = z468.object({
-  url: z468.url(),
-  displayName: z468.string().trim().min(1).max(200).optional(),
-  subscriptions: z468.array(z468.string().trim().min(1)).min(1).default(["*.final", "*.retracted", "*.recalled"]),
+var WebhooksV2CreateInputSchema = z471.object({
+  url: z471.url(),
+  displayName: z471.string().trim().min(1).max(200).optional(),
+  subscriptions: z471.array(z471.string().trim().min(1)).min(1).default(["*.final", "*.retracted", "*.recalled"]),
   defaultPayloadShape: WebhookPayloadShapeSchema.default("thin"),
-  counterSignedReceipts: z468.boolean().default(false)
+  counterSignedReceipts: z471.boolean().default(false)
 });
 var WebhookEndpointCreateResultSchema = WebhookEndpointSchema.extend({
-  signingSecret: z468.string().nullable()
+  signingSecret: z471.string().nullable()
 });
 var WebhooksV2CreateOutputSchema = createSingleResponse(WebhookEndpointCreateResultSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.delete.schema.ts
-import { z as z469 } from "zod";
-var WebhooksV2DeleteInputSchema = z469.object({
-  id: z469.uuid()
+import { z as z472 } from "zod";
+var WebhooksV2DeleteInputSchema = z472.object({
+  id: z472.uuid()
 });
 var WebhooksV2DeleteOutputSchema = DeleteResponseSchema;
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.deliveries.list.schema.ts
-import { z as z470 } from "zod";
-var WebhookDeliveryStatusSchema = z470.enum(["pending", "delivered", "failed"]);
-var WebhookDeliverySchema = z470.object({
-  id: z470.uuid(),
-  eventOutboxId: z470.uuid(),
-  endpointId: z470.uuid(),
-  tenantId: z470.string(),
-  evtId: z470.string(),
-  eventType: z470.string(),
-  attemptN: z470.number().int().nonnegative(),
-  attemptedAt: z470.coerce.date(),
-  responseStatus: z470.number().int().nullable(),
+import { z as z473 } from "zod";
+var WebhookDeliveryStatusSchema = z473.enum(["pending", "delivered", "failed"]);
+var WebhookDeliverySchema = z473.object({
+  id: z473.uuid(),
+  eventOutboxId: z473.uuid(),
+  endpointId: z473.uuid(),
+  tenantId: z473.string(),
+  evtId: z473.string(),
+  eventType: z473.string(),
+  attemptN: z473.number().int().nonnegative(),
+  attemptedAt: z473.coerce.date(),
+  responseStatus: z473.number().int().nullable(),
   failureClass: WebhookDeliveryFailureClassSchema.nullable(),
   status: WebhookDeliveryStatusSchema,
-  deliveredAt: z470.coerce.date().nullable(),
-  isReplay: z470.boolean(),
-  isTest: z470.boolean(),
-  traceId: z470.string().nullable()
+  deliveredAt: z473.coerce.date().nullable(),
+  isReplay: z473.boolean(),
+  isTest: z473.boolean(),
+  traceId: z473.string().nullable()
 });
 var WEBHOOK_DELIVERIES_COLLECTION_FIELDS = {
   status: enumField(["pending", "delivered", "failed"]),
@@ -32647,167 +32746,167 @@ var WebhooksV2DeliveriesListInputSchema = createCollectionInputSchema(WEBHOOK_DE
   defaultSort: "attemptedAt",
   globalSearch: false
 });
-var WebhooksV2DeliveriesListParamsSchema = z470.object({
-  id: z470.uuid()
+var WebhooksV2DeliveriesListParamsSchema = z473.object({
+  id: z473.uuid()
 });
 var WebhooksV2DeliveriesListOutputSchema = createPaginatedResponse(WebhookDeliverySchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.deliveries.read.schema.ts
-import { z as z471 } from "zod";
-var WebhooksV2DeliveriesReadInputSchema = z471.object({
-  id: z471.uuid(),
-  deliveryId: z471.uuid()
+import { z as z474 } from "zod";
+var WebhooksV2DeliveriesReadInputSchema = z474.object({
+  id: z474.uuid(),
+  deliveryId: z474.uuid()
 });
 var WebhookDeliveryDetailSchema = WebhookDeliverySchema.extend({
-  request: z471.object({
-    payload: z471.record(z471.string(), z471.json()),
-    signedHeaders: z471.record(z471.string(), z471.union([z471.string(), z471.array(z471.string())])),
-    signedStringPreview: z471.string()
+  request: z474.object({
+    payload: z474.record(z474.string(), z474.json()),
+    signedHeaders: z474.record(z474.string(), z474.union([z474.string(), z474.array(z474.string())])),
+    signedStringPreview: z474.string()
   }),
-  response: z471.object({
-    headers: z471.record(z471.string(), z471.union([z471.string(), z471.array(z471.string())])).nullable(),
-    body: z471.string().nullable(),
-    timings: z471.object({
-      dnsMs: z471.number().int().nullable(),
-      tlsMs: z471.number().int().nullable(),
-      connectMs: z471.number().int().nullable(),
-      ttfbMs: z471.number().int().nullable()
+  response: z474.object({
+    headers: z474.record(z474.string(), z474.union([z474.string(), z474.array(z474.string())])).nullable(),
+    body: z474.string().nullable(),
+    timings: z474.object({
+      dnsMs: z474.number().int().nullable(),
+      tlsMs: z474.number().int().nullable(),
+      connectMs: z474.number().int().nullable(),
+      ttfbMs: z474.number().int().nullable()
     })
   })
 });
 var WebhooksV2DeliveriesReadOutputSchema = createSingleResponse(WebhookDeliveryDetailSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.deliveries.retry.schema.ts
-import { z as z472 } from "zod";
-var WebhooksV2DeliveriesRetryInputSchema = z472.object({
-  id: z472.uuid(),
-  deliveryId: z472.uuid()
+import { z as z475 } from "zod";
+var WebhooksV2DeliveriesRetryInputSchema = z475.object({
+  id: z475.uuid(),
+  deliveryId: z475.uuid()
 });
-var WebhooksV2DeliveriesRetryOutputSchema = createSingleResponse(z472.object({
-  deliveryId: z472.uuid(),
-  scheduled: z472.boolean()
+var WebhooksV2DeliveriesRetryOutputSchema = createSingleResponse(z475.object({
+  deliveryId: z475.uuid(),
+  scheduled: z475.boolean()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.read.schema.ts
-import { z as z473 } from "zod";
-var WebhooksV2ReadInputSchema = z473.object({
-  id: z473.uuid()
+import { z as z476 } from "zod";
+var WebhooksV2ReadInputSchema = z476.object({
+  id: z476.uuid()
 });
 var WebhooksV2ReadOutputSchema = createSingleResponse(WebhookEndpointSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.recalls.schema.ts
-import { z as z474 } from "zod";
-var WebhooksV2RecallsParamsSchema = z474.object({
-  evtId: z474.string().trim().min(1)
-});
-var WebhooksV2RecallsBodySchema = z474.object({
-  reason: z474.string().trim().min(1).max(2000)
-});
-var WebhooksV2RecallsOutputSchema = createSingleResponse(z474.object({
-  evtId: z474.string(),
-  recalledEvtId: z474.string(),
-  supersedes: z474.string(),
-  reason: z474.string(),
-  recalledByUserId: z474.string()
+import { z as z477 } from "zod";
+var WebhooksV2RecallsParamsSchema = z477.object({
+  evtId: z477.string().trim().min(1)
+});
+var WebhooksV2RecallsBodySchema = z477.object({
+  reason: z477.string().trim().min(1).max(2000)
+});
+var WebhooksV2RecallsOutputSchema = createSingleResponse(z477.object({
+  evtId: z477.string(),
+  recalledEvtId: z477.string(),
+  supersedes: z477.string(),
+  reason: z477.string(),
+  recalledByUserId: z477.string()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.replays.schema.ts
-import { z as z475 } from "zod";
-var WebhooksV2ReplayByRangeSchema = z475.object({
-  fromBlock: z475.coerce.bigint(),
-  toBlock: z475.coerce.bigint().optional(),
-  chainId: z475.coerce.number().int().positive(),
-  confirmLargeRange: z475.boolean().default(false)
-});
-var WebhooksV2ReplayByEventSchema = z475.object({
-  evtId: z475.string().trim().min(1),
-  chainId: z475.coerce.number().int().positive().optional()
-});
-var WebhooksV2ReplaysParamsSchema = z475.object({
-  id: z475.uuid()
-});
-var WebhooksV2ReplaysBodySchema = z475.union([WebhooksV2ReplayByRangeSchema, WebhooksV2ReplayByEventSchema]);
-var WebhooksV2ReplaysOutputSchema = createSingleResponse(z475.object({
-  replayId: z475.uuid(),
-  endpointId: z475.uuid(),
-  eventsEnqueued: z475.number().int().nonnegative(),
-  snapshotToBlock: z475.string().nullable()
+import { z as z478 } from "zod";
+var WebhooksV2ReplayByRangeSchema = z478.object({
+  fromBlock: z478.coerce.bigint(),
+  toBlock: z478.coerce.bigint().optional(),
+  chainId: z478.coerce.number().int().positive(),
+  confirmLargeRange: z478.boolean().default(false)
+});
+var WebhooksV2ReplayByEventSchema = z478.object({
+  evtId: z478.string().trim().min(1),
+  chainId: z478.coerce.number().int().positive().optional()
+});
+var WebhooksV2ReplaysParamsSchema = z478.object({
+  id: z478.uuid()
+});
+var WebhooksV2ReplaysBodySchema = z478.union([WebhooksV2ReplayByRangeSchema, WebhooksV2ReplayByEventSchema]);
+var WebhooksV2ReplaysOutputSchema = createSingleResponse(z478.object({
+  replayId: z478.uuid(),
+  endpointId: z478.uuid(),
+  eventsEnqueued: z478.number().int().nonnegative(),
+  snapshotToBlock: z478.string().nullable()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.revoke-secret.schema.ts
-import { z as z476 } from "zod";
-var WebhooksV2RevokeSecretInputSchema = z476.object({
-  id: z476.uuid()
+import { z as z479 } from "zod";
+var WebhooksV2RevokeSecretInputSchema = z479.object({
+  id: z479.uuid()
 });
-var WebhooksV2RevokeSecretOutputSchema = createSingleResponse(z476.object({
-  endpointId: z476.uuid(),
-  activeVersion: z476.number().int().positive(),
-  previousVersion: z476.number().int().positive().nullable(),
-  revokedVersion: z476.number().int().positive()
+var WebhooksV2RevokeSecretOutputSchema = createSingleResponse(z479.object({
+  endpointId: z479.uuid(),
+  activeVersion: z479.number().int().positive(),
+  previousVersion: z479.number().int().positive().nullable(),
+  revokedVersion: z479.number().int().positive()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.rotate-secret.schema.ts
-import { z as z477 } from "zod";
-var WebhooksV2RotateSecretInputSchema = z477.object({
-  id: z477.uuid()
-});
-var WebhooksV2RotateSecretOutputSchema = createSingleResponse(z477.object({
-  endpointId: z477.uuid(),
-  activeVersion: z477.number().int().positive(),
-  previousVersion: z477.number().int().positive().nullable(),
-  previousRevokesAt: z477.coerce.date().nullable(),
-  signingSecret: z477.string().nullable()
+import { z as z480 } from "zod";
+var WebhooksV2RotateSecretInputSchema = z480.object({
+  id: z480.uuid()
+});
+var WebhooksV2RotateSecretOutputSchema = createSingleResponse(z480.object({
+  endpointId: z480.uuid(),
+  activeVersion: z480.number().int().positive(),
+  previousVersion: z480.number().int().positive().nullable(),
+  previousRevokesAt: z480.coerce.date().nullable(),
+  signingSecret: z480.string().nullable()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.stats.schema.ts
-import { z as z478 } from "zod";
-var WebhooksV2StatsInputSchema = z478.object({
-  endpointId: z478.uuid().optional()
+import { z as z481 } from "zod";
+var WebhooksV2StatsInputSchema = z481.object({
+  endpointId: z481.uuid().optional()
 });
-var WebhooksV2StatsOutputDataSchema = z478.object({
-  totalDeliveries: z478.number().int().min(0),
-  delivered: z478.number().int().min(0),
-  failed: z478.number().int().min(0),
-  hourlyBuckets: z478.array(z478.number().int().min(0)).length(24)
+var WebhooksV2StatsOutputDataSchema = z481.object({
+  totalDeliveries: z481.number().int().min(0),
+  delivered: z481.number().int().min(0),
+  failed: z481.number().int().min(0),
+  hourlyBuckets: z481.array(z481.number().int().min(0)).length(24)
 });
 var WebhooksV2StatsOutputSchema = createSingleResponse(WebhooksV2StatsOutputDataSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.test-event.schema.ts
-import { z as z479 } from "zod";
-var WebhooksV2TestEventParamsSchema = z479.object({
-  id: z479.uuid()
+import { z as z482 } from "zod";
+var WebhooksV2TestEventParamsSchema = z482.object({
+  id: z482.uuid()
 });
-var WebhooksV2TestEventBodySchema = z479.object({
-  eventType: z479.string().trim().min(1).default("webhook.test.final")
+var WebhooksV2TestEventBodySchema = z482.object({
+  eventType: z482.string().trim().min(1).default("webhook.test.final")
 });
-var WebhooksV2TestEventOutputSchema = createSingleResponse(z479.object({
-  evtId: z479.string(),
-  deliveryId: z479.uuid().nullable(),
-  isTest: z479.literal(true)
+var WebhooksV2TestEventOutputSchema = createSingleResponse(z482.object({
+  evtId: z482.string(),
+  deliveryId: z482.uuid().nullable(),
+  isTest: z482.literal(true)
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.update.schema.ts
-import { z as z480 } from "zod";
-var WebhooksV2UpdateParamsSchema = z480.object({
-  id: z480.uuid()
+import { z as z483 } from "zod";
+var WebhooksV2UpdateParamsSchema = z483.object({
+  id: z483.uuid()
 });
-var WebhooksV2UpdateBodySchema = z480.object({
-  url: z480.url().optional(),
-  displayName: z480.string().trim().min(1).max(200).nullable().optional(),
-  subscriptions: z480.array(z480.string().trim().min(1)).min(1).optional(),
+var WebhooksV2UpdateBodySchema = z483.object({
+  url: z483.url().optional(),
+  displayName: z483.string().trim().min(1).max(200).nullable().optional(),
+  subscriptions: z483.array(z483.string().trim().min(1)).min(1).optional(),
   defaultPayloadShape: WebhookPayloadShapeSchema.optional(),
-  counterSignedReceipts: z480.boolean().optional(),
-  disabled: z480.boolean().optional(),
-  disabledReason: z480.string().trim().min(1).max(500).nullable().optional(),
+  counterSignedReceipts: z483.boolean().optional(),
+  disabled: z483.boolean().optional(),
+  disabledReason: z483.string().trim().min(1).max(500).nullable().optional(),
   fatEventsAcknowledgment: WebhookFatEventsAcknowledgmentSchema.omit({
     acknowledgedAt: true,
     acknowledgedByUserId: true
   }).optional()
 });
-var WebhooksV2UpdateQuerySchema = z480.object({
-  acknowledgePending: z480.union([z480.literal("true"), z480.literal(true)]).transform(() => true).optional()
+var WebhooksV2UpdateQuerySchema = z483.object({
+  acknowledgePending: z483.union([z483.literal("true"), z483.literal(true)]).transform(() => true).optional()
 }).optional();
-var WebhooksV2UpdateInputSchema = z480.object({
+var WebhooksV2UpdateInputSchema = z483.object({
   params: WebhooksV2UpdateParamsSchema,
   body: WebhooksV2UpdateBodySchema,
   query: WebhooksV2UpdateQuerySchema
@@ -32942,21 +33041,21 @@ var webhooksV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhook-receipts/webhook-receipts.v2.create.schema.ts
-import { z as z482 } from "zod";
+import { z as z485 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhook-receipts/webhook-receipts.v2.list.schema.ts
-import { z as z481 } from "zod";
-var WebhookReceiptVerificationFailureClassSchema = z481.enum(["RECEIPT_INVALID_SIG", "RECEIPT_HASH_MISMATCH"]);
-var WebhookReceiptSchema = z481.object({
-  id: z481.uuid(),
-  deliveryId: z481.uuid(),
-  evtId: z481.string(),
-  tenantId: z481.string(),
-  endpointId: z481.uuid(),
-  consumerSignature: z481.string(),
-  innerEventHash: z481.string(),
-  receivedAt: z481.coerce.date(),
-  verifiedAt: z481.coerce.date().nullable(),
+import { z as z484 } from "zod";
+var WebhookReceiptVerificationFailureClassSchema = z484.enum(["RECEIPT_INVALID_SIG", "RECEIPT_HASH_MISMATCH"]);
+var WebhookReceiptSchema = z484.object({
+  id: z484.uuid(),
+  deliveryId: z484.uuid(),
+  evtId: z484.string(),
+  tenantId: z484.string(),
+  endpointId: z484.uuid(),
+  consumerSignature: z484.string(),
+  innerEventHash: z484.string(),
+  receivedAt: z484.coerce.date(),
+  verifiedAt: z484.coerce.date().nullable(),
   verificationFailureClass: WebhookReceiptVerificationFailureClassSchema.nullable()
 });
 var WEBHOOK_RECEIPTS_COLLECTION_FIELDS = {
@@ -32973,19 +33072,19 @@ var WebhookReceiptsV2ListInputSchema = createCollectionInputSchema(WEBHOOK_RECEI
 var WebhookReceiptsV2ListOutputSchema = createPaginatedResponse(WebhookReceiptSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhook-receipts/webhook-receipts.v2.create.schema.ts
-var WebhookReceiptsV2CreateInputSchema = z482.object({
-  deliveryId: z482.uuid(),
-  evtId: z482.string().trim().min(1),
-  endpointId: z482.uuid(),
-  consumerSignature: z482.string().trim().min(1),
-  innerEventHash: z482.string().trim().min(1)
+var WebhookReceiptsV2CreateInputSchema = z485.object({
+  deliveryId: z485.uuid(),
+  evtId: z485.string().trim().min(1),
+  endpointId: z485.uuid(),
+  consumerSignature: z485.string().trim().min(1),
+  innerEventHash: z485.string().trim().min(1)
 });
 var WebhookReceiptsV2CreateOutputSchema = createSingleResponse(WebhookReceiptSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhook-receipts/webhook-receipts.v2.read.schema.ts
-import { z as z483 } from "zod";
-var WebhookReceiptsV2ReadInputSchema = z483.object({
-  id: z483.uuid()
+import { z as z486 } from "zod";
+var WebhookReceiptsV2ReadInputSchema = z486.object({
+  id: z486.uuid()
 });
 var WebhookReceiptsV2ReadOutputSchema = createSingleResponse(WebhookReceiptSchema);
 
@@ -33267,7 +33366,7 @@ function normalizeDalpBaseUrl(url) {
 // package.json
 var package_default = {
   name: "@settlemint/dalp-sdk",
-  version: "2.1.7-main.26370298202",
+  version: "2.1.7-main.26370663399",
   private: false,
   description: "Fully typed SDK for the DALP tokenization platform API",
   homepage: "https://settlemint.com",