@settlemint/dalp-sdk 2.1.7-main.25674533400 → 2.1.7-main.25679765049

package/dist/index.js

@@ -23216,6 +23216,78 @@ var externalTokenV2Contract = {
   register
 };
 
+// ../../packages/dalp/api-contract/src/routes/v2/historical-balances/historical-balances.v2.at-block.schema.ts
+import { z as z324 } from "zod";
+var HISTORICAL_BALANCES_AT_BLOCK_KIND_OPTIONS = ["account", "totalSupply"];
+var REQUIRED_DISCRIMINATOR_MESSAGE = "at least one of filter[tokenAddress] or filter[account] is required when querying at-block snapshots";
+var DISCRIMINATOR_FILTER_FIELDS = new Set(["tokenAddress", "account", "kind"]);
+var HISTORICAL_BALANCES_AT_BLOCK_COLLECTION_FIELDS = {
+  tokenAddress: addressField({ sortable: false, defaultOperator: "eq" }),
+  account: addressField({ defaultOperator: "eq" }),
+  kind: enumField(HISTORICAL_BALANCES_AT_BLOCK_KIND_OPTIONS, { sortable: false, facetable: true })
+};
+var HistoricalBalancesAtBlockCollectionInputSchema = createCollectionInputSchema(HISTORICAL_BALANCES_AT_BLOCK_COLLECTION_FIELDS, {
+  defaultSort: "account",
+  globalSearch: false
+});
+function isRecord2(value2) {
+  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+}
+var HistoricalBalancesAtBlockV2InputSchema = z324.preprocess((input) => {
+  if (!isRecord2(input)) {
+    return input;
+  }
+  return {
+    block: input.block,
+    collection: input
+  };
+}, z324.object({
+  block: z324.coerce.bigint().nonnegative(),
+  collection: HistoricalBalancesAtBlockCollectionInputSchema
+})).transform(({ block, collection }) => ({ ...collection, block })).superRefine((query, ctx) => {
+  const hasDiscriminator = query.filters.some((filter) => filter.id === "tokenAddress" || filter.id === "account");
+  if (!hasDiscriminator) {
+    ctx.addIssue({
+      code: "custom",
+      message: REQUIRED_DISCRIMINATOR_MESSAGE,
+      path: ["filter"]
+    });
+  }
+  for (const filter of query.filters) {
+    if (DISCRIMINATOR_FILTER_FIELDS.has(filter.id) && filter.operator !== "eq") {
+      ctx.addIssue({
+        code: "custom",
+        message: `filter[${filter.id}] only supports operator=eq on this endpoint`,
+        path: ["filter", filter.id]
+      });
+    }
+  }
+});
+var HistoricalBalancesAtBlockV2ItemSchema = z324.object({
+  tokenAddress: ethereumAddress,
+  account: ethereumAddress,
+  kind: z324.enum(["account", "totalSupply", "no-checkpoint"]),
+  balance: bigDecimal(),
+  balanceExact: apiBigInt,
+  asOfBlockNumber: apiBigInt.nullable(),
+  asOfBlockTimestamp: timestamp().nullable(),
+  asOfTxHash: ethereumHash.nullable(),
+  asOfLogIndex: z324.number().int().nonnegative().nullable()
+});
+var HistoricalBalancesAtBlockV2OutputSchema = createPaginatedResponse(HistoricalBalancesAtBlockV2ItemSchema);
+
+// ../../packages/dalp/api-contract/src/routes/v2/historical-balances/historical-balances.v2.contract.ts
+var atBlock = v2Contract.route({
+  method: "GET",
+  path: "/historical-balances/at-block",
+  description: "List indexed token balances as of a specific block. Requires block plus filter[tokenAddress] or filter[account].",
+  successDescription: "Paginated list of historical balance snapshots at the requested block.",
+  tags: [V2_TAG.token]
+}).input(v2Input.query(HistoricalBalancesAtBlockV2InputSchema)).output(HistoricalBalancesAtBlockV2OutputSchema);
+var historicalBalancesV2Contract = {
+  atBlock
+};
+
 // ../../packages/dalp/api-contract/src/routes/v2/identity-recovery/identity-recovery.v2.contract.ts
 var preview2 = v2Contract.route({
   method: "GET",
@@ -23245,42 +23317,42 @@ var identityRecoveryV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/invitation/invitation.v2.active-deployment.schema.ts
-import { z as z324 } from "zod";
-var InvitationV2ActiveDeploymentInputSchema = z324.object({
-  invitationId: z324.string().min(1, "invitationId is required").regex(/^[A-Za-z0-9_-]+$/, "invitationId must contain only letters, digits, underscore, or dash")
+import { z as z325 } from "zod";
+var InvitationV2ActiveDeploymentInputSchema = z325.object({
+  invitationId: z325.string().min(1, "invitationId is required").regex(/^[A-Za-z0-9_-]+$/, "invitationId must contain only letters, digits, underscore, or dash")
 });
-var InvitationV2ActiveDeploymentOutputSchema = z324.discriminatedUnion("state", [
-  z324.object({
-    state: z324.literal("none")
+var InvitationV2ActiveDeploymentOutputSchema = z325.discriminatedUnion("state", [
+  z325.object({
+    state: z325.literal("none")
   }),
-  z324.object({
-    state: z324.literal("active"),
-    deploymentId: z324.string()
+  z325.object({
+    state: z325.literal("active"),
+    deploymentId: z325.string()
   }),
-  z324.object({
-    state: z324.literal("succeeded-recently"),
-    deploymentId: z324.string()
+  z325.object({
+    state: z325.literal("succeeded-recently"),
+    deploymentId: z325.string()
   }),
-  z324.object({
-    state: z324.literal("failed-purgeable"),
-    deploymentId: z324.string()
+  z325.object({
+    state: z325.literal("failed-purgeable"),
+    deploymentId: z325.string()
   }),
-  z324.object({
-    state: z324.literal("unknown")
+  z325.object({
+    state: z325.literal("unknown")
   })
 ]);
 
 // ../../packages/dalp/api-contract/src/routes/v2/invitation/invitation.v2.accept.schema.ts
-import { z as z328 } from "zod";
+import { z as z329 } from "zod";
 
 // ../../packages/dalp/api-contract/src/sse/deployment-stream.schema.ts
-import { z as z327 } from "zod";
+import { z as z328 } from "zod";
 
 // ../../packages/dalp/api-contract/src/dapi-errors/public-error.schema.ts
-import { z as z326 } from "zod";
+import { z as z327 } from "zod";
 
 // ../../packages/dalp/api-contract/src/dapi-errors/registry.schema.ts
-import { z as z325 } from "zod";
+import { z as z326 } from "zod";
 var DAPI_ERROR_CATEGORY_VALUES = [
   "client",
   "auth",
@@ -23305,65 +23377,65 @@ var DAPI_ERROR_SURFACE_VALUES = [
   "filesystem-presigned",
   "better-auth"
 ];
-var DAPI_ERROR_REGISTRY_ID_SCHEMA = z325.string().regex(/^DALP-\d{4}$/, "DAPI error ids must use DALP-0001 numeric public code format");
-var NonEmptyPublicStringSchema = z325.string().trim().min(1);
-var DAPI_ERROR_PUBLIC_COPY_SCHEMA = z325.object({
+var DAPI_ERROR_REGISTRY_ID_SCHEMA = z326.string().regex(/^DALP-\d{4}$/, "DAPI error ids must use DALP-0001 numeric public code format");
+var NonEmptyPublicStringSchema = z326.string().trim().min(1);
+var DAPI_ERROR_PUBLIC_COPY_SCHEMA = z326.object({
   message: NonEmptyPublicStringSchema,
   why: NonEmptyPublicStringSchema,
   fix: NonEmptyPublicStringSchema
 });
-var DAPI_ERROR_OBSERVABILITY_SCHEMA = z325.object({
-  severity: z325.enum(["info", "warning", "error", "fatal"]),
+var DAPI_ERROR_OBSERVABILITY_SCHEMA = z326.object({
+  severity: z326.enum(["info", "warning", "error", "fatal"]),
   otelEventName: NonEmptyPublicStringSchema,
   metricAttributeKey: NonEmptyPublicStringSchema,
-  dimensions: z325.array(NonEmptyPublicStringSchema).min(1)
+  dimensions: z326.array(NonEmptyPublicStringSchema).min(1)
 });
-var DAPI_ERROR_ENTRY_SCHEMA = z325.object({
+var DAPI_ERROR_ENTRY_SCHEMA = z326.object({
   id: DAPI_ERROR_REGISTRY_ID_SCHEMA,
-  category: z325.enum(DAPI_ERROR_CATEGORY_VALUES),
-  status: z325.number().int().min(400).max(599),
-  retryable: z325.boolean(),
-  expectedClientError: z325.boolean(),
+  category: z326.enum(DAPI_ERROR_CATEGORY_VALUES),
+  status: z326.number().int().min(400).max(599),
+  retryable: z326.boolean(),
+  expectedClientError: z326.boolean(),
   public: DAPI_ERROR_PUBLIC_COPY_SCHEMA,
-  surfaces: z325.array(z325.enum(DAPI_ERROR_SURFACE_VALUES)).min(1),
-  transports: z325.array(z325.enum(DAPI_ERROR_TRANSPORT_VALUES)).min(1),
-  orpcCode: z325.string().optional(),
-  contract: z325.object({
-    dalpCodeSource: z325.literal("contract-error-catalog"),
-    publicCodeField: z325.literal("dalpCode")
+  surfaces: z326.array(z326.enum(DAPI_ERROR_SURFACE_VALUES)).min(1),
+  transports: z326.array(z326.enum(DAPI_ERROR_TRANSPORT_VALUES)).min(1),
+  orpcCode: z326.string().optional(),
+  contract: z326.object({
+    dalpCodeSource: z326.literal("contract-error-catalog"),
+    publicCodeField: z326.literal("dalpCode")
   }).optional(),
-  authSensitivity: z325.object({
-    existenceDisclosure: z325.enum(["conceal", "public-safe"]),
+  authSensitivity: z326.object({
+    existenceDisclosure: z326.enum(["conceal", "public-safe"]),
     rationale: NonEmptyPublicStringSchema
   }).optional(),
   observability: DAPI_ERROR_OBSERVABILITY_SCHEMA,
   owner: NonEmptyPublicStringSchema,
   reviewNotes: NonEmptyPublicStringSchema.optional()
 });
-var DAPI_ERROR_SURFACE_SCHEMA = z325.object({
-  id: z325.enum(DAPI_ERROR_SURFACE_VALUES),
+var DAPI_ERROR_SURFACE_SCHEMA = z326.object({
+  id: z326.enum(DAPI_ERROR_SURFACE_VALUES),
   label: NonEmptyPublicStringSchema,
   externalConsumer: NonEmptyPublicStringSchema,
-  transport: z325.enum(DAPI_ERROR_TRANSPORT_VALUES),
-  vendorBoundary: z325.enum(["none", "vendor-owned"]),
-  coverage: z325.enum(["proof-slice", "in-scope", "excluded"]),
-  registryBehavior: z325.enum(["direct-envelope", "protocol-adapter", "registry-reference", "vendor-exclusion"]),
+  transport: z326.enum(DAPI_ERROR_TRANSPORT_VALUES),
+  vendorBoundary: z326.enum(["none", "vendor-owned"]),
+  coverage: z326.enum(["proof-slice", "in-scope", "excluded"]),
+  registryBehavior: z326.enum(["direct-envelope", "protocol-adapter", "registry-reference", "vendor-exclusion"]),
   publicAdapterBehavior: NonEmptyPublicStringSchema,
   generatedArtifactTarget: NonEmptyPublicStringSchema,
-  registryEntries: z325.array(DAPI_ERROR_REGISTRY_ID_SCHEMA),
+  registryEntries: z326.array(DAPI_ERROR_REGISTRY_ID_SCHEMA),
   notes: NonEmptyPublicStringSchema.optional()
 });
 
 // ../../packages/dalp/api-contract/src/dapi-errors/public-error.schema.ts
-var DAPI_PUBLIC_ERROR_DETAILS_SCHEMA = z326.record(z326.string(), z326.unknown());
-var DAPI_PUBLIC_ERROR_SCHEMA = z326.object({
+var DAPI_PUBLIC_ERROR_DETAILS_SCHEMA = z327.record(z327.string(), z327.unknown());
+var DAPI_PUBLIC_ERROR_SCHEMA = z327.object({
   id: DAPI_ERROR_REGISTRY_ID_SCHEMA,
-  category: z326.enum(DAPI_ERROR_CATEGORY_VALUES),
-  status: z326.number().int().min(400).max(599),
-  retryable: z326.boolean(),
-  message: z326.string().trim().min(1),
-  why: z326.string().trim().min(1),
-  fix: z326.string().trim().min(1),
+  category: z327.enum(DAPI_ERROR_CATEGORY_VALUES),
+  status: z327.number().int().min(400).max(599),
+  retryable: z327.boolean(),
+  message: z327.string().trim().min(1),
+  why: z327.string().trim().min(1),
+  fix: z327.string().trim().min(1),
   details: DAPI_PUBLIC_ERROR_DETAILS_SCHEMA.optional()
 });
 
@@ -23382,80 +23454,80 @@ var deploymentNodeTypes = [
   "paymaster",
   "other"
 ];
-var DeploymentNodeTypeSchema = z327.enum(deploymentNodeTypes);
-var DeploymentNodeStatusSchema = z327.enum(["pending", "in-progress", "completed", "failed"]);
-var DeploymentLeafNodeSchema = z327.object({
-  id: z327.string(),
-  label: z327.string(),
+var DeploymentNodeTypeSchema = z328.enum(deploymentNodeTypes);
+var DeploymentNodeStatusSchema = z328.enum(["pending", "in-progress", "completed", "failed"]);
+var DeploymentLeafNodeSchema = z328.object({
+  id: z328.string(),
+  label: z328.string(),
   type: DeploymentNodeTypeSchema,
   status: DeploymentNodeStatusSchema,
-  error: z327.string().optional()
+  error: z328.string().optional()
 });
 var DeploymentNodeSchema = DeploymentLeafNodeSchema.extend({
-  children: z327.array(DeploymentLeafNodeSchema).optional()
+  children: z328.array(DeploymentLeafNodeSchema).optional()
 });
-var DeploymentEventSchema = z327.discriminatedUnion("type", [
-  z327.object({
-    type: z327.literal("tree"),
-    nodes: z327.array(DeploymentNodeSchema)
+var DeploymentEventSchema = z328.discriminatedUnion("type", [
+  z328.object({
+    type: z328.literal("tree"),
+    nodes: z328.array(DeploymentNodeSchema)
   }),
-  z327.object({
-    type: z327.literal("update"),
-    nodeId: z327.string(),
+  z328.object({
+    type: z328.literal("update"),
+    nodeId: z328.string(),
     status: DeploymentNodeStatusSchema,
-    error: z327.string().optional()
-  }),
-  z327.object({
-    type: z327.literal("complete"),
-    success: z327.boolean(),
-    failedSteps: z327.array(z327.object({
-      id: z327.string(),
-      label: z327.string(),
-      error: z327.string().optional(),
+    error: z328.string().optional()
+  }),
+  z328.object({
+    type: z328.literal("complete"),
+    success: z328.boolean(),
+    failedSteps: z328.array(z328.object({
+      id: z328.string(),
+      label: z328.string(),
+      error: z328.string().optional(),
       wireError: ContractErrorDataSchema.optional()
     })).optional()
   }),
-  z327.object({
-    type: z327.literal("error"),
-    message: z327.string(),
+  z328.object({
+    type: z328.literal("error"),
+    message: z328.string(),
     error: DAPI_PUBLIC_ERROR_SCHEMA
   })
 ]);
 
 // ../../packages/dalp/api-contract/src/routes/v2/invitation/invitation.v2.accept.schema.ts
-var InvitationV2AcceptInputSchema = z328.object({
-  invitationId: z328.string().min(1, "invitationId is required").regex(/^[A-Za-z0-9_-]+$/, "invitationId must contain only letters, digits, underscore, or dash")
+var InvitationV2AcceptInputSchema = z329.object({
+  invitationId: z329.string().min(1, "invitationId is required").regex(/^[A-Za-z0-9_-]+$/, "invitationId must contain only letters, digits, underscore, or dash")
 });
-var InvitationV2AcceptOutputSchema = z328.object({
-  deploymentId: z328.string(),
-  tree: z328.array(DeploymentNodeSchema)
+var InvitationV2AcceptOutputSchema = z329.object({
+  deploymentId: z329.string(),
+  tree: z329.array(DeploymentNodeSchema)
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/invitation/invitation.v2.deploy.schema.ts
-import { z as z329 } from "zod";
-var InvitationV2DeployInputSchema = z329.object({
-  invitationId: z329.string().min(1, "invitationId is required").regex(/^[A-Za-z0-9_-]+$/, "invitationId must contain only letters, digits, underscore, or dash")
+import { z as z330 } from "zod";
+var InvitationV2DeployInputSchema = z330.object({
+  invitationId: z330.string().min(1, "invitationId is required").regex(/^[A-Za-z0-9_-]+$/, "invitationId must contain only letters, digits, underscore, or dash")
 });
-var InvitationV2DeployOutputSchema = z329.object({
-  deploymentId: z329.string(),
-  tree: z329.array(DeploymentNodeSchema)
+var InvitationV2DeployOutputSchema = z330.object({
+  deploymentId: z330.string(),
+  tree: z330.array(DeploymentNodeSchema)
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/invitation/invitation.v2.deploy-stream.schema.ts
 import { eventIterator as eventIterator4 } from "@orpc/contract";
-import { z as z330 } from "zod";
-var InvitationV2DeployStreamInputSchema = z330.object({
-  deploymentId: z330.string()
+import { z as z331 } from "zod";
+var InvitationV2DeployStreamInputSchema = z331.object({
+  deploymentId: z331.string()
 });
 var InvitationV2DeployStreamOutputSchema = eventIterator4(DeploymentEventSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/invitation/invitation.v2.retry.schema.ts
-import { z as z331 } from "zod";
-var InvitationV2RetryInputSchema = z331.object({
-  invitationId: z331.string().min(1, "invitationId is required").regex(/^[A-Za-z0-9_-]+$/, "invitationId must contain only letters, digits, underscore, or dash")
+import { z as z332 } from "zod";
+var InvitationV2RetryInputSchema = z332.object({
+  invitationId: z332.string().min(1, "invitationId is required").regex(/^[A-Za-z0-9_-]+$/, "invitationId must contain only letters, digits, underscore, or dash")
 });
-var InvitationV2RetryOutputSchema = z331.object({
-  ready: z331.literal(true)
+var InvitationV2RetryOutputSchema = z332.object({
+  ready: z332.literal(true)
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/invitation/invitation.v2.contract.ts
@@ -23503,50 +23575,50 @@ var invitationV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/organization/organization.v2.active-deployment.schema.ts
-import { z as z332 } from "zod";
-var OrganizationV2ActiveDeploymentOutputSchema = z332.object({
-  deploymentId: z332.string().nullable()
+import { z as z333 } from "zod";
+var OrganizationV2ActiveDeploymentOutputSchema = z333.object({
+  deploymentId: z333.string().nullable()
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/organization/organization.v2.deploy.schema.ts
-import { z as z333 } from "zod";
-var OrganizationV2DeployInputSchema = z333.object({
-  name: z333.string().min(1, "Organization name is required").max(32, "Organization name must be 32 characters or fewer"),
+import { z as z334 } from "zod";
+var OrganizationV2DeployInputSchema = z334.object({
+  name: z334.string().min(1, "Organization name is required").max(32, "Organization name must be 32 characters or fewer"),
   baseCurrency: fiatCurrency(),
-  targetCurrencies: z333.array(fiatCurrency()).min(1, "Pick at least one target currency for exchange-rate feeds")
+  targetCurrencies: z334.array(fiatCurrency()).min(1, "Pick at least one target currency for exchange-rate feeds")
 }).superRefine((value2, ctx) => {
   if (new Set(value2.targetCurrencies).size !== value2.targetCurrencies.length) {
     ctx.addIssue({
-      code: z333.ZodIssueCode.custom,
+      code: z334.ZodIssueCode.custom,
       message: "targetCurrencies must not contain duplicates",
       path: ["targetCurrencies"]
     });
   }
   if (!value2.targetCurrencies.includes(value2.baseCurrency)) {
     ctx.addIssue({
-      code: z333.ZodIssueCode.custom,
+      code: z334.ZodIssueCode.custom,
       message: "baseCurrency must be one of the selected targetCurrencies",
       path: ["baseCurrency"]
     });
   }
   if (value2.targetCurrencies.every((code2) => code2 === value2.baseCurrency)) {
     ctx.addIssue({
-      code: z333.ZodIssueCode.custom,
+      code: z334.ZodIssueCode.custom,
       message: "targetCurrencies must contain at least one currency other than baseCurrency",
       path: ["targetCurrencies"]
     });
   }
 });
-var OrganizationV2DeployOutputSchema = z333.object({
-  deploymentId: z333.string(),
-  tree: z333.array(DeploymentNodeSchema)
+var OrganizationV2DeployOutputSchema = z334.object({
+  deploymentId: z334.string(),
+  tree: z334.array(DeploymentNodeSchema)
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/organization/organization.v2.deploy-stream.schema.ts
 import { eventIterator as eventIterator5 } from "@orpc/contract";
-import { z as z334 } from "zod";
-var OrganizationV2DeployStreamInputSchema = z334.object({
-  deploymentId: z334.string()
+import { z as z335 } from "zod";
+var OrganizationV2DeployStreamInputSchema = z335.object({
+  deploymentId: z335.string()
 });
 var OrganizationV2DeployStreamOutputSchema = eventIterator5(DeploymentEventSchema);
 
@@ -23579,17 +23651,17 @@ var organizationV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/restate/restate.v2.cleanup-stale-deployments.ts
-import { z as z335 } from "zod";
-var RestateV2CleanupStaleDeploymentsInputSchema = z335.object({
-  serviceUrl: z335.string().url().meta({
+import { z as z336 } from "zod";
+var RestateV2CleanupStaleDeploymentsInputSchema = z336.object({
+  serviceUrl: z336.string().url().meta({
     description: "Service URL of the deployment to keep (e.g. `http://ddwf:9080/v1`). Every other registered deployment is treated as stale and drained."
   }),
-  forceDrain: z335.boolean().default(false).meta({
+  forceDrain: z336.boolean().default(false).meta({
     description: "Pass `forceDrain=true` to delete stale deployments even when they still have pending invocations. Use in dev/local where old deployments point to dead ports."
   })
 });
-var RestateV2CleanupStaleDeploymentsOutputSchema = z335.object({
-  acknowledged: z335.literal(true).meta({ description: "Always `true` on success." })
+var RestateV2CleanupStaleDeploymentsOutputSchema = z336.object({
+  acknowledged: z336.literal(true).meta({ description: "Always `true` on success." })
 });
 var restateCleanupStaleDeploymentsContract = operator(v2Contract.route({
   method: "POST",
@@ -23598,51 +23670,51 @@ var restateCleanupStaleDeploymentsContract = operator(v2Contract.route({
 }).input(v2Input.body(RestateV2CleanupStaleDeploymentsInputSchema)).output(RestateV2CleanupStaleDeploymentsOutputSchema), { service: "restate", verb: "cleanup-stale-deployments" });
 
 // ../../packages/dalp/api-contract/src/routes/v2/restate/restate.v2.doctor.ts
-import { z as z336 } from "zod";
-var ComponentStatusEnum = z336.enum(["ok", "unreachable", "degraded"]);
-var IngressStatusSchema = z336.object({
+import { z as z337 } from "zod";
+var ComponentStatusEnum = z337.enum(["ok", "unreachable", "degraded"]);
+var IngressStatusSchema = z337.object({
   status: ComponentStatusEnum,
-  latencyMs: z336.number().nullable()
+  latencyMs: z337.number().nullable()
 });
-var AdminStatusSchema = z336.object({
+var AdminStatusSchema = z337.object({
   status: ComponentStatusEnum,
-  latencyMs: z336.number().nullable(),
-  version: z336.string().nullable()
+  latencyMs: z337.number().nullable(),
+  version: z337.string().nullable()
 });
-var DeploymentSchema = z336.object({
-  id: z336.string(),
-  serviceUrl: z336.string(),
+var DeploymentSchema = z337.object({
+  id: z337.string(),
+  serviceUrl: z337.string(),
   createdAt: timestamp()
 });
-var ServiceSchema = z336.object({
-  name: z336.string(),
-  revision: z336.number().optional()
+var ServiceSchema = z337.object({
+  name: z337.string(),
+  revision: z337.number().optional()
 });
-var RecentFailureSchema = z336.object({
-  id: z336.string(),
-  serviceName: z336.string(),
-  serviceKey: z336.string().nullable(),
+var RecentFailureSchema = z337.object({
+  id: z337.string(),
+  serviceName: z337.string(),
+  serviceKey: z337.string().nullable(),
   failedAt: timestamp(),
-  errorMessage: z336.string().nullable()
+  errorMessage: z337.string().nullable()
 });
-var DeploymentsReadoutSchema = z336.object({
+var DeploymentsReadoutSchema = z337.object({
   status: ComponentStatusEnum,
-  items: z336.array(DeploymentSchema),
-  error: z336.string().nullable()
+  items: z337.array(DeploymentSchema),
+  error: z337.string().nullable()
 });
-var ServicesReadoutSchema = z336.object({
+var ServicesReadoutSchema = z337.object({
   status: ComponentStatusEnum,
-  items: z336.array(ServiceSchema),
-  error: z336.string().nullable()
+  items: z337.array(ServiceSchema),
+  error: z337.string().nullable()
 });
-var InvocationsReadoutSchema = z336.object({
+var InvocationsReadoutSchema = z337.object({
   status: ComponentStatusEnum,
-  byStatus: z336.record(z336.string(), z336.number()),
-  recentFailures: z336.array(RecentFailureSchema).max(20),
-  error: z336.string().nullable()
+  byStatus: z337.record(z337.string(), z337.number()),
+  recentFailures: z337.array(RecentFailureSchema).max(20),
+  error: z337.string().nullable()
 });
-var RestateV2DoctorInputSchema = z336.object({}).strict();
-var RestateV2DoctorOutputSchema = z336.object({
+var RestateV2DoctorInputSchema = z337.object({}).strict();
+var RestateV2DoctorOutputSchema = z337.object({
   ingress: IngressStatusSchema,
   admin: AdminStatusSchema,
   deployments: DeploymentsReadoutSchema,
@@ -23656,18 +23728,18 @@ var restateDoctorContract = operator(v2Contract.route({
 }).input(v2Input.body(RestateV2DoctorInputSchema)).output(RestateV2DoctorOutputSchema), { service: "restate", verb: "doctor" });
 
 // ../../packages/dalp/api-contract/src/routes/v2/restate/restate.v2.force-redeploy.ts
-import { z as z337 } from "zod";
-var RestateV2ForceRedeployInputSchema = z337.object({
-  serviceUrl: z337.string().url().meta({
+import { z as z338 } from "zod";
+var RestateV2ForceRedeployInputSchema = z338.object({
+  serviceUrl: z338.string().url().meta({
     description: "Service URL to register with Restate (e.g. `http://ddwf:9080/v1`). Use the doctor route to discover the currently registered URL."
   }),
-  force: z337.boolean().default(true).meta({
+  force: z338.boolean().default(true).meta({
     description: "Pass `force=true` to the Restate admin API even when a registration already exists."
   })
 });
-var RestateV2ForceRedeployOutputSchema = z337.object({
-  acknowledged: z337.literal(true).meta({ description: "Always `true` on success." }),
-  deploymentId: z337.string().meta({ description: "Restate deployment id of the (re-)registered service." })
+var RestateV2ForceRedeployOutputSchema = z338.object({
+  acknowledged: z338.literal(true).meta({ description: "Always `true` on success." }),
+  deploymentId: z338.string().meta({ description: "Restate deployment id of the (re-)registered service." })
 });
 var restateForceRedeployContract = operator(v2Contract.route({
   method: "POST",
@@ -23676,14 +23748,14 @@ var restateForceRedeployContract = operator(v2Contract.route({
 }).input(v2Input.body(RestateV2ForceRedeployInputSchema)).output(RestateV2ForceRedeployOutputSchema), { service: "restate", verb: "force-redeploy" });
 
 // ../../packages/dalp/api-contract/src/routes/v2/restate/restate.v2.recover-stuck-workflow.ts
-import { z as z338 } from "zod";
+import { z as z339 } from "zod";
 var SAFE_IDENTIFIER_PATTERN = /^[a-zA-Z0-9_-]+$/;
-var RestateV2RecoverStuckWorkflowInputSchema = z338.object({
-  serviceName: z338.string().regex(SAFE_IDENTIFIER_PATTERN, "serviceName must match [a-zA-Z0-9_-]+").meta({ description: "Restate service name (e.g. `IdentityRecoveryWorkflow`)." }),
-  serviceKey: z338.string().regex(SAFE_IDENTIFIER_PATTERN, "serviceKey must match [a-zA-Z0-9_-]+").meta({ description: "Workflow service key — the per-invocation identifier (e.g. an invitation id)." })
+var RestateV2RecoverStuckWorkflowInputSchema = z339.object({
+  serviceName: z339.string().regex(SAFE_IDENTIFIER_PATTERN, "serviceName must match [a-zA-Z0-9_-]+").meta({ description: "Restate service name (e.g. `IdentityRecoveryWorkflow`)." }),
+  serviceKey: z339.string().regex(SAFE_IDENTIFIER_PATTERN, "serviceKey must match [a-zA-Z0-9_-]+").meta({ description: "Workflow service key — the per-invocation identifier (e.g. an invitation id)." })
 });
-var RestateV2RecoverStuckWorkflowOutputSchema = z338.object({
-  acknowledged: z338.literal(true).meta({
+var RestateV2RecoverStuckWorkflowOutputSchema = z339.object({
+  acknowledged: z339.literal(true).meta({
     description: "Always `true` on success. The blocked-error path carries structured details (reason, invocationIds) on `RESTATE_WORKFLOW_RETRY_BLOCKED`."
   })
 });
@@ -23718,16 +23790,16 @@ var searchV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/settings.v2.contract.ts
-import { z as z355 } from "zod";
+import { z as z356 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/settings.v2.list.schema.ts
-import { z as z339 } from "zod";
-var SettingV2ItemSchema = z339.object({
-  key: z339.string().meta({
+import { z as z340 } from "zod";
+var SettingV2ItemSchema = z340.object({
+  key: z340.string().meta({
     description: "The unique key identifying the setting",
     examples: ["BASE_CURRENCY", "SYSTEM_ADDRESS", "SYSTEM_ADDONS_SKIPPED"]
   }),
-  value: z339.string().meta({
+  value: z340.string().meta({
     description: "The value of the setting",
     examples: ["EUR", "0x..."]
   }),
@@ -23748,31 +23820,31 @@ var SettingsV2ListInputSchema = createCollectionInputSchema(SETTINGS_COLLECTION_
 var SettingsV2ListOutputSchema = createPaginatedResponse(SettingV2ItemSchema);
 
 // ../../packages/core/validation/src/asset-class-definition.ts
-import { z as z340 } from "zod";
-var AssetClassDefinitionSchema = z340.object({
-  id: z340.string().min(1),
-  name: z340.string().min(1).max(255),
-  description: z340.string().max(1000).nullable(),
-  slug: z340.string().min(1).max(255),
-  isSystem: z340.boolean(),
-  organizationId: z340.string().nullable(),
-  createdBy: z340.string().nullable(),
+import { z as z341 } from "zod";
+var AssetClassDefinitionSchema = z341.object({
+  id: z341.string().min(1),
+  name: z341.string().min(1).max(255),
+  description: z341.string().max(1000).nullable(),
+  slug: z341.string().min(1).max(255),
+  isSystem: z341.boolean(),
+  organizationId: z341.string().nullable(),
+  createdBy: z341.string().nullable(),
   createdAt: timestamp(),
   updatedAt: timestamp()
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/asset-class-definitions/asset-class-definitions.v2.contract.ts
-import { z as z345 } from "zod";
+import { z as z346 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/asset-class-definitions/asset-class-definitions.v2.create.schema.ts
-import { z as z341 } from "zod";
-var CreateAssetClassInputSchema = z341.object({
-  name: z341.string().min(1).max(255).meta({ description: "Display name for the asset class", examples: ["Derivatives"] }),
-  description: z341.string().max(1000).nullable().optional().meta({
+import { z as z342 } from "zod";
+var CreateAssetClassInputSchema = z342.object({
+  name: z342.string().min(1).max(255).meta({ description: "Display name for the asset class", examples: ["Derivatives"] }),
+  description: z342.string().max(1000).nullable().optional().meta({
     description: "Optional description for the asset class",
     examples: ["Financial instruments whose value derives from underlying assets"]
   }),
-  slug: z341.string().min(1).max(255).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Slug must be kebab-case").optional().meta({
+  slug: z342.string().min(1).max(255).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Slug must be kebab-case").optional().meta({
     description: "URL-safe identifier. Auto-derived from name if not provided.",
     examples: ["derivatives"]
   })
@@ -23781,9 +23853,9 @@ var CreateAssetClassInputSchema = z341.object({
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/asset-class-definitions/asset-class-definitions.v2.delete.schema.ts
-import { z as z342 } from "zod";
-var DeleteAssetClassInputSchema = z342.object({
-  id: z342.string().min(1).meta({ description: "Asset class definition ID" })
+import { z as z343 } from "zod";
+var DeleteAssetClassInputSchema = z343.object({
+  id: z343.string().min(1).meta({ description: "Asset class definition ID" })
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/asset-class-definitions/asset-class-definitions.v2.list.schema.ts
@@ -23800,18 +23872,18 @@ var AssetClassDefinitionsV2ListInputSchema = createCollectionInputSchema(ASSET_C
 var AssetClassDefinitionsV2ListOutputSchema = createPaginatedResponse(AssetClassDefinitionSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/asset-class-definitions/asset-class-definitions.v2.read.schema.ts
-import { z as z343 } from "zod";
-var ReadAssetClassInputSchema = z343.object({
-  id: z343.string().min(1).meta({ description: "Asset class definition ID" })
+import { z as z344 } from "zod";
+var ReadAssetClassInputSchema = z344.object({
+  id: z344.string().min(1).meta({ description: "Asset class definition ID" })
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/asset-class-definitions/asset-class-definitions.v2.update.schema.ts
-import { z as z344 } from "zod";
-var UpdateAssetClassInputSchema = z344.object({
-  id: z344.string().min(1).meta({ description: "Asset class definition ID" }),
-  name: z344.string().min(1).max(255).optional().meta({ description: "Updated display name" }),
-  description: z344.string().max(1000).nullable().optional().meta({ description: "Updated description" }),
-  slug: z344.string().min(1).max(255).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Slug must be kebab-case").optional().meta({ description: "Updated slug" })
+import { z as z345 } from "zod";
+var UpdateAssetClassInputSchema = z345.object({
+  id: z345.string().min(1).meta({ description: "Asset class definition ID" }),
+  name: z345.string().min(1).max(255).optional().meta({ description: "Updated display name" }),
+  description: z345.string().max(1000).nullable().optional().meta({ description: "Updated description" }),
+  slug: z345.string().min(1).max(255).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Slug must be kebab-case").optional().meta({ description: "Updated slug" })
 }).meta({
   description: "Input schema for updating an asset class definition"
 });
@@ -23844,7 +23916,7 @@ var update6 = v2Contract.route({
   description: "Update an existing asset class definition.",
   successDescription: "Asset class definition updated successfully.",
   tags: [V2_TAG.assetClassDefinitions]
-}).input(v2Input.paramsBody(z345.object({ id: UpdateAssetClassInputSchema.shape.id }), z345.object(UpdateAssetClassInputSchema.shape).omit({ id: true }))).output(createSingleResponse(AssetClassDefinitionSchema));
+}).input(v2Input.paramsBody(z346.object({ id: UpdateAssetClassInputSchema.shape.id }), z346.object(UpdateAssetClassInputSchema.shape).omit({ id: true }))).output(createSingleResponse(AssetClassDefinitionSchema));
 var del7 = v2Contract.route({
   method: "DELETE",
   path: "/settings/asset-class-definitions/{id}",
@@ -23861,10 +23933,10 @@ var assetClassDefinitionsV2Contract = {
 };
 
 // ../../packages/core/validation/src/asset-type-template.ts
-import { z as z347 } from "zod";
+import { z as z348 } from "zod";
 
 // ../../packages/core/validation/src/asset-type-template-features.ts
-import { z as z346 } from "zod";
+import { z as z347 } from "zod";
 var tokenFeatureIds = [
   "historical-balances",
   "maturity-redemption",
@@ -23891,78 +23963,78 @@ var addonIds = [
   "price-resolver",
   "paymaster-signer"
 ];
-var tokenFeatureIdSchema = z346.enum(tokenFeatureIds);
-var addonIdSchema = z346.enum(addonIds);
+var tokenFeatureIdSchema = z347.enum(tokenFeatureIds);
+var addonIdSchema = z347.enum(addonIds);
 var tokenFeatureIdSet = new Set(tokenFeatureIds);
 var CONFIGURABLE_FEATURES = new Set(addonRegistry.filter((a) => a.configurable && a.id.endsWith("-feature-factory")).map((a) => a.id.replace("-feature-factory", "")).filter((id) => tokenFeatureIdSet.has(id)));
 
 // ../../packages/core/validation/src/asset-type-template.ts
-var metadataFieldMutability = z347.enum(["immutable", "restricted-mutable"]);
-var MetadataFieldBaseSchema = z347.object({
+var metadataFieldMutability = z348.enum(["immutable", "restricted-mutable"]);
+var MetadataFieldBaseSchema = z348.object({
   mutability: metadataFieldMutability,
-  label: z347.string().min(1),
-  description: z347.string().optional(),
-  required: z347.boolean().optional(),
-  defaultValue: z347.string().optional(),
-  configurableInDesigner: z347.boolean().optional()
+  label: z348.string().min(1),
+  description: z348.string().optional(),
+  required: z348.boolean().optional(),
+  defaultValue: z348.string().optional(),
+  configurableInDesigner: z348.boolean().optional()
 });
-var MetadataFieldSchema = z347.discriminatedUnion("type", [
+var MetadataFieldSchema = z348.discriminatedUnion("type", [
   MetadataFieldBaseSchema.extend({
-    type: z347.literal("string"),
-    minLength: z347.number().int().nonnegative().optional(),
-    maxLength: z347.number().int().positive().optional()
+    type: z348.literal("string"),
+    minLength: z348.number().int().nonnegative().optional(),
+    maxLength: z348.number().int().positive().optional()
   }),
   MetadataFieldBaseSchema.extend({
-    type: z347.literal("number"),
-    lowerBound: z347.string().optional(),
-    upperBound: z347.string().optional()
+    type: z348.literal("number"),
+    lowerBound: z348.string().optional(),
+    upperBound: z348.string().optional()
   }),
   MetadataFieldBaseSchema.extend({
-    type: z347.literal("date"),
-    lowerBound: z347.string().optional(),
-    upperBound: z347.string().optional()
+    type: z348.literal("date"),
+    lowerBound: z348.string().optional(),
+    upperBound: z348.string().optional()
   }),
   MetadataFieldBaseSchema.extend({
-    type: z347.literal("enum"),
-    options: z347.array(z347.string().min(1)).min(1).optional()
+    type: z348.literal("enum"),
+    options: z348.array(z348.string().min(1)).min(1).optional()
   }),
   MetadataFieldBaseSchema.extend({
-    type: z347.literal("isin")
+    type: z348.literal("isin")
   }),
   MetadataFieldBaseSchema.extend({
-    type: z347.literal("address")
+    type: z348.literal("address")
   })
 ]);
-var MetadataSchemaSchema = z347.record(z347.string().min(1), MetadataFieldSchema);
-var FeatureConfigPropertySchema = z347.object({
-  type: z347.enum(["string", "number", "date"]).optional(),
-  required: z347.boolean().optional(),
-  value: z347.union([z347.string(), z347.number()]).optional(),
-  upperBound: z347.number().optional()
-});
-var FeatureConfigEntryValueSchema = z347.union([z347.boolean(), FeatureConfigPropertySchema, z347.null()]);
-var FeatureConfigEntrySchema = z347.record(z347.string(), FeatureConfigEntryValueSchema);
-var FeatureConfigSchema = z347.record(z347.string().min(1), FeatureConfigEntrySchema);
+var MetadataSchemaSchema = z348.record(z348.string().min(1), MetadataFieldSchema);
+var FeatureConfigPropertySchema = z348.object({
+  type: z348.enum(["string", "number", "date"]).optional(),
+  required: z348.boolean().optional(),
+  value: z348.union([z348.string(), z348.number()]).optional(),
+  upperBound: z348.number().optional()
+});
+var FeatureConfigEntryValueSchema = z348.union([z348.boolean(), FeatureConfigPropertySchema, z348.null()]);
+var FeatureConfigEntrySchema = z348.record(z348.string(), FeatureConfigEntryValueSchema);
+var FeatureConfigSchema = z348.record(z348.string().min(1), FeatureConfigEntrySchema);
 var AssetClassFilterSchema = assetClassSlug().meta({
   description: "Asset class slug filter for template queries"
 });
-var AssetTypeTemplateSchema = z347.object({
-  id: z347.string().min(1),
-  name: z347.string().min(1).max(255),
-  description: z347.string().nullable(),
+var AssetTypeTemplateSchema = z348.object({
+  id: z348.string().min(1),
+  name: z348.string().min(1).max(255),
+  description: z348.string().nullable(),
   assetClass: assetClassSlug(),
-  typeId: z347.string().min(1),
+  typeId: z348.string().min(1),
   baseAssetType: assetType(),
-  isSystem: z347.boolean(),
-  isDraft: z347.boolean(),
-  organizationId: z347.string().nullable(),
-  version: z347.number().int().min(1),
-  requiredFeatures: z347.array(tokenFeatureIdSchema),
+  isSystem: z348.boolean(),
+  isDraft: z348.boolean(),
+  organizationId: z348.string().nullable(),
+  version: z348.number().int().min(1),
+  requiredFeatures: z348.array(tokenFeatureIdSchema),
   metadataSchema: MetadataSchemaSchema.nullable(),
   featureConfig: FeatureConfigSchema.nullable(),
-  hiddenFromSidebar: z347.boolean().optional(),
-  assetClassId: z347.string().nullable().optional(),
-  createdBy: z347.string().nullable(),
+  hiddenFromSidebar: z348.boolean().optional(),
+  assetClassId: z348.string().nullable().optional(),
+  createdBy: z348.string().nullable(),
   createdAt: timestamp(),
   updatedAt: timestamp()
 }).meta({
@@ -23970,20 +24042,20 @@ var AssetTypeTemplateSchema = z347.object({
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/asset-type-templates/asset-type-templates.v2.create.schema.ts
-import { z as z348 } from "zod";
-var CreateInputSchema = z348.object({
-  name: z348.string().trim().min(1).max(255),
-  description: z348.string().optional(),
-  typeId: z348.string().min(1).meta({ description: "Concrete asset type slug (e.g. 'bond', 'kbc-deposit')" }),
+import { z as z349 } from "zod";
+var CreateInputSchema = z349.object({
+  name: z349.string().trim().min(1).max(255),
+  description: z349.string().optional(),
+  typeId: z349.string().min(1).meta({ description: "Concrete asset type slug (e.g. 'bond', 'kbc-deposit')" }),
   baseAssetType: assetType().optional().meta({
     description: "Concrete deployable asset type that determines pricing fields. " + "Derived automatically from typeId or asset class when omitted.",
     examples: ["bond", "deposit"]
   }),
-  assetClassId: z348.string().min(1).optional().meta({
+  assetClassId: z349.string().min(1).optional().meta({
     description: "Reference to an asset class definition. When provided, links the template to a managed asset class.",
     examples: ["acd-system-fixed-income"]
   }),
-  requiredFeatures: z348.array(tokenFeatureIdSchema).default([]),
+  requiredFeatures: z349.array(tokenFeatureIdSchema).default([]),
   metadataSchema: MetadataSchemaSchema.optional(),
   featureConfig: FeatureConfigSchema.optional()
 }).meta({
@@ -23991,15 +24063,15 @@ var CreateInputSchema = z348.object({
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/asset-type-templates/asset-type-templates.v2.contract.ts
-import { z as z353 } from "zod";
+import { z as z354 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/asset-type-templates/asset-type-templates.v2.delete.schema.ts
-import { z as z349 } from "zod";
-var DeleteInputSchema2 = z349.object({
-  id: z349.string().min(1).meta({ description: "Template ID" })
+import { z as z350 } from "zod";
+var DeleteInputSchema2 = z350.object({
+  id: z350.string().min(1).meta({ description: "Template ID" })
 });
-var DeleteOutputSchema2 = z349.object({
-  success: z349.boolean()
+var DeleteOutputSchema2 = z350.object({
+  success: z350.boolean()
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/asset-type-templates/asset-type-templates.v2.list.schema.ts
@@ -24019,36 +24091,36 @@ var AssetTypeTemplatesV2ListInputSchema = createCollectionInputSchema(ASSET_TYPE
 var AssetTypeTemplatesV2ListOutputSchema = createPaginatedResponse(AssetTypeTemplateSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/asset-type-templates/asset-type-templates.v2.publish.schema.ts
-import { z as z350 } from "zod";
-var PublishInputSchema2 = z350.object({
-  id: z350.string().min(1).meta({ description: "Template ID" })
+import { z as z351 } from "zod";
+var PublishInputSchema2 = z351.object({
+  id: z351.string().min(1).meta({ description: "Template ID" })
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/asset-type-templates/asset-type-templates.v2.read.schema.ts
-import { z as z351 } from "zod";
-var ReadInputSchema2 = z351.object({
-  id: z351.string().min(1).meta({ description: "Template ID" })
+import { z as z352 } from "zod";
+var ReadInputSchema2 = z352.object({
+  id: z352.string().min(1).meta({ description: "Template ID" })
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/asset-type-templates/asset-type-templates.v2.update.schema.ts
-import { z as z352 } from "zod";
-var UpdateInputSchema2 = z352.object({
-  id: z352.string().min(1).meta({ description: "Template ID" }),
-  name: z352.string().trim().min(1).max(255).optional(),
-  description: z352.string().nullable().optional(),
-  typeId: z352.string().min(1).meta({ description: "Concrete asset type slug (e.g. 'bond', 'kbc-deposit')" }).optional(),
+import { z as z353 } from "zod";
+var UpdateInputSchema2 = z353.object({
+  id: z353.string().min(1).meta({ description: "Template ID" }),
+  name: z353.string().trim().min(1).max(255).optional(),
+  description: z353.string().nullable().optional(),
+  typeId: z353.string().min(1).meta({ description: "Concrete asset type slug (e.g. 'bond', 'kbc-deposit')" }).optional(),
   baseAssetType: assetType().optional().meta({
     description: "Concrete deployable asset type. Cannot be changed after publish.",
     examples: ["bond", "deposit"]
   }),
-  assetClassId: z352.string().min(1).nullable().optional().meta({
+  assetClassId: z353.string().min(1).nullable().optional().meta({
     description: "Reference to an asset class definition. Omit to leave unchanged. " + "Set to null to clear the link and revert to the system class mapping — " + `only valid when typeId is a recognized factory type (${assetFactoryTypeIds.join(", ")}). ` + "For org templates with custom typeId slugs, provide a valid assetClassId instead of null.",
     examples: ["acd-system-fixed-income"]
   }),
-  requiredFeatures: z352.array(tokenFeatureIdSchema).optional(),
+  requiredFeatures: z353.array(tokenFeatureIdSchema).optional(),
   metadataSchema: MetadataSchemaSchema.nullable().optional(),
   featureConfig: FeatureConfigSchema.nullable().optional(),
-  hiddenFromSidebar: z352.boolean().optional()
+  hiddenFromSidebar: z353.boolean().optional()
 }).meta({
   description: "Input schema for updating an asset type template"
 });
@@ -24081,7 +24153,7 @@ var update7 = v2Contract.route({
   description: "Update an existing asset type template.",
   successDescription: "Template updated successfully.",
   tags: [V2_TAG.assetTypeTemplates]
-}).input(v2Input.paramsBody(z353.object({ id: UpdateInputSchema2.shape.id }), z353.object(UpdateInputSchema2.shape).omit({ id: true }))).output(createSingleResponse(AssetTypeTemplateSchema));
+}).input(v2Input.paramsBody(z354.object({ id: UpdateInputSchema2.shape.id }), z354.object(UpdateInputSchema2.shape).omit({ id: true }))).output(createSingleResponse(AssetTypeTemplateSchema));
 var publish2 = v2Contract.route({
   method: "PUT",
   path: "/settings/asset-type-templates/{id}/publish",
@@ -24106,7 +24178,7 @@ var assetTypeTemplatesV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/compliance-templates/compliance-templates.v2.contract.ts
-import { z as z354 } from "zod";
+import { z as z355 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/settings/compliance-templates/compliance-templates.v2.list.schema.ts
 var COMPLIANCE_TEMPLATES_COLLECTION_FIELDS = {
@@ -24152,7 +24224,7 @@ var update8 = v2Contract.route({
   description: "Update an existing compliance template.",
   successDescription: "Template updated successfully.",
   tags: [V2_TAG.complianceTemplates]
-}).input(v2Input.paramsBody(z354.object({ id: UpdateInputSchema.shape.id }), z354.object(UpdateInputSchema.shape).omit({ id: true }))).output(createSingleResponse(ComplianceTemplateSchema));
+}).input(v2Input.paramsBody(z355.object({ id: UpdateInputSchema.shape.id }), z355.object(UpdateInputSchema.shape).omit({ id: true }))).output(createSingleResponse(ComplianceTemplateSchema));
 var publish3 = v2Contract.route({
   method: "PUT",
   path: "/settings/compliance-templates/{id}/publish",
@@ -24183,7 +24255,7 @@ var read18 = v2Contract.route({
   description: "Read a single setting by key.",
   successDescription: "Setting retrieved successfully.",
   tags: [V2_TAG.settings]
-}).input(v2Input.params(SettingsReadSchema)).output(createSingleResponse(z355.object({ value: z355.string().nullable() })));
+}).input(v2Input.params(SettingsReadSchema)).output(createSingleResponse(z356.object({ value: z356.string().nullable() })));
 var list22 = v2Contract.route({
   method: "GET",
   path: "/settings",
@@ -24197,7 +24269,7 @@ var upsert4 = v2Contract.route({
   description: "Create or update a setting by key.",
   successDescription: "Setting upserted successfully.",
   tags: [V2_TAG.settings]
-}).input(v2Input.body(SettingsUpsertSchema)).output(createSingleResponse(z355.object({ value: z355.string() })));
+}).input(v2Input.body(SettingsUpsertSchema)).output(createSingleResponse(z356.object({ value: z356.string() })));
 var del10 = v2Contract.route({
   method: "DELETE",
   path: "/settings/{key}",
@@ -24260,7 +24332,7 @@ var globalThemeSet2 = v2Contract.route({
   description: "Set or clear the global theme organization.",
   successDescription: "Global theme setting updated successfully.",
   tags: [V2_TAG.settings]
-}).input(v2Input.body(GlobalThemeSetSchema)).output(createSingleResponse(z355.object({ success: z355.boolean() })));
+}).input(v2Input.body(GlobalThemeSetSchema)).output(createSingleResponse(z356.object({ success: z356.boolean() })));
 var settingsV2Contract = {
   read: read18,
   list: list22,
@@ -24286,40 +24358,40 @@ var settingsV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/smart-wallets/smart-wallets.v2.schemas.ts
-import { z as z356 } from "zod";
-var SmartWalletSignerSchema = z356.object({
-  signer: z356.string(),
+import { z as z357 } from "zod";
+var SmartWalletSignerSchema = z357.object({
+  signer: z357.string(),
   validatorAddress: ethereumAddress,
-  weight: z356.string().nullable()
+  weight: z357.string().nullable()
 });
-var SmartWalletValidatorSchema = z356.object({
+var SmartWalletValidatorSchema = z357.object({
   moduleAddress: ethereumAddress,
-  moduleTypeId: z356.string().nullable(),
-  isInstalled: z356.boolean()
+  moduleTypeId: z357.string().nullable(),
+  isInstalled: z357.boolean()
 });
-var SmartWalletSchema = z356.object({
+var SmartWalletSchema = z357.object({
   address: ethereumAddress,
   factory: ethereumAddress,
   owner: ethereumAddress,
   defaultValidator: ethereumAddress.nullable(),
   identity: ethereumAddress.nullable(),
   system: ethereumAddress.nullable(),
-  threshold: z356.string().nullable(),
-  validators: z356.array(SmartWalletValidatorSchema),
-  signers: z356.array(SmartWalletSignerSchema),
-  description: z356.string().nullable(),
-  isDefaultWallet: z356.boolean(),
+  threshold: z357.string().nullable(),
+  validators: z357.array(SmartWalletValidatorSchema),
+  signers: z357.array(SmartWalletSignerSchema),
+  description: z357.string().nullable(),
+  isDefaultWallet: z357.boolean(),
   createdAt: timestamp()
 });
 var UINT64_MAX = 18446744073709551615n;
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-var MultisigSignerConfigSchema = z356.object({
+var MultisigSignerConfigSchema = z357.object({
   address: ethereumAddress.refine((v) => v.toLowerCase() !== ZERO_ADDRESS, "Signer address must not be the zero address. A zero-address signer can never produce a valid signature."),
-  weight: z356.string().regex(/^\d+$/, "Weight must be a positive decimal integer string").refine((v) => BigInt(v) > 0n, "Weight must be greater than 0").refine((v) => BigInt(v) <= UINT64_MAX, "Weight must fit in uint64 (max 18446744073709551615)").default("1")
+  weight: z357.string().regex(/^\d+$/, "Weight must be a positive decimal integer string").refine((v) => BigInt(v) > 0n, "Weight must be greater than 0").refine((v) => BigInt(v) <= UINT64_MAX, "Weight must fit in uint64 (max 18446744073709551615)").default("1")
 });
-var MultisigConfigSchema = z356.object({
-  signers: z356.array(MultisigSignerConfigSchema).min(1),
-  threshold: z356.string().regex(/^\d+$/, "Threshold must be a positive decimal integer string").refine((v) => BigInt(v) > 0n, "Threshold must be greater than 0").refine((v) => BigInt(v) <= UINT64_MAX, "Threshold must fit in uint64 (max 18446744073709551615)")
+var MultisigConfigSchema = z357.object({
+  signers: z357.array(MultisigSignerConfigSchema).min(1),
+  threshold: z357.string().regex(/^\d+$/, "Threshold must be a positive decimal integer string").refine((v) => BigInt(v) > 0n, "Threshold must be greater than 0").refine((v) => BigInt(v) <= UINT64_MAX, "Threshold must fit in uint64 (max 18446744073709551615)")
 }).refine((data) => {
   const addresses = data.signers.map((s) => s.address.toLowerCase());
   return new Set(addresses).size === addresses.length;
@@ -24327,24 +24399,24 @@ var MultisigConfigSchema = z356.object({
   const totalWeight = data.signers.reduce((sum, s) => sum + BigInt(s.weight), 0n);
   return totalWeight >= BigInt(data.threshold);
 }, "Total signer weights must be greater than or equal to the threshold. Otherwise no combination of signatures can ever meet the threshold.");
-var SmartWalletCreateInputSchema = z356.object({
-  description: z356.string().optional(),
-  isDefaultWallet: z356.boolean().optional(),
+var SmartWalletCreateInputSchema = z357.object({
+  description: z357.string().optional(),
+  isDefaultWallet: z357.boolean().optional(),
   multisig: MultisigConfigSchema.optional()
 });
-var SmartWalletUpdateInputSchema = z356.object({
-  description: z356.string().optional(),
-  isDefaultWallet: z356.boolean().optional()
+var SmartWalletUpdateInputSchema = z357.object({
+  description: z357.string().optional(),
+  isDefaultWallet: z357.boolean().optional()
 });
-var SmartWalletGasStatusSchema = z356.object({
-  hasPaymaster: z356.boolean(),
-  walletBalance: z356.string(),
-  chainZeroGas: z356.boolean()
+var SmartWalletGasStatusSchema = z357.object({
+  hasPaymaster: z357.boolean(),
+  walletBalance: z357.string(),
+  chainZeroGas: z357.boolean()
 });
-var SmartWalletGasStatusQuerySchema = z356.object({
+var SmartWalletGasStatusQuerySchema = z357.object({
   systemAddress: ethereumAddress.optional()
 });
-var SmartWalletAddressParamsSchema = z356.object({
+var SmartWalletAddressParamsSchema = z357.object({
   address: ethereumAddress
 });
 
@@ -24363,9 +24435,9 @@ var SmartWalletsV2ListInputSchema = createCollectionInputSchema(SMART_WALLETS_CO
 var SmartWalletsV2ListOutputSchema = createPaginatedResponse(SmartWalletSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/smart-wallets/smart-wallets.v2.approvals.schemas.ts
-import { z as z357 } from "zod";
-var hexHash = z357.string().regex(/^0x[\da-fA-F]{64}$/, "Must be a 66-character hex string (0x + 64 hex chars)").transform((v) => v);
-var MultisigApprovalStatusSchema = z357.enum([
+import { z as z358 } from "zod";
+var hexHash = z358.string().regex(/^0x[\da-fA-F]{64}$/, "Must be a 66-character hex string (0x + 64 hex chars)").transform((v) => v);
+var MultisigApprovalStatusSchema = z358.enum([
   "pending",
   "submitted",
   "executed",
@@ -24373,45 +24445,45 @@ var MultisigApprovalStatusSchema = z357.enum([
   "cancelled",
   "failed"
 ]);
-var MultisigSignatureSchema = z357.object({
-  id: z357.string(),
+var MultisigSignatureSchema = z358.object({
+  id: z358.string(),
   signerAddress: ethereumAddress,
-  signature: z357.string(),
-  weight: z357.string(),
+  signature: z358.string(),
+  weight: z358.string(),
   signedAt: timestamp()
 });
-var MultisigApprovalSchema = z357.object({
-  id: z357.string(),
-  userOpHash: z357.string(),
+var MultisigApprovalSchema = z358.object({
+  id: z358.string(),
+  userOpHash: z358.string(),
   walletAddress: ethereumAddress,
-  chainId: z357.number().int(),
-  organizationId: z357.string(),
+  chainId: z358.number().int(),
+  organizationId: z358.string(),
   initiatorAddress: ethereumAddress,
-  threshold: z357.string(),
-  currentWeight: z357.string(),
-  callData: z357.string(),
-  description: z357.string().nullable(),
+  threshold: z358.string(),
+  currentWeight: z358.string(),
+  callData: z358.string(),
+  description: z358.string().nullable(),
   status: MultisigApprovalStatusSchema,
   expiresAt: timestamp().nullable(),
   createdAt: timestamp(),
   updatedAt: timestamp(),
-  signatures: z357.array(MultisigSignatureSchema)
+  signatures: z358.array(MultisigSignatureSchema)
 });
-var ApprovalAddressParamsSchema = z357.object({
+var ApprovalAddressParamsSchema = z358.object({
   address: ethereumAddress
 });
-var ApprovalDetailParamsSchema = z357.object({
+var ApprovalDetailParamsSchema = z358.object({
   address: ethereumAddress,
   userOpHash: hexHash
 });
-var CreateApprovalInputSchema = z357.object({
+var CreateApprovalInputSchema = z358.object({
   userOpHash: hexHash,
-  threshold: z357.string().regex(/^\d+$/, "Threshold must be a positive decimal integer string").refine((v) => BigInt(v) > 0n, "Threshold must be greater than 0").optional(),
-  callData: z357.string().regex(/^0x[\da-fA-F]*$/, "callData must be a hex string starting with 0x"),
-  description: z357.string().optional(),
-  expiresAt: z357.iso.datetime().optional()
+  threshold: z358.string().regex(/^\d+$/, "Threshold must be a positive decimal integer string").refine((v) => BigInt(v) > 0n, "Threshold must be greater than 0").optional(),
+  callData: z358.string().regex(/^0x[\da-fA-F]*$/, "callData must be a hex string starting with 0x"),
+  description: z358.string().optional(),
+  expiresAt: z358.iso.datetime().optional()
 });
-var SignApprovalInputSchema = z357.object({});
+var SignApprovalInputSchema = z358.object({});
 
 // ../../packages/dalp/api-contract/src/routes/v2/smart-wallets/smart-wallets.v2.approvals.list.schema.ts
 var SMART_WALLET_APPROVALS_COLLECTION_FIELDS = {
@@ -24465,16 +24537,16 @@ var smartWalletsV2ApprovalsContract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/smart-wallets/smart-wallets.v2.modules.contract.ts
-import { z as z358 } from "zod";
+import { z as z359 } from "zod";
 var TAGS23 = [V2_TAG.smartWallets];
-var InstallModuleParamsSchema = z358.object({
+var InstallModuleParamsSchema = z359.object({
   address: ethereumAddress
 });
-var InstallModuleBodySchema = z358.object({
+var InstallModuleBodySchema = z359.object({
   moduleAddress: ethereumAddress,
-  initData: z358.string().optional()
+  initData: z359.string().optional()
 });
-var UninstallModuleParamsSchema = z358.object({
+var UninstallModuleParamsSchema = z359.object({
   address: ethereumAddress,
   moduleAddress: ethereumAddress
 });
@@ -24498,7 +24570,7 @@ var smartWalletsV2ModulesContract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/smart-wallets/smart-wallets.v2.signers.contract.ts
-import { z as z359 } from "zod";
+import { z as z360 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/smart-wallets/smart-wallets.v2.signers.list.schema.ts
 var SMART_WALLET_SIGNERS_COLLECTION_FIELDS = {
@@ -24515,17 +24587,17 @@ var SmartWalletSignersV2ListOutputSchema = createPaginatedResponse(SmartWalletSi
 
 // ../../packages/dalp/api-contract/src/routes/v2/smart-wallets/smart-wallets.v2.signers.contract.ts
 var TAGS24 = [V2_TAG.smartWallets];
-var ListSignersParamsSchema = z359.object({
+var ListSignersParamsSchema = z360.object({
   address: ethereumAddress
 });
-var AddSignerParamsSchema = z359.object({
+var AddSignerParamsSchema = z360.object({
   address: ethereumAddress
 });
-var AddSignerBodySchema = z359.object({
+var AddSignerBodySchema = z360.object({
   signer: ethereumAddress,
   weight: apiIntegerBigInt.refine((value2) => value2 > 0n && value2 <= 18446744073709551615n, "Weight must be between 1 and 2^64-1").default(1n)
 });
-var RemoveSignerParamsSchema = z359.object({
+var RemoveSignerParamsSchema = z360.object({
   address: ethereumAddress,
   signer: ethereumAddress
 });
@@ -24557,13 +24629,13 @@ var smartWalletsV2SignersContract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/smart-wallets/smart-wallets.v2.threshold.contract.ts
-import { z as z360 } from "zod";
+import { z as z361 } from "zod";
 var TAGS25 = [V2_TAG.smartWallets];
-var SetThresholdParamsSchema = z360.object({
+var SetThresholdParamsSchema = z361.object({
   address: ethereumAddress
 });
-var SetThresholdBodySchema = z360.object({
-  threshold: z360.string().regex(/^\d+$/, "Threshold must be a positive decimal integer string").refine((v) => BigInt(v) > 0n && BigInt(v) <= 18446744073709551615n, "Threshold must be between 1 and 2^64-1")
+var SetThresholdBodySchema = z361.object({
+  threshold: z361.string().regex(/^\d+$/, "Threshold must be a positive decimal integer string").refine((v) => BigInt(v) > 0n && BigInt(v) <= 18446744073709551615n, "Threshold must be between 1 and 2^64-1")
 });
 var setThreshold = v2Contract.route({
   method: "PUT",
@@ -24632,16 +24704,16 @@ var smartWalletsV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/access-manager/access-manager.v2.contract.ts
-import { z as z362 } from "zod";
+import { z as z363 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/access-manager/access-manager.v2.list.schema.ts
-import { z as z361 } from "zod";
-var SystemRolesV2ItemSchema = z361.object({
+import { z as z362 } from "zod";
+var SystemRolesV2ItemSchema = z362.object({
   account: ethereumAddress.meta({
     description: "The account address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  roles: z361.array(accessControlRole).meta({ description: "The roles of the account", examples: [["admin", "claimIssuer"]] })
+  roles: z362.array(accessControlRole).meta({ description: "The roles of the account", examples: [["admin", "claimIssuer"]] })
 });
 var SYSTEM_ROLES_COLLECTION_FIELDS = {
   account: addressField(),
@@ -24669,21 +24741,21 @@ var rolesRead = v2Contract.route({
   description: "Get the roles assigned to a specific account.",
   successDescription: "Roles retrieved successfully.",
   tags: [V2_TAG.accessManager]
-}).input(v2Input.params(z362.object({ address: SystemRolesReadInputSchema.shape.account }))).output(createSingleResponse(SystemRolesReadOutputSchema));
+}).input(v2Input.params(z363.object({ address: SystemRolesReadInputSchema.shape.account }))).output(createSingleResponse(SystemRolesReadOutputSchema));
 var grantRole = v2Contract.route({
   method: "POST",
   path: "/system/accounts/{address}/role-grants",
   description: "Grant a role to multiple accounts.",
   successDescription: "Roles granted successfully.",
   tags: [V2_TAG.accessManager]
-}).meta({ contractErrors: [...ACCESS_ERRORS] }).input(v2Input.paramsBody(z362.object({ address: GrantRoleInputSchema.shape.account }), GrantRoleInputSchema.omit({ account: true }))).output(createAsyncBlockchainMutationResponse(GrantRoleOutputSchema));
+}).meta({ contractErrors: [...ACCESS_ERRORS] }).input(v2Input.paramsBody(z363.object({ address: GrantRoleInputSchema.shape.account }), GrantRoleInputSchema.omit({ account: true }))).output(createAsyncBlockchainMutationResponse(GrantRoleOutputSchema));
 var revokeRole = v2Contract.route({
   method: "DELETE",
   path: "/system/accounts/{address}/role-grants",
   description: "Revoke a role from multiple accounts.",
   successDescription: "Roles revoked successfully.",
   tags: [V2_TAG.accessManager]
-}).meta({ contractErrors: [...ACCESS_ERRORS] }).input(v2Input.paramsBody(z362.object({ address: RevokeRoleInputSchema.shape.account }), RevokeRoleInputSchema.omit({ account: true }))).output(createAsyncBlockchainMutationResponse(RevokeRoleOutputSchema));
+}).meta({ contractErrors: [...ACCESS_ERRORS] }).input(v2Input.paramsBody(z363.object({ address: RevokeRoleInputSchema.shape.account }), RevokeRoleInputSchema.omit({ account: true }))).output(createAsyncBlockchainMutationResponse(RevokeRoleOutputSchema));
 var accessManagerV2Contract = {
   rolesList,
   rolesRead,
@@ -24692,14 +24764,14 @@ var accessManagerV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/bundler/bundler.v2.schemas.ts
-import { z as z363 } from "zod";
-var BundlerStatusSchema = z363.object({
-  address: z363.string().nullable()
+import { z as z364 } from "zod";
+var BundlerStatusSchema = z364.object({
+  address: z364.string().nullable()
 });
-var BundlerBalanceSchema = z363.object({
-  address: z363.string(),
-  balance: z363.string(),
-  nativeTokenSymbol: z363.string()
+var BundlerBalanceSchema = z364.object({
+  address: z364.string(),
+  balance: z364.string(),
+  nativeTokenSymbol: z364.string()
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/bundler/bundler.v2.contract.ts
@@ -24724,29 +24796,29 @@ var bundlerV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/activity/activity.v2.contract.ts
-import { z as z365 } from "zod";
+import { z as z366 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/activity/activity.v2.list.schema.ts
-import { z as z364 } from "zod";
-var ActivityEventV2ValueSchema = z364.object({
-  id: z364.string().meta({ description: "Unique identifier for the parameter value", examples: ["evt_val_123"] }),
-  name: z364.string().meta({ description: "Name of the event parameter", examples: ["from", "to", "amount"] }),
-  value: z364.string().meta({
+import { z as z365 } from "zod";
+var ActivityEventV2ValueSchema = z365.object({
+  id: z365.string().meta({ description: "Unique identifier for the parameter value", examples: ["evt_val_123"] }),
+  name: z365.string().meta({ description: "Name of the event parameter", examples: ["from", "to", "amount"] }),
+  value: z365.string().meta({
     description: "Value of the event parameter (address, hex hash, decimal-string number, or arbitrary text)",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F", "1000000000000000000"]
   })
 });
-var ActivityEventV2ItemSchema = z364.object({
-  id: z364.string().meta({ description: "Unique identifier for the event", examples: ["evt_123abc"] }),
-  eventName: z364.string().meta({
+var ActivityEventV2ItemSchema = z365.object({
+  id: z365.string().meta({ description: "Unique identifier for the event", examples: ["evt_123abc"] }),
+  eventName: z365.string().meta({
     description: "The event name",
     examples: ["TransferCompleted", "MintCompleted", "BurnCompleted"]
   }),
-  txIndex: z364.string().meta({
+  txIndex: z365.string().meta({
     description: "Log index within the transaction (string for parity with v1)",
     examples: ["0", "1", "5"]
   }),
-  blockNumber: z364.string().meta({
+  blockNumber: z365.string().meta({
     description: "Block number when the event occurred (decimal string for bigint precision)",
     examples: ["12345678", "20000000"]
   }),
@@ -24758,25 +24830,25 @@ var ActivityEventV2ItemSchema = z364.object({
     description: "Transaction hash",
     examples: ["0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"]
   }),
-  emitter: z364.object({
+  emitter: z365.object({
     id: ethereumAddress.meta({
       description: "Address of the contract that emitted the event",
       examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
     })
   }),
-  sender: z364.object({
+  sender: z365.object({
     id: ethereumAddress.meta({
       description: "Address that triggered the event (sender or account, falling back to the contract address)",
       examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
     })
   }),
-  involved: z364.array(z364.object({
+  involved: z365.array(z365.object({
     id: ethereumAddress.meta({
       description: "An address involved in the event (sender, recipient, account holder, etc.)",
       examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
     })
   })),
-  values: z364.array(ActivityEventV2ValueSchema).meta({
+  values: z365.array(ActivityEventV2ValueSchema).meta({
     description: "Event parameter values",
     examples: []
   })
@@ -24799,30 +24871,30 @@ var list24 = v2Contract.route({
   description: "List blockchain events where the specified account address is involved. Sortable by " + "blockTimestamp (default desc) and blockNumber. Filterable on eventName.",
   successDescription: "Paginated array of activity events with total count and faceted filter values.",
   tags: [V2_TAG.system]
-}).input(v2Input.paramsQuery(z365.object({ accountAddress: ethereumAddress }), ActivityListV2InputSchema)).output(ActivityListV2OutputSchema);
+}).input(v2Input.paramsQuery(z366.object({ accountAddress: ethereumAddress }), ActivityListV2InputSchema)).output(ActivityListV2OutputSchema);
 var stats3 = v2Contract.route({
   method: "GET",
   path: "/system/accounts/{accountAddress}/activity-metrics",
   description: "Retrieve activity statistics for the specified" + " account address. Provides time series data" + " for charting and event counts.",
   successDescription: "Activity statistics retrieved successfully",
   tags: [V2_TAG.system]
-}).input(v2Input.paramsQuery(z365.object({ accountAddress: ActivityStatsInputSchema.shape.accountAddress }), ActivityStatsInputSchema.omit({ accountAddress: true }))).output(createSingleResponse(ActivityStatsOutputSchema));
+}).input(v2Input.paramsQuery(z366.object({ accountAddress: ActivityStatsInputSchema.shape.accountAddress }), ActivityStatsInputSchema.omit({ accountAddress: true }))).output(createSingleResponse(ActivityStatsOutputSchema));
 var activityV2Contract = {
   list: list24,
   stats: stats3
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/addon-factory/addon-factory.v2.contract.ts
-import { z as z367 } from "zod";
+import { z as z368 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/addon-factory/addon-factory.v2.list.schema.ts
-import { z as z366 } from "zod";
-var AddonFactoryV2ItemSchema = z366.object({
+import { z as z367 } from "zod";
+var AddonFactoryV2ItemSchema = z367.object({
   id: ethereumAddress.meta({
     description: "The addon contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  name: z366.string().meta({ description: "The name of the system addon", examples: ["XvP Settlement", "Yield Schedule"] }),
+  name: z367.string().meta({ description: "The name of the system addon", examples: ["XvP Settlement", "Yield Schedule"] }),
   typeId: addonFactoryTypeId().meta({
     description: "The type ID of the system addon",
     examples: ["xvp-settlement", "fixed-yield-schedule"]
@@ -24871,7 +24943,7 @@ var read20 = v2Contract.route({
   description: "Get an addon factory by address",
   successDescription: "Addon factory data with type information",
   tags: [...TAGS28]
-}).input(v2Input.params(z367.object({ factoryAddress: AddonFactoryReadInputSchema.shape.addonFactoryAddress }))).output(createSingleResponse(AddonFactoryReadOutputSchema));
+}).input(v2Input.params(z368.object({ factoryAddress: AddonFactoryReadInputSchema.shape.addonFactoryAddress }))).output(createSingleResponse(AddonFactoryReadOutputSchema));
 var addonFactoryV2Contract = {
   list: list25,
   create: create13,
@@ -24879,7 +24951,7 @@ var addonFactoryV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/claim-topics/claim-topics.v2.contract.ts
-import { z as z368 } from "zod";
+import { z as z369 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/claim-topics/claim-topics.v2.list.schema.ts
 var CLAIM_TOPICS_COLLECTION_FIELDS = {
@@ -24921,14 +24993,14 @@ var update10 = v2Contract.route({
   description: "Update the signature of an existing topic scheme.",
   successDescription: "Topic scheme signature updated successfully.",
   tags: [V2_TAG.claimTopics]
-}).meta({ contractErrors: [...CLAIM_TOPIC_ERRORS] }).input(v2Input.paramsBody(z368.object({ name: TopicUpdateInputSchema.shape.name }), TopicUpdateInputSchema.omit({ name: true }))).output(createAsyncBlockchainMutationResponse(TopicUpdateOutputSchema));
+}).meta({ contractErrors: [...CLAIM_TOPIC_ERRORS] }).input(v2Input.paramsBody(z369.object({ name: TopicUpdateInputSchema.shape.name }), TopicUpdateInputSchema.omit({ name: true }))).output(createAsyncBlockchainMutationResponse(TopicUpdateOutputSchema));
 var del11 = v2Contract.route({
   method: "DELETE",
   path: "/system/claim-topics/{name}",
   description: "Remove a topic scheme from the registry.",
   successDescription: "Topic scheme removed successfully.",
   tags: [V2_TAG.claimTopics]
-}).meta({ contractErrors: [...CLAIM_TOPIC_ERRORS] }).input(v2Input.paramsBody(z368.object({ name: TopicDeleteInputSchema.shape.name }), TopicDeleteInputSchema.omit({ name: true }))).output(createAsyncBlockchainMutationResponse(TopicDeleteOutputSchema));
+}).meta({ contractErrors: [...CLAIM_TOPIC_ERRORS] }).input(v2Input.paramsBody(z369.object({ name: TopicDeleteInputSchema.shape.name }), TopicDeleteInputSchema.omit({ name: true }))).output(createAsyncBlockchainMutationResponse(TopicDeleteOutputSchema));
 var claimTopicsV2Contract = {
   list: list26,
   create: create14,
@@ -24938,8 +25010,8 @@ var claimTopicsV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/compliance-module/compliance-module.v2.list.schema.ts
-import { z as z369 } from "zod";
-var ComplianceModuleV2ItemSchema = z369.object({
+import { z as z370 } from "zod";
+var ComplianceModuleV2ItemSchema = z370.object({
   id: ethereumCompositeId.meta({
     description: "Compliance module ID (concatenation of registry address and module address)",
     examples: ["0x71c7656ec7ab88b098defb751b7401b5f6d8976f2546bcd3c84621e976d8185a91a922ae77ecec30"]
@@ -24949,8 +25021,8 @@ var ComplianceModuleV2ItemSchema = z369.object({
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
   typeId: complianceTypeId(),
-  name: z369.string(),
-  globalConfigs: z369.array(GlobalComplianceModuleConfigSchema2).default([])
+  name: z370.string(),
+  globalConfigs: z370.array(GlobalComplianceModuleConfigSchema2).default([])
 });
 var COMPLIANCE_MODULE_COLLECTION_FIELDS = {
   module: addressField({ defaultOperator: "eq" }),
@@ -24993,20 +25065,20 @@ var complianceModuleV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/core/core.v2.contract.ts
-import { z as z371 } from "zod";
+import { z as z372 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/core/system.v2.list.schema.ts
-import { z as z370 } from "zod";
-var SystemV2ItemSchema = z370.object({
+import { z as z371 } from "zod";
+var SystemV2ItemSchema = z371.object({
   id: ethereumAddress.meta({
     description: "System contract address (lowercase hex)",
     examples: ["0x71c7656ec7ab88b098defb751b7401b5f6d8976f"]
   }),
-  isBootstrapped: z370.boolean().meta({
+  isBootstrapped: z371.boolean().meta({
     description: "Whether the system has been bootstrapped",
     examples: [true]
   }),
-  tokenCount: z370.number().int().meta({
+  tokenCount: z371.number().int().meta({
     description: "Number of tokens deployed under this system",
     examples: [12]
   }),
@@ -25048,8 +25120,8 @@ var read22 = v2Contract.route({
   description: "Get details of a specific SMART system (use 'default' for the dApp system)",
   successDescription: "SMART system details with token factories",
   tags: [V2_TAG.system]
-}).input(v2Input.params(z371.object({
-  systemAddress: z371.literal("default").or(ethereumAddress)
+}).input(v2Input.params(z372.object({
+  systemAddress: z372.literal("default").or(ethereumAddress)
 }))).output(createSingleResponse(SystemSchema));
 var resume2 = v2Contract.route({
   method: "POST",
@@ -25103,11 +25175,11 @@ var entityV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/feeds/feeds.v2.contract.ts
-import { z as z374 } from "zod";
+import { z as z375 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/feeds/adapters.v2.list.schema.ts
-import { z as z372 } from "zod";
-var AdapterV2ItemSchema = z372.object({
+import { z as z373 } from "zod";
+var AdapterV2ItemSchema = z373.object({
   adapterAddress: ethereumAddress.meta({
     description: "Address of the adapter contract (stable address)",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -25116,7 +25188,7 @@ var AdapterV2ItemSchema = z372.object({
     description: "Subject the adapter is bound to (asset / identity / global zero address)",
     examples: ["0x0000000000000000000000000000000000000000"]
   }),
-  topicId: z372.string().meta({
+  topicId: z373.string().meta({
     description: "Numeric topic identifier as decimal string",
     examples: ["1", "2"]
   })
@@ -25153,8 +25225,8 @@ var FeedsV2ListInputSchema = createCollectionInputSchema(FEEDS_COLLECTION_FIELDS
 var FeedsV2ListOutputSchema = createPaginatedResponse(FeedItemSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/feeds/issuer-signed.v2.list.schema.ts
-import { z as z373 } from "zod";
-var IssuerSignedFeedV2ItemSchema = z373.object({
+import { z as z374 } from "zod";
+var IssuerSignedFeedV2ItemSchema = z374.object({
   feedAddress: ethereumAddress.meta({
     description: "Address of the issuer-signed scalar feed",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -25163,7 +25235,7 @@ var IssuerSignedFeedV2ItemSchema = z373.object({
     description: "Subject the feed is bound to (asset / identity / global zero address)",
     examples: ["0x0000000000000000000000000000000000000000"]
   }),
-  topicId: z373.string().meta({
+  topicId: z374.string().meta({
     description: "Numeric topic identifier as decimal string",
     examples: ["1", "2"]
   }),
@@ -25256,7 +25328,7 @@ var staleness2 = v2Contract.route({
   description: "Evaluate whether a feed value is stale based on a maximum age threshold",
   successDescription: "Staleness evaluation result",
   tags: [...TAGS29]
-}).input(v2Input.paramsQuery(z374.object({ feedAddress: FeedStalenessInputSchema.shape.feedAddress }), z374.object(FeedStalenessInputSchema.shape).omit({ feedAddress: true }))).output(createSingleResponse(FeedStalenessOutputSchema));
+}).input(v2Input.paramsQuery(z375.object({ feedAddress: FeedStalenessInputSchema.shape.feedAddress }), z375.object(FeedStalenessInputSchema.shape).omit({ feedAddress: true }))).output(createSingleResponse(FeedStalenessOutputSchema));
 var config2 = v2Contract.route({
   method: "GET",
   path: "/system/feeds/{feedAddress}/config",
@@ -25277,7 +25349,7 @@ var submit2 = v2Contract.route({
   description: "Sign and submit a feed update using the backend-managed signer (EIP-712)",
   successDescription: "Feed update submitted",
   tags: [...TAGS29]
-}).input(v2Input.paramsBody(z374.object({ feedAddress: FeedSubmitInputSchema.shape.feedAddress }), z374.object(FeedSubmitInputSchema.shape).omit({ feedAddress: true }))).output(createAsyncBlockchainMutationResponse(FeedSubmitOutputSchema));
+}).input(v2Input.paramsBody(z375.object({ feedAddress: FeedSubmitInputSchema.shape.feedAddress }), z375.object(FeedSubmitInputSchema.shape).omit({ feedAddress: true }))).output(createAsyncBlockchainMutationResponse(FeedSubmitOutputSchema));
 var issuerSignedCreate2 = v2Contract.route({
   method: "POST",
   path: "/system/feeds/issuer-signed/create",
@@ -25333,40 +25405,40 @@ var feedsV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/identity/identity.v2.contract.ts
-import { z as z378 } from "zod";
+import { z as z379 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/identity/identity.v2.claim-history.schema.ts
-import { z as z375 } from "zod";
+import { z as z376 } from "zod";
 var CLAIM_EVENT_NAMES = ["ClaimAdded", "ClaimChanged", "ClaimRemoved", "ClaimRevoked"];
-var ClaimHistoryV2ValueSchema = z375.object({
-  id: z375.string().meta({ description: "Unique identifier for the value", examples: ["val-0"] }),
-  name: z375.string().meta({ description: "Parameter name", examples: ["topic"] }),
-  value: z375.string().meta({ description: "String representation of the value", examples: ["1"] })
+var ClaimHistoryV2ValueSchema = z376.object({
+  id: z376.string().meta({ description: "Unique identifier for the value", examples: ["val-0"] }),
+  name: z376.string().meta({ description: "Parameter name", examples: ["topic"] }),
+  value: z376.string().meta({ description: "String representation of the value", examples: ["1"] })
 });
-var ClaimsHistoryV2ParamsSchema = z375.object({
+var ClaimsHistoryV2ParamsSchema = z376.object({
   identityAddress: ethereumAddress.meta({
     description: "Identity contract address whose claim events are listed",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   })
 });
-var ClaimsHistoryV2ItemSchema = z375.object({
-  id: z375.string().meta({
+var ClaimsHistoryV2ItemSchema = z376.object({
+  id: z376.string().meta({
     description: "Stable identifier built from txHash and logIndex (e.g. `0xabc...-0`)",
     examples: ["0xabc...-0"]
   }),
-  eventName: z375.enum(CLAIM_EVENT_NAMES).meta({
+  eventName: z376.enum(CLAIM_EVENT_NAMES).meta({
     description: "Lifecycle event emitted by the identity contract",
     examples: ["ClaimAdded"]
   }),
-  topic: z375.string().meta({
+  topic: z376.string().meta({
     description: "Claim topic id (decimal string)",
     examples: ["1"]
   }),
-  claimId: z375.string().meta({
+  claimId: z376.string().meta({
     description: "Stable claim identifier (hash)",
     examples: ["0xbb..."]
   }),
-  blockNumber: z375.string().meta({
+  blockNumber: z376.string().meta({
     description: "Block number where the event was mined (decimal string)",
     examples: ["12345678"]
   }),
@@ -25378,19 +25450,19 @@ var ClaimsHistoryV2ItemSchema = z375.object({
     description: "Transaction hash that emitted the event",
     examples: ["0xabc..."]
   }),
-  emitter: z375.object({
+  emitter: z376.object({
     id: ethereumAddress.meta({
       description: "Account or contract that emitted the event",
       examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
     })
   }),
-  sender: z375.object({
+  sender: z376.object({
     id: ethereumAddress.meta({
       description: "Address that initiated the transaction",
       examples: ["0x2546BcD3c84621e976D8185a91A922aE77ECEc30"]
     })
   }),
-  values: z375.array(ClaimHistoryV2ValueSchema).meta({
+  values: z376.array(ClaimHistoryV2ValueSchema).meta({
     description: "Decoded event arguments as name/value pairs",
     examples: [[{ id: "val-0", name: "topic", value: "1" }]]
   })
@@ -25411,31 +25483,31 @@ var ClaimsHistoryV2InputSchema = createCollectionInputSchema(CLAIM_HISTORY_COLLE
 var ClaimsHistoryV2OutputSchema = createPaginatedResponse(ClaimsHistoryV2ItemSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/identity/identity.v2.keys.schema.ts
-import { z as z376 } from "zod";
+import { z as z377 } from "zod";
 var KEY_PURPOSE_VALUES = ["management", "deposit", "claimSigner", "encryption", "unknown"];
 var KEY_TYPE_VALUES = ["ecdsa", "rsa", "unknown"];
-var IdentityV2KeysItemSchema = z376.object({
-  keyHash: z376.string().meta({
+var IdentityV2KeysItemSchema = z377.object({
+  keyHash: z377.string().meta({
     description: "ERC-734 key hash — typically `keccak256(abi.encode(eoaAddress))` for an ECDSA key",
     examples: ["0x9d8a5b6f3a7f8e2c1d4b5a6e7f8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c"]
   }),
-  purpose: z376.enum(KEY_PURPOSE_VALUES).meta({
+  purpose: z377.enum(KEY_PURPOSE_VALUES).meta({
     description: "ERC-734 key purpose label, decoded by the indexer. `management` = admin (purpose 1), `deposit` = action/signing (purpose 2), `claimSigner` = claim issuer (purpose 3), `encryption` = encryption (purpose 4).",
     examples: ["management"]
   }),
-  keyType: z376.enum(KEY_TYPE_VALUES).meta({
+  keyType: z377.enum(KEY_TYPE_VALUES).meta({
     description: "ERC-734 key type label, decoded by the indexer.",
     examples: ["ecdsa"]
   }),
-  createdAt: z376.coerce.date().meta({
+  createdAt: z377.coerce.date().meta({
     description: "Indexer ingestion timestamp (UTC)",
     examples: ["2026-05-06T12:34:56.000Z"]
   }),
-  createdAtBlock: z376.string().meta({
+  createdAtBlock: z377.string().meta({
     description: "Block number at which the `KeyAdded` event was emitted, as a decimal string",
     examples: ["12345678"]
   }),
-  createdAtTxHash: z376.string().meta({
+  createdAtTxHash: z377.string().meta({
     description: "Transaction hash that emitted the `KeyAdded` event",
     examples: ["0xabc..."]
   })
@@ -25445,7 +25517,7 @@ var IDENTITY_KEYS_COLLECTION_FIELDS = {
   keyType: enumField(KEY_TYPE_VALUES, { defaultOperator: "eq", facetable: true }),
   createdAt: dateField({ sortable: true, facetable: false })
 };
-var IdentityV2KeysParamsSchema = z376.object({
+var IdentityV2KeysParamsSchema = z377.object({
   identityAddress: ethereumAddress.meta({
     description: "Address of an indexed identity contract (organisation identity, user wallet identity, or any other contract identity).",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -25457,9 +25529,9 @@ var IdentityV2KeysInputSchema = createCollectionInputSchema(IDENTITY_KEYS_COLLEC
 var IdentityV2KeysOutputSchema = createPaginatedResponse(IdentityV2KeysItemSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/identity/identity.v2.list.schema.ts
-import { z as z377 } from "zod";
+import { z as z378 } from "zod";
 var KYC_STATUS_VALUES = ["pending", "registered"];
-var IdentityV2ListItemSchema = z377.object({
+var IdentityV2ListItemSchema = z378.object({
   id: ethereumAddress.meta({
     description: "Identity contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -25468,11 +25540,11 @@ var IdentityV2ListItemSchema = z377.object({
     description: "Wallet address registered against the identity",
     examples: ["0x2546BcD3c84621e976D8185a91A922aE77ECEc30"]
   }),
-  name: z377.string().nullable().meta({
+  name: z378.string().nullable().meta({
     description: "Account contract name when the identity belongs to a deployed contract",
     examples: ["TreasuryMultisig", null]
   }),
-  kycStatus: z377.enum(KYC_STATUS_VALUES).meta({
+  kycStatus: z378.enum(KYC_STATUS_VALUES).meta({
     description: "Registry-level KYC status: `pending` (registered, awaiting acceptance) or `registered` (active)",
     examples: ["registered"]
   }),
@@ -25480,27 +25552,27 @@ var IdentityV2ListItemSchema = z377.object({
     description: "ISO 3166-1 alpha-2 country code from the registry, when set",
     examples: ["BE", null]
   }),
-  isContract: z377.boolean().meta({
+  isContract: z378.boolean().meta({
     description: "Whether the identity belongs to a smart contract (vs an EOA)",
     examples: [false]
   }),
-  claimsCount: z377.number().int().nonnegative().meta({
+  claimsCount: z378.number().int().nonnegative().meta({
     description: "Total claims attached to the identity",
     examples: [3]
   }),
-  activeClaimsCount: z377.number().int().nonnegative().meta({
+  activeClaimsCount: z378.number().int().nonnegative().meta({
     description: "Non-revoked claims attached to the identity",
     examples: [2]
   }),
-  revokedClaimsCount: z377.number().int().nonnegative().meta({
+  revokedClaimsCount: z378.number().int().nonnegative().meta({
     description: "Revoked claims attached to the identity",
     examples: [1]
   }),
-  untrustedClaimsCount: z377.number().int().nonnegative().meta({
+  untrustedClaimsCount: z378.number().int().nonnegative().meta({
     description: "Claims whose issuer is not a trusted issuer for the claim's topic in the system's TIR chain (counted regardless of revocation)",
     examples: [0]
   }),
-  deployedInTransaction: z377.string().meta({
+  deployedInTransaction: z378.string().meta({
     description: "Transaction hash where the identity contract was deployed",
     examples: ["0xabc..."]
   })
@@ -25549,12 +25621,12 @@ var readByWallet2 = v2Contract.route({
   description: "Read identity information by wallet address with claim validation.",
   successDescription: "Identity information retrieved successfully.",
   tags: TAGS30
-}).input(v2Input.paramsQuery(z378.object({
+}).input(v2Input.paramsQuery(z379.object({
   wallet: ethereumAddress.meta({
     description: "The wallet address of the user",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   })
-}), z378.object({
+}), z379.object({
   tokenAddress: ethereumAddress.optional().meta({
     description: "Optional token address for token-specific trusted issuer validation.",
     examples: ["0x8ba1f109551bD432803012645Ac136ddd64DBA72"]
@@ -25566,12 +25638,12 @@ var readById = v2Contract.route({
   description: "Read identity information by identity contract address.",
   successDescription: "Identity information retrieved successfully.",
   tags: TAGS30
-}).input(v2Input.paramsQuery(z378.object({
+}).input(v2Input.paramsQuery(z379.object({
   identityAddress: ethereumAddress.meta({
     description: "The address of the identity contract to read",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   })
-}), z378.object({
+}), z379.object({
   tokenAddress: ethereumAddress.optional().meta({
     description: "Optional token address for token-specific trusted issuer validation.",
     examples: ["0x8ba1f109551bD432803012645Ac136ddd64DBA72"]
@@ -25611,7 +25683,7 @@ var identityDelete2 = v2Contract.route({
   description: "Delete an identity from the system's identity registry.",
   successDescription: "Identity deleted successfully.",
   tags: TAGS30
-}).meta({ contractErrors: [...IDENTITY_ERRORS] }).input(v2Input.paramsBody(z378.object({ wallet: IdentityDeleteInputSchema.shape.wallet }), IdentityDeleteInputSchema.omit({ wallet: true }))).output(createAsyncBlockchainMutationResponse(IdentityDeleteOutputSchema));
+}).meta({ contractErrors: [...IDENTITY_ERRORS] }).input(v2Input.paramsBody(z379.object({ wallet: IdentityDeleteInputSchema.shape.wallet }), IdentityDeleteInputSchema.omit({ wallet: true }))).output(createAsyncBlockchainMutationResponse(IdentityDeleteOutputSchema));
 var updateCountry = v2Contract.route({
   method: "PATCH",
   path: "/system/identity-countries",
@@ -25669,18 +25741,18 @@ var identityV2ContractShape = {
 var identityV2Contract = identityV2ContractShape;
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/migration/migration.v2.compare.schema.ts
-import { z as z379 } from "zod";
-var MigrationComponentStatusSchema = z379.enum(["up-to-date", "update-available", "new"]);
-var MigrationComponentSchema = z379.object({
-  key: z379.string().meta({
+import { z as z380 } from "zod";
+var MigrationComponentStatusSchema = z380.enum(["up-to-date", "update-available", "new"]);
+var MigrationComponentSchema = z380.object({
+  key: z380.string().meta({
     description: "Directory key or type identifier for this component",
     examples: ["SYSTEM", "COMPLIANCE", "bond"]
   }),
-  label: z379.string().meta({
+  label: z380.string().meta({
     description: "Human-readable name",
     examples: ["System Proxy", "Compliance Module Registry", "Bond Factory"]
   }),
-  group: z379.string().meta({
+  group: z380.string().meta({
     description: "Logical category for UI grouping",
     examples: ["core", "identity", "compliance", "registries", "tokenFactories", "addons", "complianceModules"]
   }),
@@ -25691,62 +25763,62 @@ var MigrationComponentSchema = z379.object({
     description: "Expected implementation address from the directory (null if not registered)"
   }),
   status: MigrationComponentStatusSchema,
-  affectedTokenCount: z379.number().optional().meta({
+  affectedTokenCount: z380.number().optional().meta({
     description: "Number of tokens affected by this component's upgrade (for factory components)",
     examples: [0, 12, 47]
   })
 });
-var MigrationComponentGroupSchema = z379.object({
-  id: z379.string().meta({
+var MigrationComponentGroupSchema = z380.object({
+  id: z380.string().meta({
     description: "Group identifier",
     examples: ["core", "identity", "tokenFactories"]
   }),
-  label: z379.string().meta({
+  label: z380.string().meta({
     description: "Human-readable group name",
     examples: ["Core System", "Identity", "Token Factories"]
   }),
-  components: z379.array(MigrationComponentSchema)
+  components: z380.array(MigrationComponentSchema)
 });
-var MigrationCompareOutputSchema = z379.object({
+var MigrationCompareOutputSchema = z380.object({
   systemAddress: ethereumAddress.meta({
     description: "The system contract address that was compared"
   }),
   directoryAddress: ethereumAddress.meta({
     description: "The directory contract address used as reference"
   }),
-  summary: z379.object({
-    totalComponents: z379.number(),
-    upToDate: z379.number(),
-    updateAvailable: z379.number(),
-    pendingInstall: z379.number(),
-    totalAffectedTokens: z379.number()
+  summary: z380.object({
+    totalComponents: z380.number(),
+    upToDate: z380.number(),
+    updateAvailable: z380.number(),
+    pendingInstall: z380.number(),
+    totalAffectedTokens: z380.number()
   }),
-  groups: z379.array(MigrationComponentGroupSchema)
+  groups: z380.array(MigrationComponentGroupSchema)
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/migration/migration.v2.start.schema.ts
-import { z as z380 } from "zod";
-var MigrationV2StartOutputSchema = z380.object({
-  migrationId: z380.string().meta({
+import { z as z381 } from "zod";
+var MigrationV2StartOutputSchema = z381.object({
+  migrationId: z381.string().meta({
     description: "Unique migration identifier (used for SSE stream subscription)"
   }),
-  tree: z380.array(DeploymentNodeSchema).meta({
+  tree: z381.array(DeploymentNodeSchema).meta({
     description: "Initial deployment tree with all steps in pending state"
   })
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/migration/migration.v2.stream.schema.ts
 import { eventIterator as eventIterator6 } from "@orpc/contract";
-import { z as z381 } from "zod";
-var MigrationV2StreamInputSchema = z381.object({
-  migrationId: z381.string()
+import { z as z382 } from "zod";
+var MigrationV2StreamInputSchema = z382.object({
+  migrationId: z382.string()
 });
 var MigrationV2StreamOutputSchema = eventIterator6(DeploymentEventSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/migration/migration.v2.active.schema.ts
-import { z as z382 } from "zod";
-var MigrationV2ActiveOutputSchema = z382.object({
-  migrationId: z382.string().nullable().meta({
+import { z as z383 } from "zod";
+var MigrationV2ActiveOutputSchema = z383.object({
+  migrationId: z383.string().nullable().meta({
     description: "Active migration ID if one is in-flight, null otherwise"
   })
 });
@@ -25788,7 +25860,7 @@ var migrationV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/stats/stats.v2.contract.ts
-import { z as z383 } from "zod";
+import { z as z384 } from "zod";
 var assets2 = v2Contract.route({
   method: "GET",
   path: "/system/stats/assets",
@@ -25802,8 +25874,8 @@ var assetLifecycleByRange = v2Contract.route({
   description: "Retrieve counts for created and launched assets over custom time range",
   successDescription: "System asset lifecycle metrics retrieved successfully",
   tags: [V2_TAG.systemStats]
-}).input(v2Input.query(z383.object({
-  interval: z383.enum(["hour", "day"]),
+}).input(v2Input.query(z384.object({
+  interval: z384.enum(["hour", "day"]),
   from: timestamp(),
   to: timestamp()
 }))).output(createSingleResponse(StatsAssetLifecycleOutputSchema));
@@ -25813,8 +25885,8 @@ var assetLifecycleByPreset = v2Contract.route({
   description: "Retrieve counts for created and launched assets using preset range",
   successDescription: "System asset lifecycle metrics retrieved successfully",
   tags: [V2_TAG.systemStats]
-}).input(v2Input.params(z383.object({
-  preset: z383.enum(["trailing24Hours", "trailing7Days"])
+}).input(v2Input.params(z384.object({
+  preset: z384.enum(["trailing24Hours", "trailing7Days"])
 }))).output(createSingleResponse(StatsAssetLifecycleOutputSchema));
 var assetActivityByRange = v2Contract.route({
   method: "GET",
@@ -25822,8 +25894,8 @@ var assetActivityByRange = v2Contract.route({
   description: "Retrieve counts for transfer, mint, and burn events over custom time range",
   successDescription: "System asset activity metrics retrieved successfully",
   tags: [V2_TAG.systemStats]
-}).input(v2Input.query(z383.object({
-  interval: z383.enum(["hour", "day"]),
+}).input(v2Input.query(z384.object({
+  interval: z384.enum(["hour", "day"]),
   from: timestamp(),
   to: timestamp()
 }))).output(createSingleResponse(StatsAssetActivityOutputSchema));
@@ -25833,8 +25905,8 @@ var assetActivityByPreset = v2Contract.route({
   description: "Retrieve counts for transfer, mint, and burn events using preset range",
   successDescription: "System asset activity metrics retrieved successfully",
   tags: [V2_TAG.systemStats]
-}).input(v2Input.params(z383.object({
-  preset: z383.enum(["trailing24Hours", "trailing7Days"])
+}).input(v2Input.params(z384.object({
+  preset: z384.enum(["trailing24Hours", "trailing7Days"])
 }))).output(createSingleResponse(StatsAssetActivityOutputSchema));
 var claimsStatsByRange = v2Contract.route({
   method: "GET",
@@ -25842,8 +25914,8 @@ var claimsStatsByRange = v2Contract.route({
   description: "Retrieve claims statistics over custom time range including issued, active, removed, and revoked claims",
   successDescription: "Claims statistics retrieved successfully",
   tags: [V2_TAG.systemStats]
-}).input(v2Input.query(z383.object({
-  interval: z383.enum(["hour", "day"]),
+}).input(v2Input.query(z384.object({
+  interval: z384.enum(["hour", "day"]),
   from: timestamp(),
   to: timestamp()
 }))).output(createSingleResponse(StatsClaimsStatsOutputSchema));
@@ -25853,8 +25925,8 @@ var claimsStatsByPreset = v2Contract.route({
   description: "Retrieve claims statistics using preset range including issued, active, removed, and revoked claims",
   successDescription: "Claims statistics retrieved successfully",
   tags: [V2_TAG.systemStats]
-}).input(v2Input.params(z383.object({
-  preset: z383.enum(["trailing24Hours", "trailing7Days"])
+}).input(v2Input.params(z384.object({
+  preset: z384.enum(["trailing24Hours", "trailing7Days"])
 }))).output(createSingleResponse(StatsClaimsStatsOutputSchema));
 var claimsStatsState = v2Contract.route({
   method: "GET",
@@ -25883,8 +25955,8 @@ var identityStatsOverTimeByRange = v2Contract.route({
   description: "Retrieve identity statistics over custom time range for charts",
   successDescription: "Identity statistics over time retrieved successfully",
   tags: [V2_TAG.systemStats]
-}).input(v2Input.query(z383.object({
-  interval: z383.enum(["hour", "day"]),
+}).input(v2Input.query(z384.object({
+  interval: z384.enum(["hour", "day"]),
   from: timestamp(),
   to: timestamp()
 }))).output(createSingleResponse(StatsIdentityStatsOverTimeOutputSchema));
@@ -25894,8 +25966,8 @@ var identityStatsOverTimeByPreset = v2Contract.route({
   description: "Retrieve identity statistics using preset range for charts",
   successDescription: "Identity statistics over time retrieved successfully",
   tags: [V2_TAG.systemStats]
-}).input(v2Input.params(z383.object({
-  preset: z383.enum(["trailing24Hours", "trailing7Days"])
+}).input(v2Input.params(z384.object({
+  preset: z384.enum(["trailing24Hours", "trailing7Days"])
 }))).output(createSingleResponse(StatsIdentityStatsOverTimeOutputSchema));
 var transactionCount = v2Contract.route({
   method: "GET",
@@ -25917,8 +25989,8 @@ var trustedIssuerStatsByRange = v2Contract.route({
   description: "Retrieve trusted issuer statistics over custom time range including added, active, and removed issuers",
   successDescription: "Trusted issuer statistics retrieved successfully",
   tags: [V2_TAG.systemStats]
-}).input(v2Input.query(z383.object({
-  interval: z383.enum(["hour", "day"]),
+}).input(v2Input.query(z384.object({
+  interval: z384.enum(["hour", "day"]),
   from: timestamp(),
   to: timestamp()
 }))).output(createSingleResponse(StatsTrustedIssuerStatsOutputSchema));
@@ -25928,8 +26000,8 @@ var trustedIssuerStatsByPreset = v2Contract.route({
   description: "Retrieve trusted issuer statistics using preset range including added, active, and removed issuers",
   successDescription: "Trusted issuer statistics retrieved successfully",
   tags: [V2_TAG.systemStats]
-}).input(v2Input.params(z383.object({
-  preset: z383.enum(["trailing24Hours", "trailing7Days"])
+}).input(v2Input.params(z384.object({
+  preset: z384.enum(["trailing24Hours", "trailing7Days"])
 }))).output(createSingleResponse(StatsTrustedIssuerStatsOutputSchema));
 var trustedIssuerStatsState = v2Contract.route({
   method: "GET",
@@ -25951,8 +26023,8 @@ var portfolioByRange = v2Contract.route({
   description: "Retrieve system-wide portfolio statistics over custom time range",
   successDescription: "System portfolio statistics retrieved successfully",
   tags: [V2_TAG.systemStats]
-}).input(v2Input.query(z383.object({
-  interval: z383.enum(["hour", "day"]),
+}).input(v2Input.query(z384.object({
+  interval: z384.enum(["hour", "day"]),
   from: timestamp(),
   to: timestamp()
 }))).output(createSingleResponse(StatsPortfolioOutputSchema));
@@ -25962,8 +26034,8 @@ var portfolioByPreset = v2Contract.route({
   description: "Retrieve system-wide portfolio statistics using preset range",
   successDescription: "System portfolio statistics retrieved successfully",
   tags: [V2_TAG.systemStats]
-}).input(v2Input.params(z383.object({
-  preset: z383.enum(["trailing24Hours", "trailing7Days"])
+}).input(v2Input.params(z384.object({
+  preset: z384.enum(["trailing24Hours", "trailing7Days"])
 }))).output(createSingleResponse(StatsPortfolioOutputSchema));
 var portfolioDetails = v2Contract.route({
   method: "GET",
@@ -25978,8 +26050,8 @@ var topicSchemesStatsByRange = v2Contract.route({
   description: "Retrieve topic schemes statistics over custom time range including registered, active, and removed schemes",
   successDescription: "Topic schemes statistics retrieved successfully",
   tags: [V2_TAG.systemStats]
-}).input(v2Input.query(z383.object({
-  interval: z383.enum(["hour", "day"]),
+}).input(v2Input.query(z384.object({
+  interval: z384.enum(["hour", "day"]),
   from: timestamp(),
   to: timestamp()
 }))).output(createSingleResponse(StatsTopicSchemesStatsOutputSchema));
@@ -25989,8 +26061,8 @@ var topicSchemesStatsByPreset = v2Contract.route({
   description: "Retrieve topic schemes statistics using preset range including registered, active, and removed schemes",
   successDescription: "Topic schemes statistics retrieved successfully",
   tags: [V2_TAG.systemStats]
-}).input(v2Input.params(z383.object({
-  preset: z383.enum(["trailing24Hours", "trailing7Days"])
+}).input(v2Input.params(z384.object({
+  preset: z384.enum(["trailing24Hours", "trailing7Days"])
 }))).output(createSingleResponse(StatsTopicSchemesStatsOutputSchema));
 var topicSchemesStatsState = v2Contract.route({
   method: "GET",
@@ -26012,8 +26084,8 @@ var systemValueHistoryByRange = v2Contract.route({
   description: "Retrieve total system value history over custom time range",
   successDescription: "System value history retrieved successfully",
   tags: [V2_TAG.systemStats]
-}).input(v2Input.query(z383.object({
-  interval: z383.enum(["hour", "day"]),
+}).input(v2Input.query(z384.object({
+  interval: z384.enum(["hour", "day"]),
   from: timestamp(),
   to: timestamp()
 }))).output(createSingleResponse(StatsSystemValueHistoryOutputSchema));
@@ -26023,8 +26095,8 @@ var systemValueHistoryByPreset = v2Contract.route({
   description: "Retrieve total system value history using preset range",
   successDescription: "System value history retrieved successfully",
   tags: [V2_TAG.systemStats]
-}).input(v2Input.params(z383.object({
-  preset: z383.enum(["trailing24Hours", "trailing7Days"])
+}).input(v2Input.params(z384.object({
+  preset: z384.enum(["trailing24Hours", "trailing7Days"])
 }))).output(createSingleResponse(StatsSystemValueHistoryOutputSchema));
 var statsV2Contract = {
   assets: assets2,
@@ -26057,18 +26129,18 @@ var statsV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/token-factory/token-factory.v2.list.schema.ts
-import { z as z384 } from "zod";
-var TokenFactoryV2ItemSchema = z384.object({
+import { z as z385 } from "zod";
+var TokenFactoryV2ItemSchema = z385.object({
   id: ethereumAddress.meta({
     description: "The factory contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  name: z384.string().meta({ description: "The name of the token factory", examples: ["Bond Factory", "Equity Factory"] }),
+  name: z385.string().meta({ description: "The name of the token factory", examples: ["Bond Factory", "Equity Factory"] }),
   typeId: assetFactoryTypeId().meta({
     description: "The type ID of the token factory",
     examples: ["bond", "equity"]
   }),
-  hasTokens: z384.boolean().meta({ description: "Whether the factory has created any tokens", examples: [true, false] }),
+  hasTokens: z385.boolean().meta({ description: "Whether the factory has created any tokens", examples: [true, false] }),
   tokenExtensions: assetExtensionArray().meta({
     description: "The token extensions of the token factory",
     examples: [["pausable", "burnable"]]
@@ -26133,33 +26205,33 @@ var tokenFactoryV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/paymaster/paymaster.v2.schemas.ts
-import { z as z385 } from "zod";
-var PaymasterSchema = z385.object({
+import { z as z386 } from "zod";
+var PaymasterSchema = z386.object({
   address: ethereumAddress,
   system: ethereumAddress.nullable(),
   factory: ethereumAddress,
   createdAt: timestamp()
 });
-var PaymasterBalanceSchema = z385.object({
+var PaymasterBalanceSchema = z386.object({
   address: ethereumAddress,
-  depositBalance: z385.string()
+  depositBalance: z386.string()
 });
 var PaymasterDepositInputSchema = MutationInputSchema.extend({
-  amount: z385.string().regex(/^[1-9][0-9]*$/, "Must be a positive integer string representing wei (e.g. '1000000000000000000' for 1 ETH). Zero, negative, and non-numeric values are rejected.")
+  amount: z386.string().regex(/^[1-9][0-9]*$/, "Must be a positive integer string representing wei (e.g. '1000000000000000000' for 1 ETH). Zero, negative, and non-numeric values are rejected.")
 });
-var PaymasterAddressParamsSchema = z385.object({
+var PaymasterAddressParamsSchema = z386.object({
   address: ethereumAddress
 });
-var PaymasterSignerKeyRotationSchema = z385.object({
+var PaymasterSignerKeyRotationSchema = z386.object({
   signerAddress: ethereumAddress,
   rotatedAt: timestamp()
 });
-var PaymasterSignerKeyStatusSchema = z385.object({
+var PaymasterSignerKeyStatusSchema = z386.object({
   signerAddress: ethereumAddress.nullable(),
   rotatedAt: timestamp().nullable()
 });
-var PaymasterConfigSchema = z385.object({
-  enabled: z385.boolean()
+var PaymasterConfigSchema = z386.object({
+  enabled: z386.boolean()
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/paymaster/paymaster.v2.list.schema.ts
@@ -26236,24 +26308,24 @@ var paymasterV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/trusted-issuers/trusted-issuers.v2.contract.ts
-import { z as z388 } from "zod";
+import { z as z389 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/system/trusted-issuers/routes/trusted-issuer.claim-topic.schema.ts
-import { z as z386 } from "zod";
+import { z as z387 } from "zod";
 var TrustedIssuerClaimTopicMutationBodySchema = MutationInputSchema;
-var TrustedIssuerClaimTopicMutationParamsSchema = z386.object({
+var TrustedIssuerClaimTopicMutationParamsSchema = z387.object({
   issuerAddress: ethereumAddress.meta({
     description: "The identity address of the trusted issuer",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  topicId: z386.string().min(1).regex(/^\d+$/, "topicId must be a numeric string").meta({ description: "Numeric ID of the claim topic to add or remove", examples: ["1", "2", "100"] })
+  topicId: z387.string().min(1).regex(/^\d+$/, "topicId must be a numeric string").meta({ description: "Numeric ID of the claim topic to add or remove", examples: ["1", "2", "100"] })
 });
 var TrustedIssuerClaimTopicMutationOutputSchema = BaseMutationOutputSchema.extend({
   issuerAddress: ethereumAddress.meta({
     description: "Address of the trusted issuer that was mutated",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  topicId: z386.string().meta({
+  topicId: z387.string().meta({
     description: "Numeric ID of the topic that was added or removed",
     examples: ["1"]
   })
@@ -26270,8 +26342,8 @@ var TrustedIssuersV2ListInputSchema = createCollectionInputSchema(TRUSTED_ISSUER
 var TrustedIssuersV2ListOutputSchema = createPaginatedResponse(TrustedIssuerSchema2);
 
 // ../../packages/dalp/api-contract/src/routes/v2/system/trusted-issuers/trusted-issuer.v2.topics.list.schema.ts
-import { z as z387 } from "zod";
-var TrustedIssuerTopicsV2ListParamsSchema = z387.object({
+import { z as z388 } from "zod";
+var TrustedIssuerTopicsV2ListParamsSchema = z388.object({
   issuerAddress: ethereumAddress.meta({
     description: "Trusted issuer identity address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -26317,21 +26389,21 @@ var update11 = v2Contract.route({
   description: "Update the claim topics for a trusted issuer.",
   successDescription: "Trusted issuer topics updated successfully.",
   tags: [V2_TAG.trustedIssuers]
-}).meta({ contractErrors: [...TRUSTED_ISSUER_ERRORS] }).input(v2Input.paramsBody(z388.object({ issuerAddress: TrustedIssuerUpdateInputSchema.shape.issuerAddress }), TrustedIssuerUpdateInputSchema.omit({ issuerAddress: true }))).output(createAsyncBlockchainMutationResponse(TrustedIssuerUpdateOutputSchema));
+}).meta({ contractErrors: [...TRUSTED_ISSUER_ERRORS] }).input(v2Input.paramsBody(z389.object({ issuerAddress: TrustedIssuerUpdateInputSchema.shape.issuerAddress }), TrustedIssuerUpdateInputSchema.omit({ issuerAddress: true }))).output(createAsyncBlockchainMutationResponse(TrustedIssuerUpdateOutputSchema));
 var upsert5 = v2Contract.route({
   method: "PUT",
   path: "/system/trusted-issuers/{issuerAddress}",
   description: "Create or update a trusted issuer in the registry.",
   successDescription: "Trusted issuer upserted successfully.",
   tags: [V2_TAG.trustedIssuers]
-}).meta({ contractErrors: [...TRUSTED_ISSUER_ERRORS] }).input(v2Input.paramsBody(z388.object({ issuerAddress: TrustedIssuerUpsertInputSchema.shape.issuerAddress }), TrustedIssuerUpsertInputSchema.omit({ issuerAddress: true }))).output(createAsyncBlockchainMutationResponse(TrustedIssuerUpsertOutputSchema));
+}).meta({ contractErrors: [...TRUSTED_ISSUER_ERRORS] }).input(v2Input.paramsBody(z389.object({ issuerAddress: TrustedIssuerUpsertInputSchema.shape.issuerAddress }), TrustedIssuerUpsertInputSchema.omit({ issuerAddress: true }))).output(createAsyncBlockchainMutationResponse(TrustedIssuerUpsertOutputSchema));
 var del12 = v2Contract.route({
   method: "DELETE",
   path: "/system/trusted-issuers/{issuerAddress}",
   description: "Delete a trusted issuer from the registry.",
   successDescription: "Trusted issuer deleted successfully.",
   tags: [V2_TAG.trustedIssuers]
-}).meta({ contractErrors: [...TRUSTED_ISSUER_ERRORS] }).input(v2Input.paramsBody(z388.object({ issuerAddress: TrustedIssuerDeleteInputSchema.shape.issuerAddress }), TrustedIssuerDeleteInputSchema.omit({ issuerAddress: true }))).output(createAsyncBlockchainMutationResponse(TrustedIssuerDeleteOutputSchema));
+}).meta({ contractErrors: [...TRUSTED_ISSUER_ERRORS] }).input(v2Input.paramsBody(z389.object({ issuerAddress: TrustedIssuerDeleteInputSchema.shape.issuerAddress }), TrustedIssuerDeleteInputSchema.omit({ issuerAddress: true }))).output(createAsyncBlockchainMutationResponse(TrustedIssuerDeleteOutputSchema));
 var topics = v2Contract.route({
   method: "GET",
   path: "/system/trusted-issuers/{issuerAddress}/topics",
@@ -26386,7 +26458,7 @@ var systemV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.documents.list.schema.ts
-import { z as z389 } from "zod";
+import { z as z390 } from "zod";
 var TOKEN_DOCUMENTS_COLLECTION_FIELDS = {
   fileName: textField(),
   documentType: enumField(tokenDocumentTypes, { facetable: true }),
@@ -26399,22 +26471,22 @@ var TOKEN_DOCUMENTS_COLLECTION_FIELDS = {
 var TokenDocumentsV2ListInputSchema = createCollectionInputSchema(TOKEN_DOCUMENTS_COLLECTION_FIELDS, {
   defaultSort: "uploadedAt"
 });
-var TokenDocumentsV2ListItemSchema = z389.object({
-  id: z389.string(),
-  tokenAddress: z389.string(),
+var TokenDocumentsV2ListItemSchema = z390.object({
+  id: z390.string(),
+  tokenAddress: z390.string(),
   documentType: tokenDocumentType(),
   visibility: tokenDocumentVisibility(),
-  groupId: z389.string(),
-  versionNumber: z389.number(),
-  isLatest: z389.boolean(),
-  fileName: z389.string(),
-  fileSize: z389.number(),
-  mimeType: z389.string(),
-  title: z389.string().nullable(),
-  description: z389.string().nullable(),
-  fileHash: z389.string().nullable(),
+  groupId: z390.string(),
+  versionNumber: z390.number(),
+  isLatest: z390.boolean(),
+  fileName: z390.string(),
+  fileSize: z390.number(),
+  mimeType: z390.string(),
+  title: z390.string().nullable(),
+  description: z390.string().nullable(),
+  fileHash: z390.string().nullable(),
   uploadedAt: timestamp(),
-  uploadedBy: z389.string().nullable()
+  uploadedBy: z390.string().nullable()
 });
 var TokenDocumentsV2ListOutputSchema = createPaginatedResponse(TokenDocumentsV2ListItemSchema);
 
@@ -26478,7 +26550,7 @@ var TokenV2ListInputSchema = createCollectionInputSchema(TOKEN_COLLECTION_FIELDS
 var TokenV2ListOutputSchema = createPaginatedResponse(TokenListItemSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.mutations.contract.ts
-import { z as z392 } from "zod";
+import { z as z393 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/token/routes/mutations/compliance/token.install-scoped-compliance-module.schema.ts
 var TokenInstallScopedComplianceModuleInputSchema = TokenMutationInputSchema.extend({
@@ -26782,7 +26854,7 @@ var TokenRemoveMetadataInputSchema = TokenMutationInputSchema.extend({
 });
 
 // ../../packages/dalp/api-contract/src/routes/token/routes/mutations/transfer-approval/token.approve-transfer.schema.ts
-import { z as z390 } from "zod";
+import { z as z391 } from "zod";
 var TokenApproveTransferInputSchema = TokenMutationInputSchema.extend({
   fromWallet: ethereumAddress.meta({
     description: "Wallet address of the token sender whose identity will be the fromIdentity",
@@ -26810,7 +26882,7 @@ function identityAddressPairRefinement(data, ctx) {
   const hasTo = data.toIdentityAddress !== undefined;
   if (hasFrom !== hasTo) {
     ctx.addIssue({
-      code: z390.ZodIssueCode.custom,
+      code: z391.ZodIssueCode.custom,
       message: "fromIdentityAddress and toIdentityAddress must both be provided or both omitted — partial overrides are not supported.",
       path: hasFrom ? ["toIdentityAddress"] : ["fromIdentityAddress"]
     });
@@ -26850,9 +26922,9 @@ var TokenRevokeTransferApprovalBodySchema = TokenRevokeTransferApprovalInputSche
 }).superRefine(identityAddressPairRefinement);
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token-price.v2.schema.ts
-import { z as z391 } from "zod";
+import { z as z392 } from "zod";
 var TokenPriceBodySchema = MutationInputSchema.extend({
-  price: z391.string().regex(/^(?!0+(\.0+)?$)\d+(\.\d+)?$/, "Price must be a positive decimal string greater than zero").meta({
+  price: z392.string().regex(/^(?!0+(\.0+)?$)\d+(\.\d+)?$/, "Price must be a positive decimal string greater than zero").meta({
     description: "Token price in the specified currency (decimal string for arbitrary precision)",
     examples: ["100.50", "1.00", "0.01"]
   }),
@@ -26861,7 +26933,7 @@ var TokenPriceBodySchema = MutationInputSchema.extend({
     examples: ["EUR", "USD", "GBP"]
   })
 });
-var TokenPriceOutputSchema = z391.object({
+var TokenPriceOutputSchema = z392.object({
   feedAddress: ethereumAddress.meta({
     description: "The on-chain feed contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -26870,7 +26942,7 @@ var TokenPriceOutputSchema = z391.object({
     description: "Transaction hash of the price submission",
     examples: ["0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890"]
   }),
-  price: z391.string().meta({
+  price: z392.string().meta({
     description: "The submitted price (echoed back)",
     examples: ["100.50"]
   }),
@@ -26901,14 +26973,14 @@ var mint = v2Contract.route({
   description: "Mint new tokens to one or more addresses.",
   successDescription: "Tokens minted successfully.",
   tags: [V2_TAG.token]
-}).meta({ contractErrors: [...COMMON_CONTRACT_ERRORS, ...COMPLIANCE] }).input(v2Input.paramsBody(TokenReadInputSchema, z392.object(TokenMintInputSchema.shape).omit({ tokenAddress: true }))).output(mutationOutput);
+}).meta({ contractErrors: [...COMMON_CONTRACT_ERRORS, ...COMPLIANCE] }).input(v2Input.paramsBody(TokenReadInputSchema, z393.object(TokenMintInputSchema.shape).omit({ tokenAddress: true }))).output(mutationOutput);
 var burn = v2Contract.route({
   method: "POST",
   path: "/tokens/{tokenAddress}/burns",
   description: "Burn tokens from one or more addresses.",
   successDescription: "Tokens burned successfully.",
   tags: [V2_TAG.token]
-}).meta({ contractErrors: [...COMMON_CONTRACT_ERRORS, "DALP-1055"] }).input(v2Input.paramsBody(TokenReadInputSchema, z392.object(TokenBurnInputSchema.shape).omit({ tokenAddress: true }))).output(mutationOutput);
+}).meta({ contractErrors: [...COMMON_CONTRACT_ERRORS, "DALP-1055"] }).input(v2Input.paramsBody(TokenReadInputSchema, z393.object(TokenBurnInputSchema.shape).omit({ tokenAddress: true }))).output(mutationOutput);
 var transfer = v2Contract.route({
   method: "POST",
   path: "/tokens/{tokenAddress}/transfers",
@@ -26917,7 +26989,7 @@ var transfer = v2Contract.route({
   tags: [V2_TAG.token]
 }).meta({
   contractErrors: [...COMMON_CONTRACT_ERRORS, ...COMPLIANCE, ...FREEZE, "DALP-1056"]
-}).input(v2Input.paramsBody(TokenReadInputSchema, z392.object(TokenTransferSchema.shape).omit({ tokenAddress: true }))).output(mutationOutput);
+}).input(v2Input.paramsBody(TokenReadInputSchema, z393.object(TokenTransferSchema.shape).omit({ tokenAddress: true }))).output(mutationOutput);
 var forcedTransfer = v2Contract.route({
   method: "POST",
   path: "/tokens/{tokenAddress}/forced-transfers",
@@ -26926,7 +26998,7 @@ var forcedTransfer = v2Contract.route({
   tags: [V2_TAG.token]
 }).meta({
   contractErrors: [...COMMON_CONTRACT_ERRORS, ...COMPLIANCE, ...FREEZE, "DALP-1055"]
-}).input(v2Input.paramsBody(TokenReadInputSchema, z392.object(TokenForcedTransferSchema.shape).omit({ tokenAddress: true }))).output(mutationOutput);
+}).input(v2Input.paramsBody(TokenReadInputSchema, z393.object(TokenForcedTransferSchema.shape).omit({ tokenAddress: true }))).output(mutationOutput);
 var approve3 = v2Contract.route({
   method: "POST",
   path: "/tokens/{tokenAddress}/approvals",
@@ -26940,7 +27012,7 @@ var redeem = v2Contract.route({
   description: "Redeem tokens from one or more addresses.",
   successDescription: "Tokens redeemed successfully.",
   tags: [V2_TAG.token]
-}).meta({ contractErrors: [...COMMON_CONTRACT_ERRORS, "DALP-1055"] }).input(v2Input.paramsBody(TokenReadInputSchema, z392.object(TokenRedeemInputSchema.shape).omit({ tokenAddress: true }))).output(mutationOutput);
+}).meta({ contractErrors: [...COMMON_CONTRACT_ERRORS, "DALP-1055"] }).input(v2Input.paramsBody(TokenReadInputSchema, z393.object(TokenRedeemInputSchema.shape).omit({ tokenAddress: true }))).output(mutationOutput);
 var mature = v2Contract.route({
   method: "POST",
   path: "/tokens/{tokenAddress}/maturations",
@@ -27091,9 +27163,9 @@ var grantRole2 = v2Contract.route({
   description: "Grant a role to multiple accounts on a token.",
   successDescription: "Role granted successfully to accounts.",
   tags: [V2_TAG.token]
-}).meta({ contractErrors: [...COMMON_CONTRACT_ERRORS, ...ROLES] }).input(v2Input.paramsBody(TokenReadInputSchema, z392.union([
-  z392.object(TokenGrantRoleInputSchema.options[0].shape).omit({ tokenAddress: true }),
-  z392.object(TokenGrantRoleInputSchema.options[1].shape).omit({ tokenAddress: true })
+}).meta({ contractErrors: [...COMMON_CONTRACT_ERRORS, ...ROLES] }).input(v2Input.paramsBody(TokenReadInputSchema, z393.union([
+  z393.object(TokenGrantRoleInputSchema.options[0].shape).omit({ tokenAddress: true }),
+  z393.object(TokenGrantRoleInputSchema.options[1].shape).omit({ tokenAddress: true })
 ]))).output(createAsyncBlockchainMutationResponse(TokenGrantRoleOutputSchema));
 var revokeRole2 = v2Contract.route({
   method: "POST",
@@ -27101,9 +27173,9 @@ var revokeRole2 = v2Contract.route({
   description: "Revoke role(s) from account(s) on a token.",
   successDescription: "Roles revoked successfully from the specified accounts.",
   tags: [V2_TAG.token]
-}).meta({ contractErrors: [...COMMON_CONTRACT_ERRORS, ...ROLES] }).input(v2Input.paramsBody(TokenReadInputSchema, z392.union([
-  z392.object(TokenRevokeRoleInputSchema.options[0].shape).omit({ tokenAddress: true }),
-  z392.object(TokenRevokeRoleInputSchema.options[1].shape).omit({ tokenAddress: true })
+}).meta({ contractErrors: [...COMMON_CONTRACT_ERRORS, ...ROLES] }).input(v2Input.paramsBody(TokenReadInputSchema, z393.union([
+  z393.object(TokenRevokeRoleInputSchema.options[0].shape).omit({ tokenAddress: true }),
+  z393.object(TokenRevokeRoleInputSchema.options[1].shape).omit({ tokenAddress: true })
 ]))).output(createAsyncBlockchainMutationResponse(TokenRevokeRoleOutputSchema));
 var claimIssue2 = v2Contract.route({
   method: "POST",
@@ -27488,29 +27560,29 @@ var tokenV2MutationsContract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.reads.contract.ts
-import { z as z400 } from "zod";
+import { z as z403 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/token/routes/token.features.schema.ts
-import { z as z394 } from "zod";
+import { z as z395 } from "zod";
 
 // ../../packages/core/validation/src/feature-types.ts
-import { z as z393 } from "zod";
+import { z as z394 } from "zod";
 var featureTypes = tokenFeatureIds;
-var FeatureTypeSchema = z393.enum(featureTypes);
+var FeatureTypeSchema = z394.enum(featureTypes);
 
 // ../../packages/dalp/api-contract/src/routes/token/routes/token.features.schema.ts
 var TokenFeaturesInputSchema = TokenReadInputSchema;
-var feeBps = (description) => z394.number().int().min(0).max(20000).meta({
+var feeBps = (description) => z395.number().int().min(0).max(20000).meta({
   description: `${description} (1 bps = 0.01%, max 20 000 = 200%)`,
   examples: [200]
 });
-var TokenFeatureAUMFeeSchema = z394.object({
+var TokenFeatureAUMFeeSchema = z395.object({
   feeBps: feeBps("Annual AUM fee rate"),
   feeRecipient: ethereumAddress.meta({
     description: "Address receiving the collected AUM fee",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  isFrozen: z394.boolean().meta({
+  isFrozen: z395.boolean().meta({
     description: "Whether fee collection is frozen",
     examples: [false]
   }),
@@ -27523,7 +27595,7 @@ var TokenFeatureAUMFeeSchema = z394.object({
     examples: ["1000.50"]
   })
 }).nullable();
-var TokenFeatureMaturityRedemptionSchema = z394.object({
+var TokenFeatureMaturityRedemptionSchema = z395.object({
   maturityDate: timestamp().meta({
     description: "Bond maturity date",
     examples: ["2025-01-01T00:00:00Z"]
@@ -27540,7 +27612,7 @@ var TokenFeatureMaturityRedemptionSchema = z394.object({
     description: "Treasury holding denomination assets for redemption",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  isMatured: z394.boolean().meta({
+  isMatured: z395.boolean().meta({
     description: "Whether the bond has reached maturity",
     examples: [false]
   }),
@@ -27553,7 +27625,7 @@ var TokenFeatureMaturityRedemptionSchema = z394.object({
     examples: ["500.00"]
   })
 }).nullable();
-var TokenFeatureTransactionFeeSchema = z394.object({
+var TokenFeatureTransactionFeeSchema = z395.object({
   mintFeeBps: feeBps("Mint fee rate"),
   burnFeeBps: feeBps("Burn fee rate"),
   transferFeeBps: feeBps("Transfer fee rate"),
@@ -27561,7 +27633,7 @@ var TokenFeatureTransactionFeeSchema = z394.object({
     description: "Address receiving collected transaction fees",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  isFrozen: z394.boolean().meta({
+  isFrozen: z395.boolean().meta({
     description: "Whether fee collection is frozen",
     examples: [false]
   }),
@@ -27570,7 +27642,7 @@ var TokenFeatureTransactionFeeSchema = z394.object({
     examples: ["250.75"]
   })
 }).nullable();
-var TokenFeatureHistoricalBalancesSchema = z394.object({
+var TokenFeatureHistoricalBalancesSchema = z395.object({
   enabledAt: timestamp().meta({
     description: "When historical balance tracking was enabled",
     examples: ["2024-11-14T22:13:20Z"]
@@ -27580,7 +27652,7 @@ var TokenFeatureHistoricalBalancesSchema = z394.object({
     examples: ["1000000.00"]
   })
 }).nullable();
-var TokenFeatureFixedTreasuryYieldSchema = z394.object({
+var TokenFeatureFixedTreasuryYieldSchema = z395.object({
   startDate: timestamp().meta({
     description: "Yield schedule start",
     examples: ["2024-11-14T22:13:20Z"]
@@ -27589,11 +27661,11 @@ var TokenFeatureFixedTreasuryYieldSchema = z394.object({
     description: "Yield schedule end",
     examples: ["2025-01-01T00:00:00Z"]
   }),
-  rate: z394.number().meta({
+  rate: z395.number().meta({
     description: "Annual yield rate (percentage, e.g. 5.5 = 5.5%)",
     examples: [5.5]
   }),
-  interval: z394.coerce.string().meta({
+  interval: z395.coerce.string().meta({
     description: "Payout interval in seconds (string-encoded interval)",
     examples: ["2592000"]
   }),
@@ -27625,18 +27697,18 @@ var TokenFeatureFixedTreasuryYieldSchema = z394.object({
     description: "Period scheduled to start after the current one; null on the final period",
     examples: [null]
   }),
-  periods: z394.array(fixedYieldSchedulePeriod()).meta({
+  periods: z395.array(fixedYieldSchedulePeriod()).meta({
     description: "All scheduled periods. Per-period totalYield/totalUnclaimed populate as each period closes; configured rows exist from creation",
     examples: [[]]
   })
 }).nullable();
-var TokenFeatureVotingPowerSchema = z394.object({
+var TokenFeatureVotingPowerSchema = z395.object({
   enabledAt: timestamp().meta({
     description: "When voting power was enabled",
     examples: ["2024-11-14T22:13:20Z"]
   })
 }).nullable();
-var TokenFeatureExternalTransactionFeeSchema = z394.object({
+var TokenFeatureExternalTransactionFeeSchema = z395.object({
   feeToken: ethereumAddress.meta({
     description: "ERC-20 token used to pay fees",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -27657,7 +27729,7 @@ var TokenFeatureExternalTransactionFeeSchema = z394.object({
     description: "Address receiving collected external fees",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  isFrozen: z394.boolean().meta({
+  isFrozen: z395.boolean().meta({
     description: "Whether fee collection is frozen",
     examples: [false]
   }),
@@ -27666,7 +27738,7 @@ var TokenFeatureExternalTransactionFeeSchema = z394.object({
     examples: ["100.00"]
   })
 }).nullable();
-var TokenFeatureTransactionFeeAccountingSchema = z394.object({
+var TokenFeatureTransactionFeeAccountingSchema = z395.object({
   mintFeeBps: feeBps("Mint fee rate (accounting mode)"),
   burnFeeBps: feeBps("Burn fee rate (accounting mode)"),
   transferFeeBps: feeBps("Transfer fee rate (accounting mode)"),
@@ -27674,7 +27746,7 @@ var TokenFeatureTransactionFeeAccountingSchema = z394.object({
     description: "Address receiving accrued fees upon reconciliation",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  isFrozen: z394.boolean().meta({
+  isFrozen: z395.boolean().meta({
     description: "Whether fee accrual is frozen",
     examples: [false]
   }),
@@ -27687,7 +27759,7 @@ var TokenFeatureTransactionFeeAccountingSchema = z394.object({
     examples: ["100.00"]
   })
 }).nullable();
-var TokenFeatureConversionSchema = z394.object({
+var TokenFeatureConversionSchema = z395.object({
   targetToken: ethereumAddress.meta({
     description: "Token that holders can convert to",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -27701,17 +27773,17 @@ var TokenFeatureConversionSchema = z394.object({
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
   discountBps: feeBps("Conversion discount rate"),
-  partialAllowed: z394.boolean().meta({
+  partialAllowed: z395.boolean().meta({
     description: "Whether partial conversions are allowed",
     examples: [true]
   })
 }).nullable();
-var TokenFeatureConversionMinterSchema = z394.object({
-  authorizedConverters: z394.array(ethereumAddress).meta({
+var TokenFeatureConversionMinterSchema = z395.object({
+  authorizedConverters: z395.array(ethereumAddress).meta({
     description: "Addresses authorized to perform conversions",
     examples: [["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]]
   }),
-  totalIssuances: z394.number().int().meta({
+  totalIssuances: z395.number().int().meta({
     description: "Total number of conversion issuances performed",
     examples: [42]
   }),
@@ -27720,7 +27792,7 @@ var TokenFeatureConversionMinterSchema = z394.object({
     examples: ["50000.00"]
   })
 }).nullable();
-var TokenFeatureSchema = z394.object({
+var TokenFeatureSchema = z395.object({
   featureAddress: ethereumAddress.meta({
     description: "Feature contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -27729,17 +27801,17 @@ var TokenFeatureSchema = z394.object({
     description: "Feature type identifier",
     examples: ["aum-fee", "maturity-redemption", "transaction-fee"]
   }),
-  featureFactory: z394.object({
-    typeId: z394.string().meta({
+  featureFactory: z395.object({
+    typeId: z395.string().meta({
       description: "Feature factory type identifier",
       examples: ["aum-fee", "maturity-redemption"]
     }),
-    name: z394.string().meta({
+    name: z395.string().meta({
       description: "Human-readable name of the feature factory",
       examples: ["AUM Fee Feature Factory"]
     })
   }),
-  isAttached: z394.boolean().meta({
+  isAttached: z395.boolean().meta({
     description: "Whether the feature is currently attached to the token",
     examples: [true]
   }),
@@ -27792,13 +27864,13 @@ var TokenFeatureSchema = z394.object({
     examples: [null]
   })
 });
-var TokenFeaturesResponseSchema = z394.object({
-  configurable: z394.object({
-    features: z394.array(TokenFeatureSchema).meta({
+var TokenFeaturesResponseSchema = z395.object({
+  configurable: z395.object({
+    features: z395.array(TokenFeatureSchema).meta({
       description: "Feature configurations for the token",
       examples: [[]]
     }),
-    featuresCount: z394.number().int().meta({
+    featuresCount: z395.number().int().meta({
       description: "Total number of features attached to the token",
       examples: [3]
     })
@@ -27809,22 +27881,22 @@ var TokenFeaturesResponseSchema = z394.object({
 });
 
 // ../../packages/dalp/api-contract/src/routes/token/routes/token.metadata.schema.ts
-import { z as z395 } from "zod";
+import { z as z396 } from "zod";
 var TokenMetadataInputSchema = TokenReadInputSchema;
-var TokenMetadataEntrySchema = z395.object({
-  key: z395.string().meta({
+var TokenMetadataEntrySchema = z396.object({
+  key: z396.string().meta({
     description: "Human-readable metadata key string",
     examples: ["isin", "issuerName"]
   }),
-  keyHash: z395.string().meta({
+  keyHash: z396.string().meta({
     description: "On-chain keccak256 hash of the metadata key (bytes32 hex string)",
     examples: ["0x1c8aff950685c2ed4bc3174f3472287b56d9517b9c948127319a09a7a36deac8"]
   }),
-  value: z395.string().meta({
+  value: z396.string().meta({
     description: "Raw on-chain value (bytes32 hex string)",
     examples: ["0x000000"]
   }),
-  valueString: z395.string().nullable().meta({
+  valueString: z396.string().nullable().meta({
     description: "Decoded string representation of the value, null if not decodable",
     examples: ["Acme Corp", null]
   }),
@@ -27832,7 +27904,7 @@ var TokenMetadataEntrySchema = z395.object({
     description: "Numeric representation of the value, null if not numeric",
     examples: ["1000", null]
   }),
-  isImmutable: z395.boolean().meta({
+  isImmutable: z396.boolean().meta({
     description: "Whether this metadata entry is immutable (cannot be changed after being set)",
     examples: [false]
   }),
@@ -27841,22 +27913,22 @@ var TokenMetadataEntrySchema = z395.object({
     examples: ["1700000000"]
   })
 });
-var TokenMetadataResponseSchema = z395.object({
-  metadata_: z395.object({
-    entryCount: z395.number().int().meta({
+var TokenMetadataResponseSchema = z396.object({
+  metadata_: z396.object({
+    entryCount: z396.number().int().meta({
       description: "Total number of metadata entries",
       examples: [5]
     }),
-    entries: z395.array(TokenMetadataEntrySchema).meta({
+    entries: z396.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 z396 } from "zod";
-var ConversionTriggerSchema = z396.object({
-  triggerId: z396.string().meta({
+import { z as z397 } from "zod";
+var ConversionTriggerSchema = z397.object({
+  triggerId: z397.string().meta({
     description: "On-chain trigger ID (bytes32 hex)",
     examples: ["0xabc123..."]
   }),
@@ -27885,16 +27957,16 @@ var ConversionTriggerSchema = z396.object({
   expiresAt: timestamp().meta({
     description: "Trigger expiry timestamp. Epoch zero means no expiry."
   }),
-  metadataHash: z396.string().nullable().meta({
+  metadataHash: z397.string().nullable().meta({
     description: "Off-chain metadata document hash (bytes32 hex)"
   }),
-  active: z396.boolean().meta({
+  active: z397.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: z396.number().int().nonnegative().meta({
+  totalConversions: z397.number().int().nonnegative().meta({
     description: "Number of conversions executed against this trigger",
     examples: [0]
   }),
@@ -27907,16 +27979,16 @@ var ConversionTriggerSchema = z396.object({
     examples: ["0"]
   })
 });
-var ConversionTriggersResponseSchema = z396.object({
-  triggers: z396.array(ConversionTriggerSchema).meta({
+var ConversionTriggersResponseSchema = z397.object({
+  triggers: z397.array(ConversionTriggerSchema).meta({
     description: "List of conversion triggers ordered by publication time descending"
   }),
-  totalCount: z396.number().int().nonnegative().meta({
+  totalCount: z397.number().int().nonnegative().meta({
     description: "Total number of conversion triggers for this token",
     examples: [0]
   })
 });
-var ConversionTriggersInputSchema = z396.object({
+var ConversionTriggersInputSchema = z397.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -27950,26 +28022,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 z397 } from "zod";
-var TokenEventV2ValueSchema = z397.object({
-  id: z397.string().meta({ description: "Unique identifier for the parameter value", examples: ["evt_val_123"] }),
-  name: z397.string().meta({ description: "Name of the event parameter", examples: ["from", "to", "amount"] }),
-  value: z397.string().meta({
+import { z as z398 } from "zod";
+var TokenEventV2ValueSchema = z398.object({
+  id: z398.string().meta({ description: "Unique identifier for the parameter value", examples: ["evt_val_123"] }),
+  name: z398.string().meta({ description: "Name of the event parameter", examples: ["from", "to", "amount"] }),
+  value: z398.string().meta({
     description: "Value of the event parameter (address, hex hash, decimal-string number, or arbitrary text)",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F", "1000000000000000000"]
   })
 });
-var TokenEventV2ItemSchema = z397.object({
-  id: z397.string().meta({ description: "Unique identifier for the event", examples: ["evt_123abc"] }),
-  eventName: z397.string().meta({
+var TokenEventV2ItemSchema = z398.object({
+  id: z398.string().meta({ description: "Unique identifier for the event", examples: ["evt_123abc"] }),
+  eventName: z398.string().meta({
     description: "The event name",
     examples: ["TransferCompleted", "MintCompleted", "BurnCompleted"]
   }),
-  txIndex: z397.string().meta({
+  txIndex: z398.string().meta({
     description: "Log index within the transaction (string for parity with v1)",
     examples: ["0", "1", "5"]
   }),
-  blockNumber: z397.string().meta({
+  blockNumber: z398.string().meta({
     description: "Block number when the event occurred (decimal string for bigint precision)",
     examples: ["12345678", "20000000"]
   }),
@@ -27981,19 +28053,19 @@ var TokenEventV2ItemSchema = z397.object({
     description: "Transaction hash",
     examples: ["0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"]
   }),
-  emitter: z397.object({
+  emitter: z398.object({
     id: ethereumAddress.meta({
       description: "Address of the contract that emitted the event",
       examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
     })
   }),
-  sender: z397.object({
+  sender: z398.object({
     id: ethereumAddress.meta({
       description: "Address that triggered the event (account or sender, falling back to the contract address)",
       examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
     })
   }),
-  values: z397.array(TokenEventV2ValueSchema).meta({
+  values: z398.array(TokenEventV2ValueSchema).meta({
     description: "Event parameter values",
     examples: []
   })
@@ -28014,15 +28086,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 z398 } from "zod";
-var TransferApprovalSchema = z398.object({
-  id: z398.string().meta({
+import { z as z399 } from "zod";
+var TransferApprovalSchema = z399.object({
+  id: z399.string().meta({
     description: "Unique approval ID: {moduleAddress}-{token}-{fromIdentity}-{toIdentity}-{value}",
     examples: ["0xabc...-0xtoken...-0xfrom...-0xto...-1000000000000000000"]
   }),
-  token: z398.object({ id: ethereumAddress }),
-  fromIdentity: z398.object({ id: ethereumAddress }),
-  toIdentity: z398.object({ id: ethereumAddress }),
+  token: z399.object({ id: ethereumAddress }),
+  fromIdentity: z399.object({ id: ethereumAddress }),
+  toIdentity: z399.object({ id: ethereumAddress }),
   value: assetAmount.meta({
     description: "Approved transfer amount in base units",
     examples: ["1000000000000000000"]
@@ -28032,7 +28104,7 @@ var TransferApprovalSchema = z398.object({
     description: "Timestamp when approval expires. Epoch zero means no expiry.",
     examples: ["0", "1893456000"]
   }),
-  status: z398.enum(["pending", "consumed", "revoked"]).meta({
+  status: z399.enum(["pending", "consumed", "revoked"]).meta({
     description: "Current status of the approval",
     examples: ["pending"]
   }),
@@ -28045,17 +28117,17 @@ var TransferApprovalSchema = z398.object({
     examples: ["2023-11-14T12:05:00.000Z"]
   })
 });
-var TransferApprovalsResponseSchema = z398.object({
-  transferApprovals: z398.array(TransferApprovalSchema).meta({
+var TransferApprovalsResponseSchema = z399.object({
+  transferApprovals: z399.array(TransferApprovalSchema).meta({
     description: "List of transfer approvals ordered by creation time descending",
     examples: []
   }),
-  totalCount: z398.number().int().nonnegative().meta({
+  totalCount: z399.number().int().nonnegative().meta({
     description: "Total number of transfer approvals for this token",
     examples: [3]
   })
 });
-var TransferApprovalsInputSchema = z398.object({
+var TransferApprovalsInputSchema = z399.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -28063,20 +28135,20 @@ var TransferApprovalsInputSchema = z398.object({
 });
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.price.schema.ts
-import { z as z399 } from "zod";
-var TokenPriceInputParamsSchema = z399.object({
+import { z as z400 } from "zod";
+var TokenPriceInputParamsSchema = z400.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   })
 });
-var TokenPriceInputQuerySchema = z399.object({
+var TokenPriceInputQuerySchema = z400.object({
   currency: fiatCurrency().default("USD").meta({
     description: "Target ISO 4217 currency code for price conversion",
     examples: ["USD", "EUR", "GBP", "AED"]
   })
 });
-var ConversionHopSchema = z399.object({
+var ConversionHopSchema = z400.object({
   from: fiatCurrency().meta({
     description: "Source currency of this hop",
     examples: ["AED"]
@@ -28085,7 +28157,7 @@ var ConversionHopSchema = z399.object({
     description: "Target currency of this hop",
     examples: ["USD"]
   }),
-  rate: z399.string().meta({
+  rate: z400.string().meta({
     description: "Exchange rate (18-decimal string)",
     examples: ["272300000000000000"]
   }),
@@ -28097,17 +28169,17 @@ var ConversionHopSchema = z399.object({
     description: "When the feed was last updated",
     examples: ["2024-03-22T12:00:00.000Z"]
   }),
-  inverse: z399.boolean().meta({
+  inverse: z400.boolean().meta({
     description: "Whether this hop uses an inverse rate (1/rate of the registered feed)",
     examples: [false]
   })
 });
-var TokenPriceResponseSchema = z399.object({
+var TokenPriceResponseSchema = z400.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  price: z399.string().meta({
+  price: z400.string().meta({
     description: "The resolved price as a decimal string (18-decimal normalized)",
     examples: ["27230000000000000000"]
   }),
@@ -28115,11 +28187,11 @@ var TokenPriceResponseSchema = z399.object({
     description: "The currency of the returned price",
     examples: ["USD"]
   }),
-  decimals: z399.number().meta({
+  decimals: z400.number().meta({
     description: "Decimal precision of the price (always 18)",
     examples: [18]
   }),
-  source: z399.enum(["feed", "claim"]).meta({
+  source: z400.enum(["feed", "claim"]).meta({
     description: "Whether the base price came from a feed or identity claim",
     examples: ["feed"]
   }),
@@ -28127,7 +28199,7 @@ var TokenPriceResponseSchema = z399.object({
     description: "The native currency of the base price before conversion",
     examples: ["AED"]
   }),
-  convertible: z399.boolean().meta({
+  convertible: z400.boolean().meta({
     description: "Whether the price was successfully converted to the target currency",
     examples: [true]
   }),
@@ -28135,15 +28207,15 @@ var TokenPriceResponseSchema = z399.object({
     description: "The requested target currency (only present when convertible is false)",
     examples: ["USD"]
   }),
-  reason: z399.string().optional().meta({
+  reason: z400.string().optional().meta({
     description: "Reason for conversion failure (only present when convertible is false)",
     examples: ["no_fx_path"]
   }),
-  message: z399.string().optional().meta({
+  message: z400.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: z399.array(fiatCurrency()).optional().meta({
+  availableCurrencies: z400.array(fiatCurrency()).optional().meta({
     description: "Currencies reachable from the source currency (only present when convertible is false)",
     examples: [["AED", "EUR"]]
   }),
@@ -28151,7 +28223,7 @@ var TokenPriceResponseSchema = z399.object({
     description: "When the price data was last updated (ISO 8601)",
     examples: ["2026-03-22T10:30:00.000Z"]
   }),
-  conversionPath: z399.array(ConversionHopSchema).meta({
+  conversionPath: z400.array(ConversionHopSchema).meta({
     description: "The FX conversion hops applied (empty if no conversion needed)",
     examples: [[]]
   })
@@ -28169,6 +28241,48 @@ 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 z401 } from "zod";
+var HISTORICAL_BALANCE_KIND_OPTIONS = ["account", "totalSupply"];
+var TOKEN_HISTORICAL_BALANCES_COLLECTION_FIELDS = {
+  account: addressField({ defaultOperator: "eq" }),
+  blockNumber: bigintField(),
+  blockTimestamp: dateField(),
+  oldBalance: bigintField(),
+  newBalance: bigintField(),
+  kind: enumField(HISTORICAL_BALANCE_KIND_OPTIONS, { sortable: false, facetable: true })
+};
+var DISCRIMINATOR_FILTER_FIELDS2 = new Set(["account", "kind"]);
+var TokenHistoricalBalancesV2InputSchema = createCollectionInputSchema(TOKEN_HISTORICAL_BALANCES_COLLECTION_FIELDS, {
+  defaultSort: "-blockNumber",
+  globalSearch: false
+}).superRefine((query, ctx) => {
+  for (const filter of query.filters) {
+    if (DISCRIMINATOR_FILTER_FIELDS2.has(filter.id) && filter.operator !== "eq") {
+      ctx.addIssue({
+        code: "custom",
+        message: `filter[${filter.id}] only supports operator=eq on this endpoint`,
+        path: ["filter", filter.id]
+      });
+    }
+  }
+});
+var TokenHistoricalBalanceV2ItemSchema = z401.object({
+  id: z401.string().uuid(),
+  account: ethereumAddress,
+  kind: z401.enum(HISTORICAL_BALANCE_KIND_OPTIONS),
+  sender: ethereumAddress,
+  oldBalance: bigDecimal(),
+  oldBalanceExact: apiBigInt,
+  newBalance: bigDecimal(),
+  newBalanceExact: apiBigInt,
+  blockNumber: apiBigInt,
+  blockTimestamp: timestamp(),
+  txHash: ethereumHash,
+  logIndex: z401.number().int().nonnegative()
+});
+var TokenHistoricalBalancesV2OutputSchema = createPaginatedResponse(TokenHistoricalBalanceV2ItemSchema);
+
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.transfer-approvals.schema.ts
 var TRANSFER_APPROVAL_COLLECTION_FIELDS = {
   status: enumField(["pending", "consumed", "revoked"]),
@@ -28181,6 +28295,38 @@ 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 z402 } from "zod";
+var VOTING_DELEGATIONS_COLLECTION_FIELDS = {
+  account: addressField({ defaultOperator: "iLike" }),
+  delegate: addressField({ defaultOperator: "iLike" }),
+  isActive: booleanField({ sortable: false, facetable: true }),
+  delegatedBlockNumber: bigintField(),
+  delegatedAt: dateField(),
+  fromDelegate: addressField({ defaultOperator: "iLike" }),
+  toDelegate: addressField({ defaultOperator: "iLike" })
+};
+var VotingDelegationsV2InputSchema = createCollectionInputSchema(VOTING_DELEGATIONS_COLLECTION_FIELDS, {
+  defaultSort: "-delegatedAt",
+  globalSearch: false
+});
+var VotingDelegationV2ItemSchema = z402.object({
+  id: z402.string().uuid(),
+  delegator: ethereumAddress,
+  fromDelegate: ethereumAddress.nullable(),
+  toDelegate: ethereumAddress,
+  delegatedAt: timestamp(),
+  delegatedBlockNumber: apiBigInt,
+  delegatedTxHash: ethereumHash,
+  delegatedLogIndex: z402.number().int().nonnegative(),
+  undelegatedAt: timestamp().nullable(),
+  undelegatedBlockNumber: apiBigInt.nullable(),
+  undelegatedTxHash: ethereumHash.nullable(),
+  undelegatedLogIndex: z402.number().int().nonnegative().nullable(),
+  isActive: z402.boolean()
+});
+var VotingDelegationsV2OutputSchema = createPaginatedResponse(VotingDelegationV2ItemSchema);
+
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.reads.contract.ts
 var read27 = v2Contract.route({
   method: "GET",
@@ -28195,21 +28341,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(z400.object({ tokenAddress: TokenAllowanceInputSchema.shape.tokenAddress }), z400.object(TokenAllowanceInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(TokenAllowanceResponseSchema));
+}).input(v2Input.paramsQuery(z403.object({ tokenAddress: TokenAllowanceInputSchema.shape.tokenAddress }), z403.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(z400.object({ tokenAddress: TokenHolderInputSchema.shape.tokenAddress }), z400.object(TokenHolderInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(TokenHolderResponseSchema));
+}).input(v2Input.paramsQuery(z403.object({ tokenAddress: TokenHolderInputSchema.shape.tokenAddress }), z403.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(z400.object({
+}).input(v2Input.paramsQuery(z403.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -28221,7 +28367,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(z400.object({
+}).input(v2Input.paramsQuery(z403.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address to filter actions by",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -28233,7 +28379,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(z400.object({
+}).input(v2Input.paramsQuery(z403.object({
   tokenAddress: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
@@ -28245,7 +28391,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(z400.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), DenominationAssetsV2InputSchema)).output(DenominationAssetsV2OutputSchema);
+}).input(v2Input.paramsQuery(z403.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), DenominationAssetsV2InputSchema)).output(DenominationAssetsV2OutputSchema);
 var compliance = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/compliance-modules",
@@ -28273,7 +28419,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(z400.object({ tokenAddress: TransferApprovalsInputSchema.shape.tokenAddress }), TransferApprovalsV2InputSchema)).output(TransferApprovalsV2OutputSchema);
+}).input(v2Input.paramsQuery(z403.object({ tokenAddress: TransferApprovalsInputSchema.shape.tokenAddress }), TransferApprovalsV2InputSchema)).output(TransferApprovalsV2OutputSchema);
 var price = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/price",
@@ -28287,7 +28433,21 @@ 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(z400.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), ConversionTriggersV2InputSchema)).output(ConversionTriggersV2OutputSchema);
+}).input(v2Input.paramsQuery(z403.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(z403.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(z403.object({ tokenAddress: TokenReadInputSchema.shape.tokenAddress }), TokenHistoricalBalancesV2InputSchema)).output(TokenHistoricalBalancesV2OutputSchema);
 var tokenV2ReadsContract = {
   read: read27,
   allowance,
@@ -28301,11 +28461,13 @@ var tokenV2ReadsContract = {
   metadata: tokenMetadata,
   transferApprovals,
   conversionTriggers,
+  votingDelegations,
+  historicalBalances,
   price
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/token/token.v2.stats.contract.ts
-import { z as z401 } from "zod";
+import { z as z404 } from "zod";
 var statsBondStatus = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/stats/bond-status",
@@ -28326,25 +28488,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(z401.object({
+}).input(v2Input.paramsQuery(z404.object({
   tokenAddress: StatsTotalSupplyInputSchema.shape.tokenAddress
-}), z401.object(StatsTotalSupplyInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(StatsTotalSupplyOutputSchema));
+}), z404.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(z401.object({
+}).input(v2Input.paramsQuery(z404.object({
   tokenAddress: StatsSupplyChangesInputSchema.shape.tokenAddress
-}), z401.object(StatsSupplyChangesInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(StatsSupplyChangesOutputSchema));
+}), z404.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(z401.object({ tokenAddress: StatsVolumeInputSchema.shape.tokenAddress }), z401.object(StatsVolumeInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(StatsVolumeOutputSchema));
+}).input(v2Input.paramsQuery(z404.object({ tokenAddress: StatsVolumeInputSchema.shape.tokenAddress }), z404.object(StatsVolumeInputSchema.shape).omit({ tokenAddress: true }))).output(createSingleResponse(StatsVolumeOutputSchema));
 var statsWalletDistribution = v2Contract.route({
   method: "GET",
   path: "/tokens/{tokenAddress}/stats/wallet-distribution",
@@ -28394,7 +28556,7 @@ var tokenV2Contract = {
 };
 
 // ../../packages/core/validation/src/transaction-request-state.ts
-import { z as z402 } from "zod";
+import { z as z405 } from "zod";
 var transactionRequestStates = [
   "RECEIVED",
   "QUEUED",
@@ -28409,7 +28571,7 @@ var transactionRequestStates = [
   "CANCELLED"
 ];
 var TERMINAL_STATES = ["COMPLETED", "FAILED", "DEAD_LETTER", "CANCELLED"];
-var TransactionRequestStateSchema = z402.enum(transactionRequestStates).meta({
+var TransactionRequestStateSchema = z405.enum(transactionRequestStates).meta({
   description: "Current state in the transaction request lifecycle",
   examples: ["RECEIVED", "QUEUED", "BROADCASTING", "COMPLETED", "FAILED"]
 });
@@ -28450,96 +28612,96 @@ var transactionSubStatuses = [
   "WORKFLOW_BATCH_COMPLETED",
   "WORKFLOW_BATCH_FAILED"
 ];
-var TransactionSubStatusSchema = z402.enum(transactionSubStatuses).meta({
+var TransactionSubStatusSchema = z405.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 z403 } from "zod";
-var TransactionForceRetryInputSchema = z403.object({
-  transactionId: z403.uuid().meta({
+import { z as z406 } from "zod";
+var TransactionForceRetryInputSchema = z406.object({
+  transactionId: z406.uuid().meta({
     description: "Queue transaction identifier (UUIDv7) to retry",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   })
 });
-var TransactionForceRetryBodySchema = z403.object({
-  gasPrice: z403.string().optional().meta({
+var TransactionForceRetryBodySchema = z406.object({
+  gasPrice: z406.string().optional().meta({
     description: "Override gas price in wei (decimal string)",
     examples: ["20000000000"]
   }),
-  nonce: z403.number().int().nonnegative().optional().meta({
+  nonce: z406.number().int().nonnegative().optional().meta({
     description: "Override nonce for the retried transaction",
     examples: [42]
   })
 }).default({});
-var TransactionForceRetryResultSchema = z403.object({
-  transactionId: z403.uuid().meta({ description: "The requeued transaction ID" }),
+var TransactionForceRetryResultSchema = z406.object({
+  transactionId: z406.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 = z403.object({
-  transactionId: z403.uuid().meta({
+var TransactionForceFailInputSchema = z406.object({
+  transactionId: z406.uuid().meta({
     description: "Queue transaction identifier (UUIDv7) to force-fail",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   })
 });
-var TransactionForceFailBodySchema = z403.object({
-  reason: z403.string().min(1).max(1000).meta({
+var TransactionForceFailBodySchema = z406.object({
+  reason: z406.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 = z403.object({
-  transactionId: z403.uuid().meta({ description: "The force-failed transaction ID" }),
+var TransactionForceFailResultSchema = z406.object({
+  transactionId: z406.uuid().meta({ description: "The force-failed transaction ID" }),
   previousStatus: transactionRequestState().meta({ description: "State before force fail" }),
   status: transactionRequestState().meta({ description: "New state (FAILED)" }),
-  reason: z403.string().meta({ description: "The reason provided for the force-fail" })
+  reason: z406.string().meta({ description: "The reason provided for the force-fail" })
 });
 var TransactionV2ForceFailOutputSchema = createSingleResponse(TransactionForceFailResultSchema);
-var TransactionForceNonceInputSchema = z403.object({
-  transactionId: z403.uuid().meta({
+var TransactionForceNonceInputSchema = z406.object({
+  transactionId: z406.uuid().meta({
     description: "Queue transaction identifier — the nonce is forced on its sender wallet",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   })
 });
-var TransactionForceNonceBodySchema = z403.object({
-  nonce: z403.number().int().nonnegative().meta({
+var TransactionForceNonceBodySchema = z406.object({
+  nonce: z406.number().int().nonnegative().meta({
     description: "Nonce value to force-set on the sender's nonce tracker",
     examples: [42]
   })
 });
-var TransactionForceNonceResultSchema = z403.object({
-  previous: z403.number().nullable().meta({ description: "Previous nonce value (null if uninitialized)" }),
-  new: z403.number().meta({ description: "New nonce value after force-set" })
+var TransactionForceNonceResultSchema = z406.object({
+  previous: z406.number().nullable().meta({ description: "Previous nonce value (null if uninitialized)" }),
+  new: z406.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 z404 } from "zod";
-var TransactionV2CancelInputSchema = z404.object({
-  transactionId: z404.uuid().meta({
+import { z as z407 } from "zod";
+var TransactionV2CancelInputSchema = z407.object({
+  transactionId: z407.uuid().meta({
     description: "Queue transaction identifier (UUIDv7) to cancel",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   })
 });
-var TransactionCancelResultSchema = z404.object({
-  status: z404.enum(["cancelled", "cancellation_pending", "error"]).meta({
+var TransactionCancelResultSchema = z407.object({
+  status: z407.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: z404.string().optional().meta({
+  cancelTransactionId: z407.string().optional().meta({
     description: "RBF replacement transaction ID when cancellation is pending on-chain"
   }),
-  message: z404.string().optional().meta({
+  message: z407.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 z405 } from "zod";
+import { z as z408 } from "zod";
 var TRANSACTION_COLLECTION_FIELDS = {
   status: enumField([...transactionRequestStates]),
   operationType: textField(),
@@ -28552,12 +28714,12 @@ var TransactionV2ListInputSchema = createCollectionInputSchema(TRANSACTION_COLLE
   defaultSort: "createdAt",
   globalSearch: true
 });
-var TransactionListItemSchema = z405.object({
-  transactionId: z405.uuid().meta({
+var TransactionListItemSchema = z408.object({
+  transactionId: z408.uuid().meta({
     description: "Queue transaction identifier (UUIDv7)",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   }),
-  kind: z405.string().meta({
+  kind: z408.string().meta({
     description: "Mutation kind submitted to the queue",
     examples: ["token.create", "token.mint"]
   }),
@@ -28565,19 +28727,19 @@ var TransactionListItemSchema = z405.object({
     description: "Current transaction queue state",
     examples: ["QUEUED", "COMPLETED", "FAILED"]
   }),
-  subStatus: z405.string().nullable().meta({
+  subStatus: z408.string().nullable().meta({
     description: "Optional queue sub-status with finer-grained detail",
     examples: ["TIMEOUT", null]
   }),
-  fromAddress: z405.string().meta({
+  fromAddress: z408.string().meta({
     description: "Sender wallet address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  chainId: z405.number().int().meta({
+  chainId: z408.number().int().meta({
     description: "Target chain ID",
     examples: [1]
   }),
-  transactionHash: z405.string().nullable().meta({
+  transactionHash: z408.string().nullable().meta({
     description: "Primary transaction hash once broadcast",
     examples: ["0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef", null]
   }),
@@ -28597,19 +28759,19 @@ var TransactionV2ReadInputSchema = TransactionReadInputSchema;
 var TransactionV2ReadOutputSchema = createSingleResponse(TransactionReadOutputSchema);
 
 // ../../packages/dalp/api-contract/src/routes/transaction/routes/transaction.status.schema.ts
-import { z as z406 } from "zod";
-var TransactionStatusInputSchema = z406.object({
-  transactionId: z406.uuid().meta({
+import { z as z409 } from "zod";
+var TransactionStatusInputSchema = z409.object({
+  transactionId: z409.uuid().meta({
     description: "Queue transaction identifier (UUIDv7)",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   })
 });
-var TransactionStatusOutputSchema = z406.object({
-  transactionId: z406.uuid().meta({
+var TransactionStatusOutputSchema = z409.object({
+  transactionId: z409.uuid().meta({
     description: "Queue transaction identifier (UUIDv7)",
     examples: ["01934567-89ab-7def-8123-456789abcdef"]
   }),
-  kind: z406.string().meta({
+  kind: z409.string().meta({
     description: "Mutation kind submitted to the queue",
     examples: ["token.create", "token.mint"]
   }),
@@ -28617,23 +28779,23 @@ var TransactionStatusOutputSchema = z406.object({
     description: "Current transaction queue state",
     examples: ["QUEUED", "PREPARING", "CONFIRMING", "COMPLETED", "FAILED"]
   }),
-  subStatus: z406.string().nullable().meta({
+  subStatus: z409.string().nullable().meta({
     description: "Optional queue sub-status with finer-grained progress or failure detail",
     examples: ["TIMEOUT", "WORKFLOW_GRANTING_PERMISSIONS", null]
   }),
-  transactionHash: z406.string().nullable().meta({
+  transactionHash: z409.string().nullable().meta({
     description: "Primary transaction hash once broadcast",
     examples: ["0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef", null]
   }),
-  transactionHashes: z406.array(z406.string()).optional().meta({
+  transactionHashes: z409.array(z409.string()).optional().meta({
     description: "All transaction hashes for batch operations. Only present when the operation produced multiple transactions.",
     examples: [["0xabc...", "0xdef..."]]
   }),
-  blockNumber: z406.string().nullable().meta({
+  blockNumber: z409.string().nullable().meta({
     description: "Confirmed block number when available",
     examples: ["12345678", null]
   }),
-  errorMessage: z406.string().nullable().meta({
+  errorMessage: z409.string().nullable().meta({
     description: "Human-readable error or timeout detail when available",
     examples: ["Execution reverted", "Receipt not found after repeated checks", null]
   }),
@@ -28712,12 +28874,12 @@ var transactionV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/user/user.v2.contract.ts
-import { z as z412 } from "zod";
+import { z as z415 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/user/routes/user.read-by-national-id.schema.ts
-import { z as z407 } from "zod";
-var UserReadByNationalIdInputSchema = z407.object({
-  nationalId: z407.string().min(1).max(50).trim().meta({ description: "The national ID to look up (exact match against approved KYC)", examples: ["AB123456"] })
+import { z as z410 } from "zod";
+var UserReadByNationalIdInputSchema = z410.object({
+  nationalId: z410.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
@@ -28735,13 +28897,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 z408 } from "zod";
-var TokenAssetV2Schema = z408.object({
+import { z as z411 } from "zod";
+var TokenAssetV2Schema = z411.object({
   id: ethereumAddress.meta({
     description: "The token contract address",
     examples: ["0x71C7656EC7ab88b098defB751B7401B5f6d8976F"]
   }),
-  name: z408.string().meta({
+  name: z411.string().meta({
     description: "The token name",
     examples: ["Bond Token", "Equity Share"]
   }),
@@ -28761,19 +28923,19 @@ var TokenAssetV2Schema = z408.object({
     description: "The total supply of the token (raw on-chain uint256)",
     examples: ["1000000000000000000000", "101000000000000000000000000"]
   }),
-  bond: z408.object({
-    isMatured: z408.boolean().meta({
+  bond: z411.object({
+    isMatured: z411.boolean().meta({
       description: "Whether the bond is matured",
       examples: [true, false]
     })
   }).optional().nullable().meta({ description: "The bond details", examples: [] }),
-  yield: z408.object({
-    schedule: z408.object({
+  yield: z411.object({
+    schedule: z411.object({
       id: ethereumAddress.meta({
         description: "The yield schedule contract address",
         examples: ["0x8ba1f109551bD432803012645Ac136ddd64DBA72"]
       }),
-      denominationAsset: z408.object({
+      denominationAsset: z411.object({
         id: ethereumAddress.meta({
           description: "The denomination asset contract address",
           examples: ["0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"]
@@ -28793,8 +28955,8 @@ var TokenAssetV2Schema = z408.object({
     }).nullable().meta({ description: "The yield schedule details", examples: [] })
   }).nullable().meta({ description: "The yield details", examples: [] })
 });
-var UserAssetBalanceV2ItemSchema = z408.object({
-  id: z408.uuid().meta({
+var UserAssetBalanceV2ItemSchema = z411.object({
+  id: z411.uuid().meta({
     description: "The balance record ID (idxr_token_balances.id, UUIDv7).",
     examples: ["019283bc-7e0a-7c3d-9b1f-3f4d2c5e6a7b"]
   }),
@@ -28814,7 +28976,7 @@ var UserAssetBalanceV2ItemSchema = z408.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: z408.boolean().meta({
+  priceInBaseCurrencyReliable: z411.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]
   }),
@@ -28866,10 +29028,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 z411 } from "zod";
+import { z as z414 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/user/kyc/kyc-profile-version-documents.v2.list.schema.ts
-import { z as z409 } from "zod";
+import { z as z412 } from "zod";
 var KYC_PROFILE_VERSION_DOCUMENTS_COLLECTION_FIELDS = {
   fileName: textField(),
   documentType: enumField(kycDocumentTypes, { facetable: true }),
@@ -28880,19 +29042,19 @@ var KYC_PROFILE_VERSION_DOCUMENTS_COLLECTION_FIELDS = {
 var KycProfileVersionDocumentsV2ListInputSchema = createCollectionInputSchema(KYC_PROFILE_VERSION_DOCUMENTS_COLLECTION_FIELDS, {
   defaultSort: "uploadedAt"
 });
-var KycProfileVersionDocumentsV2ListItemSchema = z409.object({
-  id: z409.string(),
+var KycProfileVersionDocumentsV2ListItemSchema = z412.object({
+  id: z412.string(),
   documentType: kycDocumentType(),
-  fileName: z409.string(),
-  fileSize: z409.number(),
-  mimeType: z409.string(),
+  fileName: z412.string(),
+  fileSize: z412.number(),
+  mimeType: z412.string(),
   uploadedAt: timestamp(),
-  uploadedBy: z409.string().nullable()
+  uploadedBy: z412.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 z410 } from "zod";
+import { z as z413 } 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 = {
@@ -28905,21 +29067,21 @@ var KYC_PROFILE_VERSIONS_COLLECTION_FIELDS = {
 var KycProfileVersionsV2ListInputSchema = createCollectionInputSchema(KYC_PROFILE_VERSIONS_COLLECTION_FIELDS, {
   defaultSort: "versionNumber"
 });
-var KycProfileVersionsV2ListItemSchema = z410.object({
-  id: z410.string(),
-  versionNumber: z410.number(),
+var KycProfileVersionsV2ListItemSchema = z413.object({
+  id: z413.string(),
+  versionNumber: z413.number(),
   status: kycVersionStatus(),
   createdAt: timestamp(),
-  createdBy: z410.string().nullable(),
+  createdBy: z413.string().nullable(),
   submittedAt: timestamp().nullable(),
-  submittedBy: z410.string().nullable(),
+  submittedBy: z413.string().nullable(),
   reviewedAt: timestamp().nullable(),
-  reviewedBy: z410.string().nullable(),
-  reviewOutcome: z410.enum(KYC_REVIEW_OUTCOMES).nullable(),
-  isDraft: z410.boolean(),
-  isUnderReview: z410.boolean(),
-  isApproved: z410.boolean(),
-  isCurrent: z410.boolean()
+  reviewedBy: z413.string().nullable(),
+  reviewOutcome: z413.enum(KYC_REVIEW_OUTCOMES).nullable(),
+  isDraft: z413.boolean(),
+  isUnderReview: z413.boolean(),
+  isApproved: z413.boolean(),
+  isCurrent: z413.boolean()
 });
 var KycProfileVersionsV2ListOutputSchema = createPaginatedResponse(KycProfileVersionsV2ListItemSchema);
 
@@ -28937,14 +29099,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(z411.object({ userId: z411.string().min(1) }), KycProfileVersionsV2ListInputSchema)).output(KycProfileVersionsV2ListOutputSchema);
+}).input(v2Input.paramsQuery(z414.object({ userId: z414.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(z411.object({ userId: KycProfileVersionsCreateInputSchema.shape.userId }), KycProfileVersionsCreateInputSchema.omit({ userId: true }))).output(createSingleResponse(KycProfileVersionsCreateOutputSchema));
+}).input(v2Input.paramsBody(z414.object({ userId: KycProfileVersionsCreateInputSchema.shape.userId }), KycProfileVersionsCreateInputSchema.omit({ userId: true }))).output(createSingleResponse(KycProfileVersionsCreateOutputSchema));
 var versionRead = v2Contract.route({
   method: "GET",
   path: "/kyc-profile-versions/{versionId}",
@@ -28958,7 +29120,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(z411.object({ versionId: KycProfileVersionUpdateInputSchema.shape.versionId }), KycProfileVersionUpdateInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionUpdateOutputSchema));
+}).input(v2Input.paramsBody(z414.object({ versionId: KycProfileVersionUpdateInputSchema.shape.versionId }), KycProfileVersionUpdateInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionUpdateOutputSchema));
 var versionSubmit = v2Contract.route({
   method: "POST",
   path: "/kyc-profile-versions/{versionId}/submissions",
@@ -28972,28 +29134,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(z411.object({ versionId: KycProfileVersionApproveInputSchema.shape.versionId }), KycProfileVersionApproveInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionApproveOutputSchema));
+}).input(v2Input.paramsBody(z414.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(z411.object({ versionId: KycProfileVersionRejectInputSchema.shape.versionId }), KycProfileVersionRejectInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionRejectOutputSchema));
+}).input(v2Input.paramsBody(z414.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(z411.object({ versionId: KycProfileVersionRequestUpdateInputSchema.shape.versionId }), KycProfileVersionRequestUpdateInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionRequestUpdateOutputSchema));
+}).input(v2Input.paramsBody(z414.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(z411.object({ versionId: z411.string().min(1) }), KycProfileVersionDocumentsV2ListInputSchema)).output(KycProfileVersionDocumentsV2ListOutputSchema);
+}).input(v2Input.paramsQuery(z414.object({ versionId: z414.string().min(1) }), KycProfileVersionDocumentsV2ListInputSchema)).output(KycProfileVersionDocumentsV2ListOutputSchema);
 var documentsDelete = v2Contract.route({
   method: "DELETE",
   path: "/kyc-profile-versions/{versionId}/documents/{documentId}",
@@ -29007,14 +29169,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(z411.object({ versionId: KycProfileVersionDocumentGetUploadUrlInputSchema.shape.versionId }), KycProfileVersionDocumentGetUploadUrlInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionDocumentGetUploadUrlOutputSchema));
+}).input(v2Input.paramsBody(z414.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(z411.object({ versionId: KycProfileVersionDocumentConfirmUploadInputSchema.shape.versionId }), KycProfileVersionDocumentConfirmUploadInputSchema.omit({ versionId: true }))).output(createSingleResponse(KycProfileVersionDocumentConfirmUploadOutputSchema));
+}).input(v2Input.paramsBody(z414.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",
@@ -29092,14 +29254,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(z412.object({ userId: z412.string() }))).output(createSingleResponse(UserReadOutputSchema));
+}).input(v2Input.params(z415.object({ userId: z415.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(z412.object({ wallet: ethereumAddress }))).output(createSingleResponse(UserReadOutputSchema));
+}).input(v2Input.params(z415.object({ wallet: ethereumAddress }))).output(createSingleResponse(UserReadOutputSchema));
 var readByNationalId = v2Contract.route({
   method: "GET",
   path: "/national-ids/{nationalId}/user",
@@ -29208,30 +29370,30 @@ var userV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.chain-of-custody.schema.ts
-import { z as z413 } from "zod";
-var WebhooksV2ChainOfCustodyInputSchema = z413.object({
-  evtId: z413.string().trim().min(1)
-});
-var WebhooksV2ChainOfCustodyOutputSchema = createSingleResponse(z413.object({
-  evtId: z413.string(),
-  hops: z413.array(z413.object({
-    stage: z413.string(),
-    contentHash: z413.string(),
-    signedBy: z413.string().optional(),
-    recordedAt: z413.coerce.date()
+import { z as z416 } from "zod";
+var WebhooksV2ChainOfCustodyInputSchema = z416.object({
+  evtId: z416.string().trim().min(1)
+});
+var WebhooksV2ChainOfCustodyOutputSchema = createSingleResponse(z416.object({
+  evtId: z416.string(),
+  hops: z416.array(z416.object({
+    stage: z416.string(),
+    contentHash: z416.string(),
+    signedBy: z416.string().optional(),
+    recordedAt: z416.coerce.date()
   })),
-  merkleRoot: z413.string(),
-  platformSignature: z413.string()
+  merkleRoot: z416.string(),
+  platformSignature: z416.string()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.create.schema.ts
-import { z as z415 } from "zod";
+import { z as z418 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.list.schema.ts
-import { z as z414 } from "zod";
-var WebhookPayloadShapeSchema = z414.enum(["thin", "fat"]);
-var WebhookBreakerStateSchema = z414.enum(["closed", "half_open", "open"]);
-var WebhookDeliveryFailureClassSchema = z414.enum([
+import { z as z417 } from "zod";
+var WebhookPayloadShapeSchema = z417.enum(["thin", "fat"]);
+var WebhookBreakerStateSchema = z417.enum(["closed", "half_open", "open"]);
+var WebhookDeliveryFailureClassSchema = z417.enum([
   "DNS_FAIL",
   "TLS_FAIL",
   "CONNECT_TIMEOUT",
@@ -29243,35 +29405,35 @@ var WebhookDeliveryFailureClassSchema = z414.enum([
   "RECEIPT_INVALID_SIG",
   "RECEIPT_HASH_MISMATCH"
 ]);
-var WebhookFinalityStateSchema = z414.enum(["pending", "provisional", "final", "retracted", "recalled"]);
-var WebhookSigningSecretStatusSchema = z414.enum(["active", "previous", "revoked"]);
-var WebhookFatEventsAcknowledgmentSchema = z414.object({
-  acknowledgedAt: z414.coerce.date(),
-  acknowledgedByUserId: z414.string(),
-  fieldsAcknowledged: z414.array(z414.string())
-});
-var WebhookEndpointSchema = z414.object({
-  id: z414.uuid(),
-  tenantId: z414.string(),
-  systemId: z414.string(),
-  url: z414.url(),
-  displayName: z414.string().nullable(),
-  subscriptions: z414.array(z414.string()),
+var WebhookFinalityStateSchema = z417.enum(["pending", "provisional", "final", "retracted", "recalled"]);
+var WebhookSigningSecretStatusSchema = z417.enum(["active", "previous", "revoked"]);
+var WebhookFatEventsAcknowledgmentSchema = z417.object({
+  acknowledgedAt: z417.coerce.date(),
+  acknowledgedByUserId: z417.string(),
+  fieldsAcknowledged: z417.array(z417.string())
+});
+var WebhookEndpointSchema = z417.object({
+  id: z417.uuid(),
+  tenantId: z417.string(),
+  systemId: z417.string(),
+  url: z417.url(),
+  displayName: z417.string().nullable(),
+  subscriptions: z417.array(z417.string()),
   defaultPayloadShape: WebhookPayloadShapeSchema,
-  counterSignedReceipts: z414.boolean(),
+  counterSignedReceipts: z417.boolean(),
   breakerState: WebhookBreakerStateSchema,
-  disabledAt: z414.coerce.date().nullable(),
-  disabledReason: z414.string().nullable(),
+  disabledAt: z417.coerce.date().nullable(),
+  disabledReason: z417.string().nullable(),
   fatEventsAcknowledgment: WebhookFatEventsAcknowledgmentSchema.nullable(),
-  secret: z414.object({
-    activeVersion: z414.number().int().positive().nullable(),
-    previousVersion: z414.number().int().positive().nullable(),
-    previousRevokesAt: z414.coerce.date().nullable(),
-    lastUsedAt: z414.coerce.date().nullable()
+  secret: z417.object({
+    activeVersion: z417.number().int().positive().nullable(),
+    previousVersion: z417.number().int().positive().nullable(),
+    previousRevokesAt: z417.coerce.date().nullable(),
+    lastUsedAt: z417.coerce.date().nullable()
   }),
-  createdAt: z414.coerce.date(),
-  updatedAt: z414.coerce.date(),
-  createdByUserId: z414.string().nullable()
+  createdAt: z417.coerce.date(),
+  updatedAt: z417.coerce.date(),
+  createdByUserId: z417.string().nullable()
 });
 var WEBHOOKS_COLLECTION_FIELDS = {
   displayName: textField(),
@@ -29290,44 +29452,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 = z415.object({
-  url: z415.url(),
-  displayName: z415.string().trim().min(1).max(200).optional(),
-  subscriptions: z415.array(z415.string().trim().min(1)).min(1).default(["*.final", "*.retracted", "*.recalled"]),
+var WebhooksV2CreateInputSchema = z418.object({
+  url: z418.url(),
+  displayName: z418.string().trim().min(1).max(200).optional(),
+  subscriptions: z418.array(z418.string().trim().min(1)).min(1).default(["*.final", "*.retracted", "*.recalled"]),
   defaultPayloadShape: WebhookPayloadShapeSchema.default("thin"),
-  counterSignedReceipts: z415.boolean().default(false)
+  counterSignedReceipts: z418.boolean().default(false)
 });
 var WebhookEndpointCreateResultSchema = WebhookEndpointSchema.extend({
-  signingSecret: z415.string().nullable()
+  signingSecret: z418.string().nullable()
 });
 var WebhooksV2CreateOutputSchema = createSingleResponse(WebhookEndpointCreateResultSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.delete.schema.ts
-import { z as z416 } from "zod";
-var WebhooksV2DeleteInputSchema = z416.object({
-  id: z416.uuid()
+import { z as z419 } from "zod";
+var WebhooksV2DeleteInputSchema = z419.object({
+  id: z419.uuid()
 });
 var WebhooksV2DeleteOutputSchema = DeleteResponseSchema;
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.deliveries.list.schema.ts
-import { z as z417 } from "zod";
-var WebhookDeliveryStatusSchema = z417.enum(["pending", "delivered", "failed"]);
-var WebhookDeliverySchema = z417.object({
-  id: z417.uuid(),
-  eventOutboxId: z417.uuid(),
-  endpointId: z417.uuid(),
-  tenantId: z417.string(),
-  evtId: z417.string(),
-  eventType: z417.string(),
-  attemptN: z417.number().int().nonnegative(),
-  attemptedAt: z417.coerce.date(),
-  responseStatus: z417.number().int().nullable(),
+import { z as z420 } from "zod";
+var WebhookDeliveryStatusSchema = z420.enum(["pending", "delivered", "failed"]);
+var WebhookDeliverySchema = z420.object({
+  id: z420.uuid(),
+  eventOutboxId: z420.uuid(),
+  endpointId: z420.uuid(),
+  tenantId: z420.string(),
+  evtId: z420.string(),
+  eventType: z420.string(),
+  attemptN: z420.number().int().nonnegative(),
+  attemptedAt: z420.coerce.date(),
+  responseStatus: z420.number().int().nullable(),
   failureClass: WebhookDeliveryFailureClassSchema.nullable(),
   status: WebhookDeliveryStatusSchema,
-  deliveredAt: z417.coerce.date().nullable(),
-  isReplay: z417.boolean(),
-  isTest: z417.boolean(),
-  traceId: z417.string().nullable()
+  deliveredAt: z420.coerce.date().nullable(),
+  isReplay: z420.boolean(),
+  isTest: z420.boolean(),
+  traceId: z420.string().nullable()
 });
 var WEBHOOK_DELIVERIES_COLLECTION_FIELDS = {
   status: enumField(["pending", "delivered", "failed"]),
@@ -29353,167 +29515,167 @@ var WebhooksV2DeliveriesListInputSchema = createCollectionInputSchema(WEBHOOK_DE
   defaultSort: "attemptedAt",
   globalSearch: false
 });
-var WebhooksV2DeliveriesListParamsSchema = z417.object({
-  id: z417.uuid()
+var WebhooksV2DeliveriesListParamsSchema = z420.object({
+  id: z420.uuid()
 });
 var WebhooksV2DeliveriesListOutputSchema = createPaginatedResponse(WebhookDeliverySchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.deliveries.read.schema.ts
-import { z as z418 } from "zod";
-var WebhooksV2DeliveriesReadInputSchema = z418.object({
-  id: z418.uuid(),
-  deliveryId: z418.uuid()
+import { z as z421 } from "zod";
+var WebhooksV2DeliveriesReadInputSchema = z421.object({
+  id: z421.uuid(),
+  deliveryId: z421.uuid()
 });
 var WebhookDeliveryDetailSchema = WebhookDeliverySchema.extend({
-  request: z418.object({
-    payload: z418.record(z418.string(), z418.json()),
-    signedHeaders: z418.record(z418.string(), z418.union([z418.string(), z418.array(z418.string())])),
-    signedStringPreview: z418.string()
+  request: z421.object({
+    payload: z421.record(z421.string(), z421.json()),
+    signedHeaders: z421.record(z421.string(), z421.union([z421.string(), z421.array(z421.string())])),
+    signedStringPreview: z421.string()
   }),
-  response: z418.object({
-    headers: z418.record(z418.string(), z418.union([z418.string(), z418.array(z418.string())])).nullable(),
-    body: z418.string().nullable(),
-    timings: z418.object({
-      dnsMs: z418.number().int().nullable(),
-      tlsMs: z418.number().int().nullable(),
-      connectMs: z418.number().int().nullable(),
-      ttfbMs: z418.number().int().nullable()
+  response: z421.object({
+    headers: z421.record(z421.string(), z421.union([z421.string(), z421.array(z421.string())])).nullable(),
+    body: z421.string().nullable(),
+    timings: z421.object({
+      dnsMs: z421.number().int().nullable(),
+      tlsMs: z421.number().int().nullable(),
+      connectMs: z421.number().int().nullable(),
+      ttfbMs: z421.number().int().nullable()
     })
   })
 });
 var WebhooksV2DeliveriesReadOutputSchema = createSingleResponse(WebhookDeliveryDetailSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.deliveries.retry.schema.ts
-import { z as z419 } from "zod";
-var WebhooksV2DeliveriesRetryInputSchema = z419.object({
-  id: z419.uuid(),
-  deliveryId: z419.uuid()
+import { z as z422 } from "zod";
+var WebhooksV2DeliveriesRetryInputSchema = z422.object({
+  id: z422.uuid(),
+  deliveryId: z422.uuid()
 });
-var WebhooksV2DeliveriesRetryOutputSchema = createSingleResponse(z419.object({
-  deliveryId: z419.uuid(),
-  scheduled: z419.boolean()
+var WebhooksV2DeliveriesRetryOutputSchema = createSingleResponse(z422.object({
+  deliveryId: z422.uuid(),
+  scheduled: z422.boolean()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.read.schema.ts
-import { z as z420 } from "zod";
-var WebhooksV2ReadInputSchema = z420.object({
-  id: z420.uuid()
+import { z as z423 } from "zod";
+var WebhooksV2ReadInputSchema = z423.object({
+  id: z423.uuid()
 });
 var WebhooksV2ReadOutputSchema = createSingleResponse(WebhookEndpointSchema);
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.recalls.schema.ts
-import { z as z421 } from "zod";
-var WebhooksV2RecallsParamsSchema = z421.object({
-  evtId: z421.string().trim().min(1)
-});
-var WebhooksV2RecallsBodySchema = z421.object({
-  reason: z421.string().trim().min(1).max(2000)
-});
-var WebhooksV2RecallsOutputSchema = createSingleResponse(z421.object({
-  evtId: z421.string(),
-  recalledEvtId: z421.string(),
-  supersedes: z421.string(),
-  reason: z421.string(),
-  recalledByUserId: z421.string()
+import { z as z424 } from "zod";
+var WebhooksV2RecallsParamsSchema = z424.object({
+  evtId: z424.string().trim().min(1)
+});
+var WebhooksV2RecallsBodySchema = z424.object({
+  reason: z424.string().trim().min(1).max(2000)
+});
+var WebhooksV2RecallsOutputSchema = createSingleResponse(z424.object({
+  evtId: z424.string(),
+  recalledEvtId: z424.string(),
+  supersedes: z424.string(),
+  reason: z424.string(),
+  recalledByUserId: z424.string()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.replays.schema.ts
-import { z as z422 } from "zod";
-var WebhooksV2ReplayByRangeSchema = z422.object({
-  fromBlock: z422.coerce.bigint(),
-  toBlock: z422.coerce.bigint().optional(),
-  chainId: z422.coerce.number().int().positive(),
-  confirmLargeRange: z422.boolean().default(false)
-});
-var WebhooksV2ReplayByEventSchema = z422.object({
-  evtId: z422.string().trim().min(1),
-  chainId: z422.coerce.number().int().positive().optional()
-});
-var WebhooksV2ReplaysParamsSchema = z422.object({
-  id: z422.uuid()
-});
-var WebhooksV2ReplaysBodySchema = z422.union([WebhooksV2ReplayByRangeSchema, WebhooksV2ReplayByEventSchema]);
-var WebhooksV2ReplaysOutputSchema = createSingleResponse(z422.object({
-  replayId: z422.uuid(),
-  endpointId: z422.uuid(),
-  eventsEnqueued: z422.number().int().nonnegative(),
-  snapshotToBlock: z422.string().nullable()
+import { z as z425 } from "zod";
+var WebhooksV2ReplayByRangeSchema = z425.object({
+  fromBlock: z425.coerce.bigint(),
+  toBlock: z425.coerce.bigint().optional(),
+  chainId: z425.coerce.number().int().positive(),
+  confirmLargeRange: z425.boolean().default(false)
+});
+var WebhooksV2ReplayByEventSchema = z425.object({
+  evtId: z425.string().trim().min(1),
+  chainId: z425.coerce.number().int().positive().optional()
+});
+var WebhooksV2ReplaysParamsSchema = z425.object({
+  id: z425.uuid()
+});
+var WebhooksV2ReplaysBodySchema = z425.union([WebhooksV2ReplayByRangeSchema, WebhooksV2ReplayByEventSchema]);
+var WebhooksV2ReplaysOutputSchema = createSingleResponse(z425.object({
+  replayId: z425.uuid(),
+  endpointId: z425.uuid(),
+  eventsEnqueued: z425.number().int().nonnegative(),
+  snapshotToBlock: z425.string().nullable()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.revoke-secret.schema.ts
-import { z as z423 } from "zod";
-var WebhooksV2RevokeSecretInputSchema = z423.object({
-  id: z423.uuid()
+import { z as z426 } from "zod";
+var WebhooksV2RevokeSecretInputSchema = z426.object({
+  id: z426.uuid()
 });
-var WebhooksV2RevokeSecretOutputSchema = createSingleResponse(z423.object({
-  endpointId: z423.uuid(),
-  activeVersion: z423.number().int().positive(),
-  previousVersion: z423.number().int().positive().nullable(),
-  revokedVersion: z423.number().int().positive()
+var WebhooksV2RevokeSecretOutputSchema = createSingleResponse(z426.object({
+  endpointId: z426.uuid(),
+  activeVersion: z426.number().int().positive(),
+  previousVersion: z426.number().int().positive().nullable(),
+  revokedVersion: z426.number().int().positive()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.rotate-secret.schema.ts
-import { z as z424 } from "zod";
-var WebhooksV2RotateSecretInputSchema = z424.object({
-  id: z424.uuid()
-});
-var WebhooksV2RotateSecretOutputSchema = createSingleResponse(z424.object({
-  endpointId: z424.uuid(),
-  activeVersion: z424.number().int().positive(),
-  previousVersion: z424.number().int().positive().nullable(),
-  previousRevokesAt: z424.coerce.date().nullable(),
-  signingSecret: z424.string().nullable()
+import { z as z427 } from "zod";
+var WebhooksV2RotateSecretInputSchema = z427.object({
+  id: z427.uuid()
+});
+var WebhooksV2RotateSecretOutputSchema = createSingleResponse(z427.object({
+  endpointId: z427.uuid(),
+  activeVersion: z427.number().int().positive(),
+  previousVersion: z427.number().int().positive().nullable(),
+  previousRevokesAt: z427.coerce.date().nullable(),
+  signingSecret: z427.string().nullable()
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.stats.schema.ts
-import { z as z425 } from "zod";
-var WebhooksV2StatsInputSchema = z425.object({
-  endpointId: z425.uuid().optional()
+import { z as z428 } from "zod";
+var WebhooksV2StatsInputSchema = z428.object({
+  endpointId: z428.uuid().optional()
 });
-var WebhooksV2StatsOutputDataSchema = z425.object({
-  totalDeliveries: z425.number().int().min(0),
-  delivered: z425.number().int().min(0),
-  failed: z425.number().int().min(0),
-  hourlyBuckets: z425.array(z425.number().int().min(0)).length(24)
+var WebhooksV2StatsOutputDataSchema = z428.object({
+  totalDeliveries: z428.number().int().min(0),
+  delivered: z428.number().int().min(0),
+  failed: z428.number().int().min(0),
+  hourlyBuckets: z428.array(z428.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 z426 } from "zod";
-var WebhooksV2TestEventParamsSchema = z426.object({
-  id: z426.uuid()
+import { z as z429 } from "zod";
+var WebhooksV2TestEventParamsSchema = z429.object({
+  id: z429.uuid()
 });
-var WebhooksV2TestEventBodySchema = z426.object({
-  eventType: z426.string().trim().min(1).default("webhook.test.final")
+var WebhooksV2TestEventBodySchema = z429.object({
+  eventType: z429.string().trim().min(1).default("webhook.test.final")
 });
-var WebhooksV2TestEventOutputSchema = createSingleResponse(z426.object({
-  evtId: z426.string(),
-  deliveryId: z426.uuid().nullable(),
-  isTest: z426.literal(true)
+var WebhooksV2TestEventOutputSchema = createSingleResponse(z429.object({
+  evtId: z429.string(),
+  deliveryId: z429.uuid().nullable(),
+  isTest: z429.literal(true)
 }));
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhooks/webhooks.v2.update.schema.ts
-import { z as z427 } from "zod";
-var WebhooksV2UpdateParamsSchema = z427.object({
-  id: z427.uuid()
+import { z as z430 } from "zod";
+var WebhooksV2UpdateParamsSchema = z430.object({
+  id: z430.uuid()
 });
-var WebhooksV2UpdateBodySchema = z427.object({
-  url: z427.url().optional(),
-  displayName: z427.string().trim().min(1).max(200).nullable().optional(),
-  subscriptions: z427.array(z427.string().trim().min(1)).min(1).optional(),
+var WebhooksV2UpdateBodySchema = z430.object({
+  url: z430.url().optional(),
+  displayName: z430.string().trim().min(1).max(200).nullable().optional(),
+  subscriptions: z430.array(z430.string().trim().min(1)).min(1).optional(),
   defaultPayloadShape: WebhookPayloadShapeSchema.optional(),
-  counterSignedReceipts: z427.boolean().optional(),
-  disabled: z427.boolean().optional(),
-  disabledReason: z427.string().trim().min(1).max(500).nullable().optional(),
+  counterSignedReceipts: z430.boolean().optional(),
+  disabled: z430.boolean().optional(),
+  disabledReason: z430.string().trim().min(1).max(500).nullable().optional(),
   fatEventsAcknowledgment: WebhookFatEventsAcknowledgmentSchema.omit({
     acknowledgedAt: true,
     acknowledgedByUserId: true
   }).optional()
 });
-var WebhooksV2UpdateQuerySchema = z427.object({
-  acknowledgePending: z427.union([z427.literal("true"), z427.literal(true)]).transform(() => true).optional()
+var WebhooksV2UpdateQuerySchema = z430.object({
+  acknowledgePending: z430.union([z430.literal("true"), z430.literal(true)]).transform(() => true).optional()
 }).optional();
-var WebhooksV2UpdateInputSchema = z427.object({
+var WebhooksV2UpdateInputSchema = z430.object({
   params: WebhooksV2UpdateParamsSchema,
   body: WebhooksV2UpdateBodySchema,
   query: WebhooksV2UpdateQuerySchema
@@ -29648,21 +29810,21 @@ var webhooksV2Contract = {
 };
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhook-receipts/webhook-receipts.v2.create.schema.ts
-import { z as z429 } from "zod";
+import { z as z432 } from "zod";
 
 // ../../packages/dalp/api-contract/src/routes/v2/webhook-receipts/webhook-receipts.v2.list.schema.ts
-import { z as z428 } from "zod";
-var WebhookReceiptVerificationFailureClassSchema = z428.enum(["RECEIPT_INVALID_SIG", "RECEIPT_HASH_MISMATCH"]);
-var WebhookReceiptSchema = z428.object({
-  id: z428.uuid(),
-  deliveryId: z428.uuid(),
-  evtId: z428.string(),
-  tenantId: z428.string(),
-  endpointId: z428.uuid(),
-  consumerSignature: z428.string(),
-  innerEventHash: z428.string(),
-  receivedAt: z428.coerce.date(),
-  verifiedAt: z428.coerce.date().nullable(),
+import { z as z431 } from "zod";
+var WebhookReceiptVerificationFailureClassSchema = z431.enum(["RECEIPT_INVALID_SIG", "RECEIPT_HASH_MISMATCH"]);
+var WebhookReceiptSchema = z431.object({
+  id: z431.uuid(),
+  deliveryId: z431.uuid(),
+  evtId: z431.string(),
+  tenantId: z431.string(),
+  endpointId: z431.uuid(),
+  consumerSignature: z431.string(),
+  innerEventHash: z431.string(),
+  receivedAt: z431.coerce.date(),
+  verifiedAt: z431.coerce.date().nullable(),
   verificationFailureClass: WebhookReceiptVerificationFailureClassSchema.nullable()
 });
 var WEBHOOK_RECEIPTS_COLLECTION_FIELDS = {
@@ -29679,19 +29841,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 = z429.object({
-  deliveryId: z429.uuid(),
-  evtId: z429.string().trim().min(1),
-  endpointId: z429.uuid(),
-  consumerSignature: z429.string().trim().min(1),
-  innerEventHash: z429.string().trim().min(1)
+var WebhookReceiptsV2CreateInputSchema = z432.object({
+  deliveryId: z432.uuid(),
+  evtId: z432.string().trim().min(1),
+  endpointId: z432.uuid(),
+  consumerSignature: z432.string().trim().min(1),
+  innerEventHash: z432.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 z430 } from "zod";
-var WebhookReceiptsV2ReadInputSchema = z430.object({
-  id: z430.uuid()
+import { z as z433 } from "zod";
+var WebhookReceiptsV2ReadInputSchema = z433.object({
+  id: z433.uuid()
 });
 var WebhookReceiptsV2ReadOutputSchema = createSingleResponse(WebhookReceiptSchema);
 
@@ -29740,6 +29902,7 @@ var v2Contract2 = {
   compliance: complianceV2Contract,
   exchangeRates: exchangeRatesV2Contract,
   externalToken: externalTokenV2Contract,
+  historicalBalances: historicalBalancesV2Contract,
   identityRecovery: identityRecoveryV2Contract,
   invitation: invitationV2Contract,
   restate: restateV2Contract,
@@ -29838,7 +30001,7 @@ function getDapiPublicErrorFromResponseBody(body) {
   if (isDapiPublicError(body)) {
     return body;
   }
-  if (!isRecord2(body)) {
+  if (!isRecord3(body)) {
     return;
   }
   if (isDapiPublicError(body.error)) {
@@ -29847,11 +30010,11 @@ function getDapiPublicErrorFromResponseBody(body) {
   if (isDapiPublicError(body.dapiError)) {
     return body.dapiError;
   }
-  if (isRecord2(body.error)) {
+  if (isRecord3(body.error)) {
     if (isDapiPublicError(body.error.dapiError)) {
       return body.error.dapiError;
     }
-    if (isRecord2(body.error.data) && isDapiPublicError(body.error.data.dapiError)) {
+    if (isRecord3(body.error.data) && isDapiPublicError(body.error.data.dapiError)) {
       return body.error.data.dapiError;
     }
   }
@@ -29859,15 +30022,15 @@ function getDapiPublicErrorFromResponseBody(body) {
 }
 var DAPI_ERROR_ID_PATTERN = /^DALP-\d+$/;
 function isDapiPublicError(value3) {
-  if (!isRecord2(value3)) {
+  if (!isRecord3(value3)) {
     return false;
   }
   if (typeof value3.id !== "string" || !DAPI_ERROR_ID_PATTERN.test(value3.id) || typeof value3.category !== "string" || typeof value3.status !== "number" || typeof value3.retryable !== "boolean" || typeof value3.message !== "string" || typeof value3.why !== "string" || typeof value3.fix !== "string") {
     return false;
   }
-  return value3.details === undefined || isRecord2(value3.details);
+  return value3.details === undefined || isRecord3(value3.details);
 }
-function isRecord2(value3) {
+function isRecord3(value3) {
   return typeof value3 === "object" && value3 !== null && !Array.isArray(value3);
 }
 
@@ -29968,7 +30131,7 @@ function normalizeDalpBaseUrl(url) {
 // package.json
 var package_default = {
   name: "@settlemint/dalp-sdk",
-  version: "2.1.7-main.25674533400",
+  version: "2.1.7-main.25679765049",
   private: false,
   description: "Fully typed SDK for the DALP tokenization platform API",
   homepage: "https://settlemint.com",