@ensnode/ensnode-sdk 0.0.0-next-20260216171758 → 0.0.0-next-20260217102457

package/dist/index.cjs

@@ -47,13 +47,14 @@ __export(index_exports, {
   DEFAULT_EVM_COIN_TYPE: () => DEFAULT_EVM_COIN_TYPE,
   ENCODED_REFERRER_BYTE_LENGTH: () => ENCODED_REFERRER_BYTE_LENGTH,
   ENCODED_REFERRER_BYTE_OFFSET: () => ENCODED_REFERRER_BYTE_OFFSET,
-  ENSApiClient: () => ENSApiClient,
   ENSNamespaceIds: () => import_datasources.ENSNamespaceIds,
   ENSNodeClient: () => ENSNodeClient,
   ENS_ROOT: () => ENS_ROOT,
   ETH_COIN_TYPE: () => ETH_COIN_TYPE,
   ETH_NODE: () => ETH_NODE,
   EXPECTED_ENCODED_REFERRER_PADDING: () => EXPECTED_ENCODED_REFERRER_PADDING,
+  EnsApiClient: () => EnsApiClient,
+  EnsApiIndexingStatusResponseCodes: () => EnsApiIndexingStatusResponseCodes,
   ForwardResolutionProtocolStep: () => ForwardResolutionProtocolStep,
   IndexingStatusResponseCodes: () => IndexingStatusResponseCodes,
   LINEANAMES_NODE: () => LINEANAMES_NODE,
@@ -125,6 +126,10 @@ __export(index_exports, {
   deserializeDuration: () => deserializeDuration,
   deserializeENSApiPublicConfig: () => deserializeENSApiPublicConfig,
   deserializeENSIndexerPublicConfig: () => deserializeENSIndexerPublicConfig,
+  deserializeEnsApiConfigResponse: () => deserializeEnsApiConfigResponse,
+  deserializeEnsApiIndexingStatusResponse: () => deserializeEnsApiIndexingStatusResponse,
+  deserializeEnsApiPublicConfig: () => deserializeEnsApiPublicConfig,
+  deserializeEnsIndexerPublicConfig: () => deserializeEnsIndexerPublicConfig,
   deserializeErrorResponse: () => deserializeErrorResponse,
   deserializeIndexingStatusResponse: () => deserializeIndexingStatusResponse,
   deserializeOmnichainIndexingStatusSnapshot: () => deserializeOmnichainIndexingStatusSnapshot,
@@ -210,6 +215,7 @@ __export(index_exports, {
   makeENSApiPublicConfigSchema: () => makeENSApiPublicConfigSchema,
   makeENSv1DomainId: () => makeENSv1DomainId,
   makeENSv2DomainId: () => makeENSv2DomainId,
+  makeEnsApiPublicConfigSchema: () => makeEnsApiPublicConfigSchema,
   makeLatestRegistrationId: () => makeLatestRegistrationId,
   makeLatestRenewalId: () => makeLatestRenewalId,
   makePermissionsId: () => makePermissionsId,
@@ -248,6 +254,10 @@ __export(index_exports, {
   serializeDomainAssetId: () => serializeDomainAssetId,
   serializeENSApiPublicConfig: () => serializeENSApiPublicConfig,
   serializeENSIndexerPublicConfig: () => serializeENSIndexerPublicConfig,
+  serializeEnsApiConfigResponse: () => serializeEnsApiConfigResponse,
+  serializeEnsApiIndexingStatusResponse: () => serializeEnsApiIndexingStatusResponse,
+  serializeEnsApiPublicConfig: () => serializeEnsApiPublicConfig,
+  serializeEnsIndexerPublicConfig: () => serializeEnsIndexerPublicConfig,
   serializeIndexedChainIds: () => serializeIndexedChainIds,
   serializeIndexingStatusResponse: () => serializeIndexingStatusResponse,
   serializeNameToken: () => serializeNameToken,
@@ -854,7 +864,7 @@ var makeFullyPinnedLabelSetSchema = (valueLabel = "Label set") => {
   });
 };
 var makeNonEmptyStringSchema = (valueLabel = "Value") => import_v42.z.string().nonempty({ error: `${valueLabel} must be a non-empty string.` });
-var makeENSIndexerVersionInfoSchema = (valueLabel = "Value") => import_v42.z.strictObject(
+var makeEnsIndexerVersionInfoSchema = (valueLabel = "Value") => import_v42.z.strictObject(
   {
     nodejs: makeNonEmptyStringSchema(),
     ponder: makeNonEmptyStringSchema(),
@@ -868,6 +878,7 @@ var makeENSIndexerVersionInfoSchema = (valueLabel = "Value") => import_v42.z.str
     error: `${valueLabel} must be a valid ENSIndexerVersionInfo object.`
   }
 ).check(invariant_ensDbVersionIsSameAsEnsIndexerVersion);
+var makeENSIndexerVersionInfoSchema = makeEnsIndexerVersionInfoSchema;
 function invariant_isSubgraphCompatibleRequirements(ctx) {
   const { value: config } = ctx;
   if (config.isSubgraphCompatible && !isSubgraphCompatible(config)) {
@@ -878,7 +889,7 @@ function invariant_isSubgraphCompatibleRequirements(ctx) {
     });
   }
 }
-var makeENSIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => import_v42.z.object({
+var makeEnsIndexerPublicConfigSchema = (valueLabel = "ENSIndexerPublicConfig") => import_v42.z.object({
   labelSet: makeFullyPinnedLabelSetSchema(`${valueLabel}.labelSet`),
   indexedChainIds: makeIndexedChainIdsSchema(`${valueLabel}.indexedChainIds`),
   isSubgraphCompatible: import_v42.z.boolean({ error: `${valueLabel}.isSubgraphCompatible` }),
@@ -907,133 +918,43 @@ var TheGraphFallbackSchema = import_v43.z.discriminatedUnion("canFallback", [
 ]);
 
 // src/ensapi/config/zod-schemas.ts
-function makeENSApiPublicConfigSchema(valueLabel) {
+function makeEnsApiPublicConfigSchema(valueLabel) {
   const label = valueLabel ?? "ENSApiPublicConfig";
   return import_v44.z.strictObject({
     version: import_v44.z.string().min(1, `${label}.version must be a non-empty string`),
     theGraphFallback: TheGraphFallbackSchema,
-    ensIndexerPublicConfig: makeENSIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`)
+    ensIndexerPublicConfig: makeEnsIndexerPublicConfigSchema(`${label}.ensIndexerPublicConfig`)
   });
 }
+var makeENSApiPublicConfigSchema = makeEnsApiPublicConfigSchema;
 
 // src/ensapi/config/deserialize.ts
-function deserializeENSApiPublicConfig(maybeConfig, valueLabel) {
-  const schema = makeENSApiPublicConfigSchema(valueLabel);
+function deserializeEnsApiPublicConfig(maybeConfig, valueLabel) {
+  const schema = makeEnsApiPublicConfigSchema(valueLabel);
   try {
     return schema.parse(maybeConfig);
   } catch (error) {
     if (error instanceof import_v45.ZodError) {
-      throw new Error(`Cannot deserialize ENSApiPublicConfig:
+      throw new Error(`Cannot deserialize EnsApiPublicConfig:
 ${(0, import_v45.prettifyError)(error)}
 `);
     }
     throw error;
   }
 }
+var deserializeENSApiPublicConfig = deserializeEnsApiPublicConfig;
 
 // src/ensapi/api/config/deserialize.ts
-function deserializeConfigResponse(serializedResponse) {
-  return deserializeENSApiPublicConfig(serializedResponse);
-}
-
-// src/ensindexer/config/deserialize.ts
-var import_v46 = require("zod/v4");
-function deserializeENSIndexerPublicConfig(maybeConfig, valueLabel) {
-  const schema = makeENSIndexerPublicConfigSchema(valueLabel);
-  const parsed = schema.safeParse(maybeConfig);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize ENSIndexerPublicConfig:
-${(0, import_v46.prettifyError)(parsed.error)}
-`);
-  }
-  return parsed.data;
-}
-
-// src/ensindexer/config/label-utils.ts
-var import_viem9 = require("viem");
-function labelHashToBytes(labelHash) {
-  try {
-    if (labelHash.length !== 66) {
-      throw new Error(`Invalid labelHash length ${labelHash.length} characters (expected 66)`);
-    }
-    if (labelHash !== labelHash.toLowerCase()) {
-      throw new Error("Labelhash must be in lowercase");
-    }
-    if (!labelHash.startsWith("0x")) {
-      throw new Error("Labelhash must be 0x-prefixed");
-    }
-    const bytes = (0, import_viem9.hexToBytes)(labelHash);
-    if (bytes.length !== 32) {
-      throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
-    }
-    return bytes;
-  } catch (e) {
-    if (e instanceof Error) {
-      throw e;
-    }
-    throw new Error("Invalid hex format");
-  }
-}
-
-// src/ensindexer/config/labelset-utils.ts
-function buildLabelSetId(maybeLabelSetId) {
-  return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
-}
-function buildLabelSetVersion(maybeLabelSetVersion) {
-  return makeLabelSetVersionSchema("LabelSetVersion").parse(maybeLabelSetVersion);
-}
-function buildEnsRainbowClientLabelSet(labelSetId, labelSetVersion) {
-  if (labelSetVersion !== void 0 && labelSetId === void 0) {
-    throw new Error("When a labelSetVersion is defined, labelSetId must also be defined.");
-  }
-  return { labelSetId, labelSetVersion };
-}
-function validateSupportedLabelSetAndVersion(serverSet, clientSet) {
-  if (clientSet.labelSetId === void 0) {
-    return;
-  }
-  if (serverSet.labelSetId !== clientSet.labelSetId) {
-    throw new Error(
-      `Server label set ID "${serverSet.labelSetId}" does not match client's requested label set ID "${clientSet.labelSetId}".`
-    );
-  }
-  if (clientSet.labelSetVersion !== void 0 && serverSet.highestLabelSetVersion < clientSet.labelSetVersion) {
-    throw new Error(
-      `Server highest label set version ${serverSet.highestLabelSetVersion} is less than client's requested version ${clientSet.labelSetVersion} for label set ID "${clientSet.labelSetId}".`
-    );
-  }
-}
-
-// src/ensindexer/config/parsing.ts
-function parseNonNegativeInteger(maybeNumber) {
-  const trimmed = maybeNumber.trim();
-  if (!trimmed) {
-    throw new Error("Input cannot be empty");
-  }
-  if (trimmed === "-0") {
-    throw new Error("Negative zero is not a valid non-negative integer");
-  }
-  const num = Number(maybeNumber);
-  if (Number.isNaN(num)) {
-    throw new Error(`"${maybeNumber}" is not a valid number`);
-  }
-  if (!Number.isFinite(num)) {
-    throw new Error(`"${maybeNumber}" is not a finite number`);
-  }
-  if (!Number.isInteger(num)) {
-    throw new Error(`"${maybeNumber}" is not an integer`);
-  }
-  if (num < 0) {
-    throw new Error(`"${maybeNumber}" is not a non-negative integer`);
-  }
-  return num;
+function deserializeEnsApiConfigResponse(serializedResponse) {
+  return deserializeEnsApiPublicConfig(serializedResponse);
 }
+var deserializeConfigResponse = deserializeEnsApiConfigResponse;
 
 // src/ensindexer/config/serialize.ts
 function serializeIndexedChainIds(indexedChainIds) {
   return Array.from(indexedChainIds);
 }
-function serializeENSIndexerPublicConfig(config) {
+function serializeEnsIndexerPublicConfig(config) {
   const {
     labelSet,
     indexedChainIds,
@@ -1053,33 +974,36 @@ function serializeENSIndexerPublicConfig(config) {
     versionInfo
   };
 }
+var serializeENSIndexerPublicConfig = serializeEnsIndexerPublicConfig;
 
 // src/ensapi/config/serialize.ts
-function serializeENSApiPublicConfig(config) {
+function serializeEnsApiPublicConfig(config) {
   const { version, theGraphFallback, ensIndexerPublicConfig } = config;
   return {
     version,
     theGraphFallback,
-    ensIndexerPublicConfig: serializeENSIndexerPublicConfig(ensIndexerPublicConfig)
+    ensIndexerPublicConfig: serializeEnsIndexerPublicConfig(ensIndexerPublicConfig)
   };
 }
+var serializeENSApiPublicConfig = serializeEnsApiPublicConfig;
 
 // src/ensapi/api/config/serialize.ts
-function serializeConfigResponse(response) {
-  return serializeENSApiPublicConfig(response);
+function serializeEnsApiConfigResponse(response) {
+  return serializeEnsApiPublicConfig(response);
 }
+var serializeConfigResponse = serializeEnsApiConfigResponse;
 
 // src/ensapi/api/indexing-status/deserialize.ts
-var import_v415 = require("zod/v4");
+var import_v414 = require("zod/v4");
 
 // src/indexing-status/deserialize/realtime-indexing-status-projection.ts
-var import_v413 = require("zod/v4");
+var import_v412 = require("zod/v4");
 
 // src/indexing-status/zod-schema/realtime-indexing-status-projection.ts
-var import_v410 = require("zod/v4");
+var import_v49 = require("zod/v4");
 
 // src/indexing-status/zod-schema/cross-chain-indexing-status-snapshot.ts
-var import_v49 = require("zod/v4");
+var import_v48 = require("zod/v4");
 
 // src/indexing-status/chain-indexing-status-snapshot.ts
 var ChainIndexingConfigTypeIds = {
@@ -1210,7 +1134,7 @@ function getLatestIndexedBlockRef(indexingStatus, chainId) {
 }
 
 // src/indexing-status/zod-schema/omnichain-indexing-status-snapshot.ts
-var import_v48 = require("zod/v4");
+var import_v47 = require("zod/v4");
 
 // src/indexing-status/omnichain-indexing-status-snapshot.ts
 var OmnichainIndexingStatusIds = {
@@ -1294,7 +1218,7 @@ function getOmnichainIndexingCursor(chains) {
 }
 
 // src/indexing-status/zod-schema/chain-indexing-status-snapshot.ts
-var import_v47 = require("zod/v4");
+var import_v46 = require("zod/v4");
 
 // src/shared/block-ref.ts
 function isBefore(blockA, blockB) {
@@ -1382,46 +1306,46 @@ function invariant_chainSnapshotFollowingBlocks(ctx) {
     });
   }
 }
-var makeChainIndexingConfigSchema = (valueLabel = "Value") => import_v47.z.discriminatedUnion("configType", [
-  import_v47.z.object({
-    configType: import_v47.z.literal(ChainIndexingConfigTypeIds.Indefinite),
+var makeChainIndexingConfigSchema = (valueLabel = "Value") => import_v46.z.discriminatedUnion("configType", [
+  import_v46.z.object({
+    configType: import_v46.z.literal(ChainIndexingConfigTypeIds.Indefinite),
     startBlock: makeBlockRefSchema(valueLabel)
   }),
-  import_v47.z.object({
-    configType: import_v47.z.literal(ChainIndexingConfigTypeIds.Definite),
+  import_v46.z.object({
+    configType: import_v46.z.literal(ChainIndexingConfigTypeIds.Definite),
     startBlock: makeBlockRefSchema(valueLabel),
     endBlock: makeBlockRefSchema(valueLabel)
   })
 ]);
-var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => import_v47.z.object({
-  chainStatus: import_v47.z.literal(ChainIndexingStatusIds.Queued),
+var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => import_v46.z.object({
+  chainStatus: import_v46.z.literal(ChainIndexingStatusIds.Queued),
   config: makeChainIndexingConfigSchema(valueLabel)
 }).check(invariant_chainSnapshotQueuedBlocks);
-var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => import_v47.z.object({
-  chainStatus: import_v47.z.literal(ChainIndexingStatusIds.Backfill),
+var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => import_v46.z.object({
+  chainStatus: import_v46.z.literal(ChainIndexingStatusIds.Backfill),
   config: makeChainIndexingConfigSchema(valueLabel),
   latestIndexedBlock: makeBlockRefSchema(valueLabel),
   backfillEndBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotBackfillBlocks);
-var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => import_v47.z.object({
-  chainStatus: import_v47.z.literal(ChainIndexingStatusIds.Completed),
-  config: import_v47.z.object({
-    configType: import_v47.z.literal(ChainIndexingConfigTypeIds.Definite),
+var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => import_v46.z.object({
+  chainStatus: import_v46.z.literal(ChainIndexingStatusIds.Completed),
+  config: import_v46.z.object({
+    configType: import_v46.z.literal(ChainIndexingConfigTypeIds.Definite),
     startBlock: makeBlockRefSchema(valueLabel),
     endBlock: makeBlockRefSchema(valueLabel)
   }),
   latestIndexedBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotCompletedBlocks);
-var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => import_v47.z.object({
-  chainStatus: import_v47.z.literal(ChainIndexingStatusIds.Following),
-  config: import_v47.z.object({
-    configType: import_v47.z.literal(ChainIndexingConfigTypeIds.Indefinite),
+var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => import_v46.z.object({
+  chainStatus: import_v46.z.literal(ChainIndexingStatusIds.Following),
+  config: import_v46.z.object({
+    configType: import_v46.z.literal(ChainIndexingConfigTypeIds.Indefinite),
     startBlock: makeBlockRefSchema(valueLabel)
   }),
   latestIndexedBlock: makeBlockRefSchema(valueLabel),
   latestKnownBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotFollowingBlocks);
-var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v47.z.discriminatedUnion("chainStatus", [
+var makeChainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v46.z.discriminatedUnion("chainStatus", [
   makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
   makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeChainIndexingStatusSnapshotCompletedSchema(valueLabel),
@@ -1550,11 +1474,11 @@ function invariant_omnichainStatusSnapshotFollowingHasValidChains(ctx) {
     });
   }
 }
-var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v48.z.object({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Unstarted),
-  chains: import_v48.z.map(
+var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v47.z.object({
+  omnichainStatus: import_v47.z.literal(OmnichainIndexingStatusIds.Unstarted),
+  chains: import_v47.z.map(
     makeChainIdSchema(),
-    import_v48.z.discriminatedUnion("chainStatus", [
+    import_v47.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel)
     ]),
     {
@@ -1563,11 +1487,11 @@ var makeOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 }).check(invariant_omnichainSnapshotUnstartedHasValidChains);
-var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v48.z.object({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Backfill),
-  chains: import_v48.z.map(
+var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v47.z.object({
+  omnichainStatus: import_v47.z.literal(OmnichainIndexingStatusIds.Backfill),
+  chains: import_v47.z.map(
     makeChainIdSchema(),
-    import_v48.z.discriminatedUnion("chainStatus", [
+    import_v47.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
       makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
       makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
@@ -1578,11 +1502,11 @@ var makeOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 }).check(invariant_omnichainStatusSnapshotBackfillHasValidChains);
-var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v48.z.object({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Completed),
-  chains: import_v48.z.map(
+var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v47.z.object({
+  omnichainStatus: import_v47.z.literal(OmnichainIndexingStatusIds.Completed),
+  chains: import_v47.z.map(
     makeChainIdSchema(),
-    import_v48.z.discriminatedUnion("chainStatus", [
+    import_v47.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
     ]),
     {
@@ -1591,11 +1515,11 @@ var makeOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 }).check(invariant_omnichainStatusSnapshotCompletedHasValidChains);
-var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v48.z.object({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Following),
-  chains: import_v48.z.map(
+var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v47.z.object({
+  omnichainStatus: import_v47.z.literal(OmnichainIndexingStatusIds.Following),
+  chains: import_v47.z.map(
     makeChainIdSchema(),
-    import_v48.z.discriminatedUnion("chainStatus", [
+    import_v47.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
       makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
       makeChainIndexingStatusSnapshotFollowingSchema(valueLabel),
@@ -1607,7 +1531,7 @@ var makeOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 }).check(invariant_omnichainStatusSnapshotFollowingHasValidChains);
-var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => import_v48.z.discriminatedUnion("omnichainStatus", [
+var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexing Snapshot") => import_v47.z.discriminatedUnion("omnichainStatus", [
   makeOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
   makeOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
@@ -1615,21 +1539,21 @@ var makeOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Omnichain Indexin
 ]).check(invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot).check(invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains).check(
   invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains
 ).check(invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain);
-var makeSerializedOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v48.z.object({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Unstarted),
-  chains: import_v48.z.record(
+var makeSerializedOmnichainIndexingStatusSnapshotUnstartedSchema = (valueLabel) => import_v47.z.object({
+  omnichainStatus: import_v47.z.literal(OmnichainIndexingStatusIds.Unstarted),
+  chains: import_v47.z.record(
     makeChainIdStringSchema(),
-    import_v48.z.discriminatedUnion("chainStatus", [
+    import_v47.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel)
     ])
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeSerializedOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v48.z.object({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Backfill),
-  chains: import_v48.z.record(
+var makeSerializedOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) => import_v47.z.object({
+  omnichainStatus: import_v47.z.literal(OmnichainIndexingStatusIds.Backfill),
+  chains: import_v47.z.record(
     makeChainIdStringSchema(),
-    import_v48.z.discriminatedUnion("chainStatus", [
+    import_v47.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
       makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
       makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
@@ -1637,21 +1561,21 @@ var makeSerializedOmnichainIndexingStatusSnapshotBackfillSchema = (valueLabel) =
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeSerializedOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v48.z.object({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Completed),
-  chains: import_v48.z.record(
+var makeSerializedOmnichainIndexingStatusSnapshotCompletedSchema = (valueLabel) => import_v47.z.object({
+  omnichainStatus: import_v47.z.literal(OmnichainIndexingStatusIds.Completed),
+  chains: import_v47.z.record(
     makeChainIdStringSchema(),
-    import_v48.z.discriminatedUnion("chainStatus", [
+    import_v47.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotCompletedSchema(valueLabel)
     ])
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeSerializedOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v48.z.object({
-  omnichainStatus: import_v48.z.literal(OmnichainIndexingStatusIds.Following),
-  chains: import_v48.z.record(
+var makeSerializedOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel) => import_v47.z.object({
+  omnichainStatus: import_v47.z.literal(OmnichainIndexingStatusIds.Following),
+  chains: import_v47.z.record(
     makeChainIdStringSchema(),
-    import_v48.z.discriminatedUnion("chainStatus", [
+    import_v47.z.discriminatedUnion("chainStatus", [
       makeChainIndexingStatusSnapshotQueuedSchema(valueLabel),
       makeChainIndexingStatusSnapshotBackfillSchema(valueLabel),
       makeChainIndexingStatusSnapshotFollowingSchema(valueLabel),
@@ -1660,7 +1584,7 @@ var makeSerializedOmnichainIndexingStatusSnapshotFollowingSchema = (valueLabel)
   ),
   omnichainIndexingCursor: makeUnixTimestampSchema(valueLabel)
 });
-var makeSerializedOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v48.z.discriminatedUnion("omnichainStatus", [
+var makeSerializedOmnichainIndexingStatusSnapshotSchema = (valueLabel = "Value") => import_v47.z.discriminatedUnion("omnichainStatus", [
   makeSerializedOmnichainIndexingStatusSnapshotUnstartedSchema(valueLabel),
   makeSerializedOmnichainIndexingStatusSnapshotBackfillSchema(valueLabel),
   makeSerializedOmnichainIndexingStatusSnapshotCompletedSchema(valueLabel),
@@ -1700,17 +1624,17 @@ function invariant_snapshotTimeIsTheHighestKnownBlockTimestamp(ctx) {
     });
   }
 }
-var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => import_v49.z.object({
-  strategy: import_v49.z.literal(CrossChainIndexingStrategyIds.Omnichain),
+var makeCrossChainIndexingStatusSnapshotOmnichainSchema = (valueLabel = "Cross-chain Indexing Status Snapshot Omnichain") => import_v48.z.object({
+  strategy: import_v48.z.literal(CrossChainIndexingStrategyIds.Omnichain),
   slowestChainIndexingCursor: makeUnixTimestampSchema(valueLabel),
   snapshotTime: makeUnixTimestampSchema(valueLabel),
   omnichainSnapshot: makeOmnichainIndexingStatusSnapshotSchema(valueLabel)
 }).check(invariant_slowestChainEqualsToOmnichainSnapshotTime).check(invariant_snapshotTimeIsTheHighestKnownBlockTimestamp);
-var makeCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Cross-chain Indexing Status Snapshot") => import_v49.z.discriminatedUnion("strategy", [
+var makeCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Cross-chain Indexing Status Snapshot") => import_v48.z.discriminatedUnion("strategy", [
   makeCrossChainIndexingStatusSnapshotOmnichainSchema(valueLabel)
 ]);
-var makeSerializedCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Serialized Cross-chain Indexing Status Snapshot") => import_v49.z.object({
-  strategy: import_v49.z.enum(CrossChainIndexingStrategyIds),
+var makeSerializedCrossChainIndexingStatusSnapshotSchema = (valueLabel = "Serialized Cross-chain Indexing Status Snapshot") => import_v48.z.object({
+  strategy: import_v48.z.enum(CrossChainIndexingStrategyIds),
   slowestChainIndexingCursor: makeUnixTimestampSchema(valueLabel),
   snapshotTime: makeUnixTimestampSchema(valueLabel),
   omnichainSnapshot: makeSerializedOmnichainIndexingStatusSnapshotSchema(valueLabel)
@@ -1740,22 +1664,22 @@ function invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect(ct
     });
   }
 }
-var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => import_v410.z.object({
+var makeRealtimeIndexingStatusProjectionSchema = (valueLabel = "Realtime Indexing Status Projection") => import_v49.z.object({
   projectedAt: makeUnixTimestampSchema(valueLabel),
   worstCaseDistance: makeDurationSchema(valueLabel),
   snapshot: makeCrossChainIndexingStatusSnapshotSchema(valueLabel)
 }).check(invariant_realtimeIndexingStatusProjectionProjectedAtIsAfterOrEqualToSnapshotTime).check(invariant_realtimeIndexingStatusProjectionWorstCaseDistanceIsCorrect);
-var makeSerializedRealtimeIndexingStatusProjectionSchema = (valueLabel = "Value") => import_v410.z.object({
+var makeSerializedRealtimeIndexingStatusProjectionSchema = (valueLabel = "Value") => import_v49.z.object({
   snapshot: makeSerializedCrossChainIndexingStatusSnapshotSchema(valueLabel),
   projectedAt: makeUnixTimestampSchema(valueLabel),
   worstCaseDistance: makeDurationSchema(valueLabel)
 });
 
 // src/indexing-status/deserialize/cross-chain-indexing-status-snapshot.ts
-var import_v412 = require("zod/v4");
+var import_v411 = require("zod/v4");
 
 // src/indexing-status/deserialize/omnichain-indexing-status-snapshot.ts
-var import_v411 = require("zod/v4");
+var import_v410 = require("zod/v4");
 function buildUnvalidatedOmnichainIndexingStatusSnapshot(serializedSnapshot) {
   const chains = /* @__PURE__ */ new Map();
   for (const [chainIdString, chainIndexingStatusSnapshot] of Object.entries(
@@ -1776,7 +1700,7 @@ function deserializeOmnichainIndexingStatusSnapshot(data, valueLabel) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into OmnichainIndexingStatusSnapshot:
-${(0, import_v411.prettifyError)(parsed.error)}
+${(0, import_v410.prettifyError)(parsed.error)}
 `
     );
   }
@@ -1798,7 +1722,7 @@ function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot, valueLabel)
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into CrossChainIndexingStatusSnapshot:
-${(0, import_v412.prettifyError)(parsed.error)}
+${(0, import_v411.prettifyError)(parsed.error)}
 `
     );
   }
@@ -1818,7 +1742,7 @@ function deserializeRealtimeIndexingStatusProjection(maybeProjection, valueLabel
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into RealtimeIndexingStatusProjection:
-${(0, import_v413.prettifyError)(parsed.error)}
+${(0, import_v412.prettifyError)(parsed.error)}
 `
     );
   }
@@ -1826,7 +1750,7 @@ ${(0, import_v413.prettifyError)(parsed.error)}
 }
 
 // src/ensapi/api/indexing-status/response.ts
-var IndexingStatusResponseCodes = {
+var EnsApiIndexingStatusResponseCodes = {
   /**
    * Represents that the indexing status is available.
    */
@@ -1836,32 +1760,33 @@ var IndexingStatusResponseCodes = {
    */
   Error: "error"
 };
+var IndexingStatusResponseCodes = EnsApiIndexingStatusResponseCodes;
 
 // src/ensapi/api/indexing-status/zod-schemas.ts
-var import_v414 = require("zod/v4");
-var makeIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v414.z.strictObject({
-  responseCode: import_v414.z.literal(IndexingStatusResponseCodes.Ok),
+var import_v413 = require("zod/v4");
+var makeEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v413.z.strictObject({
+  responseCode: import_v413.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v414.z.strictObject({
-  responseCode: import_v414.z.literal(IndexingStatusResponseCodes.Error)
+var makeEnsApiIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v413.z.strictObject({
+  responseCode: import_v413.z.literal(EnsApiIndexingStatusResponseCodes.Error)
 });
-var makeIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v414.z.discriminatedUnion("responseCode", [
-  makeIndexingStatusResponseOkSchema(valueLabel),
-  makeIndexingStatusResponseErrorSchema(valueLabel)
+var makeEnsApiIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v413.z.discriminatedUnion("responseCode", [
+  makeEnsApiIndexingStatusResponseOkSchema(valueLabel),
+  makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
 ]);
-var makeSerializedIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v414.z.strictObject({
-  responseCode: import_v414.z.literal(IndexingStatusResponseCodes.Ok),
+var makeSerializedEnsApiIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v413.z.strictObject({
+  responseCode: import_v413.z.literal(EnsApiIndexingStatusResponseCodes.Ok),
   realtimeProjection: makeSerializedRealtimeIndexingStatusProjectionSchema(valueLabel)
 });
-var makeSerializedIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v414.z.discriminatedUnion("responseCode", [
-  makeSerializedIndexingStatusResponseOkSchema(valueLabel),
-  makeIndexingStatusResponseErrorSchema(valueLabel)
+var makeSerializedEnsApiIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v413.z.discriminatedUnion("responseCode", [
+  makeSerializedEnsApiIndexingStatusResponseOkSchema(valueLabel),
+  makeEnsApiIndexingStatusResponseErrorSchema(valueLabel)
 ]);
 
 // src/ensapi/api/indexing-status/deserialize.ts
-function buildUnvalidatedIndexingStatusResponse(serializedResponse) {
-  if (serializedResponse.responseCode !== IndexingStatusResponseCodes.Ok) {
+function buildUnvalidatedEnsApiIndexingStatusResponse(serializedResponse) {
+  if (serializedResponse.responseCode !== EnsApiIndexingStatusResponseCodes.Ok) {
     return serializedResponse;
   }
   return {
@@ -1871,15 +1796,18 @@ function buildUnvalidatedIndexingStatusResponse(serializedResponse) {
     )
   };
 }
-function deserializeIndexingStatusResponse(maybeResponse) {
-  const parsed = makeSerializedIndexingStatusResponseSchema().transform(buildUnvalidatedIndexingStatusResponse).pipe(makeIndexingStatusResponseSchema()).safeParse(maybeResponse);
+function deserializeEnsApiIndexingStatusResponse(maybeResponse) {
+  const parsed = makeSerializedEnsApiIndexingStatusResponseSchema().transform(buildUnvalidatedEnsApiIndexingStatusResponse).pipe(makeEnsApiIndexingStatusResponseSchema()).safeParse(maybeResponse);
   if (parsed.error) {
-    throw new Error(`Cannot deserialize IndexingStatusResponse:
-${(0, import_v415.prettifyError)(parsed.error)}
-`);
+    throw new Error(
+      `Cannot deserialize EnsApiIndexingStatusResponse:
+${(0, import_v414.prettifyError)(parsed.error)}
+`
+    );
   }
   return parsed.data;
 }
+var deserializeIndexingStatusResponse = deserializeEnsApiIndexingStatusResponse;
 
 // src/shared/serialize.ts
 var import_caip2 = require("caip");
@@ -1990,33 +1918,34 @@ function serializeRealtimeIndexingStatusProjection(indexingProjection) {
 }
 
 // src/ensapi/api/indexing-status/serialize.ts
-function serializeIndexingStatusResponse(response) {
+function serializeEnsApiIndexingStatusResponse(response) {
   switch (response.responseCode) {
-    case IndexingStatusResponseCodes.Ok:
+    case EnsApiIndexingStatusResponseCodes.Ok:
       return {
         responseCode: response.responseCode,
         realtimeProjection: serializeRealtimeIndexingStatusProjection(response.realtimeProjection)
       };
-    case IndexingStatusResponseCodes.Error:
+    case EnsApiIndexingStatusResponseCodes.Error:
       return response;
   }
 }
+var serializeIndexingStatusResponse = serializeEnsApiIndexingStatusResponse;
 
 // src/ensapi/api/name-tokens/deserialize.ts
-var import_v420 = require("zod/v4");
+var import_v419 = require("zod/v4");
 
 // src/ensapi/api/name-tokens/zod-schemas.ts
-var import_viem14 = require("viem");
-var import_v419 = require("zod/v4");
+var import_viem13 = require("viem");
+var import_v418 = require("zod/v4");
 
 // src/tokenscope/name-token.ts
-var import_viem13 = require("viem");
+var import_viem12 = require("viem");
 var import_datasources5 = require("@ensnode/datasources");
 
 // src/shared/account-id.ts
-var import_viem10 = require("viem");
+var import_viem9 = require("viem");
 var accountIdEqual = (a, b) => {
-  return a.chainId === b.chainId && (0, import_viem10.isAddressEqual)(a.address, b.address);
+  return a.chainId === b.chainId && (0, import_viem9.isAddressEqual)(a.address, b.address);
 };
 
 // src/shared/datasource-contract.ts
@@ -2046,13 +1975,13 @@ var makeContractMatcher = (namespace, b) => (datasourceName, contractName) => {
 };
 
 // src/tokenscope/assets.ts
-var import_viem12 = require("viem");
-var import_v417 = require("zod/v4");
+var import_viem11 = require("viem");
+var import_v416 = require("zod/v4");
 
 // src/tokenscope/zod-schemas.ts
 var import_caip3 = require("caip");
-var import_viem11 = require("viem");
-var import_v416 = require("zod/v4");
+var import_viem10 = require("viem");
+var import_v415 = require("zod/v4");
 
 // src/shared/types.ts
 var AssetNamespaces = {
@@ -2061,10 +1990,10 @@ var AssetNamespaces = {
 };
 
 // src/tokenscope/zod-schemas.ts
-var tokenIdSchemaSerializable = import_v416.z.string();
-var tokenIdSchemaNative = import_v416.z.preprocess(
+var tokenIdSchemaSerializable = import_v415.z.string();
+var tokenIdSchemaNative = import_v415.z.preprocess(
   (v) => typeof v === "string" ? BigInt(v) : v,
-  import_v416.z.bigint().positive()
+  import_v415.z.bigint().positive()
 );
 function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false) {
   if (serializable) {
@@ -2074,13 +2003,13 @@ function makeTokenIdSchema(_valueLabel = "Token ID Schema", serializable = false
   }
 }
 var makeAssetIdSchema = (valueLabel = "Asset ID Schema", serializable) => {
-  return import_v416.z.object({
-    assetNamespace: import_v416.z.enum(AssetNamespaces),
+  return import_v415.z.object({
+    assetNamespace: import_v415.z.enum(AssetNamespaces),
     contract: makeAccountIdSchema(valueLabel),
     tokenId: makeTokenIdSchema(valueLabel, serializable ?? false)
   });
 };
-var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v416.z.preprocess((v) => {
+var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_v415.z.preprocess((v) => {
   if (typeof v === "string") {
     const result = new import_caip3.AssetId(v);
     return {
@@ -2096,7 +2025,7 @@ var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_
 }, makeAssetIdSchema(valueLabel));
 function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
   const ownership = ctx.value;
-  if (ctx.value.owner.address === import_viem11.zeroAddress) {
+  if (ctx.value.owner.address === import_viem10.zeroAddress) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -2104,25 +2033,25 @@ function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
     });
   }
 }
-var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => import_v416.z.object({
-  ownershipType: import_v416.z.literal(NameTokenOwnershipTypes.NameWrapper),
+var makeNameTokenOwnershipNameWrapperSchema = (valueLabel = "Name Token Ownership NameWrapper") => import_v415.z.object({
+  ownershipType: import_v415.z.literal(NameTokenOwnershipTypes.NameWrapper),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v416.z.object({
-  ownershipType: import_v416.z.literal(NameTokenOwnershipTypes.FullyOnchain),
+var makeNameTokenOwnershipFullyOnchainSchema = (valueLabel = "Name Token Ownership Fully Onchain") => import_v415.z.object({
+  ownershipType: import_v415.z.literal(NameTokenOwnershipTypes.FullyOnchain),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
-var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v416.z.object({
-  ownershipType: import_v416.z.literal(NameTokenOwnershipTypes.Burned),
+var makeNameTokenOwnershipBurnedSchema = (valueLabel = "Name Token Ownership Burned") => import_v415.z.object({
+  ownershipType: import_v415.z.literal(NameTokenOwnershipTypes.Burned),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasZeroAddressOwner);
-var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v416.z.object({
-  ownershipType: import_v416.z.literal(NameTokenOwnershipTypes.Unknown),
+var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Unknown") => import_v415.z.object({
+  ownershipType: import_v415.z.literal(NameTokenOwnershipTypes.Unknown),
   owner: makeAccountIdSchema(`${valueLabel}.owner`)
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
 function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
   const ownership = ctx.value;
-  if (ctx.value.owner.address !== import_viem11.zeroAddress) {
+  if (ctx.value.owner.address !== import_viem10.zeroAddress) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -2130,16 +2059,16 @@ function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
     });
   }
 }
-var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => import_v416.z.discriminatedUnion("ownershipType", [
+var makeNameTokenOwnershipSchema = (valueLabel = "Name Token Ownership") => import_v415.z.discriminatedUnion("ownershipType", [
   makeNameTokenOwnershipNameWrapperSchema(valueLabel),
   makeNameTokenOwnershipFullyOnchainSchema(valueLabel),
   makeNameTokenOwnershipBurnedSchema(valueLabel),
   makeNameTokenOwnershipUnknownSchema(valueLabel)
 ]);
-var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => import_v416.z.object({
+var makeNameTokenSchema = (valueLabel = "Name Token Schema", serializable) => import_v415.z.object({
   token: makeAssetIdSchema(`${valueLabel}.token`, serializable),
   ownership: makeNameTokenOwnershipSchema(`${valueLabel}.ownership`),
-  mintStatus: import_v416.z.enum(NFTMintStatuses)
+  mintStatus: import_v415.z.enum(NFTMintStatuses)
 });
 
 // src/tokenscope/assets.ts
@@ -2155,7 +2084,7 @@ function deserializeAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AssetId:
-${(0, import_v417.prettifyError)(parsed.error)}
+${(0, import_v416.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2165,7 +2094,7 @@ function parseAssetId(maybeAssetId, valueLabel) {
   const parsed = schema.safeParse(maybeAssetId);
   if (parsed.error) {
     throw new RangeError(`Cannot parse AssetId:
-${(0, import_v417.prettifyError)(parsed.error)}
+${(0, import_v416.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2300,11 +2229,11 @@ var NFTTransferTypes = {
 };
 var getNFTTransferType = (from, to, allowMintedRemint, metadata, currentlyIndexedOwner) => {
   const isIndexed = currentlyIndexedOwner !== void 0;
-  const isIndexedAsMinted = isIndexed && !(0, import_viem12.isAddressEqual)(currentlyIndexedOwner, import_viem12.zeroAddress);
-  const isMint = (0, import_viem12.isAddressEqual)(from, import_viem12.zeroAddress);
-  const isBurn = (0, import_viem12.isAddressEqual)(to, import_viem12.zeroAddress);
-  const isSelfTransfer = (0, import_viem12.isAddressEqual)(from, to);
-  if (isIndexed && !(0, import_viem12.isAddressEqual)(currentlyIndexedOwner, from)) {
+  const isIndexedAsMinted = isIndexed && !(0, import_viem11.isAddressEqual)(currentlyIndexedOwner, import_viem11.zeroAddress);
+  const isMint = (0, import_viem11.isAddressEqual)(from, import_viem11.zeroAddress);
+  const isBurn = (0, import_viem11.isAddressEqual)(to, import_viem11.zeroAddress);
+  const isSelfTransfer = (0, import_viem11.isAddressEqual)(from, to);
+  if (isIndexed && !(0, import_viem11.isAddressEqual)(currentlyIndexedOwner, from)) {
     if (isMint && allowMintedRemint) {
     } else {
       throw new Error(
@@ -2445,7 +2374,7 @@ function getNameTokenOwnership(namespaceId, name, owner) {
       owner
     };
   }
-  if ((0, import_viem13.isAddressEqual)(owner.address, import_viem13.zeroAddress)) {
+  if ((0, import_viem12.isAddressEqual)(owner.address, import_viem12.zeroAddress)) {
     return {
       ownershipType: NameTokenOwnershipTypes.Burned,
       owner
@@ -2465,10 +2394,10 @@ function getNameTokenOwnership(namespaceId, name, owner) {
 }
 
 // src/ensapi/api/shared/errors/zod-schemas.ts
-var import_v418 = require("zod/v4");
-var ErrorResponseSchema = import_v418.z.object({
-  message: import_v418.z.string(),
-  details: import_v418.z.optional(import_v418.z.unknown())
+var import_v417 = require("zod/v4");
+var ErrorResponseSchema = import_v417.z.object({
+  message: import_v417.z.string(),
+  details: import_v417.z.optional(import_v417.z.unknown())
 });
 
 // src/ensapi/api/name-tokens/response.ts
@@ -2507,15 +2436,15 @@ var NameTokensResponseErrorCodes = {
 };
 
 // src/ensapi/api/name-tokens/zod-schemas.ts
-var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => import_v419.z.object({
+var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", serializable) => import_v418.z.object({
   domainId: makeNodeSchema(`${valueLabel}.domainId`),
   name: makeReinterpretedNameSchema(valueLabel),
-  tokens: import_v419.z.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
+  tokens: import_v418.z.array(makeNameTokenSchema(`${valueLabel}.tokens`, serializable)).nonempty(),
   expiresAt: makeUnixTimestampSchema(`${valueLabel}.expiresAt`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 }).check(function invariant_nameIsAssociatedWithDomainId(ctx) {
   const { name, domainId } = ctx.value;
-  if ((0, import_viem14.namehash)(name) !== domainId) {
+  if ((0, import_viem13.namehash)(name) !== domainId) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -2552,32 +2481,32 @@ var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", seria
     });
   }
 });
-var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => import_v419.z.strictObject({
-  responseCode: import_v419.z.literal(NameTokensResponseCodes.Ok),
+var makeNameTokensResponseOkSchema = (valueLabel = "Name Tokens Response OK", serializable) => import_v418.z.strictObject({
+  responseCode: import_v418.z.literal(NameTokensResponseCodes.Ok),
   registeredNameTokens: makeRegisteredNameTokenSchema(`${valueLabel}.nameTokens`, serializable)
 });
-var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v419.z.strictObject({
-  responseCode: import_v419.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v419.z.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
+var makeNameTokensResponseErrorNameTokensNotIndexedSchema = (_valueLabel = "Name Tokens Response Error Name Not Indexed") => import_v418.z.strictObject({
+  responseCode: import_v418.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v418.z.literal(NameTokensResponseErrorCodes.NameTokensNotIndexed),
   error: ErrorResponseSchema
 });
-var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v419.z.strictObject({
-  responseCode: import_v419.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v419.z.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
+var makeNameTokensResponseErrorEnsIndexerConfigUnsupported = (_valueLabel = "Name Tokens Response Error ENSIndexer Config Unsupported") => import_v418.z.strictObject({
+  responseCode: import_v418.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v418.z.literal(NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported),
   error: ErrorResponseSchema
 });
-var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v419.z.strictObject({
-  responseCode: import_v419.z.literal(NameTokensResponseCodes.Error),
-  errorCode: import_v419.z.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
+var makeNameTokensResponseErrorNameIndexingStatusUnsupported = (_valueLabel = "Name Tokens Response Error Indexing Status Unsupported") => import_v418.z.strictObject({
+  responseCode: import_v418.z.literal(NameTokensResponseCodes.Error),
+  errorCode: import_v418.z.literal(NameTokensResponseErrorCodes.IndexingStatusUnsupported),
   error: ErrorResponseSchema
 });
-var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v419.z.discriminatedUnion("errorCode", [
+var makeNameTokensResponseErrorSchema = (valueLabel = "Name Tokens Response Error") => import_v418.z.discriminatedUnion("errorCode", [
   makeNameTokensResponseErrorNameTokensNotIndexedSchema(valueLabel),
   makeNameTokensResponseErrorEnsIndexerConfigUnsupported(valueLabel),
   makeNameTokensResponseErrorNameIndexingStatusUnsupported(valueLabel)
 ]);
 var makeNameTokensResponseSchema = (valueLabel = "Name Tokens Response", serializable) => {
-  return import_v419.z.discriminatedUnion("responseCode", [
+  return import_v418.z.discriminatedUnion("responseCode", [
     makeNameTokensResponseOkSchema(valueLabel, serializable ?? false),
     makeNameTokensResponseErrorSchema(valueLabel)
   ]);
@@ -2590,7 +2519,7 @@ function deserializedNameTokensResponse(maybeResponse) {
   );
   if (parsed.error) {
     throw new Error(`Cannot deserialize NameTokensResponse:
-${(0, import_v420.prettifyError)(parsed.error)}
+${(0, import_v419.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -2608,7 +2537,7 @@ var nameTokensPrerequisites = Object.freeze({
    */
   requiredPlugins: ["registrars" /* Registrars */, "tokenscope" /* TokenScope */],
   /**
-   * Check if provided ENSApiPublicConfig supports the Name Tokens API.
+   * Check if provided EnsIndexerPublicConfig supports the Name Tokens API.
    */
   hasEnsIndexerConfigSupport(config) {
     return nameTokensPrerequisites.requiredPlugins.every(
@@ -2664,44 +2593,44 @@ function serializeNameTokensResponse(response) {
 }
 
 // src/ensapi/api/registrar-actions/deserialize.ts
-var import_v424 = require("zod/v4");
+var import_v423 = require("zod/v4");
 
 // src/ensapi/api/registrar-actions/zod-schemas.ts
 var import_ens7 = require("viem/ens");
-var import_v423 = require("zod/v4");
+var import_v422 = require("zod/v4");
 
 // src/registrars/zod-schemas.ts
-var import_v421 = require("zod/v4");
+var import_v420 = require("zod/v4");
 
 // src/registrars/encoded-referrer.ts
-var import_viem15 = require("viem");
+var import_viem14 = require("viem");
 var ENCODED_REFERRER_BYTE_OFFSET = 12;
 var ENCODED_REFERRER_BYTE_LENGTH = 32;
-var EXPECTED_ENCODED_REFERRER_PADDING = (0, import_viem15.pad)("0x", {
+var EXPECTED_ENCODED_REFERRER_PADDING = (0, import_viem14.pad)("0x", {
   size: ENCODED_REFERRER_BYTE_OFFSET,
   dir: "left"
 });
-var ZERO_ENCODED_REFERRER = (0, import_viem15.pad)("0x", {
+var ZERO_ENCODED_REFERRER = (0, import_viem14.pad)("0x", {
   size: ENCODED_REFERRER_BYTE_LENGTH,
   dir: "left"
 });
 function buildEncodedReferrer(address) {
   const lowercaseAddress = address.toLowerCase();
-  return (0, import_viem15.pad)(lowercaseAddress, { size: ENCODED_REFERRER_BYTE_LENGTH, dir: "left" });
+  return (0, import_viem14.pad)(lowercaseAddress, { size: ENCODED_REFERRER_BYTE_LENGTH, dir: "left" });
 }
 function decodeEncodedReferrer(encodedReferrer) {
-  if ((0, import_viem15.size)(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
+  if ((0, import_viem14.size)(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
     throw new Error(
       `Encoded referrer value must be represented by ${ENCODED_REFERRER_BYTE_LENGTH} bytes.`
     );
   }
-  const padding = (0, import_viem15.slice)(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
+  const padding = (0, import_viem14.slice)(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
   if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) {
-    return import_viem15.zeroAddress;
+    return import_viem14.zeroAddress;
   }
-  const decodedReferrer = (0, import_viem15.slice)(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
+  const decodedReferrer = (0, import_viem14.slice)(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
   try {
-    return (0, import_viem15.getAddress)(decodedReferrer);
+    return (0, import_viem14.getAddress)(decodedReferrer);
   } catch {
     throw new Error(`Decoded referrer value must be a valid EVM address.`);
   }
@@ -2746,11 +2675,11 @@ function serializeRegistrarAction(registrarAction) {
 }
 
 // src/registrars/zod-schemas.ts
-var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v421.z.object({
+var makeSubregistrySchema = (valueLabel = "Subregistry") => import_v420.z.object({
   subregistryId: makeAccountIdSchema(`${valueLabel} Subregistry ID`),
   node: makeNodeSchema(`${valueLabel} Node`)
 });
-var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v421.z.object({
+var makeRegistrationLifecycleSchema = (valueLabel = "Registration Lifecycle") => import_v420.z.object({
   subregistry: makeSubregistrySchema(`${valueLabel} Subregistry`),
   node: makeNodeSchema(`${valueLabel} Node`),
   expiresAt: makeUnixTimestampSchema(`${valueLabel} Expires at`)
@@ -2766,18 +2695,18 @@ function invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium(ctx) {
     });
   }
 }
-var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v421.z.union([
+var makeRegistrarActionPricingSchema = (valueLabel = "Registrar Action Pricing") => import_v420.z.union([
   // pricing available
-  import_v421.z.object({
+  import_v420.z.object({
     baseCost: makePriceEthSchema(`${valueLabel} Base Cost`),
     premium: makePriceEthSchema(`${valueLabel} Premium`),
     total: makePriceEthSchema(`${valueLabel} Total`)
   }).check(invariant_registrarActionPricingTotalIsSumOfBaseCostAndPremium).transform((v) => v),
   // pricing unknown
-  import_v421.z.object({
-    baseCost: import_v421.z.null(),
-    premium: import_v421.z.null(),
-    total: import_v421.z.null()
+  import_v420.z.object({
+    baseCost: import_v420.z.null(),
+    premium: import_v420.z.null(),
+    total: import_v420.z.null()
   }).transform((v) => v)
 ]);
 function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
@@ -2800,9 +2729,9 @@ function invariant_registrarActionDecodedReferrerBasedOnRawReferrer(ctx) {
     });
   }
 }
-var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v421.z.union([
+var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral") => import_v420.z.union([
   // referral available
-  import_v421.z.object({
+  import_v420.z.object({
     encodedReferrer: makeHexStringSchema(
       { bytesCount: ENCODED_REFERRER_BYTE_LENGTH },
       `${valueLabel} Encoded Referrer`
@@ -2810,9 +2739,9 @@ var makeRegistrarActionReferralSchema = (valueLabel = "Registrar Action Referral
     decodedReferrer: makeLowercaseAddressSchema(`${valueLabel} Decoded Referrer`)
   }).check(invariant_registrarActionDecodedReferrerBasedOnRawReferrer),
   // referral not applicable
-  import_v421.z.object({
-    encodedReferrer: import_v421.z.null(),
-    decodedReferrer: import_v421.z.null()
+  import_v420.z.object({
+    encodedReferrer: import_v420.z.null(),
+    decodedReferrer: import_v420.z.null()
   })
 ]);
 function invariant_eventIdsInitialElementIsTheActionId(ctx) {
@@ -2825,9 +2754,9 @@ function invariant_eventIdsInitialElementIsTheActionId(ctx) {
     });
   }
 }
-var EventIdSchema = import_v421.z.string().nonempty();
-var EventIdsSchema = import_v421.z.array(EventIdSchema).min(1).transform((v) => v);
-var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => import_v421.z.object({
+var EventIdSchema = import_v420.z.string().nonempty();
+var EventIdsSchema = import_v420.z.array(EventIdSchema).min(1).transform((v) => v);
+var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => import_v420.z.object({
   id: EventIdSchema,
   incrementalDuration: makeDurationSchema(`${valueLabel} Incremental Duration`),
   registrant: makeLowercaseAddressSchema(`${valueLabel} Registrant`),
@@ -2841,38 +2770,38 @@ var makeBaseRegistrarActionSchema = (valueLabel = "Base Registrar Action") => im
   eventIds: EventIdsSchema
 }).check(invariant_eventIdsInitialElementIsTheActionId);
 var makeRegistrarActionRegistrationSchema = (valueLabel = "Registration ") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v421.z.literal(RegistrarActionTypes.Registration)
+  type: import_v420.z.literal(RegistrarActionTypes.Registration)
 });
 var makeRegistrarActionRenewalSchema = (valueLabel = "Renewal") => makeBaseRegistrarActionSchema(valueLabel).extend({
-  type: import_v421.z.literal(RegistrarActionTypes.Renewal)
+  type: import_v420.z.literal(RegistrarActionTypes.Renewal)
 });
-var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v421.z.discriminatedUnion("type", [
+var makeRegistrarActionSchema = (valueLabel = "Registrar Action") => import_v420.z.discriminatedUnion("type", [
   makeRegistrarActionRegistrationSchema(`${valueLabel} Registration`),
   makeRegistrarActionRenewalSchema(`${valueLabel} Renewal`)
 ]);
 
 // src/ensapi/api/shared/pagination/zod-schemas.ts
-var import_v422 = require("zod/v4");
+var import_v421 = require("zod/v4");
 
 // src/ensapi/api/shared/pagination/request.ts
 var RECORDS_PER_PAGE_DEFAULT = 10;
 var RECORDS_PER_PAGE_MAX = 100;
 
 // src/ensapi/api/shared/pagination/zod-schemas.ts
-var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => import_v422.z.object({
+var makeRequestPageParamsSchema = (valueLabel = "RequestPageParams") => import_v421.z.object({
   page: makePositiveIntegerSchema(`${valueLabel}.page`),
   recordsPerPage: makePositiveIntegerSchema(`${valueLabel}.recordsPerPage`).max(
     RECORDS_PER_PAGE_MAX,
     `${valueLabel}.recordsPerPage must not exceed ${RECORDS_PER_PAGE_MAX}`
   )
 });
-var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => import_v422.z.object({
-  totalRecords: import_v422.z.literal(0),
-  totalPages: import_v422.z.literal(1),
-  hasNext: import_v422.z.literal(false),
-  hasPrev: import_v422.z.literal(false),
-  startIndex: import_v422.z.undefined(),
-  endIndex: import_v422.z.undefined()
+var makeResponsePageContextSchemaWithNoRecords = (valueLabel = "ResponsePageContextWithNoRecords") => import_v421.z.object({
+  totalRecords: import_v421.z.literal(0),
+  totalPages: import_v421.z.literal(1),
+  hasNext: import_v421.z.literal(false),
+  hasPrev: import_v421.z.literal(false),
+  startIndex: import_v421.z.undefined(),
+  endIndex: import_v421.z.undefined()
 }).extend(makeRequestPageParamsSchema(valueLabel).shape);
 function invariant_responsePageWithRecordsIsCorrect(ctx) {
   const { hasNext, hasPrev, recordsPerPage, page, totalRecords, startIndex, endIndex } = ctx.value;
@@ -2907,15 +2836,15 @@ function invariant_responsePageWithRecordsIsCorrect(ctx) {
     });
   }
 }
-var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v422.z.object({
+var makeResponsePageContextSchemaWithRecords = (valueLabel = "ResponsePageContextWithRecords") => import_v421.z.object({
   totalRecords: makePositiveIntegerSchema(`${valueLabel}.totalRecords`),
   totalPages: makePositiveIntegerSchema(`${valueLabel}.totalPages`),
-  hasNext: import_v422.z.boolean(),
-  hasPrev: import_v422.z.boolean(),
+  hasNext: import_v421.z.boolean(),
+  hasPrev: import_v421.z.boolean(),
   startIndex: makeNonNegativeIntegerSchema(`${valueLabel}.startIndex`),
   endIndex: makeNonNegativeIntegerSchema(`${valueLabel}.endIndex`)
 }).extend(makeRequestPageParamsSchema(valueLabel).shape).check(invariant_responsePageWithRecordsIsCorrect);
-var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v422.z.union([
+var makeResponsePageContextSchema = (valueLabel = "ResponsePageContext") => import_v421.z.union([
   makeResponsePageContextSchemaWithNoRecords(valueLabel),
   makeResponsePageContextSchemaWithRecords(valueLabel)
 ]);
@@ -2945,21 +2874,21 @@ function invariant_registrationLifecycleNodeMatchesName(ctx) {
     });
   }
 }
-var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v423.z.object({
+var makeNamedRegistrarActionSchema = (valueLabel = "Named Registrar Action") => import_v422.z.object({
   action: makeRegistrarActionSchema(valueLabel),
   name: makeReinterpretedNameSchema(valueLabel)
 }).check(invariant_registrationLifecycleNodeMatchesName);
-var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v423.z.object({
-  responseCode: import_v423.z.literal(RegistrarActionsResponseCodes.Ok),
-  registrarActions: import_v423.z.array(makeNamedRegistrarActionSchema(valueLabel)),
+var makeRegistrarActionsResponseOkSchema = (valueLabel = "Registrar Actions Response OK") => import_v422.z.object({
+  responseCode: import_v422.z.literal(RegistrarActionsResponseCodes.Ok),
+  registrarActions: import_v422.z.array(makeNamedRegistrarActionSchema(valueLabel)),
   pageContext: makeResponsePageContextSchema(`${valueLabel}.pageContext`),
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`).optional()
 });
-var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v423.z.strictObject({
-  responseCode: import_v423.z.literal(RegistrarActionsResponseCodes.Error),
+var makeRegistrarActionsResponseErrorSchema = (_valueLabel = "Registrar Actions Response Error") => import_v422.z.strictObject({
+  responseCode: import_v422.z.literal(RegistrarActionsResponseCodes.Error),
   error: ErrorResponseSchema
 });
-var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v423.z.discriminatedUnion("responseCode", [
+var makeRegistrarActionsResponseSchema = (valueLabel = "Registrar Actions Response") => import_v422.z.discriminatedUnion("responseCode", [
   makeRegistrarActionsResponseOkSchema(valueLabel),
   makeRegistrarActionsResponseErrorSchema(valueLabel)
 ]);
@@ -2970,7 +2899,7 @@ function deserializeRegistrarActionsResponse(maybeResponse) {
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize RegistrarActionsResponse:
-${(0, import_v424.prettifyError)(parsed.error)}
+${(0, import_v423.prettifyError)(parsed.error)}
 `
     );
   }
@@ -3065,7 +2994,7 @@ var registrarActionsPrerequisites = Object.freeze({
     "registrars" /* Registrars */
   ],
   /**
-   * Check if provided ENSApiPublicConfig supports the Registrar Actions API.
+   * Check if provided EnsIndexerPublicConfig supports the Registrar Actions API.
    */
   hasEnsIndexerConfigSupport(config) {
     return registrarActionsPrerequisites.requiredPlugins.every(
@@ -3117,12 +3046,12 @@ function serializeRegistrarActionsResponse(response) {
 }
 
 // src/ensapi/api/shared/errors/deserialize.ts
-var import_v425 = require("zod/v4");
+var import_v424 = require("zod/v4");
 function deserializeErrorResponse(maybeErrorResponse) {
   const parsed = ErrorResponseSchema.safeParse(maybeErrorResponse);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ErrorResponse:
-${(0, import_v425.prettifyError)(parsed.error)}
+${(0, import_v424.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -3195,7 +3124,7 @@ var getDefaultEnsNodeUrl = (namespace) => {
 };
 
 // src/ensapi/client.ts
-var ENSApiClient = class _ENSApiClient {
+var EnsApiClient = class _EnsApiClient {
   options;
   static defaultOptions() {
     return {
@@ -3204,7 +3133,7 @@ var ENSApiClient = class _ENSApiClient {
   }
   constructor(options = {}) {
     this.options = {
-      ..._ENSApiClient.defaultOptions(),
+      ..._EnsApiClient.defaultOptions(),
       ...options
     };
   }
@@ -3373,15 +3302,15 @@ var ENSApiClient = class _ENSApiClient {
     return data;
   }
   /**
-   * Fetch ENSNode Config
+   * Fetch ENSApi Config
    *
-   * Fetch the ENSNode's configuration.
+   * Fetch the ENSApi's configuration.
    *
-   * @returns {ConfigResponse}
+   * @returns {EnsApiConfigResponse}
    *
-   * @throws if the ENSNode request fails
-   * @throws if the ENSNode API returns an error response
-   * @throws if the ENSNode response breaks required invariants
+   * @throws if the ENSApi request fails
+   * @throws if the ENSApi returns an error response
+   * @throws if the ENSApi response breaks required invariants
    */
   async config() {
     const url = new URL(`/api/config`, this.options.url);
@@ -3394,18 +3323,18 @@ var ENSApiClient = class _ENSApiClient {
     }
     if (!response.ok) {
       const errorResponse = deserializeErrorResponse(responseData);
-      throw new Error(`Fetching ENSNode Config Failed: ${errorResponse.message}`);
+      throw new Error(`Fetching ENSApi Config Failed: ${errorResponse.message}`);
     }
-    return deserializeConfigResponse(responseData);
+    return deserializeEnsApiConfigResponse(responseData);
   }
   /**
-   * Fetch ENSNode Indexing Status
+   * Fetch ENSApi Indexing Status
    *
-   * @returns {IndexingStatusResponse}
+   * @returns {EnsApiIndexingStatusResponse}
    *
-   * @throws if the ENSNode request fails
-   * @throws if the ENSNode API returns an error response
-   * @throws if the ENSNode response breaks required invariants
+   * @throws if the ENSApi request fails
+   * @throws if the ENSApi returns an error response
+   * @throws if the ENSApi response breaks required invariants
    */
   async indexingStatus() {
     const url = new URL(`/api/indexing-status`, this.options.url);
@@ -3424,10 +3353,12 @@ var ENSApiClient = class _ENSApiClient {
         console.log("Indexing Status API: handling a known indexing status server error.");
       }
       if (typeof errorResponse !== "undefined") {
-        throw new Error(`Fetching ENSNode Indexing Status Failed: ${errorResponse.message}`);
+        throw new Error(`Fetching ENSApi Indexing Status Failed: ${errorResponse.message}`);
       }
     }
-    return deserializeIndexingStatusResponse(responseData);
+    return deserializeEnsApiIndexingStatusResponse(
+      responseData
+    );
   }
   /**
    * Fetch ENSNode Registrar Actions
@@ -3449,11 +3380,11 @@ var ENSApiClient = class _ENSApiClient {
    * ```ts
    * import {
    *   registrarActionsFilter,
-   *   ENSApiClient,
+   *   EnsApiClient,
    * } from "@ensnode/ensnode-sdk";
    * import { namehash } from "viem/ens";
    *
-   * const client: ENSApiClient;
+   * const client: EnsApiClient;
    *
    * // Get first page with default page size (10 records)
    * const response = await client.registrarActions();
@@ -3616,11 +3547,11 @@ var ENSApiClient = class _ENSApiClient {
    * @example
    * ```ts
    * import {
-   *   ENSApiClient,
+   *   EnsApiClient,
    * } from "@ensnode/ensnode-sdk";
    * import { namehash } from "viem/ens";
    *
-   * const client: ENSApiClient;
+   * const client: EnsApiClient;
    *
    * // get latest name token records from the indexed subregistry based on the requested name
    * const response = await client.nameTokens({
@@ -3660,9 +3591,103 @@ var ENSApiClient = class _ENSApiClient {
     return deserializedNameTokensResponse(responseData);
   }
 };
-var ENSNodeClient = class extends ENSApiClient {
+var ENSNodeClient = class extends EnsApiClient {
 };
 
+// src/ensindexer/config/deserialize.ts
+var import_v425 = require("zod/v4");
+function deserializeEnsIndexerPublicConfig(maybeConfig, valueLabel) {
+  const schema = makeEnsIndexerPublicConfigSchema(valueLabel);
+  const parsed = schema.safeParse(maybeConfig);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize EnsIndexerPublicConfig:
+${(0, import_v425.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+var deserializeENSIndexerPublicConfig = deserializeEnsIndexerPublicConfig;
+
+// src/ensindexer/config/label-utils.ts
+var import_viem15 = require("viem");
+function labelHashToBytes(labelHash) {
+  try {
+    if (labelHash.length !== 66) {
+      throw new Error(`Invalid labelHash length ${labelHash.length} characters (expected 66)`);
+    }
+    if (labelHash !== labelHash.toLowerCase()) {
+      throw new Error("Labelhash must be in lowercase");
+    }
+    if (!labelHash.startsWith("0x")) {
+      throw new Error("Labelhash must be 0x-prefixed");
+    }
+    const bytes = (0, import_viem15.hexToBytes)(labelHash);
+    if (bytes.length !== 32) {
+      throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
+    }
+    return bytes;
+  } catch (e) {
+    if (e instanceof Error) {
+      throw e;
+    }
+    throw new Error("Invalid hex format");
+  }
+}
+
+// src/ensindexer/config/labelset-utils.ts
+function buildLabelSetId(maybeLabelSetId) {
+  return makeLabelSetIdSchema("LabelSetId").parse(maybeLabelSetId);
+}
+function buildLabelSetVersion(maybeLabelSetVersion) {
+  return makeLabelSetVersionSchema("LabelSetVersion").parse(maybeLabelSetVersion);
+}
+function buildEnsRainbowClientLabelSet(labelSetId, labelSetVersion) {
+  if (labelSetVersion !== void 0 && labelSetId === void 0) {
+    throw new Error("When a labelSetVersion is defined, labelSetId must also be defined.");
+  }
+  return { labelSetId, labelSetVersion };
+}
+function validateSupportedLabelSetAndVersion(serverSet, clientSet) {
+  if (clientSet.labelSetId === void 0) {
+    return;
+  }
+  if (serverSet.labelSetId !== clientSet.labelSetId) {
+    throw new Error(
+      `Server label set ID "${serverSet.labelSetId}" does not match client's requested label set ID "${clientSet.labelSetId}".`
+    );
+  }
+  if (clientSet.labelSetVersion !== void 0 && serverSet.highestLabelSetVersion < clientSet.labelSetVersion) {
+    throw new Error(
+      `Server highest label set version ${serverSet.highestLabelSetVersion} is less than client's requested version ${clientSet.labelSetVersion} for label set ID "${clientSet.labelSetId}".`
+    );
+  }
+}
+
+// src/ensindexer/config/parsing.ts
+function parseNonNegativeInteger(maybeNumber) {
+  const trimmed = maybeNumber.trim();
+  if (!trimmed) {
+    throw new Error("Input cannot be empty");
+  }
+  if (trimmed === "-0") {
+    throw new Error("Negative zero is not a valid non-negative integer");
+  }
+  const num = Number(maybeNumber);
+  if (Number.isNaN(num)) {
+    throw new Error(`"${maybeNumber}" is not a valid number`);
+  }
+  if (!Number.isFinite(num)) {
+    throw new Error(`"${maybeNumber}" is not a finite number`);
+  }
+  if (!Number.isInteger(num)) {
+    throw new Error(`"${maybeNumber}" is not an integer`);
+  }
+  if (num < 0) {
+    throw new Error(`"${maybeNumber}" is not a non-negative integer`);
+  }
+  return num;
+}
+
 // src/ensv2/ids-lib.ts
 var import_viem16 = require("viem");
 var makeRegistryId = (accountId) => formatAccountId(accountId);