@ensnode/ensnode-sdk 1.9.0 → 1.10.0

package/dist/index.d.cts

@@ -1,63 +1,15 @@
 import { ENSNamespaceId, DatasourceName } from '@ensnode/datasources';
 export { ENSNamespaceId, ENSNamespaceIds, getENSRootChainId } from '@ensnode/datasources';
-import { EvmCoinType, CoinType } from '@ensdomains/address-encoder';
-export { CoinType, EvmCoinType } from '@ensdomains/address-encoder';
-import { Address, Hex, Hash, ByteArray } from 'viem';
+import * as enssdk from 'enssdk';
+import { UnixTimestamp, ChainId, Duration, ChainIdString, LabelHash, Node, Name, AssetId, Hex, AccountId, TokenId, AssetNamespace, Address, AssetIdString, InterpretedName, NormalizedAddress, DefaultableChainId, CoinType, ContentType, InterfaceId, RecordVersion, UrlString, LiteralName, DatetimeISO8601 } from 'enssdk';
 import { z } from 'zod/v4';
+import { ByteArray, Hash } from 'viem';
 
 /**
- * Chain ID
- *
- * Represents a unique identifier for a chain.
- * Guaranteed to be a positive integer.
- *
- * Chain id standards are organized by the Ethereum Community @ https://github.com/ethereum-lists/chains
- **/
-type ChainId = number;
-/**
- * Defaultable Chain ID
- *
- * Represents a unique identifier for a chain, or
- * the default chain as defined by ENSIP-19.
- *
- * @see https://docs.ens.domains/ensip/19/#annex-supported-chains
- *
- * Guaranteed to be a non-negative integer.
- **/
-type DefaultableChainId = typeof DEFAULT_EVM_CHAIN_ID | ChainId;
-/**
- * Represents an account (contract or EOA) at `address` on chain `chainId`.
- *
- * @see https://chainagnostic.org/CAIPs/caip-10
- */
-interface AccountId {
-    chainId: ChainId;
-    address: Address;
-}
-/**
- * An enum representing the possible CAIP-19 Asset Namespace values.
- *
- * @see https://chainagnostic.org/CAIPs/caip-19
- */
-declare const AssetNamespaces: {
-    readonly ERC721: "erc721";
-    readonly ERC1155: "erc1155";
-};
-type AssetNamespace = (typeof AssetNamespaces)[keyof typeof AssetNamespaces];
-/**
- * A uint256 value that identifies a specific NFT within a NFT contract.
- */
-type TokenId = bigint;
-/**
- * Represents an Asset in `assetNamespace` by `tokenId` in `contract`.
- *
- * @see https://chainagnostic.org/CAIPs/caip-19
+ * Determines whether `fuses` has set ('burnt') the PARENT_CANNOT_CONTROL fuse.
  */
-interface AssetId {
-    assetNamespace: AssetNamespace;
-    contract: AccountId;
-    tokenId: TokenId;
-}
+declare const isPccFuseSet: (fuses: number) => boolean;
+
 /**
  * Block Number
  *
@@ -68,16 +20,6 @@ type BlockNumber = number;
  * Datetime value
  */
 type Datetime = Date;
-/**
- * Unix timestamp value
- *
- * Represents the number of seconds that have elapsed
- * since January 1, 1970 (midnight UTC/GMT).
- *
- * Guaranteed to be an integer. May be zero or negative to represent a time at or
- * before Jan 1, 1970.
- */
-type UnixTimestamp = number;
 /**
  * Represents a URL that is used for RPC endpoints.
  */
@@ -96,14 +38,6 @@ interface BlockRef {
     /** Block timestamp */
     timestamp: UnixTimestamp;
 }
-/**
- * Duration
- *
- * Representing a duration in seconds.
- *
- * Guaranteed to be a non-negative integer.
- */
-type Duration = number;
 /**
  * A utility type that makes all properties of a type optional recursively,
  * including nested objects and arrays.
@@ -175,1758 +109,1582 @@ type RequiredAndNotNull<T, K extends keyof T> = T & {
 };
 
 /**
- * The ETH coinType.
- *
- * @see https://docs.ens.domains/ensip/9
+ * A label set ID identifies a label set (see https://ensnode.io/ensrainbow/concepts/glossary#label-set for definition).
+ * It is guaranteed to be 1 to 50 characters long and contain only lowercase letters (a-z)
+ * and hyphens (-).
  */
-declare const ETH_COIN_TYPE: CoinType;
+type LabelSetId = string;
 /**
- * The 'default' chainId corresponding to the below {@link DEFAULT_EVM_COIN_TYPE} in the context of
- * ENSIP-19.
+ * A label set version identifies a specific version of a label set. It allows clients to
+ * request data from a specific snapshot in time, ensuring deterministic results.
  *
- * @see https://docs.ens.domains/ensip/19
+ * It is guaranteed to be a non-negative integer.
  */
-declare const DEFAULT_EVM_CHAIN_ID = 0;
+type LabelSetVersion = number;
 /**
- * ENSIP-19 EVM CoinType representing the 'default' coinType for EVM chains in ENS.
- *
- * @see https://docs.ens.domains/ensip/19/#reverse-resolution
+ * The label set preferences of an ENSRainbow client.
  */
-declare const DEFAULT_EVM_COIN_TYPE: EvmCoinType;
+interface EnsRainbowClientLabelSet {
+    /**
+     * Optional label set ID that the ENSRainbow server is expected to use. If provided, heal
+     * operations will validate the ENSRainbow server is using this labelSetId.
+     * Required if `labelSetVersion` is defined.
+     */
+    labelSetId?: LabelSetId;
+    /**
+     * Optional highest label set version of label set id to query. Enables deterministic heal
+     * results across time even if the ENSRainbow server ingests label sets with greater versions
+     * than this value. If provided, only labels from label sets with versions less than or equal to this
+     * value will be returned. If not provided, the server will use the latest available version.
+     * When `labelSetVersion` is defined, `labelSetId` must also be defined.
+     */
+    labelSetVersion?: LabelSetVersion;
+}
 /**
- * Converts a CoinType to an EVM Chain Id.
- *
- * NOTE: for whatever reason @ensdomains/address-encoder#coinTypeToEvmChainId doesn't handle the
- * mainnet case so we implement that here
- *
- * @see https://docs.ens.domains/ensip/11/
+ * The state of label sets managed by an ENSRainbow server.
  */
-declare const coinTypeToEvmChainId: (coinType: CoinType) => ChainId;
+interface EnsRainbowServerLabelSet {
+    /**
+     * The LabelSetId managed by the ENSRainbow server.
+     */
+    labelSetId: LabelSetId;
+    /**
+     * The highest label set version available on the ENSRainbow server for the current
+     * label set ID. This represents the most recent version of the label set that the
+     * server has ingested and can provide label healing results for.
+     */
+    highestLabelSetVersion: LabelSetVersion;
+}
+
 /**
- * Converts an EVM Chain Id to a CoinType.
+ * Complete public configuration object for ENSRainbow.
  *
- * NOTE: for whatever reason @ensdomains/address-encoder#evmChainIdToCoinType doesn't handle the
- * mainnet case so we implement that here
+ * Contains all public configuration information about the ENSRainbow service instance,
+ * including version, label set information, and record counts.
  */
-declare const evmChainIdToCoinType: (chainId: ChainId) => CoinType;
+interface EnsRainbowPublicConfig {
+    /**
+     * ENSRainbow service version
+     *
+     * @see https://ghcr.io/namehash/ensnode/ensrainbow
+     */
+    version: string;
+    /**
+     * The label set reference managed by the ENSRainbow server.
+     */
+    labelSet: EnsRainbowServerLabelSet;
+    /**
+     * The total count of records managed by the ENSRainbow service.
+     */
+    recordsCount: number;
+}
+
 /**
- * Converts a bigint value representing a CoinType into a valid CoinType.
- *
- * This is useful when onchain events emit coinTypes as bigint but we want to constrain them to
- * the CoinType type.
- *
- * @throws if `value` is too large to fit in Number.MAX_SAFE_INTEGER
+ * Serialized representation of {@link EnsRainbowPublicConfig}
  */
-declare const bigintToCoinType: (value: bigint) => CoinType;
+type SerializedEnsRainbowPublicConfig = EnsRainbowPublicConfig;
 
 /**
- * Serialized CAIP-10 Asset ID that uniquely identifies a Registry contract.
+ * A PluginName is a unique id for a 'plugin': we use the notion of
+ * 'plugins' to describe bundles of indexing logic.
  */
-type RegistryId = string & {
-    __brand: "RegistryContractId";
-};
+declare enum PluginName {
+    Subgraph = "subgraph",
+    Basenames = "basenames",
+    Lineanames = "lineanames",
+    ThreeDNS = "threedns",
+    ProtocolAcceleration = "protocol-acceleration",
+    Registrars = "registrars",
+    TokenScope = "tokenscope",
+    ENSv2 = "ensv2"
+}
 /**
- * A Domain's Canonical Id is uint256(labelHash) with lower (right-most) 32 bits zero'd.
+ * Version info about ENSIndexer and its dependencies.
  */
-type CanonicalId = bigint;
+interface EnsIndexerVersionInfo {
+    /**
+     * Ponder framework version
+     *
+     * @see https://www.npmjs.com/package/ponder
+     **/
+    ponder: string;
+    /**
+     * ENSDb service version
+     *
+     * Guaranteed to be the same as {@link ENSIndexerVersionInfo.ensIndexer}.
+     * */
+    ensDb: string;
+    /**
+     * ENSIndexer service version
+     *
+     * @see https://ghcr.io/namehash/ensnode/ensindexer
+     **/
+    ensIndexer: string;
+    /**
+     * ENS Normalize package version
+     *
+     * Available on NPM as: `@adraffy/ens-normalize`
+     *
+     * @see https://www.npmjs.com/package/@adraffy/ens-normalize
+     **/
+    ensNormalize: string;
+}
 /**
- * The node that uniquely identifies an ENSv1 name.
+ * Version info about ENSIndexer and its dependencies.
+ *
+ * @deprecated Use {@link EnsIndexerVersionInfo} instead.
  */
-type ENSv1DomainId = Node & {
-    __brand: "ENSv1DomainId";
-};
+type ENSIndexerVersionInfo = EnsIndexerVersionInfo;
 /**
- * The Serialized CAIP-19 Asset ID that uniquely identifies an ENSv2 name.
+ * Complete public configuration object for ENSIndexer.
+ *
+ * We use parameter types to maintain fields layout and documentation across
+ * the domain model and its serialized counterpart.
  */
-type ENSv2DomainId = string & {
-    __brand: "ENSv2DomainId";
-};
+interface EnsIndexerPublicConfig {
+    /**
+     * The ENS namespace that ENSNode operates in the context of.
+     *
+     * See {@link ENSNamespaceIds} for available namespace identifiers.
+     */
+    namespace: ENSNamespaceId;
+    /**
+     * The "fully pinned" label set reference that ENSIndexer will request ENSRainbow use for deterministic label healing across time. This label set reference is "fully pinned" as it requires both the labelSetId and labelSetVersion fields to be defined.
+     */
+    labelSet: Required<EnsRainbowClientLabelSet>;
+    /**
+     * The name of the ENSIndexer Schema in the ENSDb instance,
+     * where the ENSIndexer instance writes indexed data.
+     *
+     * Invariants:
+     * - Must be a non-empty string that is a valid Postgres database schema
+     *   identifier.
+     */
+    ensIndexerSchemaName: string;
+    /**
+     * ENSRainbow public config
+     *
+     * Represents the public config of the connected ENSRainbow instance.
+     */
+    ensRainbowPublicConfig: EnsRainbowPublicConfig;
+    /**
+     * A set of strings referring to the names of plugins that are active.
+     *
+     * For future-proofing, this is a list of strings that may or may
+     * not be currently valid {@link PluginName} values.
+     *
+     * Invariants:
+     * - A set of strings with at least one value.
+     */
+    plugins: string[];
+    /**
+     * Indexed Chain IDs
+     *
+     * Includes the {@link ChainId} for each chain being indexed.
+     */
+    indexedChainIds: Set<ChainId>;
+    /**
+     * A feature flag to enable/disable ENSIndexer's Subgraph Compatible Indexing Behavior.
+     *
+     * If {@link isSubgraphCompatible} is true, indexing behavior will match that of the legacy ENS
+     * Subgraph.
+     *
+     * ENSIndexer will store and return Literal Labels and Literal Names without further interpretation.
+     * @see https://ensnode.io/docs/reference/terminology#literal-label
+     * @see https://ensnode.io/docs/reference/terminology#literal-name
+     *
+     * If {@link isSubgraphCompatible} is true, the following invariants are true for the ENSIndexerConfig:
+     * 1. only the 'subgraph' plugin is enabled, and
+     * 2. the labelSet must be { labelSetId: 'subgraph', labelSetVersion: 0 }
+     *
+     * If {@link isSubgraphCompatible} is false, ENSIndexer will additionally:
+     *
+     * 1. ENSIndexer will heal all subnames of addr.reverse on the ENS Root Chain.
+     *
+     * 2. ENSIndexer will track both the keys and the values of Resolver records.
+     *
+     * WARNING: Special care must be taken when interacting with indexed resolver record values. It
+     * is unsafe to naively assume that indexed resolver record values are equivalent to the
+     * resolver record values that would be returned through dynamic lookups via the ENS protocol.
+     * For example, if a resolver implements CCIP-Read, the resolver records may not be
+     * discoverable through onchain indexing.
+     *
+     * 3. Literal Labels and Literal Names encountered by ENSIndexer will be Interpreted.
+     * @see https://ensnode.io/docs/reference/terminology#interpreted-label
+     * @see https://ensnode.io/docs/reference/terminology#interpreted-name
+     *
+     * That is,
+     * a) all Labels stored and returned by ENSIndexer will be Interpreted Labels, which are either:
+     *    i. normalized, or
+     *    ii. represented as an Encoded LabelHash of the Literal Label value found onchain, and
+     * b) all Names stored and returned by ENSIndexer will be Interpreted Names, which are exclusively
+     *   composed of Interpreted Labels.
+     */
+    isSubgraphCompatible: boolean;
+    /**
+     * Version info about ENSIndexer.
+     */
+    versionInfo: EnsIndexerVersionInfo;
+}
 /**
- * A DomainId is one of ENSv1DomainId or ENSv2DomainId.
+ * Complete public configuration object for ENSIndexer.
+ *
+ * @deprecated Use {@link EnsIndexerPublicConfig} instead.
  */
-type DomainId = ENSv1DomainId | ENSv2DomainId;
+type ENSIndexerPublicConfig = EnsIndexerPublicConfig;
+
+type SerializedIndexedChainIds = Array<ChainId>;
 /**
- * Uniquely identifies a Permissions entity.
+ * Serialized representation of {@link EnsIndexerPublicConfig}
  */
-type PermissionsId = AccountIdString & {
-    __brand: "PermissionsId";
-};
+interface SerializedEnsIndexerPublicConfig extends Omit<EnsIndexerPublicConfig, "indexedChainIds"> {
+    /**
+     * Array representation of {@link EnsIndexerPublicConfig.indexedChainIds}.
+     */
+    indexedChainIds: ChainId[];
+}
 /**
- * Uniquely identifies a PermissionsResource entity.
+ * Serialized representation of {@link EnsIndexerPublicConfig}
+ *
+ * @deprecated Use {@link SerializedEnsIndexerPublicConfig} instead.
  */
-type PermissionsResourceId = string & {
-    __brand: "PermissionsResourceId";
-};
+type SerializedENSIndexerPublicConfig = SerializedEnsIndexerPublicConfig;
 /**
- * Uniquely identifies a PermissionsUser entity.
+ * Serialized representation of {@link EnsIndexerVersionInfo}
  */
-type PermissionsUserId = string & {
-    __brand: "PermissionsUserId";
-};
+type SerializedEnsIndexerVersionInfo = EnsIndexerVersionInfo;
 /**
- * Uniquely identifies a Resolver entity.
- */
-type ResolverId = AccountIdString & {
-    __brand: "ResolverId";
-};
-/**
- * Uniquely identifies a ResolverRecords entity.
- */
-type ResolverRecordsId = string & {
-    __brand: "ResolverRecordsId";
-};
-/**
- * Uniquely identifies a Registration entity.
- */
-type RegistrationId = string & {
-    __brand: "RegistrationId";
-};
-/**
- * Uniquely identifies a Renewal entity.
+ * Serialized representation of {@link EnsIndexerVersionInfo}
+ *
+ * @deprecated Use {@link SerializedEnsIndexerVersionInfo} instead.
  */
-type RenewalId = string & {
-    __brand: "RenewalId";
-};
+type SerializedENSIndexerVersionInfo = SerializedEnsIndexerVersionInfo;
 
 /**
- * Formats and brands an AccountId as a RegistryId.
- */
-declare const makeRegistryId: (accountId: AccountId) => RegistryId;
-/**
- * Makes an ENSv1 Domain Id given the ENSv1 Domain's `node`
+ * Reasons why TheGraph fallback cannot be used.
  */
-declare const makeENSv1DomainId: (node: Node) => ENSv1DomainId;
+declare const TheGraphCannotFallbackReasonSchema: z.ZodEnum<{
+    readonly NotSubgraphCompatible: "not-subgraph-compatible";
+    readonly NoApiKey: "no-api-key";
+    readonly NoSubgraphUrl: "no-subgraph-url";
+}>;
+type TheGraphCannotFallbackReason = z.infer<typeof TheGraphCannotFallbackReasonSchema>;
 /**
- * Makes an ENSv2 Domain Id given the parent `registry` and the domain's `canonicalId`.
+ * Configuration for TheGraph fallback behavior.
+ * Indicates whether fallback to TheGraph is possible and the reason if not.
  */
-declare const makeENSv2DomainId: (registry: AccountId, canonicalId: CanonicalId) => ENSv2DomainId;
+declare const TheGraphFallbackSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    canFallback: z.ZodLiteral<true>;
+    url: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    canFallback: z.ZodLiteral<false>;
+    reason: z.ZodEnum<{
+        readonly NotSubgraphCompatible: "not-subgraph-compatible";
+        readonly NoApiKey: "no-api-key";
+        readonly NoSubgraphUrl: "no-subgraph-url";
+    }>;
+}, z.core.$strict>], "canFallback">;
+type TheGraphFallback = z.infer<typeof TheGraphFallbackSchema>;
+
 /**
- * Computes a Domain's {@link CanonicalId} given its tokenId or LabelHash as `input`.
+ * Version info about ENSApi and its dependencies.
  */
-declare const getCanonicalId: (input: bigint | LabelHash) => CanonicalId;
+interface EnsApiVersionInfo {
+    /**
+     * ENSApi service version
+     *
+     * @see https://ghcr.io/namehash/ensnode/ensapi
+     */
+    ensApi: string;
+    /**
+     * ENS Normalize package version
+     *
+     * Available on NPM as: `@adraffy/ens-normalize`
+     *
+     * @see https://www.npmjs.com/package/@adraffy/ens-normalize
+     **/
+    ensNormalize: string;
+}
 /**
- * Formats and brands an AccountId as a PermissionsId.
+ * Complete public configuration object for ENSApi.
+ *
+ * Contains ENSApi-specific configuration at the top level and
+ * embeds the complete ENSIndexer public configuration.
  */
-declare const makePermissionsId: (contract: AccountId) => PermissionsId;
+interface EnsApiPublicConfig {
+    /**
+     * The Graph Fallback-related info.
+     */
+    theGraphFallback: TheGraphFallback;
+    /**
+     * Complete ENSIndexer public configuration
+     *
+     * Contains all ENSIndexer public configuration including
+     * namespace, plugins, version info, etc.
+     */
+    ensIndexerPublicConfig: EnsIndexerPublicConfig;
+    /**
+     * Version info about ENSApi.
+     */
+    versionInfo: EnsApiVersionInfo;
+}
 /**
- * Constructs a PermissionsResourceId for a given `contract`'s `resource`.
+ * ENSApi Public Config
+ *
+ * @deprecated Use {@link EnsApiPublicConfig} instead.
  */
-declare const makePermissionsResourceId: (contract: AccountId, resource: bigint) => PermissionsResourceId;
+type ENSApiPublicConfig = EnsApiPublicConfig;
+
 /**
- * Constructs a PermissionsUserId for a given `contract`'s `resource`'s `user`.
+ * Serialized representation of {@link EnsApiPublicConfig}
  */
-declare const makePermissionsUserId: (contract: AccountId, resource: bigint, user: Address) => PermissionsUserId;
+interface SerializedEnsApiPublicConfig extends Omit<EnsApiPublicConfig, "ensIndexerPublicConfig"> {
+    /**
+     * Serialized representation of {@link EnsApiPublicConfig.ensIndexerPublicConfig}.
+     */
+    ensIndexerPublicConfig: SerializedEnsIndexerPublicConfig;
+}
 /**
- * Formats and brands an AccountId as a ResolverId.
+ * Serialized representation of {@link EnsApiPublicConfig}
+ *
+ * @deprecated Use {@link SerializedEnsApiPublicConfig} instead.
  */
-declare const makeResolverId: (contract: AccountId) => ResolverId;
+type SerializedENSApiPublicConfig = SerializedEnsApiPublicConfig;
+
 /**
- * Constructs a ResolverRecordsId for a given `node` under `resolver`.
+ * Builds an unvalidated {@link EnsApiPublicConfig} object to be
+ * validated with {@link makeEnsApiPublicConfigSchema}.
+ *
+ * @param serializedPublicConfig - The serialized public config to build from.
+ * @return An unvalidated {@link EnsApiPublicConfig} object.
  */
-declare const makeResolverRecordsId: (resolver: AccountId, node: Node) => ResolverRecordsId;
+declare function buildUnvalidatedEnsApiPublicConfig(serializedPublicConfig: SerializedEnsApiPublicConfig): Unvalidated<EnsApiPublicConfig>;
 /**
- * Constructs a RegistrationId for a `domainId`'s `index`'thd Registration.
+ * Deserialize value into {@link EnsApiPublicConfig} object.
  */
-declare const makeRegistrationId: (domainId: DomainId, index: number) => RegistrationId;
+declare function deserializeEnsApiPublicConfig(maybePublicConfig: Unvalidated<SerializedEnsApiPublicConfig>, valueLabel?: string): EnsApiPublicConfig;
 /**
- * Constructs a RenewalId for a `domainId`'s `registrationIndex`thd Registration's `index`'thd Renewal.
+ * Deserialize a {@link EnsApiPublicConfig} object.
+ *
+ * @deprecated Use {@link deserializeEnsApiPublicConfig} instead.
  */
-declare const makeRenewalId: (domainId: DomainId, registrationIndex: number, index: number) => RenewalId;
+declare const deserializeENSApiPublicConfig: typeof deserializeEnsApiPublicConfig;
 
 /**
- * A hash value that uniquely identifies a single ENS name.
- * Result of `namehash` function as specified in ENSIP-1.
- *
- * @example
- * ```
- * namehash("vitalik.eth") === "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835"
- * ```
- * @see https://docs.ens.domains/ensip/1#namehash-algorithm
- * @see https://ensnode.io/docs/reference/terminology#name-node-namehash
+ * Serialize a {@link EnsApiPublicConfig} object.
  */
-type Node = Hex;
+declare function serializeEnsApiPublicConfig(config: EnsApiPublicConfig): SerializedEnsApiPublicConfig;
 /**
- * An ENS Name that may or may not be normalized.
+ * Serialize a {@link EnsApiPublicConfig} object.
  *
- * @example vitalik.eth
- * @see https://ensnode.io/docs/reference/terminology#name-node-namehash
- * @see https://docs.ens.domains/ensip/15
+ * @deprecated Use {@link serializeEnsApiPublicConfig} instead.
  */
-type Name = string;
+declare const serializeENSApiPublicConfig: typeof serializeEnsApiPublicConfig;
+
 /**
- * A Normalized Name is an ENS Name that is guaranteed to be normalized.
+ * Create a Zod schema for validating ENSApiPublicConfig.
  *
- * @example vitalik.eth
- * @see https://ensnode.io/docs/reference/terminology#name-node-namehash
- * @see https://docs.ens.domains/ensip/15
- * @dev nominally typed to enforce usage & enhance codebase clarity
+ * @param valueLabel - Optional label for the value being validated (used in error messages)
  */
-type NormalizedName = Name & {
-    __brand: "NormalizedName";
-};
+declare function makeEnsApiPublicConfigSchema(valueLabel?: string): z.ZodObject<{
+    theGraphFallback: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        canFallback: z.ZodLiteral<true>;
+        url: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        canFallback: z.ZodLiteral<false>;
+        reason: z.ZodEnum<{
+            readonly NotSubgraphCompatible: "not-subgraph-compatible";
+            readonly NoApiKey: "no-api-key";
+            readonly NoSubgraphUrl: "no-subgraph-url";
+        }>;
+    }, z.core.$strict>], "canFallback">;
+    ensIndexerPublicConfig: z.ZodObject<{
+        ensIndexerSchemaName: z.ZodString;
+        ensRainbowPublicConfig: z.ZodObject<{
+            version: z.ZodString;
+            labelSet: z.ZodObject<{
+                labelSetId: z.ZodString;
+                highestLabelSetVersion: z.ZodInt;
+            }, z.core.$strip>;
+            recordsCount: z.ZodInt;
+        }, z.core.$strip>;
+        indexedChainIds: z.ZodSet<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
+        isSubgraphCompatible: z.ZodBoolean;
+        labelSet: z.ZodObject<{
+            labelSetId: z.ZodString;
+            labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
+        }, z.core.$strip>;
+        namespace: z.ZodEnum<{
+            readonly Mainnet: "mainnet";
+            readonly Sepolia: "sepolia";
+            readonly SepoliaV2: "sepolia-v2";
+            readonly EnsTestEnv: "ens-test-env";
+        }>;
+        plugins: z.ZodArray<z.ZodString>;
+        versionInfo: z.ZodObject<{
+            ponder: z.ZodString;
+            ensDb: z.ZodString;
+            ensIndexer: z.ZodString;
+            ensNormalize: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    versionInfo: z.ZodObject<{
+        ensApi: z.ZodString;
+        ensNormalize: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 /**
- * A LabelHash is the result of the labelhash function (which is just keccak256) on a Label.
- *
- * @example
- * ```
- * labelhash('vitalik') === '0xaf2caa1c2ca1d027f1ac823b529d0a67cd144264b2789fa2ea4d63a67c7103cc'
- * ```
+ * Create a Zod schema for validating a serialized ENSApiPublicConfig.
  *
- * @see https://docs.ens.domains/terminology#labelhash
- * @see https://ensnode.io/docs/reference/terminology#labels-labelhashes-labelhash-function
- * @see https://ensnode.io/ensrainbow/concepts/glossary#labelhash
+ * @deprecated Use {@link makeEnsApiPublicConfigSchema} instead.
  */
-type LabelHash = Hex;
+declare const makeENSApiPublicConfigSchema: typeof makeEnsApiPublicConfigSchema;
+declare function makeSerializedEnsApiPublicConfigSchema(valueLabel?: string): z.ZodObject<{
+    ensIndexerPublicConfig: z.ZodObject<{
+        ensIndexerSchemaName: z.ZodString;
+        ensRainbowPublicConfig: z.ZodObject<{
+            version: z.ZodString;
+            labelSet: z.ZodObject<{
+                labelSetId: z.ZodString;
+                highestLabelSetVersion: z.ZodInt;
+            }, z.core.$strip>;
+            recordsCount: z.ZodInt;
+        }, z.core.$strip>;
+        indexedChainIds: z.ZodArray<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
+        isSubgraphCompatible: z.ZodBoolean;
+        labelSet: z.ZodObject<{
+            labelSetId: z.ZodString;
+            labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
+        }, z.core.$strip>;
+        namespace: z.ZodEnum<{
+            readonly Mainnet: "mainnet";
+            readonly Sepolia: "sepolia";
+            readonly SepoliaV2: "sepolia-v2";
+            readonly EnsTestEnv: "ens-test-env";
+        }>;
+        plugins: z.ZodArray<z.ZodString>;
+        versionInfo: z.ZodObject<{
+            ponder: z.ZodString;
+            ensDb: z.ZodString;
+            ensIndexer: z.ZodString;
+            ensNormalize: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    theGraphFallback: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        canFallback: z.ZodLiteral<true>;
+        url: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        canFallback: z.ZodLiteral<false>;
+        reason: z.ZodEnum<{
+            readonly NotSubgraphCompatible: "not-subgraph-compatible";
+            readonly NoApiKey: "no-api-key";
+            readonly NoSubgraphUrl: "no-subgraph-url";
+        }>;
+    }, z.core.$strict>], "canFallback">;
+    versionInfo: z.ZodObject<{
+        ensApi: z.ZodString;
+        ensNormalize: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+
 /**
- * A LabelHashPath is an ordered list of LabelHashes that uniquely identify an ENS Name.
- * It is ordered in namegraph TRAVERSAL order (i.e. the opposite order of an ENS Name's labels).
- *
- * ex: example.eth's LabelHashPath is
- * [
- *   '0x4f5b812789fc606be1b3b16908db13fc7a9adf7ca72641f84d75b47069d3d7f0', // 'eth'
- *   '0x6fd43e7cffc31bb581d7421c8698e29aa2bd8e7186a394b85299908b4eb9b175', // 'example'
- * ]
+ * Version info about ENSDb and its dependencies.
  */
-type LabelHashPath = LabelHash[];
+interface EnsDbVersionInfo {
+    /**
+     * Version of the PostgreSQL server hosting the ENSDb instance.
+     */
+    postgresql: string;
+}
 /**
- * CanonicalPath is an ordered list of DomainIds describing the canonical path to a Domain.
- * It is ordered in namegraph TRAVERSAL order (i.e. the opposite order of an ENS Name's labels).
+ * The public configuration of an ENSDb instance.
  */
-type CanonicalPath = DomainId[];
+interface EnsDbPublicConfig {
+    /**
+     * Version info about ENSDb.
+     */
+    versionInfo: EnsDbVersionInfo;
+}
+
 /**
- * A Label is a single part of an ENS Name.
- *
- * @example vitalik
- *
- * @see https://docs.ens.domains/terminology#label
- * @see https://ensnode.io/docs/reference/terminology#labels-labelhashes-labelhash-function
+ * Serialized representation of {@link EnsDbPublicConfig}
  */
-type Label = string;
+type SerializedEnsDbPublicConfig = EnsDbPublicConfig;
+
 /**
- * An EncodedLabelHash is a specially formatted (unnormalized) Label formatted
- * as a non-0x prefixed 32-byte hex string enclosed in square brackets.
- *
- * Care should be taken to distinguish Label values formatted as an
- * EncodedLabelHash as either a LiteralLabel or an InterpretedLabel:
- * - If a LiteralLabel is formatted as an EncodedLabelHash it does NOT
- *   symbolically represent the encoding of a LabelHash literal.
- * - If an InterpretedLabel is formatted as an EncodedLabelHash it should be
- *   interpreted as encoding a LabelHash literal.
- *
- * An InterpretedLabel may be formatted as an EncodedLabelHash if the related
- * LiteralLabel is:
- * - not a normalized label
- * - is an unknown value that could not be healed.
- * - is too long for DNS-Encoding in contexts where DNS-Encoding was required.
- *
- * @example [af2caa1c2ca1d027f1ac823b529d0a67cd144264b2789fa2ea4d63a67c7103cc]
- *
- * @see https://ensnode.io/docs/reference/terminology#encoded-labelhash
+ * ENSIndexer Public Config Response
  */
-type EncodedLabelHash = `[${string}]`;
+type EnsIndexerConfigResponse = EnsIndexerPublicConfig;
+
+type SerializedEnsIndexerConfigResponse = SerializedEnsIndexerPublicConfig;
+
 /**
- * A Literal Label is a Label as it literally appears onchain, without any interpretation
- * or normalization processing. It may be an unnormalized label for reasons including:
- * - being an empty label,
- * - containing '.' characters,
- * - being formatted as an EncodedLabelHash (which are not normalizable). Note that
- *   when LiteralLabel are formatted as an EncodedLabelHash they do NOT symbolically
- *   represent the encoding of a LabelHash literal, or
- * - containing other unnormalized characters such as null bytes or other characters
- *   not suitable for display.
- *
- *
- * @see https://ensnode.io/docs/reference/terminology#literal-label
- * @dev nominally typed to enforce usage & enhance codebase clarity
+ * Deserialize value into {@link EnsIndexerConfigResponse} object.
  */
-type LiteralLabel = Label & {
-    __brand: "LiteralLabel";
+declare function deserializeEnsIndexerConfigResponse(maybeResponse: Unvalidated<SerializedEnsIndexerConfigResponse>): EnsIndexerConfigResponse;
+
+declare function serializeEnsIndexerConfigResponse(response: EnsIndexerConfigResponse): SerializedEnsIndexerConfigResponse;
+
+declare const RangeTypeIds: {
+    readonly Unbounded: "unbounded";
+    readonly LeftBounded: "left-bounded";
+    readonly RightBounded: "right-bounded";
+    readonly Bounded: "bounded";
 };
+type RangeType = (typeof RangeTypeIds)[keyof typeof RangeTypeIds];
+/************************
+ * Block number range
+ ***********************/
 /**
- * An Interpreted Label is a Label that is either:
- * a) a Normalized Label, or
- * b) an Unnormalizable Label exclusively for the reason that it is formatted
- *    as an Encoded LabelHash that should be interpreted as encoding a
- *    LabelHash literal, where the encoded LabelHash literal is the `labelhash`
- *    of the related LiteralLabel.
- *
- * @see https://ensnode.io/docs/reference/terminology#interpreted-label
- * @dev nominally typed to enforce usage & enhance codebase clarity
+ * Block number range unbounded
  */
-type InterpretedLabel = Label & {
-    __brand: "InterpretedLabel";
-};
-/**
- * A Literal Name is a Name as it literally appears onchain, composed of 0 or more Literal Labels
- * joined by dots. It may be an unnormalized name for reasons including:
- * - containing empty labels,
- * - containing LiteralLabel values formatted as an EncodedLabelHash (which are
- *   not normalizable)). Note that when LiteralLabel values are formatted as an
- *   EncodedLabelHash they do NOT symbolically represent the encoding of a
- *   LabelHash literal, or
- * - containing other unnormalized characters such as null bytes or other characters
- *   not suitable for display.
- *
- * @see https://ensnode.io/docs/reference/terminology#literal-name
- * @dev nominally typed to enforce usage & enhance codebase clarity
- */
-type LiteralName = Name & {
-    __brand: "LiteralName";
-};
+interface BlockNumberRangeUnbounded {
+    rangeType: typeof RangeTypeIds.Unbounded;
+    startBlock?: undefined;
+    endBlock?: undefined;
+}
 /**
- * An Interpreted Name is a Name that is entirely composed of 0 or more Interpreted Labels.
- *
- * That is, it is either:
- * a) a Normalized Name, or
- * b) an Unnormalizable Name exclusively for the reason that it contains 1 or
- *    more labels formatted as Encoded LabelHashes that should be interpreted
- *    as encoding a LabelHash literal, where the encoded LabelHash literal is
- *    the `labelhash` of the related LiteralLabel.
+ * Block number range left bounded
  *
- * @see https://ensnode.io/docs/reference/terminology#interpreted-name
- * @dev nominally typed to enforce usage & enhance codebase clarity
+ * Range is inclusive of its left bound.
  */
-type InterpretedName = Name & {
-    __brand: "InterpretedName";
-};
+interface BlockNumberRangeLeftBounded {
+    rangeType: typeof RangeTypeIds.LeftBounded;
+    startBlock: BlockNumber;
+    endBlock?: undefined;
+}
 /**
- * A Subgraph Interpreted Label is a Literal Label that is either:
- * a) (if subgraph-indexable): a Literal Label, of unknown normalization status, guaranteed to not
- *   contain any of the subgraph-unindexable UTF-8 characters (and therefore guaranteed not to be
- *   an Encoded LabelHash), or
- * b) (if subgraph-unindexable): an Encoded LabelHash.
+ * Block number range right bounded
  *
- * @see https://ensnode.io/docs/reference/terminology#subgraph-interpreted-label
- * @dev nominally typed to enforce usage & enhance codebase clarity
- */
-type SubgraphInterpretedLabel = Label & {
-    __brand: "SubgraphInterpretedLabel";
-};
-/**
- * A Subgraph Interpreted Name is a name exclusively composed of 0 or more Subgraph Interpreted Labels.
- *
- * @see https://ensnode.io/docs/reference/terminology#subgraph-interpreted-name
- * @dev nominally typed to enforce usage & enhance codebase clarity
+ * Range is inclusive of its right bound.
  */
-type SubgraphInterpretedName = Name & {
-    __brand: "SubgraphInterpretedName";
-};
+interface BlockNumberRangeRightBounded {
+    rangeType: typeof RangeTypeIds.RightBounded;
+    startBlock?: undefined;
+    endBlock: BlockNumber;
+}
 /**
- * A DNS-Encoded Name as a hex string, representing the binary DNS wire format encoding
- * of a domain name. Used in ENS contracts for efficient name storage and transmission.
- * Each label is prefixed with a length byte, and the entire sequence is null-terminated.
- *
- * @example "0x076578616d706c650365746800" represents "example.eth"
- *
- * @see https://docs.ens.domains/resolution/names/#dns-encoding
- * @see https://github.com/ensdomains/ens-contracts/blob/staging/contracts/utils/NameCoder.sol
- *
- * DNS Packet Format for Domain Names:
- * - Domain names are encoded as a sequence of 0 or more labels
- * - Each label begins with a length byte (1 byte) indicating how many bytes follow for that label
- *   Note how this constrains each label in DNS encoded names to a max byte length of 255 bytes.
- * - The bytes after the length byte represent the label, as a UTF-8 byte array
- * - Labels are concatenated with no separators
- * - The sequence ends with a null byte (0x00)
- *
- * Example: "example.eth" is encoded as:
- * [0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 0x03, 'e', 't', 'h', 0x00]
- * Where 0x07 is the length of "example", 0x03 is the length of "eth", and 0x00 marks the end
- *
- * Example: "" (empty string, i.e. root node) is encoded as:
- * [0x00]
- *
- * Example: "👩🏼‍❤‍💋‍👨🏼.eth" (multi-byte unicode character) is encoded as:
- * [0x20, 240, 159, 145, 169, 240, 159, 143, 188, 226, 128, 141, 226, 157, 164, 226,
- * 128, 141, 240, 159, 146, 139, 226, 128, 141, 240, 159, 145, 168, 240, 159, 143,
- * 188, 3, 'e', 't', 'h', 0x00]
+ * Block number range bounded
  *
- * A DNS-Encoded Name Packet may be malformed if it does not exactly follow that specification.
- * Possible reasons a DNS-Encoded Name may be malfomed include:
- * - 'empty' packet
- *   - e.g. []
- *           ^-- that's empty!
- * - 'length' byte overflowing packet byte length
- *   - e.g. [0x06, 'e', 't', 'h', 0x00]
- *            ^-- length overflows available bytes!
- * - 'junk' at the end of the dns-encoded
- *   - e.g. [0x03, 'e', 't', 'h', 0x00, 0x01]
- *                                       ^-- junk!
+ * Range is inclusive of its bounds.
  *
- * @dev This type is _structurally_ typed to aid Event Argument Typing — consumers should further
- * cast the type of the event argument to a _nominally_ typed DNSEncodedName like {@link DNSEncodedLiteralName}
- * or {@link DNSEncodedPartiallyInterpretedName} depending on the context.
+ * Invariants:
+ * - `startBlock` is lower than or equal to `endBlock`
  */
-type DNSEncodedName = Hex;
+interface BlockNumberRangeBounded {
+    rangeType: typeof RangeTypeIds.Bounded;
+    startBlock: BlockNumber;
+    endBlock: BlockNumber;
+}
 /**
- * A DNSEncodedName that encodes a name containing 0 or more {@link LiteralLabel}s.
- *
- * In a DNSEncodedLiteralName, all labels are Literal Labels, including any Encoded-LabelHash-looking
- * labels. Any Encoded-LabelHash-looking Literal Label values, when interpreted, will be formatted as
- * the `labelhash` of the Literal Label value.
- *
- * The NameWrapper contract emits DNSEncodedLiteralNames:
- * @see https://github.com/ensdomains/ens-contracts/blob/staging/contracts/utils/BytesUtils_LEGACY.sol
- *
- * The ThreeDNSToken contract emits DNSEncodedLiteralNames:
- * @see https://github.com/3dns-xyz/contracts/blob/44937318ae26cc036982e8c6a496cd82ebdc2b12/src/regcontrol/libraries/BytesUtils.sol
+ * Block number range with start block defined.
  *
- * @dev nominally typed to enforce usage & enhance codebase clarity
+ * This is a useful type for representing block ranges for indexed chains.
  */
-type DNSEncodedLiteralName = DNSEncodedName & {
-    __brand: "DNSEncodedLiteralName";
-};
+type BlockNumberRangeWithStartBlock = BlockNumberRangeLeftBounded | BlockNumberRangeBounded;
 /**
- * A DNSEncodedName that encodes a name consisting of 0 or more labels that are either:
- * a) Literal Labels, or
- * b) Encoded LabelHashes, which are already an Interpreted Label.
- *
- * In a DNSEncodedPartiallyInterpretedName, any Encoded-LabelHash-looking decoded Labels (i.e. ones
- * that match the regex /^\[[\da-f]{64}\]$/) represent an Encoded LabelHash. When decoding a
- * DNSEncodedPartiallyInterpretedName, these labels are already considered Interpreted.
- *
- * NOTE: This type is unused in ENSv1, but its usage is anticipated in ENSv2 due to Encoded
- * LabelHash support in the ENSv2 implementation of the NameCoder contract.
- *
- * @see https://github.com/ensdomains/ens-contracts/blob/staging/contracts/utils/NameCoder.sol
+ * Block number range
  *
- * @dev nominally typed to enforce usage & enhance codebase clarity
- */
-type DNSEncodedPartiallyInterpretedName = DNSEncodedName & {
-    __brand: "DNSEncodedPartiallyInterpretedName";
-};
-
-declare const ROOT_NODE: Node;
-declare const ETH_NODE: Node;
-declare const BASENAMES_NODE: Node;
-declare const LINEANAMES_NODE: Node;
-declare const ADDR_REVERSE_NODE: Node;
-/**
- * NODE_ANY is a placeholder Node used in the context of DedicatedResolvers — IResolver events are
- * emitted with NODE_ANY as the `node` for which the records are issued, but the DedicatedResolver
- * returns those records regardless of the name used for record resolution.
- */
-declare const NODE_ANY: Node;
-/**
- * ROOT_RESOURCE represents the 'root' resource in an EnhancedAccessControl contract.
+ * Use the `rangeType` field to determine the specific type interpretation
+ * at runtime.
  */
-declare const ROOT_RESOURCE = 0n;
-
+type BlockNumberRange = BlockNumberRangeUnbounded | BlockNumberRangeLeftBounded | BlockNumberRangeRightBounded | BlockNumberRangeBounded;
 /**
- * Decodes a DNS-Encoded name consisting of Literal Labels into an ordered list of Literal Labels.
- *
- * For discussion on DNS-Encoding, see the {@link DNSEncodedName} and {@link DNSEncodedLiteralName} types.
- *
- * Due to the constraints of DNS-Encoding, there is an additional guarantee that each Literal Label
- * in the resulting list is guaranteed to have a maximum byte length of 255.
- *
- * @param packet a hex string that encodes a DNSEncodedLiteralName
- * @returns A list of the LiteralLabels contained in packet
- * @throws If the packet is malformed
- * @dev This is just `decodeDNSEncodedName` with semantic input/output
+ * Build a block number range object.
  */
-declare function decodeDNSEncodedLiteralName(packet: DNSEncodedLiteralName): LiteralLabel[];
+declare function buildBlockNumberRange(startBlock: undefined, endBlock: undefined): BlockNumberRangeUnbounded;
+declare function buildBlockNumberRange(startBlock: BlockNumber, endBlock: undefined): BlockNumberRangeLeftBounded;
+declare function buildBlockNumberRange(startBlock: undefined, endBlock: BlockNumber): BlockNumberRangeRightBounded;
+declare function buildBlockNumberRange(startBlock: BlockNumber, endBlock: BlockNumber): BlockNumberRangeBounded;
+declare function buildBlockNumberRange(startBlock?: BlockNumber, endBlock?: BlockNumber): BlockNumberRange;
 /**
- * Decodes a DNS-Encoded Name into an ordered list of string segments.
- *
- * For discussion on DNS-Encoding, see the {@link DNSEncodedName} type.
- *
- * Due to the constraints of DNS-Encoding, there is an additional guarantee that each segment
- * in the resulting list is guaranteed to have a maximum byte length of 255.
+ * Merge multiple block number ranges into a single range.
  *
- * @param packet a hex string that encodes a DNSEncodedName
- * @returns A UTF-8 string array of the segments contained in packet
- * @throws If the packet is malformed
- * @dev This is the generic implementation of DNS-Encoded Name Decoding
- */
-declare function decodeDNSEncodedName(packet: DNSEncodedName): string[];
-
-/**
- * Formats a LabelHash as an Encoded LabelHash.
+ * The resulting range is a union that covers all input ranges:
+ * - Uses the minimum start block when every input range has a start block
+ * - Uses the maximum end block when every input range has an end block
+ * - Leaves a side unbounded when any input range is unbounded on that side
  *
- * @see https://ensnode.io/docs/reference/terminology#encoded-labelhash
+ * Returns an unbounded range if no ranges are provided.
  *
- * @param labelHash - A 32-byte lowercase hash string starting with '0x'
- * @returns The encoded label hash in format `[hash_without_0x_prefix]`
- */
-declare const encodeLabelHash: (labelHash: LabelHash) => EncodedLabelHash;
-/**
- * Checks if the input value is an {@link EncodedLabelHash}.
- */
-declare function isEncodedLabelHash(maybeEncodedLabelHash: string): maybeEncodedLabelHash is EncodedLabelHash;
-
-/**
- * Determines whether `fuses` has set ('burnt') the PARENT_CANNOT_CONTROL fuse.
+ * @param ranges - The block number ranges to merge
+ * @returns A single merged block number range covering all inputs
  */
-declare const isPccFuseSet: (fuses: number) => boolean;
-
+declare function mergeBlockNumberRanges(...ranges: BlockNumberRange[]): BlockNumberRange;
+/************************
+ * Block ref range
+ ***********************/
 /**
- * Determines whether the Name is normalized.
- *
- * @param name - The Name to check for normalization
- * @returns True if the name is normalized according to ENS normalization rules, false otherwise
+ * Block ref range unbounded
  */
-declare function isNormalizedName(name: Name): name is NormalizedName;
+interface BlockRefRangeUnbounded {
+    rangeType: typeof RangeTypeIds.Unbounded;
+    startBlock?: undefined;
+    endBlock?: undefined;
+}
 /**
- * Determines whether the Label is normalized.
+ * Block ref range left bounded
  *
- * @param label - The Label to check for normalization
- * @returns True if the label is normalized according to ENS normalization rules, false otherwise
+ * Range is inclusive of its left bound.
  */
-declare function isNormalizedLabel(label: Label): boolean;
-
+interface BlockRefRangeLeftBounded {
+    rangeType: typeof RangeTypeIds.LeftBounded;
+    startBlock: BlockRef;
+    endBlock?: undefined;
+}
 /**
- * Checks if the input is a {@link LabelHash}.
+ * Block ref range right bounded
  *
- * @see https://ensnode.io/docs/reference/terminology#label-processing-and-classification
- */
-declare function isLabelHash(maybeLabelHash: string): maybeLabelHash is LabelHash;
-
-/**
- * Name for the ENS Root
+ * Range is inclusive of its right bound.
  */
-declare const ENS_ROOT: Name;
+interface BlockRefRangeRightBounded {
+    rangeType: typeof RangeTypeIds.RightBounded;
+    startBlock?: undefined;
+    endBlock: BlockRef;
+}
 /**
- * Constructs a name hierarchy from a given NormalizedName.
- *
- * @example
- * ```
- * getNameHierarchy("sub.example.eth") -> ["sub.example.eth", "example.eth", "eth"]
- * ```
+ * Block ref range bounded
  *
- * @dev by restricting the input type to NormalizedName we guarantee that we can split and join
- * on '.' and receive NormalizedNames as a result
- */
-declare const getNameHierarchy: (name: NormalizedName) => NormalizedName[];
-/**
- * Get FQDN of parent for a name.
- */
-declare const getParentNameFQDN: (name: Name) => Name;
-/**
- * Beautifies a name by converting each normalized label in the provided name to
- * its "beautified" form. Labels that are not normalized retain their original value.
+ * Range is inclusive of its bounds.
  *
  * Invariants:
- * - The number of labels in the returned name is the same as the number of labels in the input name.
- * - The order of the labels in the returned name is the same as the order of the labels in the input name.
- * - If a label in the input is normalized, it is returned in its "beautified" form.
- * - If a label in the input name is not normalized, it is returned without modification.
- * - Therefore, the result of ens_normalize(beautifyName(name)) is the same as the result of ens_normalize(name).
- *
- * The "beautified form" of a normalized label converts special sequences of
- * emojis and other special characters to their "beautified" equivalents. All
- * such conversions transform X -> Y where Y is normalizable and normalizes back to X.
- * Ex: '1⃣2⃣' (normalized) to '1️⃣2️⃣' (normalizable but not normalized).
- * Ex: 'ξethereum' (normalized) to 'Ξethereum' (normalizable, but not normalized).
- * Ex: 'abc' (normalized) to 'abc' (also normalized, no conversion).
- * Ex: 'ABC' (normalizable but not normalized) to 'ABC' (no conversion).
- * Ex: 'invalid|label' (not normalizable) to 'invalid|label' (no conversion).
- * Ex: '' (unnormalized as a label) to '' (no conversion).
- *
- * @param name - The name to beautify.
- * @returns The beautified name.
- */
-declare const beautifyName: (name: Name) => Name;
-
-/**
- * Parses a labelHash string and normalizes it to a canonical `LabelHash`.
- *
- * Normalization rules applied in order:
- * 1. Adds `0x` prefix if missing
- * 2. Validates all characters (excluding the optional `0x` prefix) are valid hex digits
- *    (uppercase or lowercase A-F are accepted and normalized to lowercase)
- * 3. If the hex digit count is odd, adds a leading `0` to make it even
- * 4. Validates the result is exactly 64 hex digits (32 bytes)
- *
- * @param maybeLabelHash - The string to parse as a labelHash
- * @throws {Error} If the input cannot be normalized to a valid labelHash
- */
-declare function parseLabelHash(maybeLabelHash: string): LabelHash;
-/**
- * Parses an encoded labelHash string (surrounded by square brackets) and normalizes it.
- *
- * This function is intentionally more lenient than {@link isEncodedLabelHash}: it accepts
- * both the canonical format `[hash]` (no `0x` inside brackets) and the non-canonical
- * `[0xhash]` format by delegating to {@link parseLabelHash} for the inner value.
- * `isEncodedLabelHash("[0xhash]")` returns `false` for the same input.
- *
- * @param maybeEncodedLabelHash - The string to parse as an encoded labelHash
- * @throws {Error} If the input is not properly enclosed in brackets or cannot be normalized
- */
-declare function parseEncodedLabelHash(maybeEncodedLabelHash: string): LabelHash;
-/**
- * Parses a labelHash or encoded labelHash string and normalizes it.
- *
- * Tries both formats to be maximally generous with accepted inputs:
- * - If the input starts with `[` and ends with `]`, it is treated as an encoded labelHash
- * - Otherwise, it is treated as a plain labelHash
- *
- * @param maybeLabelHash - The string to parse as a labelHash or encoded labelHash
- * @throws {Error} If the input cannot be normalized to a valid labelHash
- */
-declare function parseLabelHashOrEncodedLabelHash(maybeLabelHash: string): LabelHash;
-
-/**
- * Parse the address and coinType out of an ENSIP-19 reverse name.
- */
-declare function parseReverseName(name: Name): {
-    address: Address;
-    coinType: CoinType;
-} | null;
-
-/**
- * Gets the Label used for the reverse names of subnames as per ENSIP-11 & ENSIP-19.
- *
- * @see https://docs.ens.domains/ensip/19/#reverse-resolution
+ * - `startBlock` is before or equal to `endBlock`
  */
-declare const addrReverseLabel: (address: Address) => LiteralLabel;
+interface BlockRefRangeBounded {
+    rangeType: typeof RangeTypeIds.Bounded;
+    startBlock: BlockRef;
+    endBlock: BlockRef;
+}
 /**
- * Converts `coinType` to prefix-free hex string.
+ * Block ref range
  *
- * @see https://docs.ens.domains/ensip/19
+ * Use the `rangeType` field to determine the specific type interpretation
+ * at runtime.
  */
-declare const coinTypeReverseLabel: (coinType: CoinType) => Label;
+type BlockRefRange = BlockRefRangeUnbounded | BlockRefRangeLeftBounded | BlockRefRangeRightBounded | BlockRefRangeBounded;
 /**
- * Gets the reverse name for an address according to ENSIP-11 & ENSIP-19.
- *
- * @see https://docs.ens.domains/ensip/11#specification
- * @see https://docs.ens.domains/ensip/19#specification
- *
- * @param address - The address to get the reverse name for
- * @param coinType - The coin type to use for the reverse name
- * @returns The reverse name for the address
+ * Block ref range with start block defined.
  *
- * @example
- * ```ts
- * reverseName("0x1234", BigInt(ETH_COIN_TYPE)) // "1234.addr.reverse"
- * reverseName("0x1234", BigInt(0x80000000)) // "1234.default.reverse"
- * reverseName("0x1234", BigInt(0x5678)) // "1234.5678.reverse"
- * ```
- */
-declare function reverseName(address: Address, coinType: CoinType): Name;
-
-/**
- * Implements one step of the namehash algorithm, combining `labelHash` with `node` to produce
- * the `node` of a given subdomain. Note that the order of the arguments is 'reversed' (as compared to
- * the actual concatenation) in order to improve readability (i.e. read as [labelHash].[node]).
+ * This is a useful type for representing block ranges for indexed chains.
  */
-declare const makeSubdomainNode: (labelHash: LabelHash, node: Node) => Node;
+type BlockRefRangeWithStartBlock = BlockRefRangeLeftBounded | BlockRefRangeBounded;
 /**
- * Encodes a uint256 bigint as hex string sized to 32 bytes.
- * Uses include, in the context of ENS, decoding the uint256-encoded tokenId of NFT-issuing contracts
- * into Node or LabelHash, which is a common behavior in the ENS ecosystem.
- * (see NameWrapper, ETHRegistrarController)
+ * Build a block ref range object.
  */
-declare const uint256ToHex32: (num: bigint) => Hex;
+declare function buildBlockRefRange(startBlock: undefined, endBlock: undefined): BlockRefRangeUnbounded;
+declare function buildBlockRefRange(startBlock: BlockRef, endBlock: undefined): BlockRefRangeLeftBounded;
+declare function buildBlockRefRange(startBlock: undefined, endBlock: BlockRef): BlockRefRangeRightBounded;
+declare function buildBlockRefRange(startBlock: BlockRef, endBlock: BlockRef): BlockRefRangeBounded;
+declare function buildBlockRefRange(startBlock?: BlockRef, endBlock?: BlockRef): BlockRefRange;
 
 /**
- * A label set ID identifies a label set (see https://ensnode.io/ensrainbow/concepts/glossary#label-set for definition).
- * It is guaranteed to be 1 to 50 characters long and contain only lowercase letters (a-z)
- * and hyphens (-).
- */
-type LabelSetId = string;
-/**
- * A label set version identifies a specific version of a label set. It allows clients to
- * request data from a specific snapshot in time, ensuring deterministic results.
- *
- * It is guaranteed to be a non-negative integer.
- */
-type LabelSetVersion = number;
-/**
- * The label set preferences of an ENSRainbow client.
+ * The status of indexing a chain at the time an indexing status snapshot
+ * is captured.
  */
-interface EnsRainbowClientLabelSet {
+declare const ChainIndexingStatusIds: {
     /**
-     * Optional label set ID that the ENSRainbow server is expected to use. If provided, heal
-     * operations will validate the ENSRainbow server is using this labelSetId.
-     * Required if `labelSetVersion` is defined.
+     * Represents that indexing of the chain is not ready to begin yet because:
+     * - ENSIndexer is in its initialization phase and the data to build a
+     *   "true" {@link ChainIndexingStatusSnapshot} for the chain is still being loaded; or
+     * - ENSIndexer is using an omnichain indexing strategy and the
+     *   `omnichainIndexingCursor` is <= `config.startBlock.timestamp` for the chain's
+     *   {@link ChainIndexingStatusSnapshot}.
      */
-    labelSetId?: LabelSetId;
+    readonly Queued: "chain-queued";
     /**
-     * Optional highest label set version of label set id to query. Enables deterministic heal
-     * results across time even if the ENSRainbow server ingests label sets with greater versions
-     * than this value. If provided, only labels from label sets with versions less than or equal to this
-     * value will be returned. If not provided, the server will use the latest available version.
-     * When `labelSetVersion` is defined, `labelSetId` must also be defined.
+     * Represents that indexing of the chain is in progress and under a special
+     * "backfill" phase that optimizes for accelerated indexing until reaching the
+     * "fixed target" `backfillEndBlock`.
      */
-    labelSetVersion?: LabelSetVersion;
-}
-/**
- * The state of label sets managed by an ENSRainbow server.
- */
-interface EnsRainbowServerLabelSet {
+    readonly Backfill: "chain-backfill";
     /**
-     * The LabelSetId managed by the ENSRainbow server.
+     * Represents that the "backfill" phase of indexing the chain is completed
+     * and that the chain is configured to be indexed for an indefinite range.
+     * Therefore, indexing of the chain remains indefinitely in progress where
+     * ENSIndexer will continuously work to discover and index new blocks as they
+     * are added to the chain across time.
      */
-    labelSetId: LabelSetId;
+    readonly Following: "chain-following";
     /**
-     * The highest label set version available on the ENSRainbow server for the current
-     * label set ID. This represents the most recent version of the label set that the
-     * server has ingested and can provide label healing results for.
+     * Represents that indexing of the chain is completed as the chain is configured
+     * to be indexed for a definite range and the indexing of all blocks through
+     * that definite range is completed.
      */
-    highestLabelSetVersion: LabelSetVersion;
-}
-
+    readonly Completed: "chain-completed";
+};
 /**
- * Complete public configuration object for ENSRainbow.
+ * The derived string union of possible {@link ChainIndexingStatusIds}.
+ */
+type ChainIndexingStatusId = (typeof ChainIndexingStatusIds)[keyof typeof ChainIndexingStatusIds];
+/**
+ * Chain indexing status snapshot for a chain whose `chainStatus` is
+ * {@link ChainIndexingStatusIds.Queued}.
  *
- * Contains all public configuration information about the ENSRainbow service instance,
- * including version, label set information, and record counts.
+ * Invariants:
+ * - `chainStatus` is always {@link ChainIndexingStatusIds.Queued}.
  */
-interface EnsRainbowPublicConfig {
-    /**
-     * ENSRainbow service version
-     *
-     * @see https://ghcr.io/namehash/ensnode/ensrainbow
-     */
-    version: string;
+interface ChainIndexingStatusSnapshotQueued {
     /**
-     * The label set reference managed by the ENSRainbow server.
+     * The status of indexing the chain at the time the indexing status snapshot
+     * was captured.
      */
-    labelSet: EnsRainbowServerLabelSet;
+    chainStatus: typeof ChainIndexingStatusIds.Queued;
     /**
-     * The total count of records managed by the ENSRainbow service.
+     * The indexing configuration of the chain.
      */
-    recordsCount: number;
+    config: BlockRefRangeWithStartBlock;
 }
-
 /**
- * A PluginName is a unique id for a 'plugin': we use the notion of
- * 'plugins' to describe bundles of indexing logic.
- */
-declare enum PluginName {
-    Subgraph = "subgraph",
-    Basenames = "basenames",
-    Lineanames = "lineanames",
-    ThreeDNS = "threedns",
-    ProtocolAcceleration = "protocol-acceleration",
-    Registrars = "registrars",
-    TokenScope = "tokenscope",
-    ENSv2 = "ensv2"
-}
-/**
- * Version info about ENSIndexer and its dependencies.
- */
-interface EnsIndexerVersionInfo {
-    /**
-     * Node.js runtime version
-     *
-     * @see https://nodejs.org/en/about/previous-releases
-     **/
-    nodejs: string;
-    /**
-     * Ponder framework version
-     *
-     * @see https://www.npmjs.com/package/ponder
-     **/
-    ponder: string;
-    /**
-     * ENSDb service version
-     *
-     * Guaranteed to be the same as {@link ENSIndexerVersionInfo.ensIndexer}.
-     * */
-    ensDb: string;
-    /**
-     * ENSIndexer service version
-     *
-     * @see https://ghcr.io/namehash/ensnode/ensindexer
-     **/
-    ensIndexer: string;
-    /**
-     * ENS Normalize package version
-     *
-     * Available on NPM as: `@adraffy/ens-normalize`
-     *
-     * @see https://www.npmjs.com/package/@adraffy/ens-normalize
-     **/
-    ensNormalize: string;
-}
-/**
- * Version info about ENSIndexer and its dependencies.
+ * Chain indexing status snapshot for a chain whose `chainStatus` is
+ * {@link ChainIndexingStatusIds.Backfill}.
  *
- * @deprecated Use {@link EnsIndexerVersionInfo} instead.
- */
-type ENSIndexerVersionInfo = EnsIndexerVersionInfo;
-/**
- * Complete public configuration object for ENSIndexer.
+ * During a backfill, special performance optimizations are applied to
+ * index all blocks between `config.startBlock` and `backfillEndBlock`
+ * as fast as possible.
  *
- * We use parameter types to maintain fields layout and documentation across
- * the domain model and its serialized counterpart.
+ * Note how `backfillEndBlock` is a "fixed target" that does not change during
+ * the lifetime of an ENSIndexer process instance:
+ * - If the `config` is {@link BlockRefRangeBounded}:
+ *   `backfillEndBlock` is always the same as `config.endBlock`.
+ * - If the `config` is {@link BlockRefRangeLeftBounded}:
+ *   `backfillEndBlock` is a {@link BlockRef} to what was the latest block on the
+ *    chain when the ENSIndexer process was performing its initialization. Note how
+ *    this means that if the backfill process takes X hours to complete, because the
+ *    `backfillEndBlock` is a "fixed target", when `chainStatus` transitions to
+ *    {@link ChainIndexingStatusIds.Following} the chain will be X hours behind
+ *    "realtime" indexing.
+ *
+ * When `latestIndexedBlock` reaches `backfillEndBlock` the backfill is complete.
+ * The moment backfill is complete the `chainStatus` may not immediately transition.
+ * Instead, internal processing is completed for a period of time while
+ * `chainStatus` remains {@link ChainIndexingStatusIds.Backfill}. After this internal
+ * processing is completed `chainStatus` will transition:
+ * - to {@link ChainIndexingStatusIds.Following} if the `config` is
+ *   {@link BlockRefRangeLeftBounded}.
+ * - to {@link ChainIndexingStatusIds.Completed} if the `config` is
+ *   {@link BlockRefRangeBounded}.
+ *
+ * Invariants:
+ * - `chainStatus` is always {@link ChainIndexingStatusIds.Backfill}.
+ * - `config.startBlock` is always before or the same as `latestIndexedBlock`
+ * - `config.endBlock` is always the same as `backfillEndBlock` if and only if
+ *   the config is {@link BlockRefRangeBounded}.
+ * - `latestIndexedBlock` is always before or the same as `backfillEndBlock`
  */
-interface EnsIndexerPublicConfig {
+interface ChainIndexingStatusSnapshotBackfill {
     /**
-     * The ENS namespace that ENSNode operates in the context of.
-     *
-     * See {@link ENSNamespaceIds} for available namespace identifiers.
+     * The status of indexing the chain at the time the indexing status snapshot
+     * was captured.
      */
-    namespace: ENSNamespaceId;
+    chainStatus: typeof ChainIndexingStatusIds.Backfill;
     /**
-     * The "fully pinned" label set reference that ENSIndexer will request ENSRainbow use for deterministic label healing across time. This label set reference is "fully pinned" as it requires both the labelSetId and labelSetVersion fields to be defined.
+     * The indexing configuration of the chain.
      */
-    labelSet: Required<EnsRainbowClientLabelSet>;
+    config: BlockRefRangeWithStartBlock;
     /**
-     * A Postgres database schema name. This instance of ENSIndexer will write
-     * indexed data to the tables in this schema.
-     *
-     * Invariants:
-     * - Must be a non-empty string that is a valid Postgres database schema
-     *   identifier.
+     * A {@link BlockRef} to the block that was most recently indexed as of the time the
+     * indexing status snapshot was captured.
      */
-    databaseSchemaName: string;
+    latestIndexedBlock: BlockRef;
     /**
-     * ENSRainbow public config
-     *
-     * Represents the public config of the connected ENSRainbow instance.
+     * A {@link BlockRef} to the block where the backfill will end.
      */
-    ensRainbowPublicConfig: EnsRainbowPublicConfig;
+    backfillEndBlock: BlockRef;
+}
+/**
+ * Chain indexing status snapshot for a chain whose `chainStatus` is
+ * {@link ChainIndexingStatusIds.Following}.
+ *
+ * Invariants:
+ * - `chainStatus` is always {@link ChainIndexingStatusIds.Following}.
+ * - `config.startBlock` is always before or the same as `latestIndexedBlock`
+ * - `latestIndexedBlock` is always before or the same as `latestKnownBlock`
+ */
+interface ChainIndexingStatusSnapshotFollowing {
     /**
-     * A set of strings referring to the names of plugins that are active.
-     *
-     * For future-proofing, this is a list of strings that may or may
-     * not be currently valid {@link PluginName} values.
-     *
-     * Invariants:
-     * - A set of strings with at least one value.
+     * The status of indexing the chain at the time the indexing status snapshot
+     * was captured.
      */
-    plugins: string[];
+    chainStatus: typeof ChainIndexingStatusIds.Following;
     /**
-     * Indexed Chain IDs
-     *
-     * Includes the {@link ChainId} for each chain being indexed.
+     * The indexing configuration of the chain.
      */
-    indexedChainIds: Set<ChainId>;
+    config: BlockRefRangeLeftBounded;
     /**
-     * A feature flag to enable/disable ENSIndexer's Subgraph Compatible Indexing Behavior.
-     *
-     * If {@link isSubgraphCompatible} is true, indexing behavior will match that of the legacy ENS
-     * Subgraph.
-     *
-     * ENSIndexer will store and return Literal Labels and Literal Names without further interpretation.
-     * @see https://ensnode.io/docs/reference/terminology#literal-label
-     * @see https://ensnode.io/docs/reference/terminology#literal-name
-     *
-     * If {@link isSubgraphCompatible} is true, the following invariants are true for the ENSIndexerConfig:
-     * 1. only the 'subgraph' plugin is enabled, and
-     * 2. the labelSet must be { labelSetId: 'subgraph', labelSetVersion: 0 }
-     *
-     * If {@link isSubgraphCompatible} is false, ENSIndexer will additionally:
-     *
-     * 1. ENSIndexer will heal all subnames of addr.reverse on the ENS Root Chain.
-     *
-     * 2. ENSIndexer will track both the keys and the values of Resolver records.
-     *
-     * WARNING: Special care must be taken when interacting with indexed resolver record values. It
-     * is unsafe to naively assume that indexed resolver record values are equivalent to the
-     * resolver record values that would be returned through dynamic lookups via the ENS protocol.
-     * For example, if a resolver implements CCIP-Read, the resolver records may not be
-     * discoverable through onchain indexing.
-     *
-     * 3. Literal Labels and Literal Names encountered by ENSIndexer will be Interpreted.
-     * @see https://ensnode.io/docs/reference/terminology#interpreted-label
-     * @see https://ensnode.io/docs/reference/terminology#interpreted-name
-     *
-     * That is,
-     * a) all Labels stored and returned by ENSIndexer will be Interpreted Labels, which are either:
-     *    i. normalized, or
-     *    ii. represented as an Encoded LabelHash of the Literal Label value found onchain, and
-     * b) all Names stored and returned by ENSIndexer will be Interpreted Names, which are exclusively
-     *   composed of Interpreted Labels.
+     * A {@link BlockRef} to the block that was most recently indexed as of the time the
+     * indexing status snapshot was captured.
      */
-    isSubgraphCompatible: boolean;
+    latestIndexedBlock: BlockRef;
     /**
-     * Version info about ENSIndexer.
+     * A {@link BlockRef} to the "highest" block that has been discovered by RPCs
+     * and stored in the RPC cache as of the time the indexing status snapshot was
+     * captured.
      */
-    versionInfo: EnsIndexerVersionInfo;
+    latestKnownBlock: BlockRef;
 }
 /**
- * Complete public configuration object for ENSIndexer.
+ * Chain indexing status snapshot for a chain whose `chainStatus` is
+ * {@link ChainIndexingStatusIds.Completed}.
  *
- * @deprecated Use {@link EnsIndexerPublicConfig} instead.
- */
-type ENSIndexerPublicConfig = EnsIndexerPublicConfig;
-
-/**
- * Reasons why TheGraph fallback cannot be used.
- */
-declare const TheGraphCannotFallbackReasonSchema: z.ZodEnum<{
-    readonly NotSubgraphCompatible: "not-subgraph-compatible";
-    readonly NoApiKey: "no-api-key";
-    readonly NoSubgraphUrl: "no-subgraph-url";
-}>;
-type TheGraphCannotFallbackReason = z.infer<typeof TheGraphCannotFallbackReasonSchema>;
-/**
- * Configuration for TheGraph fallback behavior.
- * Indicates whether fallback to TheGraph is possible and the reason if not.
- */
-declare const TheGraphFallbackSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    canFallback: z.ZodLiteral<true>;
-    url: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    canFallback: z.ZodLiteral<false>;
-    reason: z.ZodEnum<{
-        readonly NotSubgraphCompatible: "not-subgraph-compatible";
-        readonly NoApiKey: "no-api-key";
-        readonly NoSubgraphUrl: "no-subgraph-url";
-    }>;
-}, z.core.$strict>], "canFallback">;
-type TheGraphFallback = z.infer<typeof TheGraphFallbackSchema>;
-
-/**
- * Complete public configuration object for ENSApi.
+ * After the backfill of a chain is completed, if the chain was configured
+ * to be indexed for a definite range, the chain indexing status will transition to
+ * {@link ChainIndexingStatusIds.Completed}.
  *
- * Contains ENSApi-specific configuration at the top level and
- * embeds the complete ENSIndexer public configuration.
+ * Invariants:
+ * - `chainStatus` is always {@link ChainIndexingStatusIds.Completed}.
+ * - `config.startBlock` is always before or the same as `latestIndexedBlock`
+ * - `latestIndexedBlock` is always the same as `config.endBlock`.
  */
-interface EnsApiPublicConfig {
+interface ChainIndexingStatusSnapshotCompleted {
     /**
-     * ENSApi service version
-     *
-     * @see https://ghcr.io/namehash/ensnode/ensapi
+     * The status of indexing the chain at the time the indexing status snapshot
+     * was captured.
      */
-    version: string;
+    chainStatus: typeof ChainIndexingStatusIds.Completed;
     /**
-     * The Graph Fallback-related info.
+     * The indexing configuration of the chain.
      */
-    theGraphFallback: TheGraphFallback;
+    config: BlockRefRangeBounded;
     /**
-     * Complete ENSIndexer public configuration
-     *
-     * Contains all ENSIndexer public configuration including
-     * namespace, plugins, version info, etc.
+     * A {@link BlockRef} to the block that was most recently indexed as of the time the
+     * indexing status snapshot was captured.
      */
-    ensIndexerPublicConfig: EnsIndexerPublicConfig;
+    latestIndexedBlock: BlockRef;
 }
 /**
- * ENSApi Public Config
+ * Indexing status snapshot for a single chain.
  *
- * @deprecated Use {@link EnsApiPublicConfig} instead.
+ * Use the `chainStatus` field to determine the specific type interpretation
+ * at runtime.
  */
-type ENSApiPublicConfig = EnsApiPublicConfig;
-
+type ChainIndexingStatusSnapshot = ChainIndexingStatusSnapshotQueued | ChainIndexingStatusSnapshotBackfill | ChainIndexingStatusSnapshotFollowing | ChainIndexingStatusSnapshotCompleted;
 /**
- * ENSApi Public Config Response
+ * Get the timestamp of the lowest `config.startBlock` across all chains
+ * in the provided array of {@link ChainIndexingStatusSnapshot}.
+ *
+ * Such timestamp is useful when presenting the "lowest" block
+ * to be indexed across all chains.
  */
-type EnsApiConfigResponse = EnsApiPublicConfig;
+declare function getTimestampForLowestOmnichainStartBlock(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
 /**
- * ENSApi Config API Response
+ * Get the timestamp of the "highest known block" across all chains
+ * in the provided array of {@link ChainIndexingStatusSnapshot}.
+ *
+ * Such timestamp is useful when presenting the "highest known block"
+ * to be indexed across all chains.
  *
- * @deprecated Use {@link EnsApiConfigResponse} instead.
+ * The "highest known block" for a chain depends on its status:
+ * - `config.endBlock` for a "queued" chain (only if the config range type is `Bounded`),
+ * - `backfillEndBlock` for a "backfill" chain,
+ * - `latestIndexedBlock` for a "completed" chain,
+ * - `latestKnownBlock` for a "following" chain.
+ */
+declare function getTimestampForHighestOmnichainKnownBlock(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
+/**
+ * Sort a list of [{@link ChainId}, {@link ChainIndexingStatusSnapshot}] tuples
+ * by the omnichain start block timestamp in ascending order.
  */
-type ConfigResponse = EnsApiConfigResponse;
+declare function sortChainStatusesByStartBlockAsc<ChainStatusType extends ChainIndexingStatusSnapshot>(chains: [ChainId, ChainStatusType][]): [ChainId, ChainStatusType][];
 
-type SerializedIndexedChainIds = Array<ChainId>;
 /**
- * Serialized representation of {@link EnsIndexerPublicConfig}
+ * The status of omnichain indexing at the time an omnichain indexing status
+ * snapshot is captured.
  */
-interface SerializedEnsIndexerPublicConfig extends Omit<EnsIndexerPublicConfig, "indexedChainIds"> {
+declare const OmnichainIndexingStatusIds: {
     /**
-     * Array representation of {@link EnsIndexerPublicConfig.indexedChainIds}.
+     * Represents that omnichain indexing is not ready to begin yet because
+     * ENSIndexer is in its initialization phase and the data to build a "true"
+     * {@link OmnichainIndexingStatusSnapshot} is still being loaded.
      */
-    indexedChainIds: ChainId[];
-}
+    readonly Unstarted: "omnichain-unstarted";
+    /**
+     * Represents that omnichain indexing is in an overall "backfill" status because
+     * - At least one indexed chain has a `chainStatus` of
+     *   {@link ChainIndexingStatusIds.Backfill}; and
+     * - No indexed chain has a `chainStatus` of {@link ChainIndexingStatusIds.Following}.
+     */
+    readonly Backfill: "omnichain-backfill";
+    /**
+     * Represents that omnichain indexing is in an overall "following" status because
+     * at least one indexed chain has a `chainStatus` of
+     * {@link ChainIndexingStatusIds.Following}.
+     */
+    readonly Following: "omnichain-following";
+    /**
+     * Represents that omnichain indexing has completed because all indexed chains have
+     * a `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
+     */
+    readonly Completed: "omnichain-completed";
+};
 /**
- * Serialized representation of {@link EnsIndexerPublicConfig}
+ * The derived string union of possible {@link OmnichainIndexingStatusIds}.
+ */
+type OmnichainIndexingStatusId = (typeof OmnichainIndexingStatusIds)[keyof typeof OmnichainIndexingStatusIds];
+/**
+ * Omnichain indexing status snapshot when the overall `omnichainStatus` is
+ * {@link OmnichainIndexingStatusIds.Unstarted}.
  *
- * @deprecated Use {@link SerializedEnsIndexerPublicConfig} instead.
+ * Invariants:
+ * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Unstarted}.
+ * - `chains` is always a map to {@link ChainIndexingStatusSnapshotQueued} values exclusively.
+ * - `omnichainIndexingCursor` is always < the `config.startBlock.timestamp` for all
+ *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Queued}.
  */
-type SerializedENSIndexerPublicConfig = SerializedEnsIndexerPublicConfig;
+interface OmnichainIndexingStatusSnapshotUnstarted {
+    /**
+     * The status of omnichain indexing.
+     */
+    omnichainStatus: typeof OmnichainIndexingStatusIds.Unstarted;
+    /**
+     * The indexing status snapshot for each indexed chain.
+     */
+    chains: Map<ChainId, ChainIndexingStatusSnapshotQueued>;
+    /**
+     * The timestamp of omnichain indexing progress across all indexed chains.
+     */
+    omnichainIndexingCursor: UnixTimestamp;
+}
 /**
- * Serialized representation of {@link EnsIndexerVersionInfo}
+ * The range of {@link ChainIndexingSnapshot} types allowed when the
+ * overall omnichain indexing status is {@link OmnichainIndexingStatusIds.Backfill}.
+ *
+ * Note that this is all of the {@link ChainIndexingSnapshot} types with the exception
+ * of {@link ChainIndexingStatusSnapshotFollowing}.
  */
-type SerializedEnsIndexerVersionInfo = EnsIndexerVersionInfo;
+type ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill = ChainIndexingStatusSnapshotQueued | ChainIndexingStatusSnapshotBackfill | ChainIndexingStatusSnapshotCompleted;
 /**
- * Serialized representation of {@link EnsIndexerVersionInfo}
+ * Omnichain indexing status snapshot when the `omnichainStatus` is
+ * {@link OmnichainIndexingStatusIds.Backfill}.
  *
- * @deprecated Use {@link SerializedEnsIndexerVersionInfo} instead.
+ * Invariants:
+ * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Backfill}.
+ * - `chains` is guaranteed to contain at least one chain with a `chainStatus` of
+ *   {@link ChainIndexingStatusIds.Backfill}.
+ * - `chains` is guaranteed to not to contain any chain with a `chainStatus` of
+ *   {@link ChainIndexingStatusIds.Following}
+ * - `omnichainIndexingCursor` is always < the `config.startBlock.timestamp` for all
+ *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Queued}.
+ * - `omnichainIndexingCursor` is always <= the `backfillEndBlock.timestamp` for all
+ *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Backfill}.
+ * - `omnichainIndexingCursor` is always >= the `latestIndexedBlock.timestamp` for all
+ *    chains with `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
+ * - `omnichainIndexingCursor` is always equal to the timestamp of the highest
+ *   `latestIndexedBlock` across all chains that have started indexing
+ *   (`chainStatus` is not {@link ChainIndexingStatusIds.Queued}).
  */
-type SerializedENSIndexerVersionInfo = SerializedEnsIndexerVersionInfo;
-
+interface OmnichainIndexingStatusSnapshotBackfill {
+    /**
+     * The status of omnichain indexing.
+     */
+    omnichainStatus: typeof OmnichainIndexingStatusIds.Backfill;
+    /**
+     * The indexing status snapshot for each indexed chain.
+     */
+    chains: Map<ChainId, ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill>;
+    /**
+     * The timestamp of omnichain indexing progress across all indexed chains.
+     */
+    omnichainIndexingCursor: UnixTimestamp;
+}
 /**
- * Serialized representation of {@link EnsApiPublicConfig}
+ * Omnichain indexing status snapshot when the overall `omnichainStatus` is
+ * {@link OmnichainIndexingStatusIds.Following}.
+ *
+ * Invariants:
+ * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Following}.
+ * - `chains` is guaranteed to contain at least one chain with a `status` of
+ *   {@link ChainIndexingStatusIds.Following}.
+ * - `omnichainIndexingCursor` is always < the `config.startBlock.timestamp` for all
+ *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Queued}.
+ * - `omnichainIndexingCursor` is always <= the `backfillEndBlock.timestamp` for all
+ *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Backfill}.
+ * - `omnichainIndexingCursor` is always >= the `latestIndexedBlock.timestamp` for all
+ *    chains with `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
+ * - `omnichainIndexingCursor` is always equal to the timestamp of the highest
+ *   `latestIndexedBlock` across all chains that have started indexing
+ *   (`chainStatus` is not {@link ChainIndexingStatusIds.Queued}).
  */
-interface SerializedEnsApiPublicConfig extends Omit<EnsApiPublicConfig, "ensIndexerPublicConfig"> {
+interface OmnichainIndexingStatusSnapshotFollowing {
     /**
-     * Serialized representation of {@link EnsApiPublicConfig.ensIndexerPublicConfig}.
+     * The status of omnichain indexing.
      */
-    ensIndexerPublicConfig: SerializedEnsIndexerPublicConfig;
+    omnichainStatus: typeof OmnichainIndexingStatusIds.Following;
+    /**
+     * The indexing status snapshot for each indexed chain.
+     */
+    chains: Map<ChainId, ChainIndexingStatusSnapshot>;
+    /**
+     * The timestamp of omnichain indexing progress across all indexed chains.
+     */
+    omnichainIndexingCursor: UnixTimestamp;
 }
 /**
- * Serialized representation of {@link EnsApiPublicConfig}
+ * Omnichain indexing status snapshot when the overall `omnichainStatus` is
+ * {@link OmnichainIndexingStatusIds.Completed}.
  *
- * @deprecated Use {@link SerializedEnsApiPublicConfig} instead.
+ * Invariants:
+ * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Completed}.
+ * - `chains` is always a map to {@link ChainIndexingStatusSnapshotCompleted} values exclusively.
+ * - `omnichainIndexingCursor` is always equal to the highest
+ *   `latestIndexedBlock.timestamp` for all chains.
  */
-type SerializedENSApiPublicConfig = SerializedEnsApiPublicConfig;
-
+interface OmnichainIndexingStatusSnapshotCompleted {
+    /**
+     * The status of omnichain indexing.
+     */
+    omnichainStatus: typeof OmnichainIndexingStatusIds.Completed;
+    /**
+     * The indexing status snapshot for each indexed chain.
+     */
+    chains: Map<ChainId, ChainIndexingStatusSnapshotCompleted>;
+    /**
+     * The timestamp of omnichain indexing progress across all indexed chains.
+     */
+    omnichainIndexingCursor: UnixTimestamp;
+}
 /**
- * Serialized representation of {@link EnsApiConfigResponse}
+ * Omnichain indexing status snapshot for one or more chains.
+ *
+ * Use the `omnichainStatus` field to determine the specific type interpretation
+ * at runtime.
  */
-type SerializedEnsApiConfigResponse = SerializedEnsApiPublicConfig;
+type OmnichainIndexingStatusSnapshot = OmnichainIndexingStatusSnapshotUnstarted | OmnichainIndexingStatusSnapshotBackfill | OmnichainIndexingStatusSnapshotCompleted | OmnichainIndexingStatusSnapshotFollowing;
 /**
- * @deprecated Use {@link SerializedEnsApiConfigResponse} instead.
+ * Check if Chain Indexing Status Snapshots fit the 'unstarted' overall status
+ * snapshot requirements:
+ * - All chains are guaranteed to have a status of "queued".
+ *
+ * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
+ * {@link ChainIndexingStatusSnapshotQueued}.
  */
-type SerializedConfigResponse = SerializedEnsApiConfigResponse;
-
+declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotQueued[];
 /**
- * Deserialize a {@link EnsApiConfigResponse} object.
+ * Check if Chain Indexing Status Snapshots fit the 'backfill' overall status
+ * snapshot requirements:
+ * - At least one chain is guaranteed to be in the "backfill" status.
+ * - Each chain is guaranteed to have a status of either "queued",
+ *   "backfill" or "completed".
+ *
+ * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
+ * {@link ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill}.
  */
-declare function deserializeEnsApiConfigResponse(maybeResponse: Unvalidated<SerializedEnsApiConfigResponse>): EnsApiConfigResponse;
+declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill[];
 /**
- * Deserialize a {@link EnsApiConfigResponse} object.
+ * Checks if Chain Indexing Status Snapshots fit the 'completed' overall status
+ * snapshot requirements:
+ * - All chains are guaranteed to have a status of "completed".
  *
- * @deprecated Use {@link deserializeEnsApiConfigResponse} instead.
+ * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
+ * {@link ChainIndexingStatusSnapshotCompleted}.
  */
-declare const deserializeConfigResponse: typeof deserializeEnsApiConfigResponse;
-
+declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotCompleted[];
 /**
- * Serialize ENSApi Config API Response
+ * Checks Chain Indexing Status Snapshots fit the 'following' overall status
+ * snapshot requirements:
+ * - At least one chain is guaranteed to be in the "following" status.
+ * - Any other chain can have any status.
  */
-declare function serializeEnsApiConfigResponse(response: EnsApiConfigResponse): SerializedEnsApiConfigResponse;
+declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains: ChainIndexingStatusSnapshot[]): boolean;
 /**
- * Serialize ENSApi Config API Response
+ * Get {@link OmnichainIndexingStatusId} based on indexed chains' statuses.
+ *
+ * This function decides what is the `OmnichainIndexingStatusId` is,
+ * based on provided chain indexing statuses.
  *
- * @deprecated Use {@link serializeEnsApiConfigResponse} instead.
+ * @throws an error if unable to determine overall indexing status
  */
-declare const serializeConfigResponse: typeof serializeEnsApiConfigResponse;
-
-declare const RangeTypeIds: {
-    readonly Unbounded: "unbounded";
-    readonly LeftBounded: "left-bounded";
-    readonly RightBounded: "right-bounded";
-    readonly Bounded: "bounded";
-};
-type RangeType = (typeof RangeTypeIds)[keyof typeof RangeTypeIds];
-/************************
- * Block number range
- ***********************/
+declare function getOmnichainIndexingStatus(chains: ChainIndexingStatusSnapshot[]): OmnichainIndexingStatusId;
 /**
- * Block number range unbounded
+ * Get Omnichain Indexing Cursor
+ *
+ * The cursor tracks the "highest" latest indexed block timestamp across
+ * all indexed chains. If all chains are queued, the cursor tracks the moment
+ * just before the earliest start block timestamp across those chains.
+ *
+ * @throws an error if no chains are provided
  */
-interface BlockNumberRangeUnbounded {
-    rangeType: typeof RangeTypeIds.Unbounded;
-    startBlock?: undefined;
-    endBlock?: undefined;
-}
+declare function getOmnichainIndexingCursor(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
 /**
- * Block number range left bounded
+ * Build an Omnichain Indexing Status Snapshot based on the indexing status snapshots of all indexed chains.
  *
- * Range is inclusive of its left bound.
+ * @param chainStatusSnapshots - A map of chain IDs to their chain indexing status snapshots.
+ * @returns The omnichain indexing status snapshot.
  */
-interface BlockNumberRangeLeftBounded {
-    rangeType: typeof RangeTypeIds.LeftBounded;
-    startBlock: BlockNumber;
-    endBlock?: undefined;
-}
+declare function buildOmnichainIndexingStatusSnapshot(chainStatusSnapshots: Map<ChainId, ChainIndexingStatusSnapshot>): OmnichainIndexingStatusSnapshot;
+
 /**
- * Block number range right bounded
+ * The strategy used for indexing one or more chains.
  *
- * Range is inclusive of its right bound.
+ * @see https://ponder.sh/docs/api-reference/ponder/config#parameters
  */
-interface BlockNumberRangeRightBounded {
-    rangeType: typeof RangeTypeIds.RightBounded;
-    startBlock?: undefined;
-    endBlock: BlockNumber;
-}
+declare const CrossChainIndexingStrategyIds: {
+    /**
+     * Represents that the indexing of events across all indexed chains will
+     * proceed in a deterministic "omnichain" ordering by block timestamp, chain ID,
+     * and block number.
+     *
+     * This strategy is "deterministic" in that the order of processing cross-chain indexed
+     * events and each resulting indexed data state transition recorded in ENSDb is always
+     * the same for each ENSIndexer instance operating with an equivalent
+     * `ENSIndexerConfig` and ENSIndexer version. However it also has the drawbacks of:
+     * - increased indexing latency that must wait for the slowest indexed chain to
+     *   add new blocks or to discover new blocks through the configured RPCs.
+     * - if any indexed chain gets "stuck" due to chain or RPC failures, all indexed chains
+     *   will be affected.
+     */
+    readonly Omnichain: "omnichain";
+};
 /**
- * Block number range bounded
- *
- * Range is inclusive of its bounds.
- *
- * Invariants:
- * - `startBlock` is lower than or equal to `endBlock`
+ * The derived string union of possible {@link CrossChainIndexingStrategyIds}.
  */
-interface BlockNumberRangeBounded {
-    rangeType: typeof RangeTypeIds.Bounded;
-    startBlock: BlockNumber;
-    endBlock: BlockNumber;
-}
+type CrossChainIndexingStrategyId = (typeof CrossChainIndexingStrategyIds)[keyof typeof CrossChainIndexingStrategyIds];
 /**
- * Block number range with start block defined.
+ * Cross-chain indexing status snapshot when the `strategy` is
+ * {@link CrossChainIndexingStrategyId.Omnichain}.
  *
- * This is a useful type for representing block ranges for indexed chains.
+ * Invariants:
+ * - `strategy` is always {@link CrossChainIndexingStrategyId.Omnichain}.
+ * - `slowestChainIndexingCursor` is always equal to
+ *   `omnichainSnapshot.omnichainIndexingCursor`.
+ * - `snapshotTime` is always >= the "highest known block timestamp", defined as the max of:
+ *     - the `slowestChainIndexingCursor`.
+ *     - the `config.startBlock.timestamp` for all indexed chains.
+ *     - the `config.endBlock.timestamp` for all indexed chains with a `config.rangeType` of
+ *       {@link RangeTypeIds.Bounded}.
+ *     - the `backfillEndBlock.timestamp` for all chains with `chainStatus` of
+ *       {@link ChainIndexingStatusIds.Backfill}.
+ *     - the `latestKnownBlock.timestamp` for all chains with `chainStatus` of
+ *       {@link ChainIndexingStatusIds.Following}.
  */
-type BlockNumberRangeWithStartBlock = BlockNumberRangeLeftBounded | BlockNumberRangeBounded;
+interface CrossChainIndexingStatusSnapshotOmnichain {
+    /**
+     * The strategy used for indexing one or more chains.
+     */
+    strategy: typeof CrossChainIndexingStrategyIds.Omnichain;
+    /**
+     * The timestamp of the "slowest" latest indexed block timestamp
+     * across all indexed chains.
+     */
+    slowestChainIndexingCursor: UnixTimestamp;
+    /**
+     * The timestamp when the cross-chain indexing status snapshot was generated.
+     *
+     * Due to possible clock skew between different systems this value must be set
+     * to the max of each of the following values to ensure all invariants are followed:
+     * - the current system time of the system generating this cross-chain indexing
+     *   status snapshot.
+     * - the "highest known block timestamp" (see invariants above for full definition).
+     */
+    snapshotTime: UnixTimestamp;
+    /**
+     * The omnichain indexing status snapshot for one or more chains.
+     */
+    omnichainSnapshot: OmnichainIndexingStatusSnapshot;
+}
 /**
- * Block number range
+ * Cross-chain indexing status snapshot for one or more chains.
  *
- * Use the `rangeType` field to determine the specific type interpretation
+ * Use the `strategy` field to determine the specific type interpretation
  * at runtime.
- */
-type BlockNumberRange = BlockNumberRangeUnbounded | BlockNumberRangeLeftBounded | BlockNumberRangeRightBounded | BlockNumberRangeBounded;
-/**
- * Build a block number range object.
- */
-declare function buildBlockNumberRange(startBlock: undefined, endBlock: undefined): BlockNumberRangeUnbounded;
-declare function buildBlockNumberRange(startBlock: BlockNumber, endBlock: undefined): BlockNumberRangeLeftBounded;
-declare function buildBlockNumberRange(startBlock: undefined, endBlock: BlockNumber): BlockNumberRangeRightBounded;
-declare function buildBlockNumberRange(startBlock: BlockNumber, endBlock: BlockNumber): BlockNumberRangeBounded;
-declare function buildBlockNumberRange(startBlock?: BlockNumber, endBlock?: BlockNumber): BlockNumberRange;
-/**
- * Merge multiple block number ranges into a single range.
- *
- * The resulting range is a union that covers all input ranges:
- * - Uses the minimum start block when every input range has a start block
- * - Uses the maximum end block when every input range has an end block
- * - Leaves a side unbounded when any input range is unbounded on that side
- *
- * Returns an unbounded range if no ranges are provided.
- *
- * @param ranges - The block number ranges to merge
- * @returns A single merged block number range covering all inputs
- */
-declare function mergeBlockNumberRanges(...ranges: BlockNumberRange[]): BlockNumberRange;
-/************************
- * Block ref range
- ***********************/
-/**
- * Block ref range unbounded
- */
-interface BlockRefRangeUnbounded {
-    rangeType: typeof RangeTypeIds.Unbounded;
-    startBlock?: undefined;
-    endBlock?: undefined;
-}
-/**
- * Block ref range left bounded
  *
- * Range is inclusive of its left bound.
+ * Currently, only omnichain indexing is supported. This type could theoretically
+ * be extended to support other cross-chain indexing strategies in the future,
+ * such as Ponder's "multichain" indexing strategy that indexes each chain
+ * independently without deterministic ordering.
  */
-interface BlockRefRangeLeftBounded {
-    rangeType: typeof RangeTypeIds.LeftBounded;
-    startBlock: BlockRef;
-    endBlock?: undefined;
-}
+type CrossChainIndexingStatusSnapshot = CrossChainIndexingStatusSnapshotOmnichain;
 /**
- * Block ref range right bounded
+ * Gets the latest indexed {@link BlockRef} for the given {@link ChainId}.
  *
- * Range is inclusive of its right bound.
+ * @returns the latest indexed {@link BlockRef} for the given {@link ChainId}, or null if the chain
+ *          isn't being indexed at all or is queued and therefore hasn't started indexing yet.
  */
-interface BlockRefRangeRightBounded {
-    rangeType: typeof RangeTypeIds.RightBounded;
-    startBlock?: undefined;
-    endBlock: BlockRef;
-}
+declare function getLatestIndexedBlockRef(indexingStatus: CrossChainIndexingStatusSnapshot, chainId: ChainId): BlockRef | null;
 /**
- * Block ref range bounded
+ * Get the "highest known block timestamp" from chain indexing status snapshots.
  *
- * Range is inclusive of its bounds.
+ * Returns the maximum timestamp referenced anywhere in the provided chain snapshots,
+ * across all of:
+ * - `config.startBlock` timestamps for all chains
+ * - `config.endBlock` timestamps for bounded chains
+ * - `backfillEndBlock` timestamps for chains in backfill status
+ * - `latestKnownBlock` timestamps for chains in following status
  *
- * Invariants:
- * - `startBlock` is before or equal to `endBlock`
- */
-interface BlockRefRangeBounded {
-    rangeType: typeof RangeTypeIds.Bounded;
-    startBlock: BlockRef;
-    endBlock: BlockRef;
-}
-/**
- * Block ref range
+ * This is used to enforce the invariant that `snapshotTime` must be >= all
+ * referenced block timestamps. It differs from {@link getTimestampForHighestOmnichainKnownBlock},
+ * which computes the highest "target" block timestamp for progress display and
+ * does not include `startBlock` timestamps.
  *
- * Use the `rangeType` field to determine the specific type interpretation
- * at runtime.
+ * @throws Error if `chains` is empty.
  */
-type BlockRefRange = BlockRefRangeUnbounded | BlockRefRangeLeftBounded | BlockRefRangeRightBounded | BlockRefRangeBounded;
+declare function getHighestKnownBlockTimestamp(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
 /**
- * Block ref range with start block defined.
+ * Build a Cross-Chain Indexing Status Snapshot based on the omnichain indexing status snapshot.
  *
- * This is a useful type for representing block ranges for indexed chains.
- */
-type BlockRefRangeWithStartBlock = BlockRefRangeLeftBounded | BlockRefRangeBounded;
-/**
- * Build a block ref range object.
+ * @param omnichainSnapshot - The omnichain indexing status snapshot.
+ * @param snapshotTime - The timestamp when the cross-chain indexing status snapshot was generated.
+ *        Will be adjusted upward if necessary to satisfy the invariant that snapshotTime must
+ *        be >= the highest known block timestamp (handles clock skew and future block timestamps).
+ * @returns The cross-chain indexing status snapshot.
+ * @throws if the generated snapshot does not satisfy the invariants defined
+ *         in {@link CrossChainIndexingStatusSnapshotOmnichain}
  */
-declare function buildBlockRefRange(startBlock: undefined, endBlock: undefined): BlockRefRangeUnbounded;
-declare function buildBlockRefRange(startBlock: BlockRef, endBlock: undefined): BlockRefRangeLeftBounded;
-declare function buildBlockRefRange(startBlock: undefined, endBlock: BlockRef): BlockRefRangeRightBounded;
-declare function buildBlockRefRange(startBlock: BlockRef, endBlock: BlockRef): BlockRefRangeBounded;
-declare function buildBlockRefRange(startBlock?: BlockRef, endBlock?: BlockRef): BlockRefRange;
+declare function buildCrossChainIndexingStatusSnapshotOmnichain(omnichainSnapshot: OmnichainIndexingStatusSnapshot, snapshotTime: UnixTimestamp): CrossChainIndexingStatusSnapshotOmnichain;
 
 /**
- * The status of indexing a chain at the time an indexing status snapshot
- * is captured.
+ * A "realtime" indexing status projection based on worst-case assumptions
+ * from the `snapshot`.
+ *
+ * Invariants:
+ * - `projectedAt` is always >= `snapshot.snapshotTime`.
+ * - `worstCaseDistance` is always equal to
+ *   `projectedAt - snapshot.slowestChainIndexingCursor`.
  */
-declare const ChainIndexingStatusIds: {
-    /**
-     * Represents that indexing of the chain is not ready to begin yet because:
-     * - ENSIndexer is in its initialization phase and the data to build a
-     *   "true" {@link ChainIndexingStatusSnapshot} for the chain is still being loaded; or
-     * - ENSIndexer is using an omnichain indexing strategy and the
-     *   `omnichainIndexingCursor` is <= `config.startBlock.timestamp` for the chain's
-     *   {@link ChainIndexingStatusSnapshot}.
-     */
-    readonly Queued: "chain-queued";
+type RealtimeIndexingStatusProjection = {
     /**
-     * Represents that indexing of the chain is in progress and under a special
-     * "backfill" phase that optimizes for accelerated indexing until reaching the
-     * "fixed target" `backfillEndBlock`.
+     * The timestamp representing "now" as of the time this projection was generated.
      */
-    readonly Backfill: "chain-backfill";
+    projectedAt: UnixTimestamp;
     /**
-     * Represents that the "backfill" phase of indexing the chain is completed
-     * and that the chain is configured to be indexed for an indefinite range.
-     * Therefore, indexing of the chain remains indefinitely in progress where
-     * ENSIndexer will continuously work to discover and index new blocks as they
-     * are added to the chain across time.
+     * The distance between `projectedAt` and `snapshot.slowestChainIndexingCursor`.
+     *
+     * This is "worst-case" because it assumes all of the following:
+     * - the `snapshot` (which may have `snapshot.snapshotTime < projectedAt`) is still the
+     *   latest snapshot and no indexing progress has been made since `snapshotTime`.
+     * - each indexed chain has added a new block as of `projectedAt`.
      */
-    readonly Following: "chain-following";
+    worstCaseDistance: Duration;
     /**
-     * Represents that indexing of the chain is completed as the chain is configured
-     * to be indexed for a definite range and the indexing of all blocks through
-     * that definite range is completed.
+     * The {@link CrossChainIndexingStatusSnapshot} that this projection is based on.
      */
-    readonly Completed: "chain-completed";
+    snapshot: CrossChainIndexingStatusSnapshot;
 };
 /**
- * The derived string union of possible {@link ChainIndexingStatusIds}.
+ * Create realtime indexing status projection from
+ * a {@link CrossChainIndexingStatusSnapshot}.
  */
-type ChainIndexingStatusId = (typeof ChainIndexingStatusIds)[keyof typeof ChainIndexingStatusIds];
+declare function createRealtimeIndexingStatusProjection(snapshot: CrossChainIndexingStatusSnapshot, now: UnixTimestamp): RealtimeIndexingStatusProjection;
+
 /**
- * Chain indexing status snapshot for a chain whose `chainStatus` is
- * {@link ChainIndexingStatusIds.Queued}.
- *
- * Invariants:
- * - `chainStatus` is always {@link ChainIndexingStatusIds.Queued}.
+ * A status code for ENSIndexer indexing status responses.
  */
-interface ChainIndexingStatusSnapshotQueued {
+declare const EnsIndexerIndexingStatusResponseCodes: {
     /**
-     * The status of indexing the chain at the time the indexing status snapshot
-     * was captured.
+     * Represents that the indexing status is available.
      */
-    chainStatus: typeof ChainIndexingStatusIds.Queued;
+    readonly Ok: "ok";
     /**
-     * The indexing configuration of the chain.
+     * Represents that the indexing status is unavailable.
      */
-    config: BlockRefRangeWithStartBlock;
-}
+    readonly Error: "error";
+};
 /**
- * Chain indexing status snapshot for a chain whose `chainStatus` is
- * {@link ChainIndexingStatusIds.Backfill}.
- *
- * During a backfill, special performance optimizations are applied to
- * index all blocks between `config.startBlock` and `backfillEndBlock`
- * as fast as possible.
- *
- * Note how `backfillEndBlock` is a "fixed target" that does not change during
- * the lifetime of an ENSIndexer process instance:
- * - If the `config` is {@link BlockRefRangeBounded}:
- *   `backfillEndBlock` is always the same as `config.endBlock`.
- * - If the `config` is {@link BlockRefRangeLeftBounded}:
- *   `backfillEndBlock` is a {@link BlockRef} to what was the latest block on the
- *    chain when the ENSIndexer process was performing its initialization. Note how
- *    this means that if the backfill process takes X hours to complete, because the
- *    `backfillEndBlock` is a "fixed target", when `chainStatus` transitions to
- *    {@link ChainIndexingStatusIds.Following} the chain will be X hours behind
- *    "realtime" indexing.
- *
- * When `latestIndexedBlock` reaches `backfillEndBlock` the backfill is complete.
- * The moment backfill is complete the `chainStatus` may not immediately transition.
- * Instead, internal processing is completed for a period of time while
- * `chainStatus` remains {@link ChainIndexingStatusIds.Backfill}. After this internal
- * processing is completed `chainStatus` will transition:
- * - to {@link ChainIndexingStatusIds.Following} if the `config` is
- *   {@link BlockRefRangeLeftBounded}.
- * - to {@link ChainIndexingStatusIds.Completed} if the `config` is
- *   {@link BlockRefRangeBounded}.
- *
- * Invariants:
- * - `chainStatus` is always {@link ChainIndexingStatusIds.Backfill}.
- * - `config.startBlock` is always before or the same as `latestIndexedBlock`
- * - `config.endBlock` is always the same as `backfillEndBlock` if and only if
- *   the config is {@link BlockRefRangeBounded}.
- * - `latestIndexedBlock` is always before or the same as `backfillEndBlock`
+ * The derived string union of possible {@link EnsIndexerIndexingStatusResponseCodes}.
  */
-interface ChainIndexingStatusSnapshotBackfill {
-    /**
-     * The status of indexing the chain at the time the indexing status snapshot
-     * was captured.
-     */
-    chainStatus: typeof ChainIndexingStatusIds.Backfill;
-    /**
-     * The indexing configuration of the chain.
-     */
-    config: BlockRefRangeWithStartBlock;
-    /**
-     * A {@link BlockRef} to the block that was most recently indexed as of the time the
-     * indexing status snapshot was captured.
-     */
-    latestIndexedBlock: BlockRef;
-    /**
-     * A {@link BlockRef} to the block where the backfill will end.
-     */
-    backfillEndBlock: BlockRef;
-}
+type EnsIndexerIndexingStatusResponseCode = (typeof EnsIndexerIndexingStatusResponseCodes)[keyof typeof EnsIndexerIndexingStatusResponseCodes];
 /**
- * Chain indexing status snapshot for a chain whose `chainStatus` is
- * {@link ChainIndexingStatusIds.Following}.
- *
- * Invariants:
- * - `chainStatus` is always {@link ChainIndexingStatusIds.Following}.
- * - `config.startBlock` is always before or the same as `latestIndexedBlock`
- * - `latestIndexedBlock` is always before or the same as `latestKnownBlock`
+ * An ENSIndexer indexing status response when the indexing status is available.
  */
-interface ChainIndexingStatusSnapshotFollowing {
-    /**
-     * The status of indexing the chain at the time the indexing status snapshot
-     * was captured.
-     */
-    chainStatus: typeof ChainIndexingStatusIds.Following;
-    /**
-     * The indexing configuration of the chain.
-     */
-    config: BlockRefRangeLeftBounded;
-    /**
-     * A {@link BlockRef} to the block that was most recently indexed as of the time the
-     * indexing status snapshot was captured.
-     */
-    latestIndexedBlock: BlockRef;
-    /**
-     * A {@link BlockRef} to the "highest" block that has been discovered by RPCs
-     * and stored in the RPC cache as of the time the indexing status snapshot was
-     * captured.
-     */
-    latestKnownBlock: BlockRef;
-}
+type EnsIndexerIndexingStatusResponseOk = {
+    responseCode: typeof EnsIndexerIndexingStatusResponseCodes.Ok;
+    realtimeProjection: RealtimeIndexingStatusProjection;
+};
 /**
- * Chain indexing status snapshot for a chain whose `chainStatus` is
- * {@link ChainIndexingStatusIds.Completed}.
- *
- * After the backfill of a chain is completed, if the chain was configured
- * to be indexed for a definite range, the chain indexing status will transition to
- * {@link ChainIndexingStatusIds.Completed}.
- *
- * Invariants:
- * - `chainStatus` is always {@link ChainIndexingStatusIds.Completed}.
- * - `config.startBlock` is always before or the same as `latestIndexedBlock`
- * - `latestIndexedBlock` is always the same as `config.endBlock`.
+ * An ENSIndexer indexing status response when the indexing status is unavailable.
  */
-interface ChainIndexingStatusSnapshotCompleted {
-    /**
-     * The status of indexing the chain at the time the indexing status snapshot
-     * was captured.
-     */
-    chainStatus: typeof ChainIndexingStatusIds.Completed;
-    /**
-     * The indexing configuration of the chain.
-     */
-    config: BlockRefRangeBounded;
-    /**
-     * A {@link BlockRef} to the block that was most recently indexed as of the time the
-     * indexing status snapshot was captured.
-     */
-    latestIndexedBlock: BlockRef;
-}
+type EnsIndexerIndexingStatusResponseError = {
+    responseCode: typeof EnsIndexerIndexingStatusResponseCodes.Error;
+};
 /**
- * Indexing status snapshot for a single chain.
+ * ENSIndexer indexing status response.
  *
- * Use the `chainStatus` field to determine the specific type interpretation
+ * Use the `responseCode` field to determine the specific type interpretation
  * at runtime.
  */
-type ChainIndexingStatusSnapshot = ChainIndexingStatusSnapshotQueued | ChainIndexingStatusSnapshotBackfill | ChainIndexingStatusSnapshotFollowing | ChainIndexingStatusSnapshotCompleted;
+type EnsIndexerIndexingStatusResponse = EnsIndexerIndexingStatusResponseOk | EnsIndexerIndexingStatusResponseError;
+
 /**
- * Get the timestamp of the lowest `config.startBlock` across all chains
- * in the provided array of {@link ChainIndexingStatusSnapshot}.
- *
- * Such timestamp is useful when presenting the "lowest" block
- * to be indexed across all chains.
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshotUnstarted}
  */
-declare function getTimestampForLowestOmnichainStartBlock(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
+interface SerializedOmnichainIndexingStatusSnapshotUnstarted extends Omit<OmnichainIndexingStatusSnapshotUnstarted, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatusSnapshotQueued>;
+}
 /**
- * Get the timestamp of the "highest known block" across all chains
- * in the provided array of {@link ChainIndexingStatusSnapshot}.
- *
- * Such timestamp is useful when presenting the "highest known block"
- * to be indexed across all chains.
- *
- * The "highest known block" for a chain depends on its status:
- * - `config.endBlock` for a "queued" chain (only if the config range type is `Bounded`),
- * - `backfillEndBlock` for a "backfill" chain,
- * - `latestIndexedBlock` for a "completed" chain,
- * - `latestKnownBlock` for a "following" chain.
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshotBackfill}
  */
-declare function getTimestampForHighestOmnichainKnownBlock(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
+interface SerializedOmnichainIndexingStatusSnapshotBackfill extends Omit<OmnichainIndexingStatusSnapshotBackfill, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill>;
+}
 /**
- * Sort a list of [{@link ChainId}, {@link ChainIndexingStatusSnapshot}] tuples
- * by the omnichain start block timestamp in ascending order.
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshotCompleted}
  */
-declare function sortChainStatusesByStartBlockAsc<ChainStatusType extends ChainIndexingStatusSnapshot>(chains: [ChainId, ChainStatusType][]): [ChainId, ChainStatusType][];
-
+interface SerializedOmnichainIndexingStatusSnapshotCompleted extends Omit<OmnichainIndexingStatusSnapshotCompleted, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatusSnapshotCompleted>;
+}
 /**
- * The status of omnichain indexing at the time an omnichain indexing status
- * snapshot is captured.
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshotFollowing}
  */
-declare const OmnichainIndexingStatusIds: {
-    /**
-     * Represents that omnichain indexing is not ready to begin yet because
-     * ENSIndexer is in its initialization phase and the data to build a "true"
-     * {@link OmnichainIndexingStatusSnapshot} is still being loaded.
-     */
-    readonly Unstarted: "omnichain-unstarted";
-    /**
-     * Represents that omnichain indexing is in an overall "backfill" status because
-     * - At least one indexed chain has a `chainStatus` of
-     *   {@link ChainIndexingStatusIds.Backfill}; and
-     * - No indexed chain has a `chainStatus` of {@link ChainIndexingStatusIds.Following}.
-     */
-    readonly Backfill: "omnichain-backfill";
-    /**
-     * Represents that omnichain indexing is in an overall "following" status because
-     * at least one indexed chain has a `chainStatus` of
-     * {@link ChainIndexingStatusIds.Following}.
-     */
-    readonly Following: "omnichain-following";
-    /**
-     * Represents that omnichain indexing has completed because all indexed chains have
-     * a `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
-     */
-    readonly Completed: "omnichain-completed";
-};
+interface SerializedOmnichainIndexingStatusSnapshotFollowing extends Omit<OmnichainIndexingStatusSnapshotFollowing, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatusSnapshot>;
+}
 /**
- * The derived string union of possible {@link OmnichainIndexingStatusIds}.
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshot}
  */
-type OmnichainIndexingStatusId = (typeof OmnichainIndexingStatusIds)[keyof typeof OmnichainIndexingStatusIds];
+type SerializedOmnichainIndexingStatusSnapshot = SerializedOmnichainIndexingStatusSnapshotUnstarted | SerializedOmnichainIndexingStatusSnapshotBackfill | SerializedOmnichainIndexingStatusSnapshotCompleted | SerializedOmnichainIndexingStatusSnapshotFollowing;
 /**
- * Omnichain indexing status snapshot when the overall `omnichainStatus` is
- * {@link OmnichainIndexingStatusIds.Unstarted}.
- *
- * Invariants:
- * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Unstarted}.
- * - `chains` is always a map to {@link ChainIndexingStatusSnapshotQueued} values exclusively.
- * - `omnichainIndexingCursor` is always < the `config.startBlock.timestamp` for all
- *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Queued}.
+ * Serialize a {@link OmnichainIndexingStatusSnapshot} object.
  */
-interface OmnichainIndexingStatusSnapshotUnstarted {
-    /**
-     * The status of omnichain indexing.
-     */
-    omnichainStatus: typeof OmnichainIndexingStatusIds.Unstarted;
-    /**
-     * The indexing status snapshot for each indexed chain.
-     */
-    chains: Map<ChainId, ChainIndexingStatusSnapshotQueued>;
-    /**
-     * The timestamp of omnichain indexing progress across all indexed chains.
-     */
-    omnichainIndexingCursor: UnixTimestamp;
+declare function serializeOmnichainIndexingStatusSnapshot(indexingStatus: OmnichainIndexingStatusSnapshot): SerializedOmnichainIndexingStatusSnapshot;
+
+/**
+ * Serialized representation of {@link CrossChainIndexingStatusSnapshotOmnichain}
+ */
+interface SerializedCrossChainIndexingStatusSnapshotOmnichain extends Omit<CrossChainIndexingStatusSnapshotOmnichain, "omnichainSnapshot"> {
+    omnichainSnapshot: SerializedOmnichainIndexingStatusSnapshot;
 }
 /**
- * The range of {@link ChainIndexingSnapshot} types allowed when the
- * overall omnichain indexing status is {@link OmnichainIndexingStatusIds.Backfill}.
- *
- * Note that this is all of the {@link ChainIndexingSnapshot} types with the exception
- * of {@link ChainIndexingStatusSnapshotFollowing}.
+ * Serialized representation of {@link CrossChainIndexingStatusSnapshot}
  */
-type ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill = ChainIndexingStatusSnapshotQueued | ChainIndexingStatusSnapshotBackfill | ChainIndexingStatusSnapshotCompleted;
+type SerializedCrossChainIndexingStatusSnapshot = SerializedCrossChainIndexingStatusSnapshotOmnichain;
+declare function serializeCrossChainIndexingStatusSnapshotOmnichain({ strategy, slowestChainIndexingCursor, snapshotTime, omnichainSnapshot, }: CrossChainIndexingStatusSnapshotOmnichain): SerializedCrossChainIndexingStatusSnapshotOmnichain;
+declare function serializeCrossChainIndexingStatusSnapshot(snapshot: CrossChainIndexingStatusSnapshot): SerializedCrossChainIndexingStatusSnapshot;
+
 /**
- * Omnichain indexing status snapshot when the `omnichainStatus` is
- * {@link OmnichainIndexingStatusIds.Backfill}.
- *
- * Invariants:
- * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Backfill}.
- * - `chains` is guaranteed to contain at least one chain with a `chainStatus` of
- *   {@link ChainIndexingStatusIds.Backfill}.
- * - `chains` is guaranteed to not to contain any chain with a `chainStatus` of
- *   {@link ChainIndexingStatusIds.Following}
- * - `omnichainIndexingCursor` is always < the `config.startBlock.timestamp` for all
- *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Queued}.
- * - `omnichainIndexingCursor` is always <= the `backfillEndBlock.timestamp` for all
- *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Backfill}.
- * - `omnichainIndexingCursor` is always >= the `latestIndexedBlock.timestamp` for all
- *    chains with `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
- * - `omnichainIndexingCursor` is always equal to the timestamp of the highest
- *   `latestIndexedBlock` across all chains that have started indexing
- *   (`chainStatus` is not {@link ChainIndexingStatusIds.Queued}).
+ * Serialized representation of {@link RealtimeIndexingStatusProjection}
  */
-interface OmnichainIndexingStatusSnapshotBackfill {
-    /**
-     * The status of omnichain indexing.
-     */
-    omnichainStatus: typeof OmnichainIndexingStatusIds.Backfill;
-    /**
-     * The indexing status snapshot for each indexed chain.
-     */
-    chains: Map<ChainId, ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill>;
-    /**
-     * The timestamp of omnichain indexing progress across all indexed chains.
-     */
-    omnichainIndexingCursor: UnixTimestamp;
+interface SerializedCurrentIndexingProjectionOmnichain extends Omit<RealtimeIndexingStatusProjection, "snapshot"> {
+    snapshot: SerializedOmnichainIndexingStatusSnapshot;
 }
 /**
- * Omnichain indexing status snapshot when the overall `omnichainStatus` is
- * {@link OmnichainIndexingStatusIds.Following}.
- *
- * Invariants:
- * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Following}.
- * - `chains` is guaranteed to contain at least one chain with a `status` of
- *   {@link ChainIndexingStatusIds.Following}.
- * - `omnichainIndexingCursor` is always < the `config.startBlock.timestamp` for all
- *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Queued}.
- * - `omnichainIndexingCursor` is always <= the `backfillEndBlock.timestamp` for all
- *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Backfill}.
- * - `omnichainIndexingCursor` is always >= the `latestIndexedBlock.timestamp` for all
- *    chains with `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
- * - `omnichainIndexingCursor` is always equal to the timestamp of the highest
- *   `latestIndexedBlock` across all chains that have started indexing
- *   (`chainStatus` is not {@link ChainIndexingStatusIds.Queued}).
+ * Serialized representation of {@link RealtimeIndexingStatusProjection}
  */
-interface OmnichainIndexingStatusSnapshotFollowing {
-    /**
-     * The status of omnichain indexing.
-     */
-    omnichainStatus: typeof OmnichainIndexingStatusIds.Following;
-    /**
-     * The indexing status snapshot for each indexed chain.
-     */
-    chains: Map<ChainId, ChainIndexingStatusSnapshot>;
-    /**
-     * The timestamp of omnichain indexing progress across all indexed chains.
-     */
-    omnichainIndexingCursor: UnixTimestamp;
+interface SerializedRealtimeIndexingStatusProjection extends Omit<RealtimeIndexingStatusProjection, "snapshot"> {
+    snapshot: SerializedCrossChainIndexingStatusSnapshot;
 }
+declare function serializeRealtimeIndexingStatusProjection(indexingProjection: RealtimeIndexingStatusProjection): SerializedRealtimeIndexingStatusProjection;
+
 /**
- * Omnichain indexing status snapshot when the overall `omnichainStatus` is
- * {@link OmnichainIndexingStatusIds.Completed}.
- *
- * Invariants:
- * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Completed}.
- * - `chains` is always a map to {@link ChainIndexingStatusSnapshotCompleted} values exclusively.
- * - `omnichainIndexingCursor` is always equal to the highest
- *   `latestIndexedBlock.timestamp` for all chains.
+ * Serialized representation of {@link EnsIndexerIndexingStatusResponseError}.
  */
-interface OmnichainIndexingStatusSnapshotCompleted {
-    /**
-     * The status of omnichain indexing.
-     */
-    omnichainStatus: typeof OmnichainIndexingStatusIds.Completed;
-    /**
-     * The indexing status snapshot for each indexed chain.
-     */
-    chains: Map<ChainId, ChainIndexingStatusSnapshotCompleted>;
-    /**
-     * The timestamp of omnichain indexing progress across all indexed chains.
-     */
-    omnichainIndexingCursor: UnixTimestamp;
-}
+type SerializedEnsIndexerIndexingStatusResponseError = EnsIndexerIndexingStatusResponseError;
 /**
- * Omnichain indexing status snapshot for one or more chains.
- *
- * Use the `omnichainStatus` field to determine the specific type interpretation
- * at runtime.
+ * Serialized representation of {@link EnsIndexerIndexingStatusResponseOk}.
  */
-type OmnichainIndexingStatusSnapshot = OmnichainIndexingStatusSnapshotUnstarted | OmnichainIndexingStatusSnapshotBackfill | OmnichainIndexingStatusSnapshotCompleted | OmnichainIndexingStatusSnapshotFollowing;
+interface SerializedEnsIndexerIndexingStatusResponseOk extends Omit<EnsIndexerIndexingStatusResponseOk, "realtimeProjection"> {
+    realtimeProjection: SerializedRealtimeIndexingStatusProjection;
+}
 /**
- * Check if Chain Indexing Status Snapshots fit the 'unstarted' overall status
- * snapshot requirements:
- * - All chains are guaranteed to have a status of "queued".
- *
- * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
- * {@link ChainIndexingStatusSnapshotQueued}.
+ * Serialized representation of {@link EnsIndexerIndexingStatusResponse}.
  */
-declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotQueued[];
+type SerializedEnsIndexerIndexingStatusResponse = SerializedEnsIndexerIndexingStatusResponseOk | SerializedEnsIndexerIndexingStatusResponseError;
+
 /**
- * Check if Chain Indexing Status Snapshots fit the 'backfill' overall status
- * snapshot requirements:
- * - At least one chain is guaranteed to be in the "backfill" status.
- * - Each chain is guaranteed to have a status of either "queued",
- *   "backfill" or "completed".
- *
- * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
- * {@link ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill}.
+ * Deserialize a {@link EnsIndexerIndexingStatusResponse} object.
  */
-declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill[];
+declare function deserializeEnsIndexerIndexingStatusResponse(maybeResponse: Unvalidated<SerializedEnsIndexerIndexingStatusResponse>): EnsIndexerIndexingStatusResponse;
+
 /**
- * Checks if Chain Indexing Status Snapshots fit the 'completed' overall status
- * snapshot requirements:
- * - All chains are guaranteed to have a status of "completed".
- *
- * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
- * {@link ChainIndexingStatusSnapshotCompleted}.
+ * Represents a request to ENSIndexer Indexing Status API.
  */
-declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotCompleted[];
+type EnsIndexerIndexingStatusRequest = {};
+
+declare function serializeEnsIndexerIndexingStatusResponse(response: EnsIndexerIndexingStatusResponse): SerializedEnsIndexerIndexingStatusResponse;
+
 /**
- * Checks Chain Indexing Status Snapshots fit the 'following' overall status
- * snapshot requirements:
- * - At least one chain is guaranteed to be in the "following" status.
- * - Any other chain can have any status.
+ * Configuration options for ENSIndexer API client
  */
-declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains: ChainIndexingStatusSnapshot[]): boolean;
+interface EnsIndexerClientOptions {
+    /** The ENSIndexer API URL */
+    url: URL;
+}
 /**
- * Get {@link OmnichainIndexingStatusId} based on indexed chains' statuses.
+ * ENSIndexer API Client
  *
- * This function decides what is the `OmnichainIndexingStatusId` is,
- * based on provided chain indexing statuses.
+ * Provides access to the following ENSIndexer APIs:
+ * - Configuration API
+ * - Indexing Status API
  *
- * @throws an error if unable to determine overall indexing status
+ * @example
+ * ```typescript
+ * import { EnsIndexerClient } from "@ensnode/ensnode-sdk";
+ *
+ * // Custom configuration
+ * const client = new EnsIndexerClient({
+ *   url: new URL("https://my-ENSIndexer-instance.com"),
+ * });
+ * ```
  */
-declare function getOmnichainIndexingStatus(chains: ChainIndexingStatusSnapshot[]): OmnichainIndexingStatusId;
+declare class EnsIndexerClient {
+    private readonly options;
+    constructor(options: EnsIndexerClientOptions);
+    getOptions(): Readonly<EnsIndexerClientOptions>;
+    /**
+     * Fetch ENSIndexer Config
+     *
+     * Fetch the ENSIndexer's configuration.
+     *
+     * @returns {EnsIndexerConfigResponse}
+     *
+     * @throws if the ENSIndexer request fails
+     * @throws if the ENSIndexer returns a non-ok response
+     * @throws if the ENSIndexer response breaks required invariants
+     */
+    config(): Promise<EnsIndexerConfigResponse>;
+    /**
+     * Fetch ENSIndexer Indexing Status
+     *
+     * @returns {EnsIndexerIndexingStatusResponse}
+     *
+     * @throws if the ENSIndexer request fails
+     * @throws if the ENSIndexer returns a non-ok response
+     * @throws if the ENSIndexer response breaks required invariants
+     */
+    indexingStatus(): Promise<EnsIndexerIndexingStatusResponse>;
+}
+
+type EnsIndexerPublicConfigCompatibilityCheck = Omit<EnsIndexerPublicConfig, "ensIndexerSchemaName" | "ensRainbowPublicConfig" | "versionInfo">;
 /**
- * Get Omnichain Indexing Cursor
+ * Validate if `configB` is compatible with `configA`, such that `configA` equals to `configB`.
  *
- * The cursor tracks the "highest" latest indexed block timestamp across
- * all indexed chains. If all chains are queued, the cursor tracks the moment
- * just before the earliest start block timestamp across those chains.
+ * @throws error if configs are incompatible.
+ */
+declare function validateEnsIndexerPublicConfigCompatibility(configA: EnsIndexerPublicConfigCompatibilityCheck, configB: EnsIndexerPublicConfigCompatibilityCheck): void;
+
+/**
+ * Builds an unvalidated {@link EnsIndexerPublicConfig} object to be
+ * validated with {@link makeEnsIndexerPublicConfigSchema}.
  *
- * @throws an error if no chains are provided
+ * @param serializedPublicConfig - The serialized public config to build from.
+ * @return An unvalidated {@link EnsIndexerPublicConfig} object.
  */
-declare function getOmnichainIndexingCursor(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
+declare function buildUnvalidatedEnsIndexerPublicConfig(serializedPublicConfig: SerializedEnsIndexerPublicConfig): Unvalidated<EnsIndexerPublicConfig>;
 /**
- * Build an Omnichain Indexing Status Snapshot based on the indexing status snapshots of all indexed chains.
+ * Deserialize value into {@link EnsIndexerPublicConfig} object.
+ */
+declare function deserializeEnsIndexerPublicConfig(maybePublicConfig: Unvalidated<SerializedEnsIndexerPublicConfig>, valueLabel?: string): EnsIndexerPublicConfig;
+/**
+ * Deserialize object into a {@link EnsIndexerPublicConfig} object.
  *
- * @param chainStatusSnapshots - A map of chain IDs to their chain indexing status snapshots.
- * @returns The omnichain indexing status snapshot.
+ * @deprecated Use {@link deserializeEnsIndexerPublicConfig} instead.
  */
-declare function buildOmnichainIndexingStatusSnapshot(chainStatusSnapshots: Map<ChainId, ChainIndexingStatusSnapshot>): OmnichainIndexingStatusSnapshot;
+declare const deserializeENSIndexerPublicConfig: typeof deserializeEnsIndexerPublicConfig;
 
 /**
- * The strategy used for indexing one or more chains.
+ * Determines if the provided `config` results in indexing behavior compatible with the legacy ENS
+ * Subgraph.
  *
- * @see https://ponder.sh/docs/api-reference/ponder/config#parameters
+ * @see https://ensnode.io/docs/concepts/what-is-the-ens-subgraph
  */
-declare const CrossChainIndexingStrategyIds: {
-    /**
-     * Represents that the indexing of events across all indexed chains will
-     * proceed in a deterministic "omnichain" ordering by block timestamp, chain ID,
-     * and block number.
-     *
-     * This strategy is "deterministic" in that the order of processing cross-chain indexed
-     * events and each resulting indexed data state transition recorded in ENSDb is always
-     * the same for each ENSIndexer instance operating with an equivalent
-     * `ENSIndexerConfig` and ENSIndexer version. However it also has the drawbacks of:
-     * - increased indexing latency that must wait for the slowest indexed chain to
-     *   add new blocks or to discover new blocks through the configured RPCs.
-     * - if any indexed chain gets "stuck" due to chain or RPC failures, all indexed chains
-     *   will be affected.
-     */
-    readonly Omnichain: "omnichain";
-};
+declare function isSubgraphCompatible(config: Pick<EnsIndexerPublicConfig, "namespace" | "plugins" | "labelSet">): boolean;
+
 /**
- * The derived string union of possible {@link CrossChainIndexingStrategyIds}.
+ * Converts a Labelhash to bytes, with validation
+ * @param labelHash The Labelhash to convert
+ * @returns A ByteArray containing the bytes
+ * @throws Error if `labelHash` is not a valid 32-byte hex string
  */
-type CrossChainIndexingStrategyId = (typeof CrossChainIndexingStrategyIds)[keyof typeof CrossChainIndexingStrategyIds];
+declare function labelHashToBytes(labelHash: LabelHash): ByteArray;
+
 /**
- * Cross-chain indexing status snapshot when the `strategy` is
- * {@link CrossChainIndexingStrategyId.Omnichain}.
- *
- * Invariants:
- * - `strategy` is always {@link CrossChainIndexingStrategyId.Omnichain}.
- * - `slowestChainIndexingCursor` is always equal to
- *   `omnichainSnapshot.omnichainIndexingCursor`.
- * - `snapshotTime` is always >= the "highest known block timestamp", defined as the max of:
- *     - the `slowestChainIndexingCursor`.
- *     - the `config.startBlock.timestamp` for all indexed chains.
- *     - the `config.endBlock.timestamp` for all indexed chains with a `config.rangeType` of
- *       {@link RangeTypeIds.Bounded}.
- *     - the `backfillEndBlock.timestamp` for all chains with `chainStatus` of
- *       {@link ChainIndexingStatusIds.Backfill}.
- *     - the `latestKnownBlock.timestamp` for all chains with `chainStatus` of
- *       {@link ChainIndexingStatusIds.Following}.
+ * Builds a valid LabelSetId from a string.
+ * @param maybeLabelSetId - The string to validate and convert to a LabelSetId.
+ * @returns A valid LabelSetId.
+ * @throws If the input string is not a valid LabelSetId.
  */
-interface CrossChainIndexingStatusSnapshotOmnichain {
-    /**
-     * The strategy used for indexing one or more chains.
-     */
-    strategy: typeof CrossChainIndexingStrategyIds.Omnichain;
-    /**
-     * The timestamp of the "slowest" latest indexed block timestamp
-     * across all indexed chains.
-     */
-    slowestChainIndexingCursor: UnixTimestamp;
-    /**
-     * The timestamp when the cross-chain indexing status snapshot was generated.
-     *
-     * Due to possible clock skew between different systems this value must be set
-     * to the max of each of the following values to ensure all invariants are followed:
-     * - the current system time of the system generating this cross-chain indexing
-     *   status snapshot.
-     * - the "highest known block timestamp" (see invariants above for full definition).
-     */
-    snapshotTime: UnixTimestamp;
-    /**
-     * The omnichain indexing status snapshot for one or more chains.
-     */
-    omnichainSnapshot: OmnichainIndexingStatusSnapshot;
-}
+declare function buildLabelSetId(maybeLabelSetId: string): LabelSetId;
 /**
- * Cross-chain indexing status snapshot for one or more chains.
- *
- * Use the `strategy` field to determine the specific type interpretation
- * at runtime.
- *
- * Currently, only omnichain indexing is supported. This type could theoretically
- * be extended to support other cross-chain indexing strategies in the future,
- * such as Ponder's "multichain" indexing strategy that indexes each chain
- * independently without deterministic ordering.
+ * Builds a valid LabelSetVersion from a number or string.
+ * @param maybeLabelSetVersion - The number or string to validate and convert to a LabelSetVersion.
+ * @returns A valid LabelSetVersion.
+ * @throws If the input is not a valid LabelSetVersion.
  */
-type CrossChainIndexingStatusSnapshot = CrossChainIndexingStatusSnapshotOmnichain;
+declare function buildLabelSetVersion(maybeLabelSetVersion: number | string): LabelSetVersion;
 /**
- * Gets the latest indexed {@link BlockRef} for the given {@link ChainId}.
- *
- * @returns the latest indexed {@link BlockRef} for the given {@link ChainId}, or null if the chain
- *          isn't being indexed at all or is queued and therefore hasn't started indexing yet.
+ * Builds an EnsRainbowClientLabelSet.
+ * @param labelSetId - The label set ID.
+ * @param labelSetVersion - The label set version.
+ * @returns A valid EnsRainbowClientLabelSet object.
+ * @throws If `labelSetVersion` is defined without `labelSetId`.
  */
-declare function getLatestIndexedBlockRef(indexingStatus: CrossChainIndexingStatusSnapshot, chainId: ChainId): BlockRef | null;
+declare function buildEnsRainbowClientLabelSet(labelSetId?: LabelSetId, labelSetVersion?: LabelSetVersion): EnsRainbowClientLabelSet;
 /**
- * Get the "highest known block timestamp" from chain indexing status snapshots.
- *
- * Returns the maximum timestamp referenced anywhere in the provided chain snapshots,
- * across all of:
- * - `config.startBlock` timestamps for all chains
- * - `config.endBlock` timestamps for bounded chains
- * - `backfillEndBlock` timestamps for chains in backfill status
- * - `latestKnownBlock` timestamps for chains in following status
- *
- * This is used to enforce the invariant that `snapshotTime` must be >= all
- * referenced block timestamps. It differs from {@link getTimestampForHighestOmnichainKnownBlock},
- * which computes the highest "target" block timestamp for progress display and
- * does not include `startBlock` timestamps.
+ * Validates that the server's label set is compatible with the client's requested label set.
+ * @param serverSet - The label set provided by the server.
+ * @param clientSet - The label set requested by the client.
+ * @throws If the server set is not compatible with the client set.
+ */
+declare function validateSupportedLabelSetAndVersion(serverSet: EnsRainbowServerLabelSet, clientSet: EnsRainbowClientLabelSet): void;
+
+/**
+ * Parses a string into a non-negative integer.
+ * @param input The string to parse
+ * @returns The parsed non-negative integer
+ * @throws Error if the input is not a valid non-negative integer
+ */
+declare function parseNonNegativeInteger(maybeNumber: string): number;
+
+/**
+ * Serializes a {@link ChainConfig} object.
+ */
+declare function serializeIndexedChainIds(indexedChainIds: Set<ChainId>): SerializedIndexedChainIds;
+/**
+ * Serialize a {@link EnsIndexerPublicConfig} object.
+ */
+declare function serializeEnsIndexerPublicConfig(config: EnsIndexerPublicConfig): SerializedEnsIndexerPublicConfig;
+/**
+ * Serialize a {@link EnsIndexerPublicConfig} object.
  *
- * @throws Error if `chains` is empty.
+ * @deprecated Use {@link serializeEnsIndexerPublicConfig} instead.
  */
-declare function getHighestKnownBlockTimestamp(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
+declare const serializeENSIndexerPublicConfig: typeof serializeEnsIndexerPublicConfig;
+
 /**
- * Build a Cross-Chain Indexing Status Snapshot based on the omnichain indexing status snapshot.
+ * Validates an unvalidated representation of
+ * {@link EnsIndexerPublicConfig} object.
  *
- * @param omnichainSnapshot - The omnichain indexing status snapshot.
- * @param snapshotTime - The timestamp when the cross-chain indexing status snapshot was generated.
- *        Will be adjusted upward if necessary to satisfy the invariant that snapshotTime must
- *        be >= the highest known block timestamp (handles clock skew and future block timestamps).
- * @returns The cross-chain indexing status snapshot.
- * @throws if the generated snapshot does not satisfy the invariants defined
- *         in {@link CrossChainIndexingStatusSnapshotOmnichain}
+ * @throws Error if the provided object is not
+ *         a valid {@link EnsIndexerPublicConfig}.
  */
-declare function buildCrossChainIndexingStatusSnapshotOmnichain(omnichainSnapshot: OmnichainIndexingStatusSnapshot, snapshotTime: UnixTimestamp): CrossChainIndexingStatusSnapshotOmnichain;
+declare function validateEnsIndexerPublicConfig(unvalidatedConfig: Unvalidated<EnsIndexerPublicConfig>): EnsIndexerPublicConfig;
 
 /**
- * A "realtime" indexing status projection based on worst-case assumptions
- * from the `snapshot`.
+ * Validates an unvalidated representation of
+ * {@link EnsIndexerVersionInfo} object.
  *
- * Invariants:
- * - `projectedAt` is always >= `snapshot.snapshotTime`.
- * - `worstCaseDistance` is always equal to
- *   `projectedAt - snapshot.slowestChainIndexingCursor`.
+ * @throws Error if the provided object is not
+ *         a valid {@link EnsIndexerVersionInfo}.
  */
-type RealtimeIndexingStatusProjection = {
+declare function validateEnsIndexerVersionInfo(unvalidatedVersionInfo: Unvalidated<EnsIndexerVersionInfo>): EnsIndexerVersionInfo;
+
+/**
+ * Information about the stack of services inside an ENSNode instance.
+ */
+interface EnsNodeStackInfo {
     /**
-     * The timestamp representing "now" as of the time this projection was generated.
+     * ENSApi Public Config
      */
-    projectedAt: UnixTimestamp;
+    ensApi: EnsApiPublicConfig;
     /**
-     * The distance between `projectedAt` and `snapshot.slowestChainIndexingCursor`.
-     *
-     * This is "worst-case" because it assumes all of the following:
-     * - the `snapshot` (which may have `snapshot.snapshotTime < projectedAt`) is still the
-     *   latest snapshot and no indexing progress has been made since `snapshotTime`.
-     * - each indexed chain has added a new block as of `projectedAt`.
+     * ENSDb Public Config
      */
-    worstCaseDistance: Duration;
+    ensDb: EnsDbPublicConfig;
     /**
-     * The {@link CrossChainIndexingStatusSnapshot} that this projection is based on.
+     * ENSIndexer Public Config
      */
-    snapshot: CrossChainIndexingStatusSnapshot;
-};
+    ensIndexer: EnsIndexerPublicConfig;
+    /**
+     * ENSRainbow Public Config
+     *
+     * If undefined, represents that ENSRainbow is currently undergoing
+     * a cold start and may take up to an hour to become ready.
+     */
+    ensRainbow?: EnsRainbowPublicConfig;
+}
 /**
- * Create realtime indexing status projection from
- * a {@link CrossChainIndexingStatusSnapshot}.
+ * Build a complete {@link EnsNodeStackInfo} object from
+ * the given public configs of ENSApi and ENSDb.
  */
-declare function createRealtimeIndexingStatusProjection(snapshot: CrossChainIndexingStatusSnapshot, now: UnixTimestamp): RealtimeIndexingStatusProjection;
+declare function buildEnsNodeStackInfo(ensApiPublicConfig: EnsApiPublicConfig, ensDbPublicConfig: EnsDbPublicConfig): EnsNodeStackInfo;
 
 /**
  * A status code for indexing status responses.
@@ -1972,6 +1730,7 @@ type IndexingStatusResponseCode = EnsApiIndexingStatusResponseCode;
 type EnsApiIndexingStatusResponseOk = {
     responseCode: typeof EnsApiIndexingStatusResponseCodes.Ok;
     realtimeProjection: RealtimeIndexingStatusProjection;
+    stackInfo: EnsNodeStackInfo;
 };
 /**
  * An indexing status response when the indexing status is available.
@@ -2006,97 +1765,18 @@ type EnsApiIndexingStatusResponse = EnsApiIndexingStatusResponseOk | EnsApiIndex
 type IndexingStatusResponse = EnsApiIndexingStatusResponse;
 
 /**
- * Serialized representation of {@link ChainId}.
- **/
-type ChainIdString = string;
-/**
- * Datetime value following the ISO 8601 standard.
- *
- * @see https://www.iso.org/iso-8601-date-and-time-format.html
- */
-type DatetimeISO8601 = string;
-/**
- * Serialized representation of a {@link URL}.
- */
-type UrlString = string;
-/**
- * String representation of {@link AccountId}.
- *
- * Formatted as a fully lowercase CAIP-10 AccountId.
- *
- * @see https://chainagnostic.org/CAIPs/caip-10
- */
-type AccountIdString = string;
-/**
- * String representation of {@link AssetId}.
- *
- * Formatted as a fully lowercase CAIP-19 AssetId.
- *
- * @see https://chainagnostic.org/CAIPs/caip-19
- * @example "eip155:1/erc721:0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85/0xaf2caa1c2ca1d027f1ac823b529d0a67cd144264b2789fa2ea4d63a67c7103cc"
- *          for vitalik.eth in the eth base registrar on mainnet.
- */
-type AssetIdString = string;
-
-/**
- * Serialized representation of {@link OmnichainIndexingStatusSnapshotUnstarted}
- */
-interface SerializedOmnichainIndexingStatusSnapshotUnstarted extends Omit<OmnichainIndexingStatusSnapshotUnstarted, "chains"> {
-    chains: Record<ChainIdString, ChainIndexingStatusSnapshotQueued>;
-}
-/**
- * Serialized representation of {@link OmnichainIndexingStatusSnapshotBackfill}
- */
-interface SerializedOmnichainIndexingStatusSnapshotBackfill extends Omit<OmnichainIndexingStatusSnapshotBackfill, "chains"> {
-    chains: Record<ChainIdString, ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill>;
-}
-/**
- * Serialized representation of {@link OmnichainIndexingStatusSnapshotCompleted}
- */
-interface SerializedOmnichainIndexingStatusSnapshotCompleted extends Omit<OmnichainIndexingStatusSnapshotCompleted, "chains"> {
-    chains: Record<ChainIdString, ChainIndexingStatusSnapshotCompleted>;
-}
-/**
- * Serialized representation of {@link OmnichainIndexingStatusSnapshotFollowing}
- */
-interface SerializedOmnichainIndexingStatusSnapshotFollowing extends Omit<OmnichainIndexingStatusSnapshotFollowing, "chains"> {
-    chains: Record<ChainIdString, ChainIndexingStatusSnapshot>;
-}
-/**
- * Serialized representation of {@link OmnichainIndexingStatusSnapshot}
- */
-type SerializedOmnichainIndexingStatusSnapshot = SerializedOmnichainIndexingStatusSnapshotUnstarted | SerializedOmnichainIndexingStatusSnapshotBackfill | SerializedOmnichainIndexingStatusSnapshotCompleted | SerializedOmnichainIndexingStatusSnapshotFollowing;
-/**
- * Serialize a {@link OmnichainIndexingStatusSnapshot} object.
- */
-declare function serializeOmnichainIndexingStatusSnapshot(indexingStatus: OmnichainIndexingStatusSnapshot): SerializedOmnichainIndexingStatusSnapshot;
-
-/**
- * Serialized representation of {@link CrossChainIndexingStatusSnapshotOmnichain}
- */
-interface SerializedCrossChainIndexingStatusSnapshotOmnichain extends Omit<CrossChainIndexingStatusSnapshotOmnichain, "omnichainSnapshot"> {
-    omnichainSnapshot: SerializedOmnichainIndexingStatusSnapshot;
-}
-/**
- * Serialized representation of {@link CrossChainIndexingStatusSnapshot}
- */
-type SerializedCrossChainIndexingStatusSnapshot = SerializedCrossChainIndexingStatusSnapshotOmnichain;
-declare function serializeCrossChainIndexingStatusSnapshotOmnichain({ strategy, slowestChainIndexingCursor, snapshotTime, omnichainSnapshot, }: CrossChainIndexingStatusSnapshotOmnichain): SerializedCrossChainIndexingStatusSnapshotOmnichain;
-declare function serializeCrossChainIndexingStatusSnapshot(snapshot: CrossChainIndexingStatusSnapshot): SerializedCrossChainIndexingStatusSnapshot;
-
-/**
- * Serialized representation of {@link RealtimeIndexingStatusProjection}
+ * Serialized representation of {@link EnsNodeStackInfo}.
  */
-interface SerializedCurrentIndexingProjectionOmnichain extends Omit<RealtimeIndexingStatusProjection, "snapshot"> {
-    snapshot: SerializedOmnichainIndexingStatusSnapshot;
+interface SerializedEnsNodeStackInfo {
+    ensApi: SerializedEnsApiPublicConfig;
+    ensDb: SerializedEnsDbPublicConfig;
+    ensIndexer: SerializedEnsIndexerPublicConfig;
+    ensRainbow?: SerializedEnsRainbowPublicConfig;
 }
 /**
- * Serialized representation of {@link RealtimeIndexingStatusProjection}
+ * Serialize a {@link EnsNodeStackInfo} object.
  */
-interface SerializedRealtimeIndexingStatusProjection extends Omit<RealtimeIndexingStatusProjection, "snapshot"> {
-    snapshot: SerializedCrossChainIndexingStatusSnapshot;
-}
-declare function serializeRealtimeIndexingStatusProjection(indexingProjection: RealtimeIndexingStatusProjection): SerializedRealtimeIndexingStatusProjection;
+declare function serializeEnsNodeStackInfo(stackInfo: EnsNodeStackInfo): SerializedEnsNodeStackInfo;
 
 /**
  * Serialized representation of {@link EnsApiIndexingStatusResponseError}.
@@ -2111,8 +1791,9 @@ type SerializedIndexingStatusResponseError = SerializedEnsApiIndexingStatusRespo
 /**
  * Serialized representation of {@link EnsApiIndexingStatusResponseOk}.
  */
-interface SerializedEnsApiIndexingStatusResponseOk extends Omit<EnsApiIndexingStatusResponseOk, "realtimeProjection"> {
+interface SerializedEnsApiIndexingStatusResponseOk extends Omit<EnsApiIndexingStatusResponseOk, "realtimeProjection" | "stackInfo"> {
     realtimeProjection: SerializedRealtimeIndexingStatusProjection;
+    stackInfo: SerializedEnsNodeStackInfo;
 }
 /**
  * Serialized representation of {@link EnsApiIndexingStatusResponseOk}.
@@ -2134,6 +1815,8 @@ type SerializedIndexingStatusResponse = SerializedEnsApiIndexingStatusResponse;
 /**
  * Deserialize a {@link EnsApiIndexingStatusResponse} object.
  */
+declare function deserializeEnsApiIndexingStatusResponse(maybeResponse: Unvalidated<SerializedEnsApiIndexingStatusResponseOk>): EnsApiIndexingStatusResponseOk;
+declare function deserializeEnsApiIndexingStatusResponse(maybeResponse: Unvalidated<SerializedEnsApiIndexingStatusResponseError>): EnsApiIndexingStatusResponseError;
 declare function deserializeEnsApiIndexingStatusResponse(maybeResponse: Unvalidated<SerializedEnsApiIndexingStatusResponse>): EnsApiIndexingStatusResponse;
 /**
  * Deserialize a {@link EnsApiIndexingStatusResponse} object.
@@ -2535,7 +2218,7 @@ declare function getNameTokenOwnership(namespaceId: ENSNamespaceId, name: Interp
 /**
  * Schema for {@link ErrorResponse}.
  */
-declare const ErrorResponseSchema: z.ZodObject<{
+declare const makeErrorResponseSchema: () => z.ZodObject<{
     message: z.ZodString;
     details: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
@@ -2543,7 +2226,7 @@ declare const ErrorResponseSchema: z.ZodObject<{
 /**
  * API Error Response Type
  */
-type ErrorResponse = z.infer<typeof ErrorResponseSchema>;
+type ErrorResponse = z.infer<ReturnType<typeof makeErrorResponseSchema>>;
 
 /**
  * Deserialize a {@link ErrorResponse} object.
@@ -2746,7 +2429,8 @@ interface SerializedNameTokensResponseOk extends Omit<NameTokensResponseOk, "reg
 type SerializedNameTokensResponse = SerializedNameTokensResponseOk | SerializedNameTokensResponseError;
 
 declare function serializeRegisteredNameTokens({ domainId, name, tokens, expiresAt, accurateAsOf, }: RegisteredNameTokens): SerializedRegisteredNameTokens;
-declare function serializeNameTokensResponse(response: NameTokensResponse): SerializedNameTokensResponse;
+declare function serializeNameTokensResponse(response: NameTokensResponseOk): SerializedNameTokensResponseOk;
+declare function serializeNameTokensResponse<T extends NameTokensResponseError>(response: T): T;
 
 /**
  * Encoded Referrer
@@ -2785,21 +2469,21 @@ declare const EXPECTED_ENCODED_REFERRER_PADDING: Hex;
  */
 declare const ZERO_ENCODED_REFERRER: EncodedReferrer;
 /**
- * Build an {@link EncodedReferrer} value for the given {@link Address}
+ * Build an {@link EncodedReferrer} value for the given {@link NormalizedAddress}
  * according to the referrer encoding with left-zero-padding.
  */
-declare function buildEncodedReferrer(address: Address): EncodedReferrer;
+declare function buildEncodedReferrer(address: NormalizedAddress): EncodedReferrer;
 /**
- * Decode an {@link EncodedReferrer} value into a checksummed {@link Address}
+ * Decode an {@link EncodedReferrer} value into a {@link NormalizedAddress}
  * according to the referrer encoding with left-zero-padding.
  *
  * @param encodedReferrer - The "raw" {@link EncodedReferrer} value to decode.
- * @returns The decoded referrer checksummed address.
+ * @returns The decoded referrer address.
  * @throws when encodedReferrer value is not represented by
  *         {@link ENCODED_REFERRER_BYTE_LENGTH} bytes.
  * @throws when decodedReferrer is not a valid EVM address.
  */
-declare function decodeEncodedReferrer(encodedReferrer: EncodedReferrer): Address;
+declare function decodeEncodedReferrer(encodedReferrer: EncodedReferrer): NormalizedAddress;
 
 /**
  * Identifiers for supported currencies.
@@ -3406,11 +3090,11 @@ interface ResponsePageContextWithNoRecords extends Required<RequestPageParams> {
     /**
      * The start index of the records on the page (0-indexed)
      */
-    startIndex: undefined;
+    startIndex?: undefined;
     /**
      * The end index of the records on the page (0-indexed)
      */
-    endIndex: undefined;
+    endIndex?: undefined;
 }
 interface ResponsePageContextWithRecords extends Required<RequestPageParams> {
     /**
@@ -3498,15 +3182,11 @@ type RegistrarActionsResponseOk = {
      * The {@link UnixTimestamp} of when the data used to build the list of {@link NamedRegistrarAction} was accurate as of.
      *
      * @remarks
-     * **Note:** This value represents the `slowestChainIndexingCursor` from the latest omnichain indexing status
+     * **Note:** This value represents the `omnichainIndexingCursor` from the latest omnichain indexing status
      * snapshot captured by ENSApi. The state returned in the response is guaranteed to be accurate as of this
      * timestamp but may be from a timestamp higher than this value.
-     *
-     * **Temporary:** This field is currently optional to maintain backward compatibility with ENS Awards
-     * using older snapshot NPM packages. This will be changed to required in a future release.
-     * See: https://github.com/namehash/ensnode/issues/1497
      */
-    accurateAsOf?: UnixTimestamp;
+    accurateAsOf: UnixTimestamp;
 };
 /**
  * A response when Registrar Actions are unavailable.
@@ -3663,7 +3343,8 @@ declare function hasRegistrarActionsConfigSupport(config: EnsIndexerPublicConfig
 declare function hasRegistrarActionsIndexingStatusSupport(omnichainIndexingStatusId: OmnichainIndexingStatusId): PrerequisiteResult;
 
 declare function serializeNamedRegistrarAction({ action, name, }: NamedRegistrarAction): SerializedNamedRegistrarAction;
-declare function serializeRegistrarActionsResponse(response: RegistrarActionsResponse): SerializedRegistrarActionsResponse;
+declare function serializeRegistrarActionsResponse(response: RegistrarActionsResponseOk): SerializedRegistrarActionsResponseOk;
+declare function serializeRegistrarActionsResponse(response: RegistrarActionsResponseError): SerializedRegistrarActionsResponseError;
 
 /**
  * The resolution status for an `Identity`.
@@ -3855,6 +3536,31 @@ interface ResolverRecordsSelection {
      * Which keys to fetch text records for.
      */
     texts?: string[];
+    /**
+     * Whether to fetch the ENSIP-7 contenthash record.
+     */
+    contenthash?: boolean;
+    /**
+     * Whether to fetch the PubkeyResolver (x, y) pair.
+     */
+    pubkey?: boolean;
+    /**
+     * Which ABI content-type bitmask to fetch. The resolver returns the first stored ABI whose
+     * bit is present in the mask (lowest bit first).
+     */
+    abi?: ContentType;
+    /**
+     * Which ERC-165 interface implementers to fetch, keyed by InterfaceId.
+     */
+    interfaces?: InterfaceId[];
+    /**
+     * Whether to fetch the IDNSZoneResolver zonehash record.
+     */
+    dnszonehash?: boolean;
+    /**
+     * Whether to fetch the IVersionableResolver version.
+     */
+    version?: boolean;
 }
 declare const isSelectionEmpty: (selection: ResolverRecordsSelection) => boolean;
 
@@ -3883,6 +3589,41 @@ type ResolverRecordsResponseBase = {
      * Value is null if no record for the specified key is set.
      */
     texts: Record<string, string | null>;
+    /**
+     * The ENSIP-7 contenthash record raw bytes, or null if not set.
+     */
+    contenthash: Hex | null;
+    /**
+     * The PubkeyResolver (x, y) pair, or null if not set.
+     */
+    pubkey: {
+        x: Hex;
+        y: Hex;
+    } | null;
+    /**
+     * The first stored ABI matching the requested content-type bitmask, or null if no ABI is set
+     * for any matching content type.
+     */
+    abi: {
+        contentType: ContentType;
+        data: Hex;
+    } | null;
+    /**
+     * Interface implementers keyed by InterfaceId.
+     * Value is null if no implementer is set for the given InterfaceId.
+     */
+    interfaces: Record<InterfaceId, Address | null>;
+    /**
+     * The IDNSZoneResolver zonehash raw bytes, or null if not set.
+     */
+    dnszonehash: Hex | null;
+    /**
+     * The IVersionableResolver version. Null when we don't have a value — the resolver may not
+     * implement `IVersionableResolver` (RPC revert), or (on the accelerated path) no
+     * `VersionChanged` event has ever been seen for this node. `0n` is only returned when the
+     * resolver explicitly emitted `VersionChanged(node, 0)`.
+     */
+    version: RecordVersion | null;
 };
 /**
  * Represents the strongly-typed set of records based on the provided SELECTION
@@ -3906,7 +3647,7 @@ type ResolverRecordsResponseBase = {
  * ```
  */
 type ResolverRecordsResponse<T extends ResolverRecordsSelection = ResolverRecordsSelection> = {
-    [K in keyof T as T[K] extends true | any[] ? K : never]: K extends "addresses" ? Record<`${T["addresses"] extends readonly CoinType[] ? T["addresses"][number] : never}`, string | null> : K extends "texts" ? Record<T["texts"] extends readonly string[] ? T["texts"][number] : never, string | null> : ResolverRecordsResponseBase[K & keyof ResolverRecordsResponseBase];
+    [K in keyof T as T[K] extends true | readonly any[] | bigint ? K : never]: K extends "addresses" ? Record<`${T["addresses"] extends readonly CoinType[] ? T["addresses"][number] : never}`, string | null> : K extends "texts" ? Record<T["texts"] extends readonly string[] ? T["texts"][number] : never, string | null> : K extends "interfaces" ? Record<T["interfaces"] extends readonly InterfaceId[] ? T["interfaces"][number] : never, Address | null> : ResolverRecordsResponseBase[K & keyof ResolverRecordsResponseBase];
 };
 
 /**
@@ -4051,34 +3792,27 @@ interface ResolvePrimaryNamesResponse extends AcceleratableResponse, TraceableRe
 }
 
 /**
- * Configuration options for ENSNode API client
+ * Configuration options for an ENSNode client
  */
-interface EnsApiClientOptions {
-    /** The ENSNode API URL */
+interface EnsNodeClientOptions {
+    /** The ENSNode URL */
     url: URL;
 }
 /**
- * Configuration options for ENSNode API client
- *
- * @deprecated Use {@link EnsApiClientOptions} instead.
- */
-type ClientOptions = EnsApiClientOptions;
-/**
- * EnsApi Client
+ * ENSNode Client
  *
  * Provides access to the following ENSNode APIs:
  * - Resolution API
- * - Configuration API
  * - Indexing Status API
  * - Registrar Actions API
  * - Name Tokens API
  *
  * @example
  * ```typescript
- * import { EnsApiClient } from "@ensnode/ensnode-sdk";
+ * import { EnsNodeClient } from "@ensnode/ensnode-sdk";
  *
  * // Create client with default options
- * const client = new EnsApiClient();
+ * const client = new EnsNodeClient();
  *
  * // Use resolution methods
  * const { records } = await client.resolveRecords("jesse.base.eth", {
@@ -4089,39 +3823,39 @@ type ClientOptions = EnsApiClientOptions;
  *
  * @example
  * ```typescript
- * import { ENSNamespaceIds, EnsApiClient, getDefaultEnsNodeUrl } from "@ensnode/ensnode-sdk";
+ * import { ENSNamespaceIds, EnsNodeClient, getDefaultEnsNodeUrl } from "@ensnode/ensnode-sdk";
  *
- * // Use default ENSNode API URL for Mainnet
- * const client = new EnsApiClient({
+ * // Use default ENSNode URL for Mainnet
+ * const client = new EnsNodeClient({
  *   url: getDefaultEnsNodeUrl(ENSNamespaceIds.Mainnet),
  * });
  * ```
  *
  * @example
  * ```typescript
- * import { ENSNamespaceIds, EnsApiClient, getDefaultEnsNodeUrl } from "@ensnode/ensnode-sdk";
+ * import { ENSNamespaceIds, EnsNodeClient, getDefaultEnsNodeUrl } from "@ensnode/ensnode-sdk";
  *
- * // Use default ENSNode API URL for Sepolia
- * const client = new EnsApiClient({
+ * // Use default ENSNode URL for Sepolia
+ * const client = new EnsNodeClient({
  *   url: getDefaultEnsNodeUrl(ENSNamespaceIds.Sepolia),
  * });
  * ```
  *
  * @example
  * ```typescript
- * import { EnsApiClient } from "@ensnode/ensnode-sdk";
+ * import { EnsNodeClient } from "@ensnode/ensnode-sdk";
  *
  * // Custom configuration
- * const client = new EnsApiClient({
+ * const client = new EnsNodeClient({
  *   url: new URL("https://my-ensnode-instance.com"),
  * });
  * ```
  */
-declare class EnsApiClient {
+declare class EnsNodeClient {
     private readonly options;
-    static defaultOptions(): EnsApiClientOptions;
-    constructor(options?: Partial<EnsApiClientOptions>);
-    getOptions(): Readonly<EnsApiClientOptions>;
+    static defaultOptions(): EnsNodeClientOptions;
+    constructor(options?: Partial<EnsNodeClientOptions>);
+    getOptions(): Readonly<EnsNodeClientOptions>;
     /**
      * Resolves records for an ENS name (Forward Resolution).
      *
@@ -4239,19 +3973,7 @@ declare class EnsApiClient {
      */
     resolvePrimaryNames(address: ResolvePrimaryNamesRequest["address"], options?: Omit<ResolvePrimaryNamesRequest, "address">): Promise<ResolvePrimaryNamesResponse>;
     /**
-     * Fetch ENSApi Config
-     *
-     * Fetch the ENSApi's configuration.
-     *
-     * @returns {EnsApiConfigResponse}
-     *
-     * @throws if the ENSApi request fails
-     * @throws if the ENSApi returns a non-ok response
-     * @throws if the ENSApi response breaks required invariants
-     */
-    config(): Promise<EnsApiConfigResponse>;
-    /**
-     * Fetch ENSApi Indexing Status
+     * Fetch ENSApi Indexing Status
      *
      * @returns {EnsApiIndexingStatusResponse}
      *
@@ -4280,11 +4002,13 @@ declare class EnsApiClient {
      * ```ts
      * import {
      *   registrarActionsFilter,
-     *   EnsApiClient,
+     *   EnsNodeClient,
      * } from "@ensnode/ensnode-sdk";
-     * import { namehash } from "viem/ens";
+     * import { ETH_NODE, namehashInterpretedName, asInterpretedName } from "enssdk";
      *
-     * const client: EnsApiClient;
+     * const BASE_NODE = namehashInterpretedName(asInterpretedName("base.eth"));
+     *
+     * const client: EnsNodeClient;
      *
      * // Get first page with default page size (10 records)
      * const response = await client.registrarActions();
@@ -4295,494 +4019,116 @@ declare class EnsApiClient {
      *   console.log(`Accurate as of: ${response.accurateAsOf}`);
      * }
      *
-     * // Get second page with 25 records per page
-     * const response = await client.registrarActions({
-     *   page: 2,
-     *   recordsPerPage: 25,
-     * });
-     *
-     * // get latest registrar action records associated with
-     * // subregistry managing `eth` name
-     * await client.registrarActions({
-     *   filters: [registrarActionsFilter.byParentNode(namehash('eth'))],
-     * });
-     *
-     * // get latest registrar action records which include referral info
-     * await client.registrarActions({
-     *   filters: [registrarActionsFilter.withReferral(true)],
-     * });
-     *
-     * // get latest registrar action records for a specific decoded referrer
-     * await client.registrarActions({
-     *   filters: [registrarActionsFilter.byDecodedReferrer("0x1234567890123456789012345678901234567890")],
-     * });
-     *
-     * // get latest 10 registrar action records associated with
-     * // subregistry managing `base.eth` name
-     * await client.registrarActions({
-     *   filters: [registrarActionsFilter.byParentNode(namehash('base.eth'))],
-     *   recordsPerPage: 10
-     * });
-     *
-     * // get registrar actions within a specific time range
-     * const beginTimestamp = 1764547200; // Dec 1, 2025, 00:00:00 UTC
-     * const endTimestamp = 1767225600; // Jan 1, 2026, 00:00:00 UTC
-     * await client.registrarActions({
-     *   filters: [
-     *     registrarActionsFilter.beginTimestamp(beginTimestamp),
-     *     registrarActionsFilter.endTimestamp(endTimestamp),
-     *   ],
-     * });
-     *
-     * // get registrar actions from a specific timestamp onwards
-     * await client.registrarActions({
-     *   filters: [registrarActionsFilter.beginTimestamp(1764547200)],
-     * });
-     *
-     * // get registrar actions up to a specific timestamp
-     * await client.registrarActions({
-     *   filters: [registrarActionsFilter.endTimestamp(1767225600)],
-     * });
-     * ```
-     */
-    registrarActions(request?: RegistrarActionsRequest): Promise<RegistrarActionsResponse>;
-    /**
-     * Fetch Name Tokens for requested name.
-     *
-     * @param request.name - Name for which Name Tokens will be fetched.
-     * @returns {NameTokensResponse}
-     *
-     * @throws if the ENSNode request fails
-     * @throws if the ENSNode API returns an error response
-     * @throws if the ENSNode response breaks required invariants
-     *
-     * @example
-     * ```ts
-     * import {
-     *   EnsApiClient,
-     * } from "@ensnode/ensnode-sdk";
-     * import { namehash } from "viem/ens";
-     *
-     * const client: EnsApiClient;
-     *
-     * // get latest name token records from the indexed subregistry based on the requested name
-     * const response = await client.nameTokens({
-     *   name: "vitalik.eth"
-     * });
-     *
-     * const response = await client.nameTokens({
-     *   domainId: "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835" // namehash('vitalik.eth')
-     * })
-     * ```
-     */
-    nameTokens(request: NameTokensRequest): Promise<NameTokensResponse>;
-}
-/**
- * ENSNode Client
- *
- * @deprecated use {@link EnsApiClient} instead
- */
-declare class ENSNodeClient extends EnsApiClient {
-}
-
-declare class ClientError extends Error {
-    details?: unknown;
-    constructor(message: string, details?: unknown);
-    static fromErrorResponse({ message, details }: ErrorResponse): ClientError;
-}
-
-/**
- * Deserialize value into {@link EnsApiPublicConfig} object.
- */
-declare function deserializeEnsApiPublicConfig(maybePublicConfig: Unvalidated<SerializedEnsApiPublicConfig>, valueLabel?: string): EnsApiPublicConfig;
-/**
- * Deserialize a {@link EnsApiPublicConfig} object.
- *
- * @deprecated Use {@link deserializeEnsApiPublicConfig} instead.
- */
-declare const deserializeENSApiPublicConfig: typeof deserializeEnsApiPublicConfig;
-
-/**
- * Serialize a {@link EnsApiPublicConfig} object.
- */
-declare function serializeEnsApiPublicConfig(config: EnsApiPublicConfig): SerializedEnsApiPublicConfig;
-/**
- * Serialize a {@link EnsApiPublicConfig} object.
- *
- * @deprecated Use {@link serializeEnsApiPublicConfig} instead.
- */
-declare const serializeENSApiPublicConfig: typeof serializeEnsApiPublicConfig;
-
-/**
- * Create a Zod schema for validating ENSApiPublicConfig.
- *
- * @param valueLabel - Optional label for the value being validated (used in error messages)
- */
-declare function makeEnsApiPublicConfigSchema(valueLabel?: string): z.ZodObject<{
-    version: z.ZodString;
-    theGraphFallback: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        canFallback: z.ZodLiteral<true>;
-        url: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        canFallback: z.ZodLiteral<false>;
-        reason: z.ZodEnum<{
-            readonly NotSubgraphCompatible: "not-subgraph-compatible";
-            readonly NoApiKey: "no-api-key";
-            readonly NoSubgraphUrl: "no-subgraph-url";
-        }>;
-    }, z.core.$strict>], "canFallback">;
-    ensIndexerPublicConfig: z.ZodObject<{
-        databaseSchemaName: z.ZodString;
-        ensRainbowPublicConfig: z.ZodObject<{
-            version: z.ZodString;
-            labelSet: z.ZodObject<{
-                labelSetId: z.ZodString;
-                highestLabelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
-            }, z.core.$strip>;
-            recordsCount: z.ZodInt;
-        }, z.core.$strip>;
-        indexedChainIds: z.ZodSet<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
-        isSubgraphCompatible: z.ZodBoolean;
-        labelSet: z.ZodObject<{
-            labelSetId: z.ZodString;
-            labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
-        }, z.core.$strip>;
-        namespace: z.ZodEnum<{
-            readonly Mainnet: "mainnet";
-            readonly Sepolia: "sepolia";
-            readonly SepoliaV2: "sepolia-v2";
-            readonly EnsTestEnv: "ens-test-env";
-        }>;
-        plugins: z.ZodArray<z.ZodString>;
-        versionInfo: z.ZodObject<{
-            nodejs: z.ZodString;
-            ponder: z.ZodString;
-            ensDb: z.ZodString;
-            ensIndexer: z.ZodString;
-            ensNormalize: z.ZodString;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-/**
- * Create a Zod schema for validating a serialized ENSApiPublicConfig.
- *
- * @deprecated Use {@link makeEnsApiPublicConfigSchema} instead.
- */
-declare const makeENSApiPublicConfigSchema: typeof makeEnsApiPublicConfigSchema;
-declare function makeSerializedEnsApiPublicConfigSchema(valueLabel?: string): z.ZodObject<{
-    version: z.ZodString;
-    theGraphFallback: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        canFallback: z.ZodLiteral<true>;
-        url: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        canFallback: z.ZodLiteral<false>;
-        reason: z.ZodEnum<{
-            readonly NotSubgraphCompatible: "not-subgraph-compatible";
-            readonly NoApiKey: "no-api-key";
-            readonly NoSubgraphUrl: "no-subgraph-url";
-        }>;
-    }, z.core.$strict>], "canFallback">;
-    ensIndexerPublicConfig: z.ZodObject<{
-        databaseSchemaName: z.ZodString;
-        ensRainbowPublicConfig: z.ZodObject<{
-            version: z.ZodString;
-            labelSet: z.ZodObject<{
-                labelSetId: z.ZodString;
-                highestLabelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
-            }, z.core.$strip>;
-            recordsCount: z.ZodInt;
-        }, z.core.$strip>;
-        indexedChainIds: z.ZodArray<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
-        isSubgraphCompatible: z.ZodBoolean;
-        labelSet: z.ZodObject<{
-            labelSetId: z.ZodString;
-            labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
-        }, z.core.$strip>;
-        namespace: z.ZodEnum<{
-            readonly Mainnet: "mainnet";
-            readonly Sepolia: "sepolia";
-            readonly SepoliaV2: "sepolia-v2";
-            readonly EnsTestEnv: "ens-test-env";
-        }>;
-        plugins: z.ZodArray<z.ZodString>;
-        versionInfo: z.ZodObject<{
-            nodejs: z.ZodString;
-            ponder: z.ZodString;
-            ensDb: z.ZodString;
-            ensIndexer: z.ZodString;
-            ensNormalize: z.ZodString;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-
-/**
- * Default ENSNode API endpoint URL for Mainnet
- */
-declare const DEFAULT_ENSNODE_API_URL_MAINNET: "https://api.alpha.ensnode.io";
-/**
- * Default ENSNode API endpoint URL for Sepolia
- */
-declare const DEFAULT_ENSNODE_API_URL_SEPOLIA: "https://api.alpha-sepolia.ensnode.io";
-/**
- * Gets the default ENSNode URL for the provided ENSNamespaceId.
- *
- * @param namespace - Optional. The ENSNamespaceId to get the default ENSNode URL for. If not
- *                    provided, defaults to Mainnet.
- * @returns The default ENSNode URL for the provided ENSNamespaceId, or for Mainnet if no
- *          namespace is provided.
- * @throws If the provided ENSNamespaceId does not have a default ENSNode URL defined
- */
-declare const getDefaultEnsNodeUrl: (namespace?: ENSNamespaceId) => URL;
-
-/**
- * ENSIndexer Public Config Response
- */
-type EnsIndexerConfigResponse = EnsIndexerPublicConfig;
-
-type SerializedEnsIndexerConfigResponse = SerializedEnsIndexerPublicConfig;
-
-/**
- * Deserialize value into {@link EnsIndexerConfigResponse} object.
- */
-declare function deserializeEnsIndexerConfigResponse(maybeResponse: Unvalidated<SerializedEnsIndexerConfigResponse>): EnsIndexerConfigResponse;
-
-declare function serializeEnsIndexerConfigResponse(response: EnsIndexerConfigResponse): SerializedEnsIndexerConfigResponse;
-
-/**
- * A status code for ENSIndexer indexing status responses.
- */
-declare const EnsIndexerIndexingStatusResponseCodes: {
-    /**
-     * Represents that the indexing status is available.
-     */
-    readonly Ok: "ok";
-    /**
-     * Represents that the indexing status is unavailable.
-     */
-    readonly Error: "error";
-};
-/**
- * The derived string union of possible {@link EnsIndexerIndexingStatusResponseCodes}.
- */
-type EnsIndexerIndexingStatusResponseCode = (typeof EnsIndexerIndexingStatusResponseCodes)[keyof typeof EnsIndexerIndexingStatusResponseCodes];
-/**
- * An ENSIndexer indexing status response when the indexing status is available.
- */
-type EnsIndexerIndexingStatusResponseOk = {
-    responseCode: typeof EnsIndexerIndexingStatusResponseCodes.Ok;
-    realtimeProjection: RealtimeIndexingStatusProjection;
-};
-/**
- * An ENSIndexer indexing status response when the indexing status is unavailable.
- */
-type EnsIndexerIndexingStatusResponseError = {
-    responseCode: typeof EnsIndexerIndexingStatusResponseCodes.Error;
-};
-/**
- * ENSIndexer indexing status response.
- *
- * Use the `responseCode` field to determine the specific type interpretation
- * at runtime.
- */
-type EnsIndexerIndexingStatusResponse = EnsIndexerIndexingStatusResponseOk | EnsIndexerIndexingStatusResponseError;
-
-/**
- * Serialized representation of {@link EnsIndexerIndexingStatusResponseError}.
- */
-type SerializedEnsIndexerIndexingStatusResponseError = EnsIndexerIndexingStatusResponseError;
-/**
- * Serialized representation of {@link EnsIndexerIndexingStatusResponseOk}.
- */
-interface SerializedEnsIndexerIndexingStatusResponseOk extends Omit<EnsIndexerIndexingStatusResponseOk, "realtimeProjection"> {
-    realtimeProjection: SerializedRealtimeIndexingStatusProjection;
-}
-/**
- * Serialized representation of {@link EnsIndexerIndexingStatusResponse}.
- */
-type SerializedEnsIndexerIndexingStatusResponse = SerializedEnsIndexerIndexingStatusResponseOk | SerializedEnsIndexerIndexingStatusResponseError;
-
-/**
- * Deserialize a {@link EnsIndexerIndexingStatusResponse} object.
- */
-declare function deserializeEnsIndexerIndexingStatusResponse(maybeResponse: Unvalidated<SerializedEnsIndexerIndexingStatusResponse>): EnsIndexerIndexingStatusResponse;
-
-/**
- * Represents a request to ENSIndexer Indexing Status API.
- */
-type EnsIndexerIndexingStatusRequest = {};
-
-declare function serializeEnsIndexerIndexingStatusResponse(response: EnsIndexerIndexingStatusResponse): SerializedEnsIndexerIndexingStatusResponse;
-
-/**
- * Configuration options for ENSIndexer API client
- */
-interface EnsIndexerClientOptions {
-    /** The ENSIndexer API URL */
-    url: URL;
-}
-/**
- * ENSIndexer API Client
- *
- * Provides access to the following ENSIndexer APIs:
- * - Configuration API
- * - Indexing Status API
- *
- * @example
- * ```typescript
- * import { EnsIndexerClient } from "@ensnode/ensnode-sdk";
- *
- * // Custom configuration
- * const client = new EnsIndexerClient({
- *   url: new URL("https://my-ENSIndexer-instance.com"),
- * });
- * ```
- */
-declare class EnsIndexerClient {
-    private readonly options;
-    constructor(options: EnsIndexerClientOptions);
-    getOptions(): Readonly<EnsIndexerClientOptions>;
-    /**
-     * Fetch ENSIndexer Config
+     * // Get second page with 25 records per page
+     * const response = await client.registrarActions({
+     *   page: 2,
+     *   recordsPerPage: 25,
+     * });
      *
-     * Fetch the ENSIndexer's configuration.
+     * // get latest registrar action records associated with
+     * // subregistry managing `eth` name
+     * await client.registrarActions({
+     *   filters: [registrarActionsFilter.byParentNode(ETH_NODE)],
+     * });
      *
-     * @returns {EnsIndexerConfigResponse}
+     * // get latest registrar action records which include referral info
+     * await client.registrarActions({
+     *   filters: [registrarActionsFilter.withReferral(true)],
+     * });
      *
-     * @throws if the ENSIndexer request fails
-     * @throws if the ENSIndexer returns a non-ok response
-     * @throws if the ENSIndexer response breaks required invariants
+     * // get latest registrar action records for a specific decoded referrer
+     * await client.registrarActions({
+     *   filters: [registrarActionsFilter.byDecodedReferrer("0x1234567890123456789012345678901234567890")],
+     * });
+     *
+     * // get latest 10 registrar action records associated with
+     * // subregistry managing `base.eth` name
+     * await client.registrarActions({
+     *   filters: [registrarActionsFilter.byParentNode(BASE_NODE)],
+     *   recordsPerPage: 10
+     * });
+     *
+     * // get registrar actions within a specific time range
+     * const beginTimestamp = 1764547200; // Dec 1, 2025, 00:00:00 UTC
+     * const endTimestamp = 1767225600; // Jan 1, 2026, 00:00:00 UTC
+     * await client.registrarActions({
+     *   filters: [
+     *     registrarActionsFilter.beginTimestamp(beginTimestamp),
+     *     registrarActionsFilter.endTimestamp(endTimestamp),
+     *   ],
+     * });
+     *
+     * // get registrar actions from a specific timestamp onwards
+     * await client.registrarActions({
+     *   filters: [registrarActionsFilter.beginTimestamp(1764547200)],
+     * });
+     *
+     * // get registrar actions up to a specific timestamp
+     * await client.registrarActions({
+     *   filters: [registrarActionsFilter.endTimestamp(1767225600)],
+     * });
+     * ```
      */
-    config(): Promise<EnsIndexerConfigResponse>;
+    registrarActions(request?: RegistrarActionsRequest): Promise<RegistrarActionsResponse>;
     /**
-     * Fetch ENSIndexer Indexing Status
+     * Fetch Name Tokens for requested name.
      *
-     * @returns {EnsIndexerIndexingStatusResponse}
+     * @param request.name - Name for which Name Tokens will be fetched.
+     * @returns {NameTokensResponse}
      *
-     * @throws if the ENSIndexer request fails
-     * @throws if the ENSIndexer returns a non-ok response
-     * @throws if the ENSIndexer response breaks required invariants
+     * @throws if the ENSNode request fails
+     * @throws if the ENSNode API returns an error response
+     * @throws if the ENSNode response breaks required invariants
+     *
+     * @example
+     * ```ts
+     * import {
+     *   EnsNodeClient,
+     * } from "@ensnode/ensnode-sdk";
+     * import { namehashInterpretedName, asInterpretedName } from "enssdk";
+     *
+     * const VITALIK_NAME = asInterpretedName("vitalik.eth");
+     * const VITALIK_DOMAIN_ID = namehashInterpretedName(VITALIK_NAME);
+     *
+     * const client: EnsNodeClient;
+     *
+     * // get latest name token records from the indexed subregistry based on the requested name
+     * const response = await client.nameTokens({
+     *   name: VITALIK_NAME,
+     * });
+     *
+     * const response = await client.nameTokens({
+     *   domainId: VITALIK_DOMAIN_ID,
+     * })
+     * ```
      */
-    indexingStatus(): Promise<EnsIndexerIndexingStatusResponse>;
+    nameTokens(request: NameTokensRequest): Promise<NameTokensResponse>;
 }
 
-type EnsIndexerPublicConfigCompatibilityCheck = Omit<EnsIndexerPublicConfig, "databaseSchemaName" | "ensRainbowPublicConfig" | "versionInfo">;
-/**
- * Validate if `configB` is compatible with `configA`, such that `configA` equals to `configB`.
- *
- * @throws error if configs are incompatible.
- */
-declare function validateEnsIndexerPublicConfigCompatibility(configA: EnsIndexerPublicConfigCompatibilityCheck, configB: EnsIndexerPublicConfigCompatibilityCheck): void;
-
-/**
- * Builds an unvalidated {@link EnsIndexerPublicConfig} object to be
- * validated with {@link makeEnsIndexerPublicConfigSchema}.
- *
- * @param serializedPublicConfig - The serialized public config to build from.
- * @return An unvalidated {@link EnsIndexerPublicConfig} object.
- */
-declare function buildUnvalidatedEnsIndexerPublicConfig(serializedPublicConfig: SerializedEnsIndexerPublicConfig): Unvalidated<EnsIndexerPublicConfig>;
-/**
- * Deserialize value into {@link EnsIndexerPublicConfig} object.
- */
-declare function deserializeEnsIndexerPublicConfig(maybePublicConfig: Unvalidated<SerializedEnsIndexerPublicConfig>, valueLabel?: string): EnsIndexerPublicConfig;
-/**
- * Deserialize object into a {@link EnsIndexerPublicConfig} object.
- *
- * @deprecated Use {@link deserializeEnsIndexerPublicConfig} instead.
- */
-declare const deserializeENSIndexerPublicConfig: typeof deserializeEnsIndexerPublicConfig;
-
-/**
- * Determines if the provided `config` results in indexing behavior compatible with the legacy ENS
- * Subgraph.
- *
- * @see https://ensnode.io/docs/concepts/what-is-the-ens-subgraph
- */
-declare function isSubgraphCompatible(config: Pick<EnsIndexerPublicConfig, "namespace" | "plugins" | "labelSet">): boolean;
-
-/**
- * Converts a Labelhash to bytes, with validation
- * @param labelHash The Labelhash to convert
- * @returns A ByteArray containing the bytes
- * @throws Error if `labelHash` is not a valid 32-byte hex string
- */
-declare function labelHashToBytes(labelHash: LabelHash): ByteArray;
-
-/**
- * Builds a valid LabelSetId from a string.
- * @param maybeLabelSetId - The string to validate and convert to a LabelSetId.
- * @returns A valid LabelSetId.
- * @throws If the input string is not a valid LabelSetId.
- */
-declare function buildLabelSetId(maybeLabelSetId: string): LabelSetId;
-/**
- * Builds a valid LabelSetVersion from a number or string.
- * @param maybeLabelSetVersion - The number or string to validate and convert to a LabelSetVersion.
- * @returns A valid LabelSetVersion.
- * @throws If the input is not a valid LabelSetVersion.
- */
-declare function buildLabelSetVersion(maybeLabelSetVersion: number | string): LabelSetVersion;
-/**
- * Builds an EnsRainbowClientLabelSet.
- * @param labelSetId - The label set ID.
- * @param labelSetVersion - The label set version.
- * @returns A valid EnsRainbowClientLabelSet object.
- * @throws If `labelSetVersion` is defined without `labelSetId`.
- */
-declare function buildEnsRainbowClientLabelSet(labelSetId?: LabelSetId, labelSetVersion?: LabelSetVersion): EnsRainbowClientLabelSet;
-/**
- * Validates that the server's label set is compatible with the client's requested label set.
- * @param serverSet - The label set provided by the server.
- * @param clientSet - The label set requested by the client.
- * @throws If the server set is not compatible with the client set.
- */
-declare function validateSupportedLabelSetAndVersion(serverSet: EnsRainbowServerLabelSet, clientSet: EnsRainbowClientLabelSet): void;
-
-/**
- * Parses a string into a non-negative integer.
- * @param input The string to parse
- * @returns The parsed non-negative integer
- * @throws Error if the input is not a valid non-negative integer
- */
-declare function parseNonNegativeInteger(maybeNumber: string): number;
+declare class ClientError extends Error {
+    details?: unknown;
+    constructor(message: string, details?: unknown);
+    static fromErrorResponse({ message, details }: ErrorResponse): ClientError;
+}
 
 /**
- * Serializes a {@link ChainConfig} object.
- */
-declare function serializeIndexedChainIds(indexedChainIds: Set<ChainId>): SerializedIndexedChainIds;
-/**
- * Serialize a {@link EnsIndexerPublicConfig} object.
- */
-declare function serializeEnsIndexerPublicConfig(config: EnsIndexerPublicConfig): SerializedEnsIndexerPublicConfig;
-/**
- * Serialize a {@link EnsIndexerPublicConfig} object.
- *
- * @deprecated Use {@link serializeEnsIndexerPublicConfig} instead.
+ * Default ENSNode URL for Mainnet
  */
-declare const serializeENSIndexerPublicConfig: typeof serializeEnsIndexerPublicConfig;
-
+declare const DEFAULT_ENSNODE_URL_MAINNET: "https://api.alpha.ensnode.io";
 /**
- * Validates an unvalidated representation of
- * {@link EnsIndexerPublicConfig} object.
- *
- * @throws Error if the provided object is not
- *         a valid {@link EnsIndexerPublicConfig}.
+ * Default ENSNode URL for Sepolia
  */
-declare function validateEnsIndexerPublicConfig(unvalidatedConfig: Unvalidated<EnsIndexerPublicConfig>): EnsIndexerPublicConfig;
-
+declare const DEFAULT_ENSNODE_URL_SEPOLIA: "https://api.alpha-sepolia.ensnode.io";
 /**
- * Validates an unvalidated representation of
- * {@link EnsIndexerVersionInfo} object.
+ * Gets the default ENSNode URL for the provided ENSNamespaceId.
  *
- * @throws Error if the provided object is not
- *         a valid {@link EnsIndexerVersionInfo}.
- */
-declare function validateEnsIndexerVersionInfo(unvalidatedVersionInfo: Unvalidated<EnsIndexerVersionInfo>): EnsIndexerVersionInfo;
-
-/**
- * Check if provided EnsIndexerPublicConfig supports the ENSNode GraphQL API.
+ * @param namespace - Optional. The ENSNamespaceId to get the default ENSNode URL for. If not
+ *                    provided, defaults to Mainnet.
+ * @returns The default ENSNode URL for the provided ENSNamespaceId, or for Mainnet if no
+ *          namespace is provided.
+ * @throws If the provided ENSNamespaceId does not have a default ENSNode URL defined
  */
-declare function hasGraphqlApiConfigSupport(config: EnsIndexerPublicConfig): PrerequisiteResult;
+declare const getDefaultEnsNodeUrl: (namespace?: ENSNamespaceId) => URL;
 
 /**
  * Serialized representation of {@link ChainIndexingStatusSnapshot}
@@ -4881,6 +4227,11 @@ declare function validateOmnichainIndexingStatusSnapshot(unvalidatedSnapshot: Un
  */
 declare function validateRealtimeIndexingStatusProjection(unvalidatedProjection: Unvalidated<RealtimeIndexingStatusProjection>, valueLabel?: string): RealtimeIndexingStatusProjection;
 
+/**
+ * Check if provided EnsIndexerPublicConfig supports the ENSNode Omnigraph API.
+ */
+declare function hasOmnigraphApiConfigSupport(config: EnsIndexerPublicConfig): PrerequisiteResult;
+
 /**
  * Gets the SubregistryId (an AccountId) of the Basenames Subregistry contract (this is the
  * "BaseRegistrar" contract for Basenames) for the provided namespace.
@@ -4897,7 +4248,7 @@ declare function getBasenamesSubregistryId(namespace: ENSNamespaceId): AccountId
  * @returns registrar managed name
  * @throws an error when no registrar managed name could be returned
  */
-declare function getBasenamesSubregistryManagedName(namespaceId: ENSNamespaceId): Name;
+declare function getBasenamesSubregistryManagedName(namespaceId: ENSNamespaceId): InterpretedName;
 
 /**
  * Gets the SubregistryId (an AccountId) of the Ethnames Subregistry contract (this is the
@@ -4914,7 +4265,7 @@ declare function getEthnamesSubregistryId(namespace: ENSNamespaceId): AccountId;
  * @param namespaceId
  * @returns registrar managed name
  */
-declare function getEthnamesSubregistryManagedName(namespaceId: ENSNamespaceId): Name;
+declare function getEthnamesSubregistryManagedName(namespaceId: ENSNamespaceId): InterpretedName;
 
 /**
  * Gets the SubregistryId (an AccountId) of the Lineanames Subregistry contract (this is the
@@ -4932,7 +4283,7 @@ declare function getLineanamesSubregistryId(namespace: ENSNamespaceId): AccountI
  * @returns registrar managed name
  * @throws an error when no registrar managed name could be returned
  */
-declare function getLineanamesSubregistryManagedName(namespaceId: ENSNamespaceId): Name;
+declare function getLineanamesSubregistryManagedName(namespaceId: ENSNamespaceId): InterpretedName;
 
 interface RegistrationExpiryInfo {
     expiry: bigint | null;
@@ -4958,14 +4309,6 @@ declare function isRegistrationInGracePeriod(info: RegistrationExpiryInfo, now:
  */
 declare const accountIdEqual: (a: AccountId, b: AccountId) => boolean;
 
-/**
- * Converts an EVM address to its lowercase representation.
- *
- * @param address - EVM address to convert.
- * @returns The lowercase representation of the EVM address.
- */
-declare function asLowerCaseAddress(address: Address): Address;
-
 /**
  * Cache that maps from string -> ValueType.
  */
@@ -5242,18 +4585,18 @@ declare const interpretAddress: (owner: Address) => `0x${string}` | null;
  * Interprets a name record value string and returns null if the value is interpreted as a deletion.
  *
  * The interpreted record value is either:
- * a) null, representing a non-existant or deletion of the record, or
- * b) a normalized, non-empty-string Name.
+ * a) null, representing a non-existent or deletion of the record, or
+ * b) an {@link InterpretedName}.
  *
  * @param value - The name record value string to interpret.
  * @returns The interpreted name string, or null if deleted.
  */
-declare function interpretNameRecordValue(value: string): NormalizedName | null;
+declare function interpretNameRecordValue(value: LiteralName): InterpretedName | null;
 /**
  * Interprets an address record value string and returns null if the value is interpreted as a deletion.
  *
  * The interpreted record value is either:
- * a) null, representing a non-existant or deletion of the record, or
+ * a) null, representing a non-existent or deletion of the record, or
  *   i. contains null bytes
  *   ii. empty string
  *   iii. empty hex (0x)
@@ -5284,7 +4627,7 @@ declare function interpretTextRecordKey(key: string): string | null;
  * Interprets a text record value string and returns null if the value is interpreted as a deletion.
  *
  * The interpreted record value is either:
- * a) null, representing a non-existant or deletion of the record, or
+ * a) null, representing a non-existent or deletion of the record, or
  *   i. contains null bytes
  *   ii. empty string
  * b) a text record value that
@@ -5296,125 +4639,22 @@ declare function interpretTextRecordKey(key: string): string | null;
 declare function interpretTextRecordValue(value: string): string | null;
 
 /**
- * Decodes a uint256-encoded-LabelHash (eg. from a tokenId) into a {@link LabelHash}.
- *
- * Remember that contracts that operate in the context of a Managed Name frequently store and operate
- * over _LabelHashes_ that represent a direct subname of a Managed Name. These contracts also frequently
- * implement ERC721 or ERC1155 to represent ownership of these Names. As such, to construct the
- * ERC721/ERC1155 tokenId, they may encode the direct subnames's LabelHash as a uint256.
- *
- * This is true for the ENSv1 BaseRegistrar, RegistrarControllers, as well as any
- * contracts forked from it (which includes Basenames' and Lineanames' implementations).
- *
- * So, in order to turn the tokenId into a LabelHash, we perform the opposite operation, decoding
- * from a uint256 into a Hex (of size 32) and cast it as our semantic {@link LabelHash} type.
- *
- * @see https://github.com/ensdomains/ens-contracts/blob/db613bc/contracts/ethregistrar/ETHRegistrarController.sol#L215
- * @see https://github.com/base/basenames/blob/1b5c1ad/src/L2/RegistrarController.sol#L488
- * @see https://github.com/Consensys/linea-ens/blob/3a4f02f/packages/linea-ens-contracts/contracts/ethregistrar/ETHRegistrarController.sol#L447
- */
-declare const interpretTokenIdAsLabelHash: (tokenId: bigint) => LabelHash;
-/**
- * Decodes a uint256-encoded-Node (eg. from a tokenId) into a {@link Node}.
- *
- * Contracts in the ENSv1 ecosystem frequently implement ERC721 or ERC1155 to represent
- * ownership of a Domain. As such, to construct the ERC721/ERC1155 tokenId, they may encode the
- * domain's {@link Node} as a uint256.
- *
- * This is true for the ENSv1 NameWrapper, as well as any contracts forked from it (which includes
- * Lineanames' implementation).
- *
- * So, in order to turn the tokenId into a Node, we perform the opposite operation, decoding
- * from a uint256 into a Hex (of size 32) and cast it as our semantic {@link Node} type.
- *
- * @see https://github.com/ensdomains/ens-contracts/blob/db613bc/contracts/wrapper/ERC1155Fuse.sol#L262
- */
-declare const interpretTokenIdAsNode: (tokenId: bigint) => Node;
-
-/**
- * Interprets a Literal Label, producing an Interpreted Label.
- *
- * @see https://ensnode.io/docs/reference/terminology#literal-label
- * @see https://ensnode.io/docs/reference/terminology#interpreted-label
- *
- * @param label - The Literal Label string to interpret
- * @returns The provided label if it is a normalized label, else the EncodedLabelHash of the label
- */
-declare function literalLabelToInterpretedLabel(label: LiteralLabel): InterpretedLabel;
-/**
- * Interprets an ordered list of Literal Labels, producing an Interpreted Name.
- *
- * Note that it's important that the Literal Labels are provided as an array, otherwise it's
- * impossible to differentiate between 'a.label.eth' being ['a.label', 'eth'] or ['a', 'label', 'eth'].
- *
- * Note that the input is an ordered list of _Literal_ Labels: in this context, any literal label
- * that is formatted as an Encoded LabelHash will NOT be interpreted as such. Instead it will be
- * interpreted into an Encoded LabelHash that encodes the literal labelhash of the Literal Label.
- *
- * @param labels An ordered list of 0 or more Literal Labels
- * @returns An InterpretedName
- */
-declare function literalLabelsToInterpretedName(labels: LiteralLabel[]): InterpretedName;
-/**
- * Joins the list of Interpreted Labels with '.' to form an Interpreted Name.
- *
- * @param labels An ordered list of 0 or more Interpreted Labels
- * @returns An InterpretedName
- */
-declare function interpretedLabelsToInterpretedName(labels: InterpretedLabel[]): InterpretedName;
-/**
- * Joins the list of Literal Labels with '.' to form a Literal Name.
- *
- * Note: LiteralLabel values may contain '.' characters, which will be preserved
- * in the resulting LiteralName. Therefore, the number of labels in the returned
- * LiteralName may be greater than the number of LiteralLabels in the input array.
- *
- * @param labels An ordered list of 0 or more Literal Labels
- * @returns An LiteralName
- */
-declare function literalLabelsToLiteralName(labels: LiteralLabel[]): LiteralName;
-/**
- * Converts an Interpreted Name into a list of Interpreted Labels.
- */
-declare function interpretedNameToInterpretedLabels(name: InterpretedName): InterpretedLabel[];
-declare function encodedLabelToLabelhash(label: string): LabelHash | null;
-declare function isInterpetedLabel(label: Label): label is InterpretedLabel;
-declare function isInterpretedName(name: Name): name is InterpretedName;
-/**
- * Converts InterpretedLabels into a LabelHashPath.
- */
-declare function interpretedLabelsToLabelHashPath(labels: InterpretedLabel[]): LabelHashPath;
-/**
- * Constructs a new InterpretedName from an InterpretedLabel (child) and InterpretedName (parent).
- *
- * If no parent is available the InterpretedLabel is cast to an InterpretedName and returned.
- *
- * @dev the following is safe due to InterpretedLabel/InterpretedName semantics, see above.
- */
-declare function constructSubInterpretedName(label: InterpretedLabel, name: InterpretedName | undefined): InterpretedName;
-/**
- * Given a `labelHash` and optionally its healed InterpretedLabel, return an InterpretedLabel.
+ * Interprets an ENSIP-7 contenthash value. Empty bytes are interpreted as deletion.
  */
-declare function ensureInterpretedLabel(labelHash: LabelHash, label: InterpretedLabel | undefined): InterpretedLabel;
+declare function interpretContenthashValue(value: Hex): Hex | null;
 /**
- * Parses a Partial InterpretedName into concrete InterpretedLabels and the partial Label.
+ * Interprets a PubkeyResolver (x, y) pair. A (zeroHash, zeroHash) pair is interpreted as deletion.
  *
- * @throws if the provided `partialInterpretedName` is not composed of concrete InterpretedLabels.
+ * Invariant: both null together, or both set together.
  */
-declare function parsePartialInterpretedName(partialInterpretedName: Name): {
-    concrete: InterpretedLabel[];
-    partial: string;
-};
-
+declare function interpretPubkeyValue(x: Hex, y: Hex): {
+    x: Hex;
+    y: Hex;
+} | null;
 /**
- * Implements the ENS `labelhash` function for Literal Labels.
- * @see https://docs.ens.domains/ensip/1
- *
- * @param label the Literal Label to hash
- * @returns the hash of the provided label
- * @dev This function is viem/ens#labelhash but without the special-case handling of Encoded LabelHashes.
+ * Interprets an IDNSZoneResolver zonehash value. Empty bytes are interpreted as deletion.
  */
-declare const labelhashLiteralLabel: (label: LiteralLabel) => LabelHash;
+declare function interpretDnszonehashValue(value: Hex): Hex | null;
 
 /**
  * A value that varies by ENS namespace, with a required default.
@@ -5498,7 +4738,7 @@ declare const getENSv2RootRegistry: (namespace: ENSNamespaceId) => AccountId;
  *
  * @throws if the ENSv2Root Datasource or the RootRegistry contract are not defined
  */
-declare const getENSv2RootRegistryId: (namespace: ENSNamespaceId) => RegistryId;
+declare const getENSv2RootRegistryId: (namespace: ENSNamespaceId) => enssdk.RegistryId;
 /**
  * Determines whether `contract` is the ENSv2 Root Registry in `namespace`.
  *
@@ -5518,7 +4758,7 @@ declare const maybeGetENSv2RootRegistry: (namespace: ENSNamespaceId) => AccountI
  *
  * TODO: remove this function and its usage after all namespaces define ENSv2Root
  */
-declare const maybeGetENSv2RootRegistryId: (namespace: ENSNamespaceId) => RegistryId | undefined;
+declare const maybeGetENSv2RootRegistryId: (namespace: ENSNamespaceId) => enssdk.RegistryId | undefined;
 
 /**
  * Serializes a {@link ChainId} value into its string representation.
@@ -5548,29 +4788,26 @@ declare function serializePriceUsdc(price: PriceUsdc): SerializedPriceUsdc;
  * Serializes a {@link PriceDai} object.
  */
 declare function serializePriceDai(price: PriceDai): SerializedPriceDai;
+
+declare function isHttpProtocol(url: URL): boolean;
+declare function isWebSocketProtocol(url: URL): boolean;
+
 /**
- * Format {@link AccountId} object as a string.
+ * Builds an unvalidated {@link EnsNodeStackInfo} object to be
+ * validated with {@link makeEnsNodeStackInfoSchema}.
  *
- * Formatted as a fully lowercase CAIP-10 AccountId.
- *
- * @see https://chainagnostic.org/CAIPs/caip-10
+ * @param serializedStackInfo - The serialized stack info to build from.
+ * @return An unvalidated {@link EnsNodeStackInfo} object.
  */
-declare function formatAccountId(accountId: AccountId): AccountIdString;
+declare function buildUnvalidatedEnsNodeStackInfo(serializedStackInfo: SerializedEnsNodeStackInfo): Unvalidated<EnsNodeStackInfo>;
 /**
- * Format {@link AssetId} object as a string.
- *
- * Formatted as a fully lowercase CAIP-19 AssetId.
- *
- * @see https://chainagnostic.org/CAIPs/caip-19
+ * Deserialize value into {@link EnsNodeStackInfo} object.
  */
-declare function formatAssetId({ assetNamespace, contract: { chainId, address }, tokenId, }: AssetId): AssetIdString;
-
-declare function isHttpProtocol(url: URL): boolean;
-declare function isWebSocketProtocol(url: URL): boolean;
+declare function deserializeEnsNodeStackInfo(maybeStackInfo: Unvalidated<SerializedEnsNodeStackInfo>, valueLabel?: string): EnsNodeStackInfo;
 
 /**
  * Check if provided EnsIndexerPublicConfig supports the Subgraph API.
  */
 declare function hasSubgraphApiConfigSupport(config: EnsIndexerPublicConfig): PrerequisiteResult;
 
-export { ADDR_REVERSE_NODE, ATTR_PROTOCOL_NAME, ATTR_PROTOCOL_STEP, ATTR_PROTOCOL_STEP_RESULT, type AcceleratableRequest, type AcceleratableResponse, type AccountId, type AccountIdString, type AssetId, type AssetIdString, type AssetNamespace, AssetNamespaces, BASENAMES_NODE, type BlockNumber, type BlockNumberRange, type BlockNumberRangeBounded, type BlockNumberRangeLeftBounded, type BlockNumberRangeRightBounded, type BlockNumberRangeUnbounded, type BlockNumberRangeWithStartBlock, type BlockRef, type BlockRefRange, type BlockRefRangeBounded, type BlockRefRangeLeftBounded, type BlockRefRangeRightBounded, type BlockRefRangeUnbounded, type BlockRefRangeWithStartBlock, type Cache, type CachedResult, type CanonicalId, type CanonicalPath, type ChainId, type ChainIdString, type ChainIndexingStatusId, ChainIndexingStatusIds, type ChainIndexingStatusSnapshot, type ChainIndexingStatusSnapshotBackfill, type ChainIndexingStatusSnapshotCompleted, type ChainIndexingStatusSnapshotFollowing, type ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill, type ChainIndexingStatusSnapshotQueued, ClientError, type ClientOptions, type ConfigResponse, type CrossChainIndexingStatusSnapshot, type CrossChainIndexingStatusSnapshotOmnichain, type CrossChainIndexingStrategyId, CrossChainIndexingStrategyIds, type CurrencyAmount, type CurrencyId, CurrencyIds, type CurrencyInfo, DEFAULT_ENSNODE_API_URL_MAINNET, DEFAULT_ENSNODE_API_URL_SEPOLIA, DEFAULT_EVM_CHAIN_ID, DEFAULT_EVM_COIN_TYPE, type DNSEncodedLiteralName, type DNSEncodedName, type DNSEncodedPartiallyInterpretedName, type Datetime, type DatetimeISO8601, type DeepPartial, type DefaultableChainId, type DomainAssetId, type DomainId, type Duration, ENCODED_REFERRER_BYTE_LENGTH, ENCODED_REFERRER_BYTE_OFFSET, type ENSApiPublicConfig, type ENSIndexerPublicConfig, type ENSIndexerVersionInfo, ENSNodeClient, ENS_ROOT, type ENSv1DomainId, type ENSv2DomainId, ETH_COIN_TYPE, ETH_NODE, EXPECTED_ENCODED_REFERRER_PADDING, type EncodedLabelHash, type EncodedReferrer, EnsApiClient, type EnsApiClientOptions, type EnsApiConfigResponse, type EnsApiIndexingStatusRequest, type EnsApiIndexingStatusResponse, type EnsApiIndexingStatusResponseCode, EnsApiIndexingStatusResponseCodes, type EnsApiIndexingStatusResponseError, type EnsApiIndexingStatusResponseOk, type EnsApiPublicConfig, EnsIndexerClient, type EnsIndexerClientOptions, type EnsIndexerConfigResponse, type EnsIndexerIndexingStatusRequest, type EnsIndexerIndexingStatusResponse, type EnsIndexerIndexingStatusResponseCode, EnsIndexerIndexingStatusResponseCodes, type EnsIndexerIndexingStatusResponseError, type EnsIndexerIndexingStatusResponseOk, type EnsIndexerPublicConfig, type EnsIndexerPublicConfigCompatibilityCheck, type EnsIndexerVersionInfo, type EnsRainbowClientLabelSet, type EnsRainbowPublicConfig, type EnsRainbowServerLabelSet, type ErrorResponse, type ForwardResolutionArgs, ForwardResolutionProtocolStep, type ForwardResolutionResult, type Identity, type IndexingStatusRequest, type IndexingStatusResponse, type IndexingStatusResponseCode, IndexingStatusResponseCodes, type IndexingStatusResponseError, type IndexingStatusResponseOk, type InterpretedLabel, type InterpretedName, LINEANAMES_NODE, type Label, type LabelHash, type LabelHashPath, type LabelSetId, type LabelSetVersion, type LiteralLabel, type LiteralName, LruCache, type MultichainPrimaryNameResolutionArgs, type MultichainPrimaryNameResolutionResult, type NFTMintStatus, NFTMintStatuses, type NFTTransferEventMetadata, type NFTTransferType, NFTTransferTypes, NODE_ANY, type Name, type NameToken, type NameTokenOwnership, type NameTokenOwnershipBurned, type NameTokenOwnershipFullyOnchain, type NameTokenOwnershipNameWrapper, type NameTokenOwnershipType, NameTokenOwnershipTypes, type NameTokenOwnershipUnknown, type NameTokensRequest, type NameTokensResponse, type NameTokensResponseCode, NameTokensResponseCodes, type NameTokensResponseError, type NameTokensResponseErrorCode, NameTokensResponseErrorCodes, type NameTokensResponseErrorEnsIndexerConfigUnsupported, type NameTokensResponseErrorIndexingStatusUnsupported, type NameTokensResponseErrorNameTokensNotIndexed, type NameTokensResponseOk, type NamedIdentity, type NamedRegistrarAction, type NamespaceSpecificValue, type Node, type NormalizedName, type OmnichainIndexingStatusId, OmnichainIndexingStatusIds, type OmnichainIndexingStatusSnapshot, type OmnichainIndexingStatusSnapshotBackfill, type OmnichainIndexingStatusSnapshotCompleted, type OmnichainIndexingStatusSnapshotFollowing, type OmnichainIndexingStatusSnapshotUnstarted, PROTOCOL_ATTRIBUTE_PREFIX, type PermissionsId, type PermissionsResourceId, type PermissionsUserId, PluginName, type PrerequisiteResult, type Price, type PriceDai, type PriceEth, type PriceUsdc, RECORDS_PER_PAGE_DEFAULT, RECORDS_PER_PAGE_MAX, ROOT_NODE, ROOT_RESOURCE, type RangeType, RangeTypeIds, type RealtimeIndexingStatusProjection, type RegisteredNameTokens, type RegistrarAction, type RegistrarActionEventId, type RegistrarActionPricing, type RegistrarActionPricingAvailable, type RegistrarActionPricingUnknown, type RegistrarActionReferral, type RegistrarActionReferralAvailable, type RegistrarActionReferralNotApplicable, type RegistrarActionType, RegistrarActionTypes, type RegistrarActionsFilter, type RegistrarActionsFilterBeginTimestamp, type RegistrarActionsFilterByDecodedReferrer, type RegistrarActionsFilterBySubregistryNode, type RegistrarActionsFilterEndTimestamp, type RegistrarActionsFilterType, RegistrarActionsFilterTypes, type RegistrarActionsFilterWithEncodedReferral, type RegistrarActionsOrder, RegistrarActionsOrders, type RegistrarActionsRequest, type RegistrarActionsResponse, type RegistrarActionsResponseCode, RegistrarActionsResponseCodes, type RegistrarActionsResponseError, type RegistrarActionsResponseOk, type RegistrationExpiryInfo, type RegistrationId, type RegistrationLifecycle, type RegistrationLifecycleStage, type RegistryId, type RenewalId, type RequestPageParams, type RequiredAndNotNull, type ResolutionStatusId, ResolutionStatusIds, type ResolvePrimaryNameRequest, type ResolvePrimaryNameResponse, type ResolvePrimaryNamesRequest, type ResolvePrimaryNamesResponse, type ResolveRecordsRequest, type ResolveRecordsResponse, type ResolvedIdentity, type ResolverId, type ResolverRecordsId, type ResolverRecordsResponse, type ResolverRecordsResponseBase, type ResolverRecordsSelection, type ResponsePageContext, type ResponsePageContextWithNoRecords, type ResponsePageContextWithRecords, type ReverseResolutionArgs, ReverseResolutionProtocolStep, type ReverseResolutionResult, type RpcUrl, SWRCache, type SWRCacheOptions, type SerializedAssetId, type SerializedChainIndexingStatusSnapshot, type SerializedChainIndexingStatusSnapshotBackfill, type SerializedChainIndexingStatusSnapshotCompleted, type SerializedChainIndexingStatusSnapshotFollowing, type SerializedChainIndexingStatusSnapshotQueued, type SerializedConfigResponse, type SerializedCrossChainIndexingStatusSnapshot, type SerializedCrossChainIndexingStatusSnapshotOmnichain, type SerializedCurrencyAmount, type SerializedCurrentIndexingProjectionOmnichain, type SerializedDomainAssetId, type SerializedENSApiPublicConfig, type SerializedENSIndexerPublicConfig, type SerializedENSIndexerVersionInfo, type SerializedEnsApiConfigResponse, type SerializedEnsApiIndexingStatusResponse, type SerializedEnsApiIndexingStatusResponseError, type SerializedEnsApiIndexingStatusResponseOk, type SerializedEnsApiPublicConfig, type SerializedEnsIndexerConfigResponse, type SerializedEnsIndexerIndexingStatusResponse, type SerializedEnsIndexerIndexingStatusResponseError, type SerializedEnsIndexerIndexingStatusResponseOk, type SerializedEnsIndexerPublicConfig, type SerializedEnsIndexerVersionInfo, type SerializedIndexedChainIds, type SerializedIndexingStatusResponse, type SerializedIndexingStatusResponseError, type SerializedIndexingStatusResponseOk, type SerializedNameToken, type SerializedNameTokensResponse, type SerializedNameTokensResponseError, type SerializedNameTokensResponseOk, type SerializedNamedRegistrarAction, type SerializedOmnichainIndexingStatusSnapshot, type SerializedOmnichainIndexingStatusSnapshotBackfill, type SerializedOmnichainIndexingStatusSnapshotCompleted, type SerializedOmnichainIndexingStatusSnapshotFollowing, type SerializedOmnichainIndexingStatusSnapshotUnstarted, type SerializedPrice, type SerializedPriceDai, type SerializedPriceEth, type SerializedPriceUsdc, type SerializedRealtimeIndexingStatusProjection, type SerializedRegisteredNameTokens, type SerializedRegistrarAction, type SerializedRegistrarActionPricing, type SerializedRegistrarActionPricingAvailable, type SerializedRegistrarActionPricingUnknown, type SerializedRegistrarActionsResponse, type SerializedRegistrarActionsResponseError, type SerializedRegistrarActionsResponseOk, type SerializedTokenId, type SubgraphInterpretedLabel, type SubgraphInterpretedName, type Subregistry, type TheGraphCannotFallbackReason, TheGraphCannotFallbackReasonSchema, type TheGraphFallback, TheGraphFallbackSchema, type TokenId, TraceableENSProtocol, type TraceableRequest, type TraceableResponse, type TracingNode, type TracingSpan, type TracingTrace, TtlCache, type UnixTimestamp, type UnknownIdentity, type UnnamedIdentity, type UnresolvedIdentity, type Unvalidated, type UrlString, ZERO_ENCODED_REFERRER, accountIdEqual, addDuration, addPrices, addrReverseLabel, asLowerCaseAddress, beautifyName, bigIntToNumber, bigintToCoinType, buildAssetId, buildBlockNumberRange, buildBlockRefRange, buildCrossChainIndexingStatusSnapshotOmnichain, buildEncodedReferrer, buildEnsRainbowClientLabelSet, buildIndexedBlockranges, buildLabelSetId, buildLabelSetVersion, buildOmnichainIndexingStatusSnapshot, buildPageContext, buildUnresolvedIdentity, buildUnvalidatedCrossChainIndexingStatusSnapshot, buildUnvalidatedEnsIndexerPublicConfig, buildUnvalidatedOmnichainIndexingStatusSnapshot, buildUnvalidatedRealtimeIndexingStatusProjection, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted, coinTypeReverseLabel, coinTypeToEvmChainId, constructSubInterpretedName, createRealtimeIndexingStatusProjection, decodeDNSEncodedLiteralName, decodeDNSEncodedName, decodeEncodedReferrer, deserializeAssetId, deserializeBlockNumber, deserializeBlockRef, deserializeChainId, deserializeChainIndexingStatusSnapshot, deserializeConfigResponse, deserializeCrossChainIndexingStatusSnapshot, deserializeDatetime, deserializeDuration, deserializeENSApiPublicConfig, deserializeENSIndexerPublicConfig, deserializeEnsApiConfigResponse, deserializeEnsApiIndexingStatusResponse, deserializeEnsApiPublicConfig, deserializeEnsIndexerConfigResponse, deserializeEnsIndexerIndexingStatusResponse, deserializeEnsIndexerPublicConfig, deserializeErrorResponse, deserializeIndexingStatusResponse, deserializeOmnichainIndexingStatusSnapshot, deserializePriceDai, deserializePriceEth, deserializePriceUsdc, deserializeRealtimeIndexingStatusProjection, deserializeRegistrarActionsResponse, deserializeUnixTimestamp, deserializeUrl, deserializedNameTokensResponse, durationBetween, encodeLabelHash, encodedLabelToLabelhash, ensureInterpretedLabel, evmChainIdToCoinType, formatAccountId, formatAssetId, formatNFTTransferEventMetadata, getBasenamesSubregistryId, getBasenamesSubregistryManagedName, getCanonicalId, getCurrencyInfo, getDatasourceContract, getDefaultEnsNodeUrl, getENSv1Registry, getENSv2RootRegistry, getENSv2RootRegistryId, getEthnamesSubregistryId, getEthnamesSubregistryManagedName, getHighestKnownBlockTimestamp, getLatestIndexedBlockRef, getLineanamesSubregistryId, getLineanamesSubregistryManagedName, getNFTTransferType, getNameHierarchy, getNameTokenOwnership, getNameWrapperAccounts, getNamespaceSpecificValue, getOmnichainIndexingCursor, getOmnichainIndexingStatus, getParentNameFQDN, getResolvePrimaryNameChainIdParam, getTimestampForHighestOmnichainKnownBlock, getTimestampForLowestOmnichainStartBlock, hasGraphqlApiConfigSupport, hasNullByte, hasRegistrarActionsConfigSupport, hasRegistrarActionsIndexingStatusSupport, hasSubgraphApiConfigSupport, interpretAddress, interpretAddressRecordValue, interpretNameRecordValue, interpretTextRecordKey, interpretTextRecordValue, interpretTokenIdAsLabelHash, interpretTokenIdAsNode, interpretedLabelsToInterpretedName, interpretedLabelsToLabelHashPath, interpretedNameToInterpretedLabels, isENSv1Registry, isENSv2RootRegistry, isEncodedLabelHash, isHttpProtocol, isInterpetedLabel, isInterpretedName, isLabelHash, isNormalizedLabel, isNormalizedName, isPccFuseSet, isPriceCurrencyEqual, isPriceEqual, isRegistrarActionPricingAvailable, isRegistrarActionReferralAvailable, isRegistrationExpired, isRegistrationFullyExpired, isRegistrationInGracePeriod, isResolvedIdentity, isSelectionEmpty, isSubgraphCompatible, isWebSocketProtocol, labelHashToBytes, labelhashLiteralLabel, literalLabelToInterpretedLabel, literalLabelsToInterpretedName, literalLabelsToLiteralName, makeContractMatcher, makeENSApiPublicConfigSchema, makeENSv1DomainId, makeENSv2DomainId, makeEnsApiPublicConfigSchema, makePermissionsId, makePermissionsResourceId, makePermissionsUserId, makeRegistrationId, makeRegistryId, makeRenewalId, makeResolverId, makeResolverRecordsId, makeSerializedEnsApiPublicConfigSchema, makeSubdomainNode, maybeGetDatasourceContract, maybeGetENSv2RootRegistry, maybeGetENSv2RootRegistryId, mergeBlockNumberRanges, nameTokensPrerequisites, parseAccountId, parseAssetId, parseDai, parseEncodedLabelHash, parseEth, parseLabelHash, parseLabelHashOrEncodedLabelHash, parseNonNegativeInteger, parsePartialInterpretedName, parseReverseName, parseTimestamp, parseUsdc, priceDai, priceEth, priceUsdc, registrarActionsFilter, reverseName, scaleBigintByNumber, scalePrice, serializeAssetId, serializeChainId, serializeChainIndexingSnapshots, serializeConfigResponse, serializeCrossChainIndexingStatusSnapshot, serializeCrossChainIndexingStatusSnapshotOmnichain, serializeDatetime, serializeDomainAssetId, serializeENSApiPublicConfig, serializeENSIndexerPublicConfig, serializeEnsApiConfigResponse, serializeEnsApiIndexingStatusResponse, serializeEnsApiPublicConfig, serializeEnsIndexerConfigResponse, serializeEnsIndexerIndexingStatusResponse, serializeEnsIndexerPublicConfig, serializeIndexedChainIds, serializeIndexingStatusResponse, serializeNameToken, serializeNameTokensResponse, serializeNamedRegistrarAction, serializeOmnichainIndexingStatusSnapshot, serializePrice, serializePriceDai, serializePriceEth, serializePriceUsdc, serializeRealtimeIndexingStatusProjection, serializeRegisteredNameTokens, serializeRegistrarAction, serializeRegistrarActionPricing, serializeRegistrarActionsResponse, serializeUrl, sortChainStatusesByStartBlockAsc, stripNullBytes, translateDefaultableChainIdToChainId, uint256ToHex32, uniq, validateChainIndexingStatusSnapshot, validateCrossChainIndexingStatusSnapshot, validateEnsIndexerPublicConfig, validateEnsIndexerPublicConfigCompatibility, validateEnsIndexerVersionInfo, validateOmnichainIndexingStatusSnapshot, validateRealtimeIndexingStatusProjection, validateSupportedLabelSetAndVersion };
+export { ATTR_PROTOCOL_NAME, ATTR_PROTOCOL_STEP, ATTR_PROTOCOL_STEP_RESULT, type AcceleratableRequest, type AcceleratableResponse, type BlockNumber, type BlockNumberRange, type BlockNumberRangeBounded, type BlockNumberRangeLeftBounded, type BlockNumberRangeRightBounded, type BlockNumberRangeUnbounded, type BlockNumberRangeWithStartBlock, type BlockRef, type BlockRefRange, type BlockRefRangeBounded, type BlockRefRangeLeftBounded, type BlockRefRangeRightBounded, type BlockRefRangeUnbounded, type BlockRefRangeWithStartBlock, type Cache, type CachedResult, type ChainIndexingStatusId, ChainIndexingStatusIds, type ChainIndexingStatusSnapshot, type ChainIndexingStatusSnapshotBackfill, type ChainIndexingStatusSnapshotCompleted, type ChainIndexingStatusSnapshotFollowing, type ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill, type ChainIndexingStatusSnapshotQueued, ClientError, type CrossChainIndexingStatusSnapshot, type CrossChainIndexingStatusSnapshotOmnichain, type CrossChainIndexingStrategyId, CrossChainIndexingStrategyIds, type CurrencyAmount, type CurrencyId, CurrencyIds, type CurrencyInfo, DEFAULT_ENSNODE_URL_MAINNET, DEFAULT_ENSNODE_URL_SEPOLIA, type Datetime, type DeepPartial, type DomainAssetId, ENCODED_REFERRER_BYTE_LENGTH, ENCODED_REFERRER_BYTE_OFFSET, type ENSApiPublicConfig, type ENSIndexerPublicConfig, type ENSIndexerVersionInfo, EXPECTED_ENCODED_REFERRER_PADDING, type EncodedReferrer, type EnsApiIndexingStatusRequest, type EnsApiIndexingStatusResponse, type EnsApiIndexingStatusResponseCode, EnsApiIndexingStatusResponseCodes, type EnsApiIndexingStatusResponseError, type EnsApiIndexingStatusResponseOk, type EnsApiPublicConfig, type EnsApiVersionInfo, type EnsDbPublicConfig, type EnsDbVersionInfo, EnsIndexerClient, type EnsIndexerClientOptions, type EnsIndexerConfigResponse, type EnsIndexerIndexingStatusRequest, type EnsIndexerIndexingStatusResponse, type EnsIndexerIndexingStatusResponseCode, EnsIndexerIndexingStatusResponseCodes, type EnsIndexerIndexingStatusResponseError, type EnsIndexerIndexingStatusResponseOk, type EnsIndexerPublicConfig, type EnsIndexerPublicConfigCompatibilityCheck, type EnsIndexerVersionInfo, EnsNodeClient, type EnsNodeClientOptions, type EnsNodeStackInfo, type EnsRainbowClientLabelSet, type EnsRainbowPublicConfig, type EnsRainbowServerLabelSet, type ErrorResponse, type ForwardResolutionArgs, ForwardResolutionProtocolStep, type ForwardResolutionResult, type Identity, type IndexingStatusRequest, type IndexingStatusResponse, type IndexingStatusResponseCode, IndexingStatusResponseCodes, type IndexingStatusResponseError, type IndexingStatusResponseOk, type LabelSetId, type LabelSetVersion, LruCache, type MultichainPrimaryNameResolutionArgs, type MultichainPrimaryNameResolutionResult, type NFTMintStatus, NFTMintStatuses, type NFTTransferEventMetadata, type NFTTransferType, NFTTransferTypes, type NameToken, type NameTokenOwnership, type NameTokenOwnershipBurned, type NameTokenOwnershipFullyOnchain, type NameTokenOwnershipNameWrapper, type NameTokenOwnershipType, NameTokenOwnershipTypes, type NameTokenOwnershipUnknown, type NameTokensRequest, type NameTokensResponse, type NameTokensResponseCode, NameTokensResponseCodes, type NameTokensResponseError, type NameTokensResponseErrorCode, NameTokensResponseErrorCodes, type NameTokensResponseErrorEnsIndexerConfigUnsupported, type NameTokensResponseErrorIndexingStatusUnsupported, type NameTokensResponseErrorNameTokensNotIndexed, type NameTokensResponseOk, type NamedIdentity, type NamedRegistrarAction, type NamespaceSpecificValue, type OmnichainIndexingStatusId, OmnichainIndexingStatusIds, type OmnichainIndexingStatusSnapshot, type OmnichainIndexingStatusSnapshotBackfill, type OmnichainIndexingStatusSnapshotCompleted, type OmnichainIndexingStatusSnapshotFollowing, type OmnichainIndexingStatusSnapshotUnstarted, PROTOCOL_ATTRIBUTE_PREFIX, PluginName, type PrerequisiteResult, type Price, type PriceDai, type PriceEth, type PriceUsdc, RECORDS_PER_PAGE_DEFAULT, RECORDS_PER_PAGE_MAX, type RangeType, RangeTypeIds, type RealtimeIndexingStatusProjection, type RegisteredNameTokens, type RegistrarAction, type RegistrarActionEventId, type RegistrarActionPricing, type RegistrarActionPricingAvailable, type RegistrarActionPricingUnknown, type RegistrarActionReferral, type RegistrarActionReferralAvailable, type RegistrarActionReferralNotApplicable, type RegistrarActionType, RegistrarActionTypes, type RegistrarActionsFilter, type RegistrarActionsFilterBeginTimestamp, type RegistrarActionsFilterByDecodedReferrer, type RegistrarActionsFilterBySubregistryNode, type RegistrarActionsFilterEndTimestamp, type RegistrarActionsFilterType, RegistrarActionsFilterTypes, type RegistrarActionsFilterWithEncodedReferral, type RegistrarActionsOrder, RegistrarActionsOrders, type RegistrarActionsRequest, type RegistrarActionsResponse, type RegistrarActionsResponseCode, RegistrarActionsResponseCodes, type RegistrarActionsResponseError, type RegistrarActionsResponseOk, type RegistrationExpiryInfo, type RegistrationLifecycle, type RegistrationLifecycleStage, type RequestPageParams, type RequiredAndNotNull, type ResolutionStatusId, ResolutionStatusIds, type ResolvePrimaryNameRequest, type ResolvePrimaryNameResponse, type ResolvePrimaryNamesRequest, type ResolvePrimaryNamesResponse, type ResolveRecordsRequest, type ResolveRecordsResponse, type ResolvedIdentity, type ResolverRecordsResponse, type ResolverRecordsResponseBase, type ResolverRecordsSelection, type ResponsePageContext, type ResponsePageContextWithNoRecords, type ResponsePageContextWithRecords, type ReverseResolutionArgs, ReverseResolutionProtocolStep, type ReverseResolutionResult, type RpcUrl, SWRCache, type SWRCacheOptions, type SerializedAssetId, type SerializedChainIndexingStatusSnapshot, type SerializedChainIndexingStatusSnapshotBackfill, type SerializedChainIndexingStatusSnapshotCompleted, type SerializedChainIndexingStatusSnapshotFollowing, type SerializedChainIndexingStatusSnapshotQueued, type SerializedCrossChainIndexingStatusSnapshot, type SerializedCrossChainIndexingStatusSnapshotOmnichain, type SerializedCurrencyAmount, type SerializedCurrentIndexingProjectionOmnichain, type SerializedDomainAssetId, type SerializedENSApiPublicConfig, type SerializedENSIndexerPublicConfig, type SerializedENSIndexerVersionInfo, type SerializedEnsApiIndexingStatusResponse, type SerializedEnsApiIndexingStatusResponseError, type SerializedEnsApiIndexingStatusResponseOk, type SerializedEnsApiPublicConfig, type SerializedEnsDbPublicConfig, type SerializedEnsIndexerConfigResponse, type SerializedEnsIndexerIndexingStatusResponse, type SerializedEnsIndexerIndexingStatusResponseError, type SerializedEnsIndexerIndexingStatusResponseOk, type SerializedEnsIndexerPublicConfig, type SerializedEnsIndexerVersionInfo, type SerializedEnsNodeStackInfo, type SerializedEnsRainbowPublicConfig, type SerializedIndexedChainIds, type SerializedIndexingStatusResponse, type SerializedIndexingStatusResponseError, type SerializedIndexingStatusResponseOk, type SerializedNameToken, type SerializedNameTokensResponse, type SerializedNameTokensResponseError, type SerializedNameTokensResponseOk, type SerializedNamedRegistrarAction, type SerializedOmnichainIndexingStatusSnapshot, type SerializedOmnichainIndexingStatusSnapshotBackfill, type SerializedOmnichainIndexingStatusSnapshotCompleted, type SerializedOmnichainIndexingStatusSnapshotFollowing, type SerializedOmnichainIndexingStatusSnapshotUnstarted, type SerializedPrice, type SerializedPriceDai, type SerializedPriceEth, type SerializedPriceUsdc, type SerializedRealtimeIndexingStatusProjection, type SerializedRegisteredNameTokens, type SerializedRegistrarAction, type SerializedRegistrarActionPricing, type SerializedRegistrarActionPricingAvailable, type SerializedRegistrarActionPricingUnknown, type SerializedRegistrarActionsResponse, type SerializedRegistrarActionsResponseError, type SerializedRegistrarActionsResponseOk, type SerializedTokenId, type Subregistry, type TheGraphCannotFallbackReason, TheGraphCannotFallbackReasonSchema, type TheGraphFallback, TheGraphFallbackSchema, TraceableENSProtocol, type TraceableRequest, type TraceableResponse, type TracingNode, type TracingSpan, type TracingTrace, TtlCache, type UnknownIdentity, type UnnamedIdentity, type UnresolvedIdentity, type Unvalidated, ZERO_ENCODED_REFERRER, accountIdEqual, addDuration, addPrices, bigIntToNumber, buildAssetId, buildBlockNumberRange, buildBlockRefRange, buildCrossChainIndexingStatusSnapshotOmnichain, buildEncodedReferrer, buildEnsNodeStackInfo, buildEnsRainbowClientLabelSet, buildIndexedBlockranges, buildLabelSetId, buildLabelSetVersion, buildOmnichainIndexingStatusSnapshot, buildPageContext, buildUnresolvedIdentity, buildUnvalidatedCrossChainIndexingStatusSnapshot, buildUnvalidatedEnsApiPublicConfig, buildUnvalidatedEnsIndexerPublicConfig, buildUnvalidatedEnsNodeStackInfo, buildUnvalidatedOmnichainIndexingStatusSnapshot, buildUnvalidatedRealtimeIndexingStatusProjection, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted, createRealtimeIndexingStatusProjection, decodeEncodedReferrer, deserializeAssetId, deserializeBlockNumber, deserializeBlockRef, deserializeChainId, deserializeChainIndexingStatusSnapshot, deserializeCrossChainIndexingStatusSnapshot, deserializeDatetime, deserializeDuration, deserializeENSApiPublicConfig, deserializeENSIndexerPublicConfig, deserializeEnsApiIndexingStatusResponse, deserializeEnsApiPublicConfig, deserializeEnsIndexerConfigResponse, deserializeEnsIndexerIndexingStatusResponse, deserializeEnsIndexerPublicConfig, deserializeEnsNodeStackInfo, deserializeErrorResponse, deserializeIndexingStatusResponse, deserializeOmnichainIndexingStatusSnapshot, deserializePriceDai, deserializePriceEth, deserializePriceUsdc, deserializeRealtimeIndexingStatusProjection, deserializeRegistrarActionsResponse, deserializeUnixTimestamp, deserializeUrl, deserializedNameTokensResponse, durationBetween, formatNFTTransferEventMetadata, getBasenamesSubregistryId, getBasenamesSubregistryManagedName, getCurrencyInfo, getDatasourceContract, getDefaultEnsNodeUrl, getENSv1Registry, getENSv2RootRegistry, getENSv2RootRegistryId, getEthnamesSubregistryId, getEthnamesSubregistryManagedName, getHighestKnownBlockTimestamp, getLatestIndexedBlockRef, getLineanamesSubregistryId, getLineanamesSubregistryManagedName, getNFTTransferType, getNameTokenOwnership, getNameWrapperAccounts, getNamespaceSpecificValue, getOmnichainIndexingCursor, getOmnichainIndexingStatus, getResolvePrimaryNameChainIdParam, getTimestampForHighestOmnichainKnownBlock, getTimestampForLowestOmnichainStartBlock, hasNullByte, hasOmnigraphApiConfigSupport, hasRegistrarActionsConfigSupport, hasRegistrarActionsIndexingStatusSupport, hasSubgraphApiConfigSupport, interpretAddress, interpretAddressRecordValue, interpretContenthashValue, interpretDnszonehashValue, interpretNameRecordValue, interpretPubkeyValue, interpretTextRecordKey, interpretTextRecordValue, isENSv1Registry, isENSv2RootRegistry, isHttpProtocol, isPccFuseSet, isPriceCurrencyEqual, isPriceEqual, isRegistrarActionPricingAvailable, isRegistrarActionReferralAvailable, isRegistrationExpired, isRegistrationFullyExpired, isRegistrationInGracePeriod, isResolvedIdentity, isSelectionEmpty, isSubgraphCompatible, isWebSocketProtocol, labelHashToBytes, makeContractMatcher, makeENSApiPublicConfigSchema, makeEnsApiPublicConfigSchema, makeSerializedEnsApiPublicConfigSchema, maybeGetDatasourceContract, maybeGetENSv2RootRegistry, maybeGetENSv2RootRegistryId, mergeBlockNumberRanges, nameTokensPrerequisites, parseAccountId, parseAssetId, parseDai, parseEth, parseNonNegativeInteger, parseTimestamp, parseUsdc, priceDai, priceEth, priceUsdc, registrarActionsFilter, scaleBigintByNumber, scalePrice, serializeAssetId, serializeChainId, serializeChainIndexingSnapshots, serializeCrossChainIndexingStatusSnapshot, serializeCrossChainIndexingStatusSnapshotOmnichain, serializeDatetime, serializeDomainAssetId, serializeENSApiPublicConfig, serializeENSIndexerPublicConfig, serializeEnsApiIndexingStatusResponse, serializeEnsApiPublicConfig, serializeEnsIndexerConfigResponse, serializeEnsIndexerIndexingStatusResponse, serializeEnsIndexerPublicConfig, serializeEnsNodeStackInfo, serializeIndexedChainIds, serializeIndexingStatusResponse, serializeNameToken, serializeNameTokensResponse, serializeNamedRegistrarAction, serializeOmnichainIndexingStatusSnapshot, serializePrice, serializePriceDai, serializePriceEth, serializePriceUsdc, serializeRealtimeIndexingStatusProjection, serializeRegisteredNameTokens, serializeRegistrarAction, serializeRegistrarActionPricing, serializeRegistrarActionsResponse, serializeUrl, sortChainStatusesByStartBlockAsc, stripNullBytes, translateDefaultableChainIdToChainId, uniq, validateChainIndexingStatusSnapshot, validateCrossChainIndexingStatusSnapshot, validateEnsIndexerPublicConfig, validateEnsIndexerPublicConfigCompatibility, validateEnsIndexerVersionInfo, validateOmnichainIndexingStatusSnapshot, validateRealtimeIndexingStatusProjection, validateSupportedLabelSetAndVersion };