@settlemint/dalp-sdk 2.1.7-main.25736341678 → 2.1.7-main.25738823940

package/dist/index.js

@@ -27738,7 +27738,7 @@ var tokenV2MutationsContract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.reads.contract.ts
-import { z as z408 } from "zod";
+import { z as z410 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/token/routes/token.features.schema.ts
 import { z as z398 } from "zod";
@@ -28061,23 +28061,49 @@ var TokenFeaturesResponseSchema = z398.object({
   })
 });
 
-// ../../packages/dalp/api-contract/src/routes/token/routes/token.metadata.schema.ts
+// ../../packages/dalp/api-contract/src/routes/token/routes/token.aum-fee-accrued-estimate.schema.ts
 import { z as z399 } from "zod";
+var TokenAumFeeAccruedEstimateInputSchema = TokenReadInputSchema;
+var TokenAumFeeAccruedEstimateResponseSchema = z399.object({
+  accruedEstimate: bigDecimal().meta({
+    description: "Current accrued AUM fee (token units, scaled by token decimals) — authoritative chain read via getAccruedFees().",
+    examples: ["10.50"]
+  }),
+  feeBps: feeRateBps().meta({
+    description: "Annual AUM fee rate in basis points (1 bps = 0.01%, max 10 000 = 100%).",
+    examples: [200]
+  }),
+  lastCollectionTime: timestamp().meta({
+    description: "When the AUM fee was last collected on-chain. Read via the same multicall as accruedEstimate so the two cannot disagree.",
+    examples: ["2024-11-14T22:13:20Z"]
+  }),
+  measuredAt: timestamp().meta({
+    description: "Server wall-clock timestamp captured immediately after the chain read. Used by clients to extrapolate.",
+    examples: ["2024-11-14T22:13:25Z"]
+  }),
+  featureAddress: ethereumAddress.meta({
+    description: "AUM-fee feature contract address that was read.",
+    examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
+  })
+}).nullable();
+
+// ../../packages/dalp/api-contract/src/routes/token/routes/token.metadata.schema.ts
+import { z as z400 } from "zod";
 var TokenMetadataInputSchema = TokenReadInputSchema;
-var TokenMetadataEntrySchema = z399.object({
-  key: z399.string().meta({
+var TokenMetadataEntrySchema = z400.object({
+  key: z400.string().meta({
     description: "Human-readable metadata key string",
     examples: ["isin", "issuerName"]
   }),
-  keyHash: z399.string().meta({
+  keyHash: z400.string().meta({
     description: "On-chain keccak256 hash of the metadata key (bytes32 hex string)",
     examples: ["0x1c8aff950685c2ed4bc3174f3472287b56d9517b9c948127319a09a7a36deac8"]
   }),
-  value: z399.string().meta({
+  value: z400.string().meta({
     description: "Raw on-chain value (bytes32 hex string)",
     examples: ["0x000000"]
   }),
-  valueString: z399.string().nullable().meta({
+  valueString: z400.string().nullable().meta({
     description: "Decoded string representation of the value, null if not decodable",
     examples: ["Acme Corp", null]
   }),
@@ -28085,7 +28111,7 @@ var TokenMetadataEntrySchema = z399.object({
     description: "Numeric representation of the value, null if not numeric",
     examples: ["1000", null]
   }),
-  isImmutable: z399.boolean().meta({
+  isImmutable: z400.boolean().meta({
     description: "Whether this metadata entry is immutable (cannot be changed after being set)",
     examples: [false]
   }),
@@ -28094,22 +28120,22 @@ var TokenMetadataEntrySchema = z399.object({
     examples: ["1700000000"]
   })
 });
-var TokenMetadataResponseSchema = z399.object({
-  metadata_: z399.object({
-    entryCount: z399.number().int().meta({
+var TokenMetadataResponseSchema = z400.object({
+  metadata_: z400.object({
+    entryCount: z400.number().int().meta({
       description: "Total number of metadata entries",
       examples: [5]
     }),
-    entries: z399.array(TokenMetadataEntrySchema).meta({
+    entries: z400.array(TokenMetadataEntrySchema).meta({
       description: "List of metadata entries for the token"
     })
   }).nullable()
 });
 
 // ../../packages/dalp/api-contract/src/routes/token/routes/token.conversion-triggers.schema.ts
-import { z as z400 } from "zod";
-var ConversionTriggerSchema = z400.object({
-  triggerId: z400.string().meta({
+import { z as z401 } from "zod";
+var ConversionTriggerSchema = z401.object({
+  triggerId: z401.string().meta({
     description: "On-chain trigger ID (bytes32 hex)",
     examples: ["0xabc123..."]
   }),
@@ -28138,16 +28164,16 @@ var ConversionTriggerSchema = z400.object({
   expiresAt: timestamp().meta({
     description: "Trigger expiry timestamp. Epoch zero means no expiry."
   }),
-  metadataHash: z400.string().nullable().meta({
+  metadataHash: z401.string().nullable().meta({
     description: "Off-chain metadata document hash (bytes32 hex)"
   }),
-  active: z400.boolean().meta({
+  active: z401.boolean().meta({
     description: "Whether the trigger is currently active"
   }),
   disabledAt: timestamp().nullable().meta({
     description: "Timestamp when the trigger was disabled, null if still active"
   }),
-  totalConversions: z400.number().int().nonnegative().meta({
+  totalConversions: z401.number().int().nonnegative().meta({
     description: "Number of conversions executed against this trigger",
     examples: [0]
   }),
@@ -28160,16 +28186,16 @@ var ConversionTriggerSchema = z400.object({
     examples: ["0"]
   })
 });
-var ConversionTriggersResponseSchema = z400.object({
-  triggers: z400.array(ConversionTriggerSchema).meta({
+var ConversionTriggersResponseSchema = z401.object({
+  triggers: z401.array(ConversionTriggerSchema).meta({
     description: "List of conversion triggers ordered by publication time descending"
   }),
-  totalCount: z400.number().int().nonnegative().meta({
+  totalCount: z401.number().int().nonnegative().meta({
     description: "Total number of conversion triggers for this token",
     examples: [0]
   })
 });
-var ConversionTriggersInputSchema = z400.object({
+var ConversionTriggersInputSchema = z401.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -28203,26 +28229,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 z401 } from "zod";
-var TokenEventV2ValueSchema = z401.object({
-  id: z401.string().meta({ description: "Unique identifier for the parameter value", examples: ["evt_val_123"] }),
-  name: z401.string().meta({ description: "Name of the event parameter", examples: ["from", "to", "amount"] }),
-  value: z401.string().meta({
+import { z as z402 } from "zod";
+var TokenEventV2ValueSchema = z402.object({
+  id: z402.string().meta({ description: "Unique identifier for the parameter value", examples: ["evt_val_123"] }),
+  name: z402.string().meta({ description: "Name of the event parameter", examples: ["from", "to", "amount"] }),
+  value: z402.string().meta({
     description: "Value of the event parameter (address, hex hash, decimal-string number, or arbitrary text)",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F", "1000000000000000000"]
   })
 });
-var TokenEventV2ItemSchema = z401.object({
-  id: z401.string().meta({ description: "Unique identifier for the event", examples: ["evt_123abc"] }),
-  eventName: z401.string().meta({
+var TokenEventV2ItemSchema = z402.object({
+  id: z402.string().meta({ description: "Unique identifier for the event", examples: ["evt_123abc"] }),
+  eventName: z402.string().meta({
     description: "The event name",
     examples: ["TransferCompleted", "MintCompleted", "BurnCompleted"]
   }),
-  txIndex: z401.string().meta({
+  txIndex: z402.string().meta({
     description: "Log index within the transaction (string for parity with v1)",
     examples: ["0", "1", "5"]
   }),
-  blockNumber: z401.string().meta({
+  blockNumber: z402.string().meta({
     description: "Block number when the event occurred (decimal string for bigint precision)",
     examples: ["12345678", "20000000"]
   }),
@@ -28234,19 +28260,19 @@ var TokenEventV2ItemSchema = z401.object({
     description: "Transaction hash",
     examples: ["0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"]
   }),
-  emitter: z401.object({
+  emitter: z402.object({
     id: ethereumAddress.meta({
       description: "Address of the contract that emitted the event",
       examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
     })
   }),
-  sender: z401.object({
+  sender: z402.object({
     id: ethereumAddress.meta({
       description: "Address that triggered the event (account or sender, falling back to the contract address)",
       examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
     })
   }),
-  values: z401.array(TokenEventV2ValueSchema).meta({
+  values: z402.array(TokenEventV2ValueSchema).meta({
     description: "Event parameter values",
     examples: []
   })
@@ -28267,15 +28293,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 z402 } from "zod";
-var TransferApprovalSchema = z402.object({
-  id: z402.string().meta({
+import { z as z403 } from "zod";
+var TransferApprovalSchema = z403.object({
+  id: z403.string().meta({
     description: "Unique approval ID: {moduleAddress}-{token}-{fromIdentity}-{toIdentity}-{value}",
     examples: ["0xabc...-0xtoken...-0xfrom...-0xto...-1000000000000000000"]
   }),
-  token: z402.object({ id: ethereumAddress }),
-  fromIdentity: z402.object({ id: ethereumAddress }),
-  toIdentity: z402.object({ id: ethereumAddress }),
+  token: z403.object({ id: ethereumAddress }),
+  fromIdentity: z403.object({ id: ethereumAddress }),
+  toIdentity: z403.object({ id: ethereumAddress }),
   value: assetAmount.meta({
     description: "Approved transfer amount in base units",
     examples: ["1000000000000000000"]
@@ -28285,7 +28311,7 @@ var TransferApprovalSchema = z402.object({
     description: "Timestamp when approval expires. Epoch zero means no expiry.",
     examples: ["0", "1893456000"]
   }),
-  status: z402.enum(["pending", "consumed", "revoked"]).meta({
+  status: z403.enum(["pending", "consumed", "revoked"]).meta({
     description: "Current status of the approval",
     examples: ["pending"]
   }),
@@ -28298,17 +28324,17 @@ var TransferApprovalSchema = z402.object({
     examples: ["2023-11-14T12:05:00.000Z"]
   })
 });
-var TransferApprovalsResponseSchema = z402.object({
-  transferApprovals: z402.array(TransferApprovalSchema).meta({
+var TransferApprovalsResponseSchema = z403.object({
+  transferApprovals: z403.array(TransferApprovalSchema).meta({
     description: "List of transfer approvals ordered by creation time descending",
     examples: []
   }),
-  totalCount: z402.number().int().nonnegative().meta({
+  totalCount: z403.number().int().nonnegative().meta({
     description: "Total number of transfer approvals for this token",
     examples: [3]
   })
 });
-var TransferApprovalsInputSchema = z402.object({
+var TransferApprovalsInputSchema = z403.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -28316,20 +28342,20 @@ var TransferApprovalsInputSchema = z402.object({
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.price.schema.ts
-import { z as z403 } from "zod";
-var TokenPriceInputParamsSchema = z403.object({
+import { z as z404 } from "zod";
+var TokenPriceInputParamsSchema = z404.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   })
 });
-var TokenPriceInputQuerySchema = z403.object({
+var TokenPriceInputQuerySchema = z404.object({
   currency: fiatCurrency().default("USD").meta({
     description: "Target ISO 4217 currency code for price conversion",
     examples: ["USD", "EUR", "GBP", "AED"]
   })
 });
-var ConversionHopSchema = z403.object({
+var ConversionHopSchema = z404.object({
   from: fiatCurrency().meta({
     description: "Source currency of this hop",
     examples: ["AED"]
@@ -28338,7 +28364,7 @@ var ConversionHopSchema = z403.object({
     description: "Target currency of this hop",
     examples: ["USD"]
   }),
-  rate: z403.string().meta({
+  rate: z404.string().meta({
     description: "Exchange rate (18-decimal string)",
     examples: ["272300000000000000"]
   }),
@@ -28350,17 +28376,17 @@ var ConversionHopSchema = z403.object({
     description: "When the feed was last updated",
     examples: ["2024-03-22T12:00:00.000Z"]
   }),
-  inverse: z403.boolean().meta({
+  inverse: z404.boolean().meta({
     description: "Whether this hop uses an inverse rate (1/rate of the registered feed)",
     examples: [false]
   })
 });
-var TokenPriceResponseSchema = z403.object({
+var TokenPriceResponseSchema = z404.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  price: z403.string().meta({
+  price: z404.string().meta({
     description: "The resolved price as a decimal string (18-decimal normalized)",
     examples: ["27230000000000000000"]
   }),
@@ -28368,11 +28394,11 @@ var TokenPriceResponseSchema = z403.object({
     description: "The currency of the returned price",
     examples: ["USD"]
   }),
-  decimals: z403.number().meta({
+  decimals: z404.number().meta({
     description: "Decimal precision of the price (always 18)",
     examples: [18]
   }),
-  source: z403.enum(["feed", "claim"]).meta({
+  source: z404.enum(["feed", "claim"]).meta({
     description: "Whether the base price came from a feed or identity claim",
     examples: ["feed"]
   }),
@@ -28380,7 +28406,7 @@ var TokenPriceResponseSchema = z403.object({
     description: "The native currency of the base price before conversion",
     examples: ["AED"]
   }),
-  convertible: z403.boolean().meta({
+  convertible: z404.boolean().meta({
     description: "Whether the price was successfully converted to the target currency",
     examples: [true]
   }),
@@ -28388,15 +28414,15 @@ var TokenPriceResponseSchema = z403.object({
     description: "The requested target currency (only present when convertible is false)",
     examples: ["USD"]
   }),
-  reason: z403.string().optional().meta({
+  reason: z404.string().optional().meta({
     description: "Reason for conversion failure (only present when convertible is false)",
     examples: ["no_fx_path"]
   }),
-  message: z403.string().optional().meta({
+  message: z404.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: z403.array(fiatCurrency()).optional().meta({
+  availableCurrencies: z404.array(fiatCurrency()).optional().meta({
     description: "Currencies reachable from the source currency (only present when convertible is false)",
     examples: [["AED", "EUR"]]
   }),
@@ -28404,7 +28430,7 @@ var TokenPriceResponseSchema = z403.object({
     description: "When the price data was last updated (ISO 8601)",
     examples: ["2026-03-22T10:30:00.000Z"]
   }),
-  conversionPath: z403.array(ConversionHopSchema).meta({
+  conversionPath: z404.array(ConversionHopSchema).meta({
     description: "The FX conversion hops applied (empty if no conversion needed)",
     examples: [[]]
   })
@@ -28423,7 +28449,7 @@ var HoldersV2InputSchema = createCollectionInputSchema(HOLDER_COLLECTION_FIELDS,
 var HoldersV2OutputSchema = createPaginatedResponse(assetBalance());
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.historical-balances.schema.ts
-import { z as z404 } from "zod";
+import { z as z405 } from "zod";
 var HISTORICAL_BALANCE_KIND_OPTIONS = ["account", "totalSupply"];
 var TOKEN_HISTORICAL_BALANCES_COLLECTION_FIELDS = {
   account: addressField({ defaultOperator: "eq" }),
@@ -28448,10 +28474,10 @@ var TokenHistoricalBalancesV2InputSchema = createCollectionInputSchema(TOKEN_HIS
     }
   }
 });
-var TokenHistoricalBalanceV2ItemSchema = z404.object({
-  id: z404.string().uuid(),
+var TokenHistoricalBalanceV2ItemSchema = z405.object({
+  id: z405.string().uuid(),
   account: ethereumAddress,
-  kind: z404.enum(HISTORICAL_BALANCE_KIND_OPTIONS),
+  kind: z405.enum(HISTORICAL_BALANCE_KIND_OPTIONS),
   sender: ethereumAddress,
   oldBalance: bigDecimal(),
   oldBalanceExact: apiBigInt,
@@ -28460,12 +28486,12 @@ var TokenHistoricalBalanceV2ItemSchema = z404.object({
   blockNumber: apiBigInt,
   blockTimestamp: timestamp(),
   txHash: ethereumHash,
-  logIndex: z404.number().int().nonnegative()
+  logIndex: z405.number().int().nonnegative()
 });
 var TokenHistoricalBalancesV2OutputSchema = createPaginatedResponse(TokenHistoricalBalanceV2ItemSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.transaction-fee-collections.list.schema.ts
-import { z as z405 } from "zod";
+import { z as z406 } from "zod";
 var OPERATION_TYPE_OPTIONS = ["mint", "burn", "transfer", "redeem"];
 var TOKEN_TRANSACTION_FEE_COLLECTIONS_COLLECTION_FIELDS = {
   collectedAt: dateField(),
@@ -28478,21 +28504,21 @@ var TokenTransactionFeeCollectionsV2InputSchema = createCollectionInputSchema(TO
   defaultSort: "-collectedAt",
   globalSearch: false
 });
-var TokenTransactionFeeCollectionV2ItemSchema = z405.object({
-  id: z405.string().uuid(),
+var TokenTransactionFeeCollectionV2ItemSchema = z406.object({
+  id: z406.string().uuid(),
   counterpartyAddress: ethereumAddress,
-  operationType: z405.enum(OPERATION_TYPE_OPTIONS),
+  operationType: z406.enum(OPERATION_TYPE_OPTIONS),
   feeAmount: bigDecimal(),
   feeAmountExact: apiBigInt,
   blockNumber: apiBigInt,
   blockTimestamp: timestamp(),
   txHash: ethereumHash,
-  logIndex: z405.number().int().nonnegative()
+  logIndex: z406.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 z406 } from "zod";
+import { z as z407 } from "zod";
 var FEE_ACCRUAL_OPERATION_TYPE_OPTIONS = [...OPERATION_TYPE_OPTIONS, "unknown"];
 var TOKEN_FEE_ACCRUAL_EVENTS_COLLECTION_FIELDS = {
   accruedAt: dateField(),
@@ -28508,25 +28534,54 @@ var TokenFeeAccrualEventsV2InputSchema = createCollectionInputSchema(TOKEN_FEE_A
   defaultSort: "-accruedAt",
   globalSearch: false
 });
-var TokenFeeAccrualEventV2ItemSchema = z406.object({
-  id: z406.uuid(),
+var TokenFeeAccrualEventV2ItemSchema = z407.object({
+  id: z407.uuid(),
   payer: ethereumAddress,
   fromAddress: ethereumAddress,
   toAddress: ethereumAddress,
-  operationType: z406.enum(FEE_ACCRUAL_OPERATION_TYPE_OPTIONS),
+  operationType: z407.enum(FEE_ACCRUAL_OPERATION_TYPE_OPTIONS),
   operationAmount: bigDecimal(),
   operationAmountExact: apiBigInt,
-  feeBps: z406.number().int().nonnegative(),
+  feeBps: z407.number().int().nonnegative(),
   feeAmount: bigDecimal(),
   feeAmountExact: apiBigInt,
   blockNumber: apiBigInt,
   blockTimestamp: timestamp(),
   eventTimestamp: timestamp(),
   txHash: ethereumHash,
-  logIndex: z406.number().int().nonnegative()
+  logIndex: z407.number().int().nonnegative()
 });
 var TokenFeeAccrualEventsV2OutputSchema = createPaginatedResponse(TokenFeeAccrualEventV2ItemSchema);
 
+// ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.external-fee-collection-events.list.schema.ts
+import { z as z408 } from "zod";
+var EXTERNAL_OPERATION_TYPE_OPTIONS = ["mint", "burn", "transfer", "unknown"];
+var TOKEN_EXTERNAL_FEE_COLLECTION_EVENTS_COLLECTION_FIELDS = {
+  collectedAt: dateField(),
+  blockNumber: bigintField(),
+  operationType: enumField(EXTERNAL_OPERATION_TYPE_OPTIONS, { sortable: false, facetable: true }),
+  payer: addressField({ defaultOperator: "iLike" }),
+  feeToken: addressField({ defaultOperator: "iLike" }),
+  feeAmount: bigintField()
+};
+var TokenExternalFeeCollectionEventsV2InputSchema = createCollectionInputSchema(TOKEN_EXTERNAL_FEE_COLLECTION_EVENTS_COLLECTION_FIELDS, {
+  defaultSort: "-collectedAt",
+  globalSearch: false
+});
+var TokenExternalFeeCollectionEventV2ItemSchema = z408.object({
+  id: z408.uuid(),
+  payer: ethereumAddress,
+  feeToken: ethereumAddress,
+  operationType: z408.enum(EXTERNAL_OPERATION_TYPE_OPTIONS),
+  feeAmount: bigDecimal(),
+  feeAmountExact: apiBigInt,
+  blockNumber: apiBigInt,
+  blockTimestamp: timestamp(),
+  txHash: ethereumHash,
+  logIndex: z408.number().int().nonnegative()
+});
+var TokenExternalFeeCollectionEventsV2OutputSchema = createPaginatedResponse(TokenExternalFeeCollectionEventV2ItemSchema);
+
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.transfer-approvals.schema.ts
 var TRANSFER_APPROVAL_COLLECTION_FIELDS = {
   status: enumField(["pending", "consumed", "revoked"]),
@@ -28540,7 +28595,7 @@ var TransferApprovalsV2InputSchema = createCollectionInputSchema(TRANSFER_APPROV
 var TransferApprovalsV2OutputSchema = createPaginatedResponse(TransferApprovalSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.voting-delegations.schema.ts
-import { z as z407 } from "zod";
+import { z as z409 } from "zod";
 var VOTING_DELEGATIONS_COLLECTION_FIELDS = {
   account: addressField({ defaultOperator: "iLike" }),
   delegate: addressField({ defaultOperator: "iLike" }),
@@ -28554,20 +28609,20 @@ var VotingDelegationsV2InputSchema = createCollectionInputSchema(VOTING_DELEGATI
   defaultSort: "-delegatedAt",
   globalSearch: false
 });
-var VotingDelegationV2ItemSchema = z407.object({
-  id: z407.string().uuid(),
+var VotingDelegationV2ItemSchema = z409.object({
+  id: z409.string().uuid(),
   delegator: ethereumAddress,
   fromDelegate: ethereumAddress.nullable(),
   toDelegate: ethereumAddress,
   delegatedAt: timestamp(),
   delegatedBlockNumber: apiBigInt,
   delegatedTxHash: ethereumHash,
-  delegatedLogIndex: z407.number().int().nonnegative(),
+  delegatedLogIndex: z409.number().int().nonnegative(),
   undelegatedAt: timestamp().nullable(),
   undelegatedBlockNumber: apiBigInt.nullable(),
   undelegatedTxHash: ethereumHash.nullable(),
-  undelegatedLogIndex: z407.number().int().nonnegative().nullable(),
-  isActive: z407.boolean()
+  undelegatedLogIndex: z409.number().int().nonnegative().nullable(),
+  isActive: z409.boolean()
 });
 var VotingDelegationsV2OutputSchema = createPaginatedResponse(VotingDelegationV2ItemSchema);
 
@@ -28585,21 +28640,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(z408.object({ tokenAddress: TokenAllowanceInputSchema.shape.tokenAddress }), z408.object(TokenAllowanceInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(TokenAllowanceResponseSchema));
+}).input(v2Input.paramsQuery(z410.object({ tokenAddress: TokenAllowanceInputSchema.shape.tokenAddress }), z410.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(z408.object({ tokenAddress: TokenHolderInputSchema.shape.tokenAddress }), z408.object(TokenHolderInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(TokenHolderResponseSchema));
+}).input(v2Input.paramsQuery(z410.object({ tokenAddress: TokenHolderInputSchema.shape.tokenAddress }), z410.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(z408.object({
+}).input(v2Input.paramsQuery(z410.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -28611,7 +28666,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(z408.object({
+}).input(v2Input.paramsQuery(z410.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address to filter actions by",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -28623,7 +28678,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(z408.object({
+}).input(v2Input.paramsQuery(z410.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -28635,7 +28690,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(z408.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), DenominationAssetsV2InputSchema)).output(DenominationAssetsV2OutputSchema);
+}).input(v2Input.paramsQuery(z410.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), DenominationAssetsV2InputSchema)).output(DenominationAssetsV2OutputSchema);
 var compliance = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/compliance-modules",
@@ -28650,6 +28705,13 @@ var features = v2Contract.route({
   successDescription: "Token features retrieved successfully.",
   tags: [V2_TAG.token]
 }).input(v2Input.params(TokenFeaturesInputSchema)).output(createSingleResponse(TokenFeaturesResponseSchema));
+var aumFeeAccruedEstimate = v2Contract.route({
+  method: "GET",
+  path: "/tokens/{tokenAddress}/aum-fee/accrued-estimate",
+  description: "Read the authoritative on-chain accrued AUM fee for the token's attached AUM-fee feature. Multicalls getAccruedFees() and getLastCollectionTime() against the same block; returns null when no AUM-fee feature is attached.",
+  successDescription: "AUM-fee accrued estimate retrieved successfully.",
+  tags: [V2_TAG.token]
+}).input(v2Input.params(TokenAumFeeAccruedEstimateInputSchema)).output(createSingleResponse(TokenAumFeeAccruedEstimateResponseSchema));
 var tokenMetadata = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/metadata",
@@ -28663,7 +28725,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(z408.object({ tokenAddress: TransferApprovalsInputSchema.shape.tokenAddress }), TransferApprovalsV2InputSchema)).output(TransferApprovalsV2OutputSchema);
+}).input(v2Input.paramsQuery(z410.object({ tokenAddress: TransferApprovalsInputSchema.shape.tokenAddress }), TransferApprovalsV2InputSchema)).output(TransferApprovalsV2OutputSchema);
 var price = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/price",
@@ -28677,35 +28739,42 @@ 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(z408.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), ConversionTriggersV2InputSchema)).output(ConversionTriggersV2OutputSchema);
+}).input(v2Input.paramsQuery(z410.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), ConversionTriggersV2InputSchema)).output(ConversionTriggersV2OutputSchema);
 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(z408.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), VotingDelegationsV2InputSchema)).output(VotingDelegationsV2OutputSchema);
+}).input(v2Input.paramsQuery(z410.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), VotingDelegationsV2InputSchema)).output(VotingDelegationsV2OutputSchema);
 var historicalBalances = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/historical-balances",
   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(z408.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenHistoricalBalancesV2InputSchema)).output(TokenHistoricalBalancesV2OutputSchema);
+}).input(v2Input.paramsQuery(z410.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenHistoricalBalancesV2InputSchema)).output(TokenHistoricalBalancesV2OutputSchema);
 var transactionFeeCollections = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/transaction-fee/collections",
   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(z408.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenTransactionFeeCollectionsV2InputSchema)).output(TokenTransactionFeeCollectionsV2OutputSchema);
+}).input(v2Input.paramsQuery(z410.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(z408.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenFeeAccrualEventsV2InputSchema)).output(TokenFeeAccrualEventsV2OutputSchema);
+}).input(v2Input.paramsQuery(z410.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenFeeAccrualEventsV2InputSchema)).output(TokenFeeAccrualEventsV2OutputSchema);
+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(z410.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenExternalFeeCollectionEventsV2InputSchema)).output(TokenExternalFeeCollectionEventsV2OutputSchema);
 var tokenV2ReadsContract = {
   read: read27,
   allowance,
@@ -28716,6 +28785,7 @@ var tokenV2ReadsContract = {
   denominationAssets,
   compliance,
   features,
+  aumFeeAccruedEstimate,
   metadata: tokenMetadata,
   transferApprovals,
   conversionTriggers,
@@ -28723,11 +28793,12 @@ var tokenV2ReadsContract = {
   historicalBalances,
   transactionFeeCollections,
   feeAccrualEvents,
+  externalFeeCollectionEvents,
   price
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.stats.contract.ts
-import { z as z409 } from "zod";
+import { z as z411 } from "zod";
 var statsBondStatus = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/stats/bond-status",
@@ -28748,25 +28819,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(z409.object({
+}).input(v2Input.paramsQuery(z411.object({
   tokenAddress: StatsTotalSupplyInputSchema.shape.tokenAddress
-}), z409.object(StatsTotalSupplyInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(StatsTotalSupplyOutputSchema));
+}), z411.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(z409.object({
+}).input(v2Input.paramsQuery(z411.object({
   tokenAddress: StatsSupplyChangesInputSchema.shape.tokenAddress
-}), z409.object(StatsSupplyChangesInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(StatsSupplyChangesOutputSchema));
+}), z411.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(z409.object({ tokenAddress: StatsVolumeInputSchema.shape.tokenAddress }), z409.object(StatsVolumeInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(StatsVolumeOutputSchema));
+}).input(v2Input.paramsQuery(z411.object({ tokenAddress: StatsVolumeInputSchema.shape.tokenAddress }), z411.object(StatsVolumeInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(StatsVolumeOutputSchema));
 var statsWalletDistribution = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/stats/wallet-distribution",
@@ -28816,7 +28887,7 @@ var tokenV2Contract = {
 };
 
 // ../../packages/core/validation/src/transaction-request-state.ts
-import { z as z410 } from "zod";
+import { z as z412 } from "zod";
 var transactionRequestStates = [
   "RECEIVED",
   "QUEUED",
@@ -28831,7 +28902,7 @@ var transactionRequestStates = [
   "CANCELLED"
 ];
 var TERMINAL_STATES = ["COMPLETED", "FAILED", "DEAD_LETTER", "CANCELLED"];
-var TransactionRequestStateSchema = z410.enum(transactionRequestStates).meta({
+var TransactionRequestStateSchema = z412.enum(transactionRequestStates).meta({
   description: "Current state in the transaction request lifecycle",
   examples: ["RECEIVED", "QUEUED", "BROADCASTING", "COMPLETED", "FAILED"]
 });
@@ -28872,96 +28943,96 @@ var transactionSubStatuses = [
   "WORKFLOW_BATCH_COMPLETED",
   "WORKFLOW_BATCH_FAILED"
 ];
-var TransactionSubStatusSchema = z410.enum(transactionSubStatuses).meta({
+var TransactionSubStatusSchema = z412.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 z411 } from "zod";
-var TransactionForceRetryInputSchema = z411.object({
-  transactionId: z411.uuid().meta({
+import { z as z413 } from "zod";
+var TransactionForceRetryInputSchema = z413.object({
+  transactionId: z413.uuid().meta({
     description: "Queue transaction identifier (UUIDv7) to retry",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   })
 });
-var TransactionForceRetryBodySchema = z411.object({
-  gasPrice: z411.string().optional().meta({
+var TransactionForceRetryBodySchema = z413.object({
+  gasPrice: z413.string().optional().meta({
     description: "Override gas price in wei (decimal string)",
     examples: ["20000000000"]
   }),
-  nonce: z411.number().int().nonnegative().optional().meta({
+  nonce: z413.number().int().nonnegative().optional().meta({
     description: "Override nonce for the retried transaction",
     examples: [42]
   })
 }).default({});
-var TransactionForceRetryResultSchema = z411.object({
-  transactionId: z411.uuid().meta({ description: "The requeued transaction ID" }),
+var TransactionForceRetryResultSchema = z413.object({
+  transactionId: z413.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 = z411.object({
-  transactionId: z411.uuid().meta({
+var TransactionForceFailInputSchema = z413.object({
+  transactionId: z413.uuid().meta({
     description: "Queue transaction identifier (UUIDv7) to force-fail",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   })
 });
-var TransactionForceFailBodySchema = z411.object({
-  reason: z411.string().min(1).max(1000).meta({
+var TransactionForceFailBodySchema = z413.object({
+  reason: z413.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 = z411.object({
-  transactionId: z411.uuid().meta({ description: "The force-failed transaction ID" }),
+var TransactionForceFailResultSchema = z413.object({
+  transactionId: z413.uuid().meta({ description: "The force-failed transaction ID" }),
   previousStatus: transactionRequestState().meta({ description: "State before force fail" }),
   status: transactionRequestState().meta({ description: "New state (FAILED)" }),
-  reason: z411.string().meta({ description: "The reason provided for the force-fail" })
+  reason: z413.string().meta({ description: "The reason provided for the force-fail" })
 });
 var TransactionV2ForceFailOutputSchema = createSingleResponse(TransactionForceFailResultSchema);
-var TransactionForceNonceInputSchema = z411.object({
-  transactionId: z411.uuid().meta({
+var TransactionForceNonceInputSchema = z413.object({
+  transactionId: z413.uuid().meta({
     description: "Queue transaction identifier — the nonce is forced on its sender wallet",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   })
 });
-var TransactionForceNonceBodySchema = z411.object({
-  nonce: z411.number().int().nonnegative().meta({
+var TransactionForceNonceBodySchema = z413.object({
+  nonce: z413.number().int().nonnegative().meta({
     description: "Nonce value to force-set on the sender's nonce tracker",
     examples: [42]
   })
 });
-var TransactionForceNonceResultSchema = z411.object({
-  previous: z411.number().nullable().meta({ description: "Previous nonce value (null if uninitialized)" }),
-  new: z411.number().meta({ description: "New nonce value after force-set" })
+var TransactionForceNonceResultSchema = z413.object({
+  previous: z413.number().nullable().meta({ description: "Previous nonce value (null if uninitialized)" }),
+  new: z413.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 z412 } from "zod";
-var TransactionV2CancelInputSchema = z412.object({
-  transactionId: z412.uuid().meta({
+import { z as z414 } from "zod";
+var TransactionV2CancelInputSchema = z414.object({
+  transactionId: z414.uuid().meta({
     description: "Queue transaction identifier (UUIDv7) to cancel",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   })
 });
-var TransactionCancelResultSchema = z412.object({
-  status: z412.enum(["cancelled", "cancellation_pending", "error"]).meta({
+var TransactionCancelResultSchema = z414.object({
+  status: z414.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: z412.string().optional().meta({
+  cancelTransactionId: z414.string().optional().meta({
     description: "RBF replacement transaction ID when cancellation is pending on-chain"
   }),
-  message: z412.string().optional().meta({
+  message: z414.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 z413 } from "zod";
+import { z as z415 } from "zod";
 var TRANSACTION_COLLECTION_FIELDS = {
   status: enumField([...transactionRequestStates]),
   operationType: textField(),
@@ -28974,12 +29045,12 @@ var TransactionV2ListInputSchema = createCollectionInputSchema(TRANSACTION_COLLE
   defaultSort: "createdAt",
   globalSearch: true
 });
-var TransactionListItemSchema = z413.object({
-  transactionId: z413.uuid().meta({
+var TransactionListItemSchema = z415.object({
+  transactionId: z415.uuid().meta({
     description: "Queue transaction identifier (UUIDv7)",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   }),
-  kind: z413.string().meta({
+  kind: z415.string().meta({
     description: "Mutation kind submitted to the queue",
     examples: ["token.create", "token.mint"]
   }),
@@ -28987,19 +29058,19 @@ var TransactionListItemSchema = z413.object({
     description: "Current transaction queue state",
     examples: ["QUEUED", "COMPLETED", "FAILED"]
   }),
-  subStatus: z413.string().nullable().meta({
+  subStatus: z415.string().nullable().meta({
     description: "Optional queue sub-status with finer-grained detail",
     examples: ["TIMEOUT", null]
   }),
-  fromAddress: z413.string().meta({
+  fromAddress: z415.string().meta({
     description: "Sender wallet address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  chainId: z413.number().int().meta({
+  chainId: z415.number().int().meta({
     description: "Target chain ID",
     examples: [1]
   }),
-  transactionHash: z413.string().nullable().meta({
+  transactionHash: z415.string().nullable().meta({
     description: "Primary transaction hash once broadcast",
     examples: ["0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef", null]
   }),
@@ -29019,19 +29090,19 @@ var TransactionV2ReadInputSchema = TransactionReadInputSchema;
 var TransactionV2ReadOutputSchema = createSingleResponse(TransactionReadOutputSchema);
 
 // ../../packages/dalp/api-contract/src/routes/transaction/routes/transaction.status.schema.ts
-import { z as z414 } from "zod";
-var TransactionStatusInputSchema = z414.object({
-  transactionId: z414.uuid().meta({
+import { z as z416 } from "zod";
+var TransactionStatusInputSchema = z416.object({
+  transactionId: z416.uuid().meta({
     description: "Queue transaction identifier (UUIDv7)",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   })
 });
-var TransactionStatusOutputSchema = z414.object({
-  transactionId: z414.uuid().meta({
+var TransactionStatusOutputSchema = z416.object({
+  transactionId: z416.uuid().meta({
     description: "Queue transaction identifier (UUIDv7)",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   }),
-  kind: z414.string().meta({
+  kind: z416.string().meta({
     description: "Mutation kind submitted to the queue",
     examples: ["token.create", "token.mint"]
   }),
@@ -29039,23 +29110,23 @@ var TransactionStatusOutputSchema = z414.object({
     description: "Current transaction queue state",
     examples: ["QUEUED", "PREPARING", "CONFIRMING", "COMPLETED", "FAILED"]
   }),
-  subStatus: z414.string().nullable().meta({
+  subStatus: z416.string().nullable().meta({
     description: "Optional queue sub-status with finer-grained progress or failure detail",
     examples: ["TIMEOUT", "WORKFLOW_GRANTING_PERMISSIONS", null]
   }),
-  transactionHash: z414.string().nullable().meta({
+  transactionHash: z416.string().nullable().meta({
     description: "Primary transaction hash once broadcast",
     examples: ["0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef", null]
   }),
-  transactionHashes: z414.array(z414.string()).optional().meta({
+  transactionHashes: z416.array(z416.string()).optional().meta({
     description: "All transaction hashes for batch operations. Only present when the operation produced multiple transactions.",
     examples: [["0xabc...", "0xdef..."]]
   }),
-  blockNumber: z414.string().nullable().meta({
+  blockNumber: z416.string().nullable().meta({
     description: "Confirmed block number when available",
     examples: ["12345678", null]
   }),
-  errorMessage: z414.string().nullable().meta({
+  errorMessage: z416.string().nullable().meta({
     description: "Human-readable error or timeout detail when available",
     examples: ["Execution reverted", "Receipt not found after repeated checks", null]
   }),
@@ -29134,12 +29205,12 @@ var transactionV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/user/user.v2.contract.ts
-import { z as z420 } from "zod";
+import { z as z422 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/user/routes/user.read-by-national-id.schema.ts
-import { z as z415 } from "zod";
-var UserReadByNationalIdInputSchema = z415.object({
-  nationalId: z415.string().min(1).max(50).trim().meta({ description: "The national ID to look up (exact match against approved KYC)", examples: ["AB123456"] })
+import { z as z417 } from "zod";
+var UserReadByNationalIdInputSchema = z417.object({
+  nationalId: z417.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
@@ -29157,13 +29228,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 z416 } from "zod";
-var TokenAssetV2Schema = z416.object({
+import { z as z418 } from "zod";
+var TokenAssetV2Schema = z418.object({
   id: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  name: z416.string().meta({
+  name: z418.string().meta({
     description: "The token name",
     examples: ["Bond Token", "Equity Share"]
   }),
@@ -29183,19 +29254,19 @@ var TokenAssetV2Schema = z416.object({
     description: "The total supply of the token (raw on-chain uint256)",
     examples: ["1000000000000000000000", "101000000000000000000000000"]
   }),
-  bond: z416.object({
-    isMatured: z416.boolean().meta({
+  bond: z418.object({
+    isMatured: z418.boolean().meta({
       description: "Whether the bond is matured",
       examples: [true, false]
     })
   }).optional().nullable().meta({ description: "The bond details", examples: [] }),
-  yield: z416.object({
-    schedule: z416.object({
+  yield: z418.object({
+    schedule: z418.object({
       id: ethereumAddress.meta({
         description: "The yield schedule contract address",
         examples: ["0x8ba1f109551bD432803012645Ac136ddd64DBA72"]
       }),
-      denominationAsset: z416.object({
+      denominationAsset: z418.object({
         id: ethereumAddress.meta({
           description: "The denomination asset contract address",
           examples: ["0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"]
@@ -29215,8 +29286,8 @@ var TokenAssetV2Schema = z416.object({
     }).nullable().meta({ description: "The yield schedule details", examples: [] })
   }).nullable().meta({ description: "The yield details", examples: [] })
 });
-var UserAssetBalanceV2ItemSchema = z416.object({
-  id: z416.uuid().meta({
+var UserAssetBalanceV2ItemSchema = z418.object({
+  id: z418.uuid().meta({
     description: "The balance record ID (idxr_token_balances.id, UUIDv7).",
     examples: ["019283bc-7e0a-7c3d-9b1f-3f4d2c5e6a7b"]
   }),
@@ -29236,7 +29307,7 @@ var UserAssetBalanceV2ItemSchema = z416.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: z416.boolean().meta({
+  priceInBaseCurrencyReliable: z418.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]
   }),
@@ -29288,10 +29359,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 z419 } from "zod";
+import { z as z421 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/user/kyc/kyc-profile-version-documents.v2.list.schema.ts
-import { z as z417 } from "zod";
+import { z as z419 } from "zod";
 var KYC_PROFILE_VERSION_DOCUMENTS_COLLECTION_FIELDS = {
   fileName: textField(),
   documentType: enumField(kycDocumentTypes, { facetable: true }),
@@ -29302,19 +29373,19 @@ var KYC_PROFILE_VERSION_DOCUMENTS_COLLECTION_FIELDS = {
 var KycProfileVersionDocumentsV2ListInputSchema = createCollectionInputSchema(KYC_PROFILE_VERSION_DOCUMENTS_COLLECTION_FIELDS, {
   defaultSort: "uploadedAt"
 });
-var KycProfileVersionDocumentsV2ListItemSchema = z417.object({
-  id: z417.string(),
+var KycProfileVersionDocumentsV2ListItemSchema = z419.object({
+  id: z419.string(),
   documentType: kycDocumentType(),
-  fileName: z417.string(),
-  fileSize: z417.number(),
-  mimeType: z417.string(),
+  fileName: z419.string(),
+  fileSize: z419.number(),
+  mimeType: z419.string(),
   uploadedAt: timestamp(),
-  uploadedBy: z417.string().nullable()
+  uploadedBy: z419.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 z418 } from "zod";
+import { z as z420 } 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 = {
@@ -29327,21 +29398,21 @@ var KYC_PROFILE_VERSIONS_COLLECTION_FIELDS = {
 var KycProfileVersionsV2ListInputSchema = createCollectionInputSchema(KYC_PROFILE_VERSIONS_COLLECTION_FIELDS, {
   defaultSort: "versionNumber"
 });
-var KycProfileVersionsV2ListItemSchema = z418.object({
-  id: z418.string(),
-  versionNumber: z418.number(),
+var KycProfileVersionsV2ListItemSchema = z420.object({
+  id: z420.string(),
+  versionNumber: z420.number(),
   status: kycVersionStatus(),
   createdAt: timestamp(),
-  createdBy: z418.string().nullable(),
+  createdBy: z420.string().nullable(),
   submittedAt: timestamp().nullable(),
-  submittedBy: z418.string().nullable(),
+  submittedBy: z420.string().nullable(),
   reviewedAt: timestamp().nullable(),
-  reviewedBy: z418.string().nullable(),
-  reviewOutcome: z418.enum(KYC_REVIEW_OUTCOMES).nullable(),
-  isDraft: z418.boolean(),
-  isUnderReview: z418.boolean(),
-  isApproved: z418.boolean(),
-  isCurrent: z418.boolean()
+  reviewedBy: z420.string().nullable(),
+  reviewOutcome: z420.enum(KYC_REVIEW_OUTCOMES).nullable(),
+  isDraft: z420.boolean(),
+  isUnderReview: z420.boolean(),
+  isApproved: z420.boolean(),
+  isCurrent: z420.boolean()
 });
 var KycProfileVersionsV2ListOutputSchema = createPaginatedResponse(KycProfileVersionsV2ListItemSchema);
 
@@ -29359,14 +29430,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(z419.object({ userId: z419.string().min(1) }), KycProfileVersionsV2ListInputSchema)).output(KycProfileVersionsV2ListOutputSchema);
+}).input(v2Input.paramsQuery(z421.object({ userId: z421.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(z419.object({ userId: KycProfileVersionsCreateInputSchema.shape.userId }), KycProfileVersionsCreateInputSchema.omit({ userId: true }))).output(createSingleResponse(KycProfileVersionsCreateOutputSchema));
+}).input(v2Input.paramsBody(z421.object({ userId: KycProfileVersionsCreateInputSchema.shape.userId }), KycProfileVersionsCreateInputSchema.omit({ userId: true }))).output(createSingleResponse(KycProfileVersionsCreateOutputSchema));
 var versionRead = v2Contract.route({
   method: "GET",
   path: "/kyc-profile-versions/{versionId}",
@@ -29380,7 +29451,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(z419.object({ versionId: KycProfileVersionUpdateInputSchema.shape.versionId }), KycProfileVersionUpdateInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionUpdateOutputSchema));
+}).input(v2Input.paramsBody(z421.object({ versionId: KycProfileVersionUpdateInputSchema.shape.versionId }), KycProfileVersionUpdateInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionUpdateOutputSchema));
 var versionSubmit = v2Contract.route({
   method: "POST",
   path: "/kyc-profile-versions/{versionId}/submissions",
@@ -29394,28 +29465,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(z419.object({ versionId: KycProfileVersionApproveInputSchema.shape.versionId }), KycProfileVersionApproveInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionApproveOutputSchema));
+}).input(v2Input.paramsBody(z421.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(z419.object({ versionId: KycProfileVersionRejectInputSchema.shape.versionId }), KycProfileVersionRejectInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionRejectOutputSchema));
+}).input(v2Input.paramsBody(z421.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(z419.object({ versionId: KycProfileVersionRequestUpdateInputSchema.shape.versionId }), KycProfileVersionRequestUpdateInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionRequestUpdateOutputSchema));
+}).input(v2Input.paramsBody(z421.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(z419.object({ versionId: z419.string().min(1) }), KycProfileVersionDocumentsV2ListInputSchema)).output(KycProfileVersionDocumentsV2ListOutputSchema);
+}).input(v2Input.paramsQuery(z421.object({ versionId: z421.string().min(1) }), KycProfileVersionDocumentsV2ListInputSchema)).output(KycProfileVersionDocumentsV2ListOutputSchema);
 var documentsDelete = v2Contract.route({
   method: "DELETE",
   path: "/kyc-profile-versions/{versionId}/documents/{documentId}",
@@ -29429,14 +29500,14 @@ var documentsGetUploadUrl = v2Contract.route({
   description: "Generate a presigned URL for uploading a KYC document directly to storage.",
   successDescription: "Upload URL generated successfully.",
   tags: [V2_TAG.userKyc]
-}).input(v2Input.paramsBody(z419.object({ versionId: KycProfileVersionDocumentGetUploadUrlInputSchema.shape.versionId }), KycProfileVersionDocumentGetUploadUrlInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionDocumentGetUploadUrlOutputSchema));
+}).input(v2Input.paramsBody(z421.object({ versionId: KycProfileVersionDocumentGetUploadUrlInputSchema.shape.versionId }), KycProfileVersionDocumentGetUploadUrlInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionDocumentGetUploadUrlOutputSchema));
 var documentsConfirmUpload = v2Contract.route({
   method: "POST",
   path: "/kyc-profile-versions/{versionId}/documents",
   description: "Confirm a document upload after successfully uploading to the presigned URL.",
   successDescription: "Document upload confirmed.",
   tags: [V2_TAG.userKyc]
-}).input(v2Input.paramsBody(z419.object({ versionId: KycProfileVersionDocumentConfirmUploadInputSchema.shape.versionId }), KycProfileVersionDocumentConfirmUploadInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionDocumentConfirmUploadOutputSchema));
+}).input(v2Input.paramsBody(z421.object({ versionId: KycProfileVersionDocumentConfirmUploadInputSchema.shape.versionId }), KycProfileVersionDocumentConfirmUploadInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionDocumentConfirmUploadOutputSchema));
 var documentsGetDownloadUrl = v2Contract.route({
   method: "POST",
   path: "/kyc-profile-versions/{versionId}/documents/{documentId}/downloads",
@@ -29514,14 +29585,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(z420.object({ userId: z420.string() }))).output(createSingleResponse(UserReadOutputSchema));
+}).input(v2Input.params(z422.object({ userId: z422.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(z420.object({ wallet: ethereumAddress }))).output(createSingleResponse(UserReadOutputSchema));
+}).input(v2Input.params(z422.object({ wallet: ethereumAddress }))).output(createSingleResponse(UserReadOutputSchema));
 var readByNationalId = v2Contract.route({
   method: "GET",
   path: "/national-ids/{nationalId}/user",
@@ -29630,30 +29701,30 @@ var userV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.chain-of-custody.schema.ts
-import { z as z421 } from "zod";
-var WebhooksV2ChainOfCustodyInputSchema = z421.object({
-  evtId: z421.string().trim().min(1)
-});
-var WebhooksV2ChainOfCustodyOutputSchema = createSingleResponse(z421.object({
-  evtId: z421.string(),
-  hops: z421.array(z421.object({
-    stage: z421.string(),
-    contentHash: z421.string(),
-    signedBy: z421.string().optional(),
-    recordedAt: z421.coerce.date()
+import { z as z423 } from "zod";
+var WebhooksV2ChainOfCustodyInputSchema = z423.object({
+  evtId: z423.string().trim().min(1)
+});
+var WebhooksV2ChainOfCustodyOutputSchema = createSingleResponse(z423.object({
+  evtId: z423.string(),
+  hops: z423.array(z423.object({
+    stage: z423.string(),
+    contentHash: z423.string(),
+    signedBy: z423.string().optional(),
+    recordedAt: z423.coerce.date()
   })),
-  merkleRoot: z421.string(),
-  platformSignature: z421.string()
+  merkleRoot: z423.string(),
+  platformSignature: z423.string()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.create.schema.ts
-import { z as z423 } from "zod";
+import { z as z425 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.list.schema.ts
-import { z as z422 } from "zod";
-var WebhookPayloadShapeSchema = z422.enum(["thin", "fat"]);
-var WebhookBreakerStateSchema = z422.enum(["closed", "half_open", "open"]);
-var WebhookDeliveryFailureClassSchema = z422.enum([
+import { z as z424 } from "zod";
+var WebhookPayloadShapeSchema = z424.enum(["thin", "fat"]);
+var WebhookBreakerStateSchema = z424.enum(["closed", "half_open", "open"]);
+var WebhookDeliveryFailureClassSchema = z424.enum([
   "DNS_FAIL",
   "TLS_FAIL",
   "CONNECT_TIMEOUT",
@@ -29665,35 +29736,35 @@ var WebhookDeliveryFailureClassSchema = z422.enum([
   "RECEIPT_INVALID_SIG",
   "RECEIPT_HASH_MISMATCH"
 ]);
-var WebhookFinalityStateSchema = z422.enum(["pending", "provisional", "final", "retracted", "recalled"]);
-var WebhookSigningSecretStatusSchema = z422.enum(["active", "previous", "revoked"]);
-var WebhookFatEventsAcknowledgmentSchema = z422.object({
-  acknowledgedAt: z422.coerce.date(),
-  acknowledgedByUserId: z422.string(),
-  fieldsAcknowledged: z422.array(z422.string())
-});
-var WebhookEndpointSchema = z422.object({
-  id: z422.uuid(),
-  tenantId: z422.string(),
-  systemId: z422.string(),
-  url: z422.url(),
-  displayName: z422.string().nullable(),
-  subscriptions: z422.array(z422.string()),
+var WebhookFinalityStateSchema = z424.enum(["pending", "provisional", "final", "retracted", "recalled"]);
+var WebhookSigningSecretStatusSchema = z424.enum(["active", "previous", "revoked"]);
+var WebhookFatEventsAcknowledgmentSchema = z424.object({
+  acknowledgedAt: z424.coerce.date(),
+  acknowledgedByUserId: z424.string(),
+  fieldsAcknowledged: z424.array(z424.string())
+});
+var WebhookEndpointSchema = z424.object({
+  id: z424.uuid(),
+  tenantId: z424.string(),
+  systemId: z424.string(),
+  url: z424.url(),
+  displayName: z424.string().nullable(),
+  subscriptions: z424.array(z424.string()),
   defaultPayloadShape: WebhookPayloadShapeSchema,
-  counterSignedReceipts: z422.boolean(),
+  counterSignedReceipts: z424.boolean(),
   breakerState: WebhookBreakerStateSchema,
-  disabledAt: z422.coerce.date().nullable(),
-  disabledReason: z422.string().nullable(),
+  disabledAt: z424.coerce.date().nullable(),
+  disabledReason: z424.string().nullable(),
   fatEventsAcknowledgment: WebhookFatEventsAcknowledgmentSchema.nullable(),
-  secret: z422.object({
-    activeVersion: z422.number().int().positive().nullable(),
-    previousVersion: z422.number().int().positive().nullable(),
-    previousRevokesAt: z422.coerce.date().nullable(),
-    lastUsedAt: z422.coerce.date().nullable()
+  secret: z424.object({
+    activeVersion: z424.number().int().positive().nullable(),
+    previousVersion: z424.number().int().positive().nullable(),
+    previousRevokesAt: z424.coerce.date().nullable(),
+    lastUsedAt: z424.coerce.date().nullable()
   }),
-  createdAt: z422.coerce.date(),
-  updatedAt: z422.coerce.date(),
-  createdByUserId: z422.string().nullable()
+  createdAt: z424.coerce.date(),
+  updatedAt: z424.coerce.date(),
+  createdByUserId: z424.string().nullable()
 });
 var WEBHOOKS_COLLECTION_FIELDS = {
   displayName: textField(),
@@ -29712,44 +29783,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 = z423.object({
-  url: z423.url(),
-  displayName: z423.string().trim().min(1).max(200).optional(),
-  subscriptions: z423.array(z423.string().trim().min(1)).min(1).default(["*.final", "*.retracted", "*.recalled"]),
+var WebhooksV2CreateInputSchema = z425.object({
+  url: z425.url(),
+  displayName: z425.string().trim().min(1).max(200).optional(),
+  subscriptions: z425.array(z425.string().trim().min(1)).min(1).default(["*.final", "*.retracted", "*.recalled"]),
   defaultPayloadShape: WebhookPayloadShapeSchema.default("thin"),
-  counterSignedReceipts: z423.boolean().default(false)
+  counterSignedReceipts: z425.boolean().default(false)
 });
 var WebhookEndpointCreateResultSchema = WebhookEndpointSchema.extend({
-  signingSecret: z423.string().nullable()
+  signingSecret: z425.string().nullable()
 });
 var WebhooksV2CreateOutputSchema = createSingleResponse(WebhookEndpointCreateResultSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.delete.schema.ts
-import { z as z424 } from "zod";
-var WebhooksV2DeleteInputSchema = z424.object({
-  id: z424.uuid()
+import { z as z426 } from "zod";
+var WebhooksV2DeleteInputSchema = z426.object({
+  id: z426.uuid()
 });
 var WebhooksV2DeleteOutputSchema = DeleteResponseSchema;
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.deliveries.list.schema.ts
-import { z as z425 } from "zod";
-var WebhookDeliveryStatusSchema = z425.enum(["pending", "delivered", "failed"]);
-var WebhookDeliverySchema = z425.object({
-  id: z425.uuid(),
-  eventOutboxId: z425.uuid(),
-  endpointId: z425.uuid(),
-  tenantId: z425.string(),
-  evtId: z425.string(),
-  eventType: z425.string(),
-  attemptN: z425.number().int().nonnegative(),
-  attemptedAt: z425.coerce.date(),
-  responseStatus: z425.number().int().nullable(),
+import { z as z427 } from "zod";
+var WebhookDeliveryStatusSchema = z427.enum(["pending", "delivered", "failed"]);
+var WebhookDeliverySchema = z427.object({
+  id: z427.uuid(),
+  eventOutboxId: z427.uuid(),
+  endpointId: z427.uuid(),
+  tenantId: z427.string(),
+  evtId: z427.string(),
+  eventType: z427.string(),
+  attemptN: z427.number().int().nonnegative(),
+  attemptedAt: z427.coerce.date(),
+  responseStatus: z427.number().int().nullable(),
   failureClass: WebhookDeliveryFailureClassSchema.nullable(),
   status: WebhookDeliveryStatusSchema,
-  deliveredAt: z425.coerce.date().nullable(),
-  isReplay: z425.boolean(),
-  isTest: z425.boolean(),
-  traceId: z425.string().nullable()
+  deliveredAt: z427.coerce.date().nullable(),
+  isReplay: z427.boolean(),
+  isTest: z427.boolean(),
+  traceId: z427.string().nullable()
 });
 var WEBHOOK_DELIVERIES_COLLECTION_FIELDS = {
   status: enumField(["pending", "delivered", "failed"]),
@@ -29775,167 +29846,167 @@ var WebhooksV2DeliveriesListInputSchema = createCollectionInputSchema(WEBHOOK_DE
   defaultSort: "attemptedAt",
   globalSearch: false
 });
-var WebhooksV2DeliveriesListParamsSchema = z425.object({
-  id: z425.uuid()
+var WebhooksV2DeliveriesListParamsSchema = z427.object({
+  id: z427.uuid()
 });
 var WebhooksV2DeliveriesListOutputSchema = createPaginatedResponse(WebhookDeliverySchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.deliveries.read.schema.ts
-import { z as z426 } from "zod";
-var WebhooksV2DeliveriesReadInputSchema = z426.object({
-  id: z426.uuid(),
-  deliveryId: z426.uuid()
+import { z as z428 } from "zod";
+var WebhooksV2DeliveriesReadInputSchema = z428.object({
+  id: z428.uuid(),
+  deliveryId: z428.uuid()
 });
 var WebhookDeliveryDetailSchema = WebhookDeliverySchema.extend({
-  request: z426.object({
-    payload: z426.record(z426.string(), z426.json()),
-    signedHeaders: z426.record(z426.string(), z426.union([z426.string(), z426.array(z426.string())])),
-    signedStringPreview: z426.string()
+  request: z428.object({
+    payload: z428.record(z428.string(), z428.json()),
+    signedHeaders: z428.record(z428.string(), z428.union([z428.string(), z428.array(z428.string())])),
+    signedStringPreview: z428.string()
   }),
-  response: z426.object({
-    headers: z426.record(z426.string(), z426.union([z426.string(), z426.array(z426.string())])).nullable(),
-    body: z426.string().nullable(),
-    timings: z426.object({
-      dnsMs: z426.number().int().nullable(),
-      tlsMs: z426.number().int().nullable(),
-      connectMs: z426.number().int().nullable(),
-      ttfbMs: z426.number().int().nullable()
+  response: z428.object({
+    headers: z428.record(z428.string(), z428.union([z428.string(), z428.array(z428.string())])).nullable(),
+    body: z428.string().nullable(),
+    timings: z428.object({
+      dnsMs: z428.number().int().nullable(),
+      tlsMs: z428.number().int().nullable(),
+      connectMs: z428.number().int().nullable(),
+      ttfbMs: z428.number().int().nullable()
     })
   })
 });
 var WebhooksV2DeliveriesReadOutputSchema = createSingleResponse(WebhookDeliveryDetailSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.deliveries.retry.schema.ts
-import { z as z427 } from "zod";
-var WebhooksV2DeliveriesRetryInputSchema = z427.object({
-  id: z427.uuid(),
-  deliveryId: z427.uuid()
+import { z as z429 } from "zod";
+var WebhooksV2DeliveriesRetryInputSchema = z429.object({
+  id: z429.uuid(),
+  deliveryId: z429.uuid()
 });
-var WebhooksV2DeliveriesRetryOutputSchema = createSingleResponse(z427.object({
-  deliveryId: z427.uuid(),
-  scheduled: z427.boolean()
+var WebhooksV2DeliveriesRetryOutputSchema = createSingleResponse(z429.object({
+  deliveryId: z429.uuid(),
+  scheduled: z429.boolean()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.read.schema.ts
-import { z as z428 } from "zod";
-var WebhooksV2ReadInputSchema = z428.object({
-  id: z428.uuid()
+import { z as z430 } from "zod";
+var WebhooksV2ReadInputSchema = z430.object({
+  id: z430.uuid()
 });
 var WebhooksV2ReadOutputSchema = createSingleResponse(WebhookEndpointSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.recalls.schema.ts
-import { z as z429 } from "zod";
-var WebhooksV2RecallsParamsSchema = z429.object({
-  evtId: z429.string().trim().min(1)
-});
-var WebhooksV2RecallsBodySchema = z429.object({
-  reason: z429.string().trim().min(1).max(2000)
-});
-var WebhooksV2RecallsOutputSchema = createSingleResponse(z429.object({
-  evtId: z429.string(),
-  recalledEvtId: z429.string(),
-  supersedes: z429.string(),
-  reason: z429.string(),
-  recalledByUserId: z429.string()
+import { z as z431 } from "zod";
+var WebhooksV2RecallsParamsSchema = z431.object({
+  evtId: z431.string().trim().min(1)
+});
+var WebhooksV2RecallsBodySchema = z431.object({
+  reason: z431.string().trim().min(1).max(2000)
+});
+var WebhooksV2RecallsOutputSchema = createSingleResponse(z431.object({
+  evtId: z431.string(),
+  recalledEvtId: z431.string(),
+  supersedes: z431.string(),
+  reason: z431.string(),
+  recalledByUserId: z431.string()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.replays.schema.ts
-import { z as z430 } from "zod";
-var WebhooksV2ReplayByRangeSchema = z430.object({
-  fromBlock: z430.coerce.bigint(),
-  toBlock: z430.coerce.bigint().optional(),
-  chainId: z430.coerce.number().int().positive(),
-  confirmLargeRange: z430.boolean().default(false)
+import { z as z432 } from "zod";
+var WebhooksV2ReplayByRangeSchema = z432.object({
+  fromBlock: z432.coerce.bigint(),
+  toBlock: z432.coerce.bigint().optional(),
+  chainId: z432.coerce.number().int().positive(),
+  confirmLargeRange: z432.boolean().default(false)
 });
-var WebhooksV2ReplayByEventSchema = z430.object({
-  evtId: z430.string().trim().min(1),
-  chainId: z430.coerce.number().int().positive().optional()
+var WebhooksV2ReplayByEventSchema = z432.object({
+  evtId: z432.string().trim().min(1),
+  chainId: z432.coerce.number().int().positive().optional()
 });
-var WebhooksV2ReplaysParamsSchema = z430.object({
-  id: z430.uuid()
+var WebhooksV2ReplaysParamsSchema = z432.object({
+  id: z432.uuid()
 });
-var WebhooksV2ReplaysBodySchema = z430.union([WebhooksV2ReplayByRangeSchema, WebhooksV2ReplayByEventSchema]);
-var WebhooksV2ReplaysOutputSchema = createSingleResponse(z430.object({
-  replayId: z430.uuid(),
-  endpointId: z430.uuid(),
-  eventsEnqueued: z430.number().int().nonnegative(),
-  snapshotToBlock: z430.string().nullable()
+var WebhooksV2ReplaysBodySchema = z432.union([WebhooksV2ReplayByRangeSchema, WebhooksV2ReplayByEventSchema]);
+var WebhooksV2ReplaysOutputSchema = createSingleResponse(z432.object({
+  replayId: z432.uuid(),
+  endpointId: z432.uuid(),
+  eventsEnqueued: z432.number().int().nonnegative(),
+  snapshotToBlock: z432.string().nullable()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.revoke-secret.schema.ts
-import { z as z431 } from "zod";
-var WebhooksV2RevokeSecretInputSchema = z431.object({
-  id: z431.uuid()
-});
-var WebhooksV2RevokeSecretOutputSchema = createSingleResponse(z431.object({
-  endpointId: z431.uuid(),
-  activeVersion: z431.number().int().positive(),
-  previousVersion: z431.number().int().positive().nullable(),
-  revokedVersion: z431.number().int().positive()
+import { z as z433 } from "zod";
+var WebhooksV2RevokeSecretInputSchema = z433.object({
+  id: z433.uuid()
+});
+var WebhooksV2RevokeSecretOutputSchema = createSingleResponse(z433.object({
+  endpointId: z433.uuid(),
+  activeVersion: z433.number().int().positive(),
+  previousVersion: z433.number().int().positive().nullable(),
+  revokedVersion: z433.number().int().positive()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.rotate-secret.schema.ts
-import { z as z432 } from "zod";
-var WebhooksV2RotateSecretInputSchema = z432.object({
-  id: z432.uuid()
+import { z as z434 } from "zod";
+var WebhooksV2RotateSecretInputSchema = z434.object({
+  id: z434.uuid()
 });
-var WebhooksV2RotateSecretOutputSchema = createSingleResponse(z432.object({
-  endpointId: z432.uuid(),
-  activeVersion: z432.number().int().positive(),
-  previousVersion: z432.number().int().positive().nullable(),
-  previousRevokesAt: z432.coerce.date().nullable(),
-  signingSecret: z432.string().nullable()
+var WebhooksV2RotateSecretOutputSchema = createSingleResponse(z434.object({
+  endpointId: z434.uuid(),
+  activeVersion: z434.number().int().positive(),
+  previousVersion: z434.number().int().positive().nullable(),
+  previousRevokesAt: z434.coerce.date().nullable(),
+  signingSecret: z434.string().nullable()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.stats.schema.ts
-import { z as z433 } from "zod";
-var WebhooksV2StatsInputSchema = z433.object({
-  endpointId: z433.uuid().optional()
+import { z as z435 } from "zod";
+var WebhooksV2StatsInputSchema = z435.object({
+  endpointId: z435.uuid().optional()
 });
-var WebhooksV2StatsOutputDataSchema = z433.object({
-  totalDeliveries: z433.number().int().min(0),
-  delivered: z433.number().int().min(0),
-  failed: z433.number().int().min(0),
-  hourlyBuckets: z433.array(z433.number().int().min(0)).length(24)
+var WebhooksV2StatsOutputDataSchema = z435.object({
+  totalDeliveries: z435.number().int().min(0),
+  delivered: z435.number().int().min(0),
+  failed: z435.number().int().min(0),
+  hourlyBuckets: z435.array(z435.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 z434 } from "zod";
-var WebhooksV2TestEventParamsSchema = z434.object({
-  id: z434.uuid()
+import { z as z436 } from "zod";
+var WebhooksV2TestEventParamsSchema = z436.object({
+  id: z436.uuid()
 });
-var WebhooksV2TestEventBodySchema = z434.object({
-  eventType: z434.string().trim().min(1).default("webhook.test.final")
+var WebhooksV2TestEventBodySchema = z436.object({
+  eventType: z436.string().trim().min(1).default("webhook.test.final")
 });
-var WebhooksV2TestEventOutputSchema = createSingleResponse(z434.object({
-  evtId: z434.string(),
-  deliveryId: z434.uuid().nullable(),
-  isTest: z434.literal(true)
+var WebhooksV2TestEventOutputSchema = createSingleResponse(z436.object({
+  evtId: z436.string(),
+  deliveryId: z436.uuid().nullable(),
+  isTest: z436.literal(true)
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.update.schema.ts
-import { z as z435 } from "zod";
-var WebhooksV2UpdateParamsSchema = z435.object({
-  id: z435.uuid()
+import { z as z437 } from "zod";
+var WebhooksV2UpdateParamsSchema = z437.object({
+  id: z437.uuid()
 });
-var WebhooksV2UpdateBodySchema = z435.object({
-  url: z435.url().optional(),
-  displayName: z435.string().trim().min(1).max(200).nullable().optional(),
-  subscriptions: z435.array(z435.string().trim().min(1)).min(1).optional(),
+var WebhooksV2UpdateBodySchema = z437.object({
+  url: z437.url().optional(),
+  displayName: z437.string().trim().min(1).max(200).nullable().optional(),
+  subscriptions: z437.array(z437.string().trim().min(1)).min(1).optional(),
   defaultPayloadShape: WebhookPayloadShapeSchema.optional(),
-  counterSignedReceipts: z435.boolean().optional(),
-  disabled: z435.boolean().optional(),
-  disabledReason: z435.string().trim().min(1).max(500).nullable().optional(),
+  counterSignedReceipts: z437.boolean().optional(),
+  disabled: z437.boolean().optional(),
+  disabledReason: z437.string().trim().min(1).max(500).nullable().optional(),
   fatEventsAcknowledgment: WebhookFatEventsAcknowledgmentSchema.omit({
     acknowledgedAt: true,
     acknowledgedByUserId: true
   }).optional()
 });
-var WebhooksV2UpdateQuerySchema = z435.object({
-  acknowledgePending: z435.union([z435.literal("true"), z435.literal(true)]).transform(() => true).optional()
+var WebhooksV2UpdateQuerySchema = z437.object({
+  acknowledgePending: z437.union([z437.literal("true"), z437.literal(true)]).transform(() => true).optional()
 }).optional();
-var WebhooksV2UpdateInputSchema = z435.object({
+var WebhooksV2UpdateInputSchema = z437.object({
   params: WebhooksV2UpdateParamsSchema,
   body: WebhooksV2UpdateBodySchema,
   query: WebhooksV2UpdateQuerySchema
@@ -30070,21 +30141,21 @@ var webhooksV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhook-receipts/webhook-receipts.v2.create.schema.ts
-import { z as z437 } from "zod";
+import { z as z439 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhook-receipts/webhook-receipts.v2.list.schema.ts
-import { z as z436 } from "zod";
-var WebhookReceiptVerificationFailureClassSchema = z436.enum(["RECEIPT_INVALID_SIG", "RECEIPT_HASH_MISMATCH"]);
-var WebhookReceiptSchema = z436.object({
-  id: z436.uuid(),
-  deliveryId: z436.uuid(),
-  evtId: z436.string(),
-  tenantId: z436.string(),
-  endpointId: z436.uuid(),
-  consumerSignature: z436.string(),
-  innerEventHash: z436.string(),
-  receivedAt: z436.coerce.date(),
-  verifiedAt: z436.coerce.date().nullable(),
+import { z as z438 } from "zod";
+var WebhookReceiptVerificationFailureClassSchema = z438.enum(["RECEIPT_INVALID_SIG", "RECEIPT_HASH_MISMATCH"]);
+var WebhookReceiptSchema = z438.object({
+  id: z438.uuid(),
+  deliveryId: z438.uuid(),
+  evtId: z438.string(),
+  tenantId: z438.string(),
+  endpointId: z438.uuid(),
+  consumerSignature: z438.string(),
+  innerEventHash: z438.string(),
+  receivedAt: z438.coerce.date(),
+  verifiedAt: z438.coerce.date().nullable(),
   verificationFailureClass: WebhookReceiptVerificationFailureClassSchema.nullable()
 });
 var WEBHOOK_RECEIPTS_COLLECTION_FIELDS = {
@@ -30101,19 +30172,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 = z437.object({
-  deliveryId: z437.uuid(),
-  evtId: z437.string().trim().min(1),
-  endpointId: z437.uuid(),
-  consumerSignature: z437.string().trim().min(1),
-  innerEventHash: z437.string().trim().min(1)
+var WebhookReceiptsV2CreateInputSchema = z439.object({
+  deliveryId: z439.uuid(),
+  evtId: z439.string().trim().min(1),
+  endpointId: z439.uuid(),
+  consumerSignature: z439.string().trim().min(1),
+  innerEventHash: z439.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 z438 } from "zod";
-var WebhookReceiptsV2ReadInputSchema = z438.object({
-  id: z438.uuid()
+import { z as z440 } from "zod";
+var WebhookReceiptsV2ReadInputSchema = z440.object({
+  id: z440.uuid()
 });
 var WebhookReceiptsV2ReadOutputSchema = createSingleResponse(WebhookReceiptSchema);
 
@@ -30392,7 +30463,7 @@ function normalizeDalpBaseUrl(url) {
 // package.json
 var package_default = {
   name: "@settlemint/dalp-sdk",
-  version: "2.1.7-main.25736341678",
+  version: "2.1.7-main.25738823940",
   private: false,
   description: "Fully typed SDK for the DALP tokenization platform API",
   homepage: "https://settlemint.com",