@ensnode/ensnode-sdk 0.34.0 → 0.36.0

package/dist/index.d.ts

@@ -1,10 +1,8 @@
 import { Hex, Address, ByteArray } from 'viem';
-import * as _ensdomains_address_encoder from '@ensdomains/address-encoder';
 import { CoinType, EvmCoinType } from '@ensdomains/address-encoder';
 export { CoinType, EvmCoinType } from '@ensdomains/address-encoder';
 import { ENSNamespaceId } from '@ensnode/datasources';
-export { ENSNamespaceId, ENSNamespaceIds } from '@ensnode/datasources';
-import z from 'zod/v4';
+export { ENSNamespaceId, ENSNamespaceIds, getENSRootChainId } from '@ensnode/datasources';
 
 /**
  * A hash value that uniquely identifies a single ENS name.
@@ -14,47 +12,249 @@ import z from 'zod/v4';
  * ```
  * namehash("vitalik.eth") === "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835"
  * ```
- * @link https://docs.ens.domains/ensip/1#namehash-algorithm
+ * @see https://docs.ens.domains/ensip/1#namehash-algorithm
+ * @see https://ensnode.io/docs/reference/terminology#name-node-namehash
  */
 type Node = Hex;
 /**
- * A Name represents a human-readable ENS name.
+ * An ENS Name that may or may not be normalized.
  *
- * ex: vitalik.eth
+ * @example vitalik.eth
+ * @see https://ensnode.io/docs/reference/terminology#name-node-namehash
+ * @see https://docs.ens.domains/ensip/15
  */
 type Name = string;
+/**
+ * A Normalized Name is an ENS Name that is guaranteed to be normalized.
+ *
+ * @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
+ */
+type NormalizedName = Name & {
+    __brand: "NormalizedName";
+};
 /**
  * A LabelHash is the result of the labelhash function (which is just keccak256) on a Label.
  *
- * @link https://docs.ens.domains/terminology#labelhash
+ * @example
+ * ```
+ * labelhash('vitalik') === '0xaf2caa1c2ca1d027f1ac823b529d0a67cd144264b2789fa2ea4d63a67c7103cc'
+ * ```
+ *
+ * @see https://docs.ens.domains/terminology#labelhash
+ * @see https://ensnode.io/docs/reference/terminology#labels-labelhashes-labelhash-function
  */
 type LabelHash = Hex;
 /**
  * A Label is a single part of an ENS Name.
  *
- * @link https://docs.ens.domains/terminology#label
+ * @example vitalik
+ *
+ * @see https://docs.ens.domains/terminology#label
+ * @see https://ensnode.io/docs/reference/terminology#labels-labelhashes-labelhash-function
  */
 type Label = string;
 /**
- * An EncodedLabelHash is a specially formatted unnormalized Label that should be interpreted as a
- * LabelHash literal, particularly for use within an ENS Name.
+ * 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]
  *
- * @example [abcd]
- * @example [abcd].example.eth
+ * @see https://ensnode.io/docs/reference/terminology#encoded-labelhash
  */
 type EncodedLabelHash = `[${string}]`;
-
-declare const ROOT_NODE: Node;
-declare const ETH_NODE: `0x${string}`;
-declare const BASENAMES_NODE: `0x${string}`;
-declare const LINEANAMES_NODE: `0x${string}`;
 /**
- * A set of nodes whose children are used for reverse resolution.
+ * 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
+ */
+type LiteralLabel = Label & {
+    __brand: "LiteralLabel";
+};
+/**
+ * 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
+ */
+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";
+};
+/**
+ * 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.
+ *
+ * @see https://ensnode.io/docs/reference/terminology#interpreted-name
+ * @dev nominally typed to enforce usage & enhance codebase clarity
+ */
+type InterpretedName = Name & {
+    __brand: "InterpretedName";
+};
+/**
+ * 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.
+ *
+ * @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
+ */
+type SubgraphInterpretedName = Name & {
+    __brand: "SubgraphInterpretedName";
+};
+/**
+ * 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]
+ *
+ * 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!
+ *
+ * @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.
+ */
+type DNSEncodedName = Hex;
+/**
+ * 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
+ *
+ * @dev nominally typed to enforce usage & enhance codebase clarity
+ */
+type DNSEncodedLiteralName = DNSEncodedName & {
+    __brand: "DNSEncodedLiteralName";
+};
+/**
+ * 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
  *
- * Useful for identifying if a domain is used for reverse resolution.
- * See apps/ensindexer/src/handlers/Registry.ts for context.
+ * @dev nominally typed to enforce usage & enhance codebase clarity
  */
-declare const REVERSE_ROOT_NODES: Set<Node>;
+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;
 
 /**
  * Implements one step of the namehash algorithm, combining `labelHash` with `node` to produce
@@ -62,20 +262,6 @@ declare const REVERSE_ROOT_NODES: Set<Node>;
  * the actual concatenation) in order to improve readability (i.e. read as [labelHash].[node]).
  */
 declare const makeSubdomainNode: (labelHash: LabelHash, node: Node) => Node;
-/**
- * Attempt to heal the labelHash of an addr.reverse subname using an address that might be related to the subname.
- *
- * @throws if maybeReverseAddress is not a valid Address
- * @throws if labelHash is not a valid Labelhash
- *
- * @returns the original label if healed, otherwise null
- */
-declare const maybeHealLabelByReverseAddress: ({ maybeReverseAddress, labelHash, }: {
-    /** The address that is possibly associated with the addr.reverse subname */
-    maybeReverseAddress: Address;
-    /** The labelhash of the addr.reverse subname */
-    labelHash: LabelHash;
-}) => string | null;
 /**
  * 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
@@ -83,18 +269,14 @@ declare const maybeHealLabelByReverseAddress: ({ maybeReverseAddress, labelHash,
  * (see NameWrapper, ETHRegistrarController)
  */
 declare const uint256ToHex32: (num: bigint) => Hex;
+
 /**
- * Check if any characters in `label` are "unindexable".
+ * Converts an EVM address to its lowercase representation.
  *
- * Related logic in ENS Subgraph:
- * https://github.com/ensdomains/ens-subgraph/blob/c844791/src/utils.ts#L68
- *
- * @param label - The label to check. Note:
- * A `null` value for `label` represents an unhealable labelhash.
- *
- * @returns `true` if the label is indexable, `false` otherwise.
+ * @param address - EVM address to convert.
+ * @returns The lowercase representation of the EVM address.
  */
-declare const isLabelIndexable: (label: Label | null) => label is Label;
+declare function asLowerCaseAddress(address: Address): Address;
 
 /**
  * Cache that maps from string -> ValueType.
@@ -163,6 +345,17 @@ declare const uniq: <T>(arr: T[]) => T[];
  * Guaranteed to be a positive integer.
  **/
 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`.
  *
@@ -185,7 +378,11 @@ type Datetime = Date;
 /**
  * Unix timestamp value
  *
- * Guaranteed to be an integer.
+ * 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;
 /**
@@ -260,7 +457,7 @@ type DeepPartial<T> = {
 };
 
 /**
- * A string representation of {@link ChainId}.
+ * Serialized representation of {@link ChainId}.
  **/
 type ChainIdString = string;
 /**
@@ -270,7 +467,7 @@ type ChainIdString = string;
  */
 type DatetimeISO8601 = string;
 /**
- * A string representation of a {@link URL}.
+ * Serialized representation of a {@link URL}.
  */
 type UrlString = string;
 
@@ -289,6 +486,7 @@ declare function serializeUrl(url: URL): UrlString;
 
 declare function deserializeChainId(maybeChainId: ChainIdString, valueLabel?: string): ChainId;
 declare function deserializeDatetime(maybeDatetime: string, valueLabel?: string): Datetime;
+declare function deserializeUnixTimestamp(maybeTimestamp: number, valueLabel?: string): number;
 declare function deserializeUrl(maybeUrl: UrlString, valueLabel?: string): URL;
 declare function deserializeBlockNumber(maybeBlockNumber: number, valueLabel?: string): BlockNumber;
 declare function deserializeBlockrange(maybeBlockrange: Partial<Blockrange>, valueLabel?: string): {
@@ -298,13 +496,82 @@ declare function deserializeBlockrange(maybeBlockrange: Partial<Blockrange>, val
 declare function deserializeBlockRef(maybeBlockRef: Partial<BlockRef>, valueLabel?: string): BlockRef;
 declare function deserializeDuration(maybeDuration: string, valueLabel?: string): Duration;
 
-declare function isNormalized(name: Name): boolean;
+/**
+ * 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
+ */
+declare function isNormalizedName(name: Name): name is NormalizedName;
+/**
+ * Determines whether the Label is normalized.
+ *
+ * @param label - The Label to check for normalization
+ * @returns True if the label is normalized according to ENS normalization rules, false otherwise
+ */
+declare function isNormalizedLabel(label: Label): boolean;
 
 /**
  * Determines where the provided AccountId values represent the same address on the same chain.
  */
 declare const accountIdEqual: (a: AccountId, b: AccountId) => boolean;
 
+/**
+ * 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;
+
+/**
+ * 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.
+ */
+declare const labelhashLiteralLabel: (label: LiteralLabel) => LabelHash;
+
+declare function isHttpProtocol(url: URL): boolean;
+declare function isWebSocketProtocol(url: URL): boolean;
+
 /**
  * The ETH coinType.
  *
@@ -317,7 +584,7 @@ declare const ETH_COIN_TYPE: CoinType;
  *
  * @see https://docs.ens.domains/ensip/19
  */
-declare const DEFAULT_EVM_CHAIN_ID: ChainId;
+declare const DEFAULT_EVM_CHAIN_ID = 0;
 /**
  * ENSIP-19 EVM CoinType representing the 'default' coinType for EVM chains in ENS.
  *
@@ -351,17 +618,49 @@ declare const evmChainIdToCoinType: (chainId: ChainId) => CoinType;
 declare const bigintToCoinType: (value: bigint) => CoinType;
 
 /**
- * Constructs a name hierarchy from a given Name.
- * i.e. sub.example.eth -> [sub.example.eth, example.eth, eth]
+ * Constructs a name hierarchy from a given NormalizedName.
+ *
+ * @example
+ * ```
+ * getNameHierarchy("sub.example.eth") -> ["sub.example.eth", "example.eth", "eth"]
+ * ```
+ *
+ * @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: Name) => Name[];
+declare const getNameHierarchy: (name: NormalizedName) => NormalizedName[];
+/**
+ * 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.
+ *
+ * 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;
 
 /**
  * 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
  */
-declare const addrReverseLabel: (address: Address) => Label;
+declare const addrReverseLabel: (address: Address) => LiteralLabel;
 /**
  * Converts `coinType` to prefix-free hex string.
  *
@@ -395,6 +694,45 @@ declare function parseReverseName(name: Name): {
     coinType: CoinType;
 } | null;
 
+/**
+ * Formats a LabelHash as an Encoded LabelHash.
+ *
+ * @see https://ensnode.io/docs/reference/terminology#encoded-labelhash
+ *
+ * @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;
+
+/**
+ * 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
+ */
+declare function decodeDNSEncodedLiteralName(packet: DNSEncodedLiteralName): LiteralLabel[];
+/**
+ * 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.
+ *
+ * @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[];
+
 /**
  * A label set ID identifies a set of labels that can be used for deterministic healing.
  * A label set allows clients to deterministically heal their state against a server,
@@ -455,22 +793,56 @@ declare enum PluginName {
     Basenames = "basenames",
     Lineanames = "lineanames",
     ThreeDNS = "threedns",
-    ReverseResolvers = "reverse-resolvers",
+    ProtocolAcceleration = "protocol-acceleration",
     Referrals = "referrals",
     TokenScope = "tokenscope"
 }
 /**
- * Information about ENSIndexer's dependencies.
+ * Version info about ENSIndexer and its dependencies.
  */
-interface DependencyInfo {
-    /** Node.js runtime version */
+interface ENSIndexerVersionInfo {
+    /**
+     * Node.js runtime version
+     *
+     * @see https://nodejs.org/en/about/previous-releases
+     **/
     nodejs: string;
-    /** Ponder framework version */
+    /**
+     * Ponder framework version
+     *
+     * @see https://www.npmjs.com/package/ponder
+     **/
     ponder: string;
-    /** ENSRainbow service version */
+    /**
+     * 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;
+    /**
+     * ENSRainbow service version
+     *
+     * @see https://ghcr.io/namehash/ensnode/ensindexer
+     **/
     ensRainbow: string;
-    /** ENSRainbow schema version */
+    /**
+     * ENSRainbow schema version
+     **/
     ensRainbowSchema: number;
+    /**
+     * ENS Normalize package version
+     *
+     * Available on NPM as: `@adraffy/ens-normalize`
+     *
+     * @see https://www.npmjs.com/package/@adraffy/ens-normalize
+     **/
+    ensNormalize: string;
 }
 /**
  * Complete public configuration object for ENSIndexer.
@@ -485,24 +857,6 @@ interface ENSIndexerPublicConfig {
      * See {@link ENSNamespaceIds} for available namespace identifiers.
      */
     namespace: ENSNamespaceId;
-    /**
-     * An ENSAdmin URL
-     *
-     * The ENSNode root api route `/` redirects to {@link ensAdminUrl},
-     * configuring ENSAdmin with an entry for this instance of ENSNode,
-     * identified by {@link ensNodePublicUrl}.
-     *
-     * @see https://ensnode.io/ensadmin/overview/what-is-ensadmin
-     */
-    ensAdminUrl: URL;
-    /**
-     * The publicly accessible endpoint of the ENSNode API
-     * (ex: http://localhost:42069).
-     *
-     * ENSAdmin will use this url to connect to the ENSNode api for querying
-     * state about the ENSNode instance.
-     */
-    ensNodePublicUrl: URL;
     /**
      * 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.
      */
@@ -517,42 +871,15 @@ interface ENSIndexerPublicConfig {
      */
     databaseSchemaName: string;
     /**
-     * A set of {@link PluginName}s indicating which plugins to activate.
+     * A set of strings referring to the names of plugins that are active.
      *
-     * Invariants:
-     * - A set of valid {@link PluginName}s with at least one value
-     */
-    plugins: PluginName[];
-    /**
-     * Enable or disable healing of addr.reverse subnames.
-     * If this is set to true, ENSIndexer will attempt to heal subnames of
-     * addr.reverse.
-     */
-    healReverseAddresses: boolean;
-    /**
-     * Enable or disable the indexing of Resolver record values.
-     * If this is set to false, ENSIndexer will apply subgraph-backwards
-     * compatible logic that only tracks the keys of Resolver records.
-     * If this is set to true, ENSIndexer will track both the keys and the values
-     * of Resolver records.
+     * For future-proofing, this is a list of strings that may or may
+     * not be currently valid {@link PluginName} values.
      *
-     * 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. This feature is under R&D. At this time we do not
-     * recommend anyone directly use indexed resolver record values in their
-     * applications. Features are planned in the ENSNode roadmap that will
-     * provide safe use of indexed resolver record values (in appropriate
-     * contexts).
-     *
-     * Note that enabling {@link indexAdditionalResolverRecords} results in
-     * indexed data becoming a _superset_ of the Subgraph. For exact data-level
-     * backwards compatibility with the ENS Subgraph,
-     * {@link indexAdditionalResolverRecords} should be `false`.
+     * Invariants:
+     * - A set of strings with at least one value.
      */
-    indexAdditionalResolverRecords: boolean;
+    plugins: string[];
     /**
      * Indexed Chain IDs
      *
@@ -560,41 +887,63 @@ interface ENSIndexerPublicConfig {
      */
     indexedChainIds: Set<ChainId>;
     /**
-     * A flag derived from the built config indicating whether ENSIndexer is operating in a
-     * subgraph-compatible way. This flag is true if:
-     * a) only the subgraph plugin is activated,
-     * b) healReverseAddresess is false, and
-     * c) indexRecordValues is false
+     * 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.
      *
-     * If {@link isSubgraphCompatible} is true, ENSIndexer will:
-     * 1) use subgraph-compatible IDs for entities and events
-     * 2) limit indexing behavior to subgraph indexing semantics
+     * 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;
     /**
-     * Information about the ENSIndexer instance dependencies.
+     * Version info about ENSIndexer.
      */
-    dependencyInfo: DependencyInfo;
+    versionInfo: ENSIndexerVersionInfo;
 }
 
 type SerializedIndexedChainIds = Array<ChainId>;
 /**
  * Serialized representation of {@link ENSIndexerPublicConfig}
  */
-interface SerializedENSIndexerPublicConfig extends Omit<ENSIndexerPublicConfig, "ensAdminUrl" | "ensNodePublicUrl" | "indexedChainIds"> {
-    /**
-     * String representation of {@link ENSIndexerPublicConfig.ensAdminUrl}.
-     */
-    ensAdminUrl: UrlString;
-    /**
-     * String representation of {@link ENSIndexerPublicConfig.ensNodePublicUrl}.
-     */
-    ensNodePublicUrl: UrlString;
+interface SerializedENSIndexerPublicConfig extends Omit<ENSIndexerPublicConfig, "indexedChainIds"> {
     /**
      * Array representation of {@link ENSIndexerPublicConfig.indexedChainIds}.
      */
     indexedChainIds: ChainId[];
 }
+/**
+ * Serialized representation of {@link ENSIndexerVersionInfo}
+ */
+type SerializedENSIndexerVersionInfo = ENSIndexerVersionInfo;
 
 /**
  * Serialize a {@link ENSIndexerPublicConfig} object.
@@ -602,12 +951,12 @@ interface SerializedENSIndexerPublicConfig extends Omit<ENSIndexerPublicConfig,
 declare function deserializeENSIndexerPublicConfig(maybeConfig: SerializedENSIndexerPublicConfig, valueLabel?: string): ENSIndexerPublicConfig;
 
 /**
- * Subgraph compatibility
+ * Determines if the provided `config` results in indexing behavior compatible with the legacy ENS
+ * Subgraph.
  *
- * Tells if indexer config guarantees data to be indexed while
- * maintaining full subgraph-compatibility.
+ * @see https://ensnode.io/docs/reference/subgraph-compatibility/
  */
-declare function isSubgraphCompatible(config: Pick<ENSIndexerPublicConfig, "plugins" | "healReverseAddresses" | "indexAdditionalResolverRecords" | "labelSet">): boolean;
+declare function isSubgraphCompatible(config: Pick<ENSIndexerPublicConfig, "namespace" | "plugins" | "labelSet">): boolean;
 
 /**
  * Serializes a {@link ChainConfig} object.
@@ -618,113 +967,6 @@ declare function serializeIndexedChainIds(indexedChainIds: Set<ChainId>): Serial
  */
 declare function serializeENSIndexerPublicConfig(config: ENSIndexerPublicConfig): SerializedENSIndexerPublicConfig;
 
-/**
- * All zod schemas we define must remain internal implementation details.
- * We want the freedom to move away from zod in the future without impacting
- * any users of the ensnode-sdk package.
- *
- * The only way to share Zod schemas is to re-export them from
- * `./src/internal.ts` file.
- */
-
-/**
- * Zod `.check()` function input.
- */
-type ZodCheckFnInput<T> = z.core.ParsePayload<T>;
-
-/**
- * All zod schemas we define must remain internal implementation details.
- * We want the freedom to move away from zod in the future without impacting
- * any users of the ensnode-sdk package.
- *
- * The only way to share Zod schemas is to re-export them from
- * `./src/internal.ts` file.
- */
-
-/**
- * Makes a schema for parsing {@link IndexedChainIds}.
- */
-declare const makeIndexedChainIdsSchema: (valueLabel?: string) => z.ZodPipe<z.ZodArray<z.ZodInt>, z.ZodTransform<Set<number>, number[]>>;
-/**
- * Makes a schema for parsing a list of {@link PluginName} items.
- *
- * The list is guaranteed to include at least one item exists, and no duplicates.
- */
-declare const makePluginsListSchema: (valueLabel?: string) => z.ZodArray<z.ZodEnum<typeof PluginName>>;
-/**
- * Makes a schema for parsing a name for a database schema.
- *
- * The name is guaranteed to be a non-empty string.
- */
-declare const makeDatabaseSchemaNameSchema: (valueLabel?: string) => z.ZodString;
-/**
- * Makes a schema for parsing a label set ID.
- *
- * The label set ID is guaranteed to be a string between 1-50 characters
- * containing only lowercase letters (a-z) and hyphens (-).
- *
- * @param valueLabel - The label to use in error messages (e.g., "Label set ID", "LABEL_SET_ID")
- */
-declare const makeLabelSetIdSchema: (valueLabel: string) => z.ZodString;
-/**
- * Makes a schema for parsing a label set version.
- *
- * The label set version is guaranteed to be a non-negative integer.
- *
- * @param valueLabel - The label to use in error messages (e.g., "Label set version", "LABEL_SET_VERSION")
-
- */
-declare const makeLabelSetVersionSchema: (valueLabel: string) => z.ZodPipe<z.coerce.ZodCoercedNumber<unknown>, z.ZodInt>;
-/**
- * Makes a schema for parsing a label set where both label set ID and label set version are required.
- *
- * @param valueLabel - The label to use in error messages (e.g., "Label set", "LABEL_SET")
- */
-declare const makeFullyPinnedLabelSetSchema: (valueLabel?: string) => z.ZodObject<{
-    labelSetId: z.ZodString;
-    labelSetVersion: z.ZodPipe<z.coerce.ZodCoercedNumber<unknown>, z.ZodInt>;
-}, z.core.$strip>;
-declare const makeDependencyInfoSchema: (valueLabel?: string) => z.ZodObject<{
-    nodejs: z.ZodString;
-    ponder: z.ZodString;
-    ensRainbow: z.ZodString;
-    ensRainbowSchema: z.ZodInt;
-}, z.core.$strict>;
-declare function invariant_reverseResolversPluginNeedsResolverRecords(ctx: ZodCheckFnInput<Pick<ENSIndexerPublicConfig, "plugins" | "indexAdditionalResolverRecords">>): void;
-declare function invariant_isSubgraphCompatibleRequirements(ctx: ZodCheckFnInput<Pick<ENSIndexerPublicConfig, "plugins" | "isSubgraphCompatible" | "healReverseAddresses" | "indexAdditionalResolverRecords" | "labelSet">>): void;
-/**
- * ENSIndexer Public Config Schema
- *
- * Makes a Zod schema definition for validating all important settings used
- * during runtime of the ENSIndexer instance.
- */
-declare const makeENSIndexerPublicConfigSchema: (valueLabel?: string) => z.ZodObject<{
-    ensAdminUrl: z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>;
-    ensNodePublicUrl: z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>;
-    labelSet: z.ZodObject<{
-        labelSetId: z.ZodString;
-        labelSetVersion: z.ZodPipe<z.coerce.ZodCoercedNumber<unknown>, z.ZodInt>;
-    }, z.core.$strip>;
-    healReverseAddresses: z.ZodBoolean;
-    indexAdditionalResolverRecords: z.ZodBoolean;
-    indexedChainIds: z.ZodPipe<z.ZodArray<z.ZodInt>, z.ZodTransform<Set<number>, number[]>>;
-    isSubgraphCompatible: z.ZodBoolean;
-    namespace: z.ZodEnum<{
-        readonly Mainnet: "mainnet";
-        readonly Sepolia: "sepolia";
-        readonly Holesky: "holesky";
-        readonly EnsTestEnv: "ens-test-env";
-    }>;
-    plugins: z.ZodArray<z.ZodEnum<typeof PluginName>>;
-    databaseSchemaName: z.ZodString;
-    dependencyInfo: z.ZodObject<{
-        nodejs: z.ZodString;
-        ponder: z.ZodString;
-        ensRainbow: z.ZodString;
-        ensRainbowSchema: z.ZodInt;
-    }, z.core.$strict>;
-}, z.core.$strip>;
-
 /**
  * Builds a valid LabelSetId from a string.
  * @param maybeLabelSetId - The string to validate and convert to a LabelSetId.
@@ -771,427 +1013,658 @@ declare function labelHashToBytes(labelHash: LabelHash): ByteArray;
  */
 declare function parseNonNegativeInteger(maybeNumber: string): number;
 
-declare const ChainIndexingStatusIds: {
-    readonly Unstarted: "unstarted";
-    readonly Backfill: "backfill";
-    readonly Following: "following";
-    readonly Completed: "completed";
-};
-/**
- * ChainIndexingStatusId is the derived string union of possible Chain Indexing Status identifiers.
- */
-type ChainIndexingStatusId = (typeof ChainIndexingStatusIds)[keyof typeof ChainIndexingStatusIds];
-declare const OverallIndexingStatusIds: {
-    readonly Unstarted: "unstarted";
-    readonly Backfill: "backfill";
-    readonly Following: "following";
-    readonly Completed: "completed";
-    readonly IndexerError: "indexer-error";
-};
 /**
- * OverallIndexingStatusId is the derived string union of possible Overall Indexing Status identifiers.
+ * The type of indexing configuration for a chain.
  */
-type OverallIndexingStatusId = (typeof OverallIndexingStatusIds)[keyof typeof OverallIndexingStatusIds];
-declare const ChainIndexingStrategyIds: {
+declare const ChainIndexingConfigTypeIds: {
+    /**
+     * Represents that indexing of the chain should be performed for an indefinite range.
+     */
     readonly Indefinite: "indefinite";
+    /**
+     * Represents that indexing of the chain should be performed for a definite range.
+     */
     readonly Definite: "definite";
 };
 /**
- * ChainIndexingStrategyIds is the derived string union of possible Chain Indexing Strategy identifiers.
+ * The derived string union of possible {@link ChainIndexingConfigTypeIds}.
  */
-type ChainIndexingStrategyId = (typeof ChainIndexingStrategyIds)[keyof typeof ChainIndexingStrategyIds];
+type ChainIndexingConfigTypeId = (typeof ChainIndexingConfigTypeIds)[keyof typeof ChainIndexingConfigTypeIds];
 /**
- * Chain Indexing Indefinite Config
+ * Chain indexing config for a chain whose indexing config `configType` is
+ * {@link ChainIndexingConfigTypeIds.Indefinite}.
  *
- * Configures a chain to be indexed for an indefinite range.
+ * Invariants:
+ * - `configType` is always `ChainIndexingConfigTypeIds.Indefinite`.
  */
-interface ChainIndexingIndefiniteConfig {
+interface ChainIndexingConfigIndefinite {
     /**
-     * Chain indexing strategy.
+     * The type of chain indexing config.
      */
-    strategy: typeof ChainIndexingStrategyIds.Indefinite;
+    configType: typeof ChainIndexingConfigTypeIds.Indefinite;
     /**
-     * The block where indexing of the chain starts.
-     *
-     * An indexed chain always has its `startBlock` defined.
+     * A {@link BlockRef} to the block where indexing of the chain should start.
      */
     startBlock: BlockRef;
     /**
-     * Indefinite chain indexing configs always have a null `endBlock`.
+     * A {@link BlockRef} to the block where indexing of the chain should end.
      */
     endBlock?: null;
 }
 /**
- * Chain Indexing Definite Config
- *
- * Configures a chain to be indexed for a definite range.
+ * Chain indexing config for a chain whose indexing config `configType` is
+ * {@link ChainIndexingConfigTypeIds.Definite}.
  *
  * Invariants:
- * - `startBlock` is always before or the same as `endBlock`
+ * - `configType` is always `ChainIndexingConfigTypeIds.Definite`.
+ * - `startBlock` is always before or the same as `endBlock`.
  */
-interface ChainIndexingDefiniteConfig {
+interface ChainIndexingConfigDefinite {
     /**
-     * Chain indexing strategy.
+     * The type of chain indexing config.
      */
-    strategy: typeof ChainIndexingStrategyIds.Definite;
+    configType: typeof ChainIndexingConfigTypeIds.Definite;
     /**
-     * The block where indexing of the chain starts.
-     *
-     * `startBlock` must always be defined.
+     * A {@link BlockRef} to the block where indexing of the chain should start.
      */
     startBlock: BlockRef;
     /**
-     * The block where indexing of the chain ends.
-     *
-     * Definite chain indexing configs always have a defined `endBlock`.
+     * A {@link BlockRef} to the block where indexing of the chain should end.
      */
     endBlock: BlockRef;
 }
 /**
- * Chain Indexing Config
+ * Indexing configuration for a chain.
  *
- * Configuration of an indexed chain.
+ * Use the `configType` field to determine the specific type interpretation
+ * at runtime.
  */
-type ChainIndexingConfig = ChainIndexingIndefiniteConfig | ChainIndexingDefiniteConfig;
+type ChainIndexingConfig = ChainIndexingConfigIndefinite | ChainIndexingConfigDefinite;
 /**
- * Chain Indexing Status: Unstarted
+ * The status of indexing a chain at the time an indexing status snapshot
+ * is captured.
+ */
+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 ChainIndexingSnapshot} 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 ChainIndexingSnapshot}.
+     */
+    readonly Queued: "chain-queued";
+    /**
+     * 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`.
+     */
+    readonly Backfill: "chain-backfill";
+    /**
+     * 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.
+     */
+    readonly Following: "chain-following";
+    /**
+     * 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.
+     */
+    readonly Completed: "chain-completed";
+};
+/**
+ * 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}.
  *
- * Notes:
- * - The "unstarted" status applies when using omnichain ordering and
- *   the omnichainIndexingCursor from the overall indexing status <= config.startBlock.timestamp.
+ * Invariants:
+ * - `chainStatus` is always {@link ChainIndexingStatusIds.Queued}.
  */
-interface ChainIndexingUnstartedStatus {
-    status: typeof ChainIndexingStatusIds.Unstarted;
+interface ChainIndexingStatusSnapshotQueued {
+    /**
+     * The status of indexing the chain at the time the indexing status snapshot
+     * was captured.
+     */
+    chainStatus: typeof ChainIndexingStatusIds.Queued;
+    /**
+     * The indexing configuration of the chain.
+     */
     config: ChainIndexingConfig;
 }
 /**
- * Chain Indexing Status: Backfill
+ * 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
+ * index all blocks between `config.startBlock` and `backfillEndBlock`
  * as fast as possible.
  *
- * Notes:
- * - The backfillEndBlock is either config.endBlock (if present) or
- *   the latest block on the chain when the ENSIndexer process started up.
- *   Note how this means the backfillEndBlock is always a "fixed target".
- * - When latestIndexedBlock reaches backfillEndBlock, the backfill is complete.
- *   The moment backfill is complete the status does not immediately transition.
- *   Instead, internal processing is completed for a period of time while
- *   the status remains "backfill". After this internal processing is completed
- *   the status will change to "following" or "completed" depending on
- *   the configured indexing strategy. If the strategy is indefinite,
- *   changes to "following", else if the strategy is definite, changes to
- *   "completed".
+ * Note how `backfillEndBlock` is a "fixed target" that does not change during
+ * the lifetime of an ENSIndexer process instance:
+ * - If the `config` is {@link ChainIndexingConfigDefinite}:
+ *   `backfillEndBlock` is always the same as `config.endBlock`.
+ * - If the `config` is {@link ChainIndexingConfigIndefinite}:
+ *   `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 ChainIndexingConfigIndefinite}.
+ * - to {@link ChainIndexingStatusIds.Completed} if the `config` is
+ *   {@link ChainIndexingConfigDefinite}.
  *
  * Invariants:
+ * - `chainStatus` is always {@link ChainIndexingStatusIds.Backfill}.
  * - `config.startBlock` is always before or the same as `latestIndexedBlock`
- * - `latestIndexedBlock` is always before or the same as `latestSyncedBlock`
- * - `latestSyncedBlock` is always before or the same as `backfillEndBlock`
- * - `backfillEndBlock` is the same as `config.endBlock` if and only if
- *   the config is definite.
+ * - `config.endBlock` is always the same as `backfillEndBlock` if and only if
+ *   the config is {@link ChainIndexingConfigDefinite}.
+ * - `latestIndexedBlock` is always before or the same as `backfillEndBlock`
  */
-interface ChainIndexingBackfillStatus {
-    status: typeof ChainIndexingStatusIds.Backfill;
-    config: ChainIndexingConfig;
+interface ChainIndexingStatusSnapshotBackfill {
     /**
-     * The block that was most recently indexed.
+     * The status of indexing the chain at the time the indexing status snapshot
+     * was captured.
      */
-    latestIndexedBlock: BlockRef;
+    chainStatus: typeof ChainIndexingStatusIds.Backfill;
+    /**
+     * The indexing configuration of the chain.
+     */
+    config: ChainIndexingConfig;
     /**
-     * The "highest" block that has been synced into RPC cache. Backfill indexing
-     * is accelerated by cached RPC calls through this block height.
+     * A {@link BlockRef} to the block that was most recently indexed as of the time the
+     * indexing status snapshot was captured.
      */
-    latestSyncedBlock: BlockRef;
+    latestIndexedBlock: BlockRef;
     /**
-     * The block that is the target for finishing the backfill.
+     * A {@link BlockRef} to the block where the backfill will end.
      */
     backfillEndBlock: BlockRef;
 }
 /**
- * Chain Indexing Status: Following
- *
- * Following occurs after the backfill of a chain is completed and represents
- * the process of indefinitely following (and indexing!) new blocks as they are
- * added to the indexed chain across time.
+ * Chain indexing status snapshot for a chain whose `chainStatus` is
+ * {@link ChainIndexingStatusIds.Following}.
  *
  * Invariants:
+ * - `chainStatus` is always {@link ChainIndexingStatusIds.Following}.
+ * - `config` is always {@link ChainIndexingConfigIndefinite}
  * - `config.startBlock` is always before or the same as `latestIndexedBlock`
  * - `latestIndexedBlock` is always before or the same as `latestKnownBlock`
  */
-interface ChainIndexingFollowingStatus {
-    status: typeof ChainIndexingStatusIds.Following;
-    config: ChainIndexingIndefiniteConfig;
+interface ChainIndexingStatusSnapshotFollowing {
     /**
-     * The block that was most recently indexed.
+     * The status of indexing the chain at the time the indexing status snapshot
+     * was captured.
      */
-    latestIndexedBlock: BlockRef;
+    chainStatus: typeof ChainIndexingStatusIds.Following;
     /**
-     * The "highest" block that has been fetched by RPC calls and stored in
-     * the RPC cache as part of the indexing process.
+     * The indexing configuration of the chain.
      */
-    latestKnownBlock: BlockRef;
+    config: ChainIndexingConfigIndefinite;
     /**
-     * The number of seconds between `latestIndexedBlock.timestamp` and
-     * the current time in ENSIndexer. This represents the upper-bound worst case
-     * distance approximation between the latest block on the chain (independent
-     * of it becoming known to us) and the latest block that has completed
-     * indexing. The true distance to the latest block on the chain will be less
-     * if the latest block on the chain was not issued at the current second.
+     * A {@link BlockRef} to the block that was most recently indexed as of the time the
+     * indexing status snapshot was captured.
      */
-    approxRealtimeDistance: Duration;
+    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;
 }
 /**
- * Chain Indexing Status: Completed
+ * Chain indexing status snapshot for a chain whose `chainStatus` is
+ * {@link ChainIndexingStatusIds.Completed}.
  *
- * Indexing of a chain is completed after the backfill when the chain is
- * not configured to be indefinitely indexed.
+ * 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` is always {@link ChainIndexingConfigDefinite}
  * - `config.startBlock` is always before or the same as `latestIndexedBlock`
  * - `latestIndexedBlock` is always the same as `config.endBlock`.
  */
-interface ChainIndexingCompletedStatus {
-    status: typeof ChainIndexingStatusIds.Completed;
-    config: ChainIndexingDefiniteConfig;
+interface ChainIndexingStatusSnapshotCompleted {
     /**
-     * The block that was most recently indexed.
+     * 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: ChainIndexingConfigDefinite;
+    /**
+     * A {@link BlockRef} to the block that was most recently indexed as of the time the
+     * indexing status snapshot was captured.
      */
     latestIndexedBlock: BlockRef;
 }
 /**
- * Chain Indexing Status
+ * Indexing status snapshot for a single chain.
  *
- * Use the `status` field to determine the correct type interpretation at runtime.
+ * Use the `chainStatus` field to determine the specific type interpretation
+ * at runtime.
  */
-type ChainIndexingStatus = ChainIndexingUnstartedStatus | ChainIndexingBackfillStatus | ChainIndexingFollowingStatus | ChainIndexingCompletedStatus;
+type ChainIndexingStatusSnapshot = ChainIndexingStatusSnapshotQueued | ChainIndexingStatusSnapshotBackfill | ChainIndexingStatusSnapshotFollowing | ChainIndexingStatusSnapshotCompleted;
 /**
- * Chain Indexing Status: Active
- *
- * Represents a chain where indexing is currently active.
- * The `latestIndexedBlock` field will be available.
+ * The status of omnichain indexing at the time an omnichain indexing status
+ * snapshot is captured.
  */
-type ChainIndexingActiveStatus = ChainIndexingBackfillStatus | ChainIndexingFollowingStatus;
+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";
+};
 /**
- * Chain Indexing Status: Standby
- *
- * Represents a chain where indexing is currently on standby (not happening).
- * The `latestIndexedBlock` field will not be available.
+ * The derived string union of possible {@link OmnichainIndexingStatusIds}.
  */
-type ChainIndexingStandbyStatus = ChainIndexingUnstartedStatus | ChainIndexingCompletedStatus;
+type OmnichainIndexingStatusId = (typeof OmnichainIndexingStatusIds)[keyof typeof OmnichainIndexingStatusIds];
 /**
- * ENSIndexer Overall Indexing Status: Unstarted
+ * Omnichain indexing status snapshot when the overall `omnichainStatus` is
+ * {@link OmnichainIndexingStatusIds.Unstarted}.
  *
- * Describes the current state of indexing operations across all indexed chains
- * when the overall indexing status is {@link OverallIndexingStatusIds.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}.
  */
-interface ENSIndexerOverallIndexingUnstartedStatus {
+interface OmnichainIndexingStatusSnapshotUnstarted {
     /**
-     * Overall Indexing Status
+     * The status of omnichain indexing.
      */
-    overallStatus: typeof OverallIndexingStatusIds.Unstarted;
+    omnichainStatus: typeof OmnichainIndexingStatusIds.Unstarted;
     /**
-     * Indexing Status for each chain.
-     *
-     * Each chain is guaranteed to have the "unstarted" status.
-     * It's impossible for any chain to have status other than "unstarted".
+     * The indexing status snapshot for each indexed chain.
+     */
+    chains: Map<ChainId, ChainIndexingStatusSnapshotQueued>;
+    /**
+     * The timestamp of omnichain indexing progress across all indexed chains.
      */
-    chains: Map<ChainId, ChainIndexingUnstartedStatus>;
+    omnichainIndexingCursor: UnixTimestamp;
 }
 /**
- * Chain Indexing Status allowed when overall status is 'backfill'.
+ * 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 ChainIndexingStatusForBackfillOverallStatus = ChainIndexingUnstartedStatus | ChainIndexingBackfillStatus | ChainIndexingCompletedStatus;
+type ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill = ChainIndexingStatusSnapshotQueued | ChainIndexingStatusSnapshotBackfill | ChainIndexingStatusSnapshotCompleted;
 /**
- * ENSIndexer Overall Indexing Status: Backfill
+ * Omnichain indexing status snapshot when the `omnichainStatus` is
+ * {@link OmnichainIndexingStatusIds.Backfill}.
  *
- * Describes the current state of indexing operations across all indexed chains
- * when the overall indexing status is {@link OverallIndexingStatusIds.Backfill}.
- */
-interface ENSIndexerOverallIndexingBackfillStatus {
+ * 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}).
+ */
+interface OmnichainIndexingStatusSnapshotBackfill {
     /**
-     * Overall Indexing Status
+     * The status of omnichain indexing.
      */
-    overallStatus: typeof OverallIndexingStatusIds.Backfill;
+    omnichainStatus: typeof OmnichainIndexingStatusIds.Backfill;
     /**
-     * Omnichain Indexing Cursor
-     *
-     * Identifies the timestamp of the progress of omnichain indexing across
-     * all chains in {@link ChainIndexingBackfillStatus} status.
-     *
-     * Invariants:
-     * - the cursor value is guaranteed to be lower than or equal to
-     *   the timestamp of the earliest `config.startBlock` across all chains
-     *   in {@link ChainIndexingStandbyStatus} status.
+     * The indexing status snapshot for each indexed chain.
+     */
+    chains: Map<ChainId, ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill>;
+    /**
+     * The timestamp of omnichain indexing progress across all indexed chains.
      */
     omnichainIndexingCursor: UnixTimestamp;
+}
+/**
+ * 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 OmnichainIndexingStatusSnapshotFollowing {
     /**
-     * Indexing Status for each chain.
-     *
-     * At least one chain is guaranteed to be in the "backfill" status.
-     * Each chain is guaranteed to have a status of either "unstarted",
-     * "backfill" or "completed". It's impossible for any chain to be
-     * in the "following" status.
+     * 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.
      */
-    chains: Map<ChainId, ChainIndexingStatusForBackfillOverallStatus>;
+    omnichainIndexingCursor: UnixTimestamp;
 }
 /**
- * ENSIndexer Overall Indexing Status: Completed
+ * Omnichain indexing status snapshot when the overall `omnichainStatus` is
+ * {@link OmnichainIndexingStatusIds.Completed}.
  *
- * Describes the final state of indexing operations across all indexed chains
- * when all indexed chains are configured for a definite indexing strategy and
- * all indexing of that definite range is 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.
  */
-interface ENSIndexerOverallIndexingCompletedStatus {
+interface OmnichainIndexingStatusSnapshotCompleted {
     /**
-     * Overall Indexing Status
+     * The status of omnichain indexing.
      */
-    overallStatus: typeof OverallIndexingStatusIds.Completed;
+    omnichainStatus: typeof OmnichainIndexingStatusIds.Completed;
     /**
-     * Indexing Status for each chain.
-     *
-     * Each chain is guaranteed to have the "completed" status.
-     * It's impossible for any chain to have status other than "completed".
+     * The indexing status snapshot for each indexed chain.
      */
-    chains: Map<ChainId, ChainIndexingCompletedStatus>;
+    chains: Map<ChainId, ChainIndexingStatusSnapshotCompleted>;
+    /**
+     * The timestamp of omnichain indexing progress across all indexed chains.
+     */
+    omnichainIndexingCursor: UnixTimestamp;
 }
 /**
- * ENSIndexer Overall Indexing Status: Following
+ * Omnichain indexing status snapshot for one or more chains.
+ *
+ * Use the `omnichainStatus` field to determine the specific type interpretation
+ * at runtime.
+ */
+type OmnichainIndexingStatusSnapshot = OmnichainIndexingStatusSnapshotUnstarted | OmnichainIndexingStatusSnapshotBackfill | OmnichainIndexingStatusSnapshotCompleted | OmnichainIndexingStatusSnapshotFollowing;
+/**
+ * The strategy used for indexing one or more chains.
  *
- * Describes the state when the overall indexing status is
- * {@link OverallIndexingStatusIds.Following}.
+ * @see https://ponder.sh/docs/api-reference/ponder/config#parameters
  */
-interface ENSIndexerOverallIndexingFollowingStatus {
+declare const CrossChainIndexingStrategyIds: {
     /**
-     * Overall Indexing Status
+     * 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.
      */
-    overallStatus: typeof OverallIndexingStatusIds.Following;
+    readonly Omnichain: "omnichain";
+};
+/**
+ * The derived string union of possible {@link CrossChainIndexingStrategyIds}.
+ */
+type CrossChainIndexingStrategyId = (typeof CrossChainIndexingStrategyIds)[keyof typeof CrossChainIndexingStrategyIds];
+/**
+ * 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.configType` of
+ *       {@link ChainIndexingConfigTypeIds.Definite}.
+ *     - the `backfillEndBlock.timestamp` for all chains with `chainStatus` of
+ *       {@link ChainIndexingStatusIds.Backfill}.
+ *     - the `latestKnownBlock.timestamp` for all chains with `chainStatus` of
+ *       {@link ChainIndexingStatusIds.Following}.
+ */
+interface CrossChainIndexingStatusSnapshotOmnichain {
     /**
-     * Omnichain Indexing Cursor
-     *
-     * Identifies the timestamp of the progress of omnichain indexing across
-     * all chains in {@link ChainIndexingActiveStatus} status.
-     *
-     * Invariants:
-     * - the cursor value is guaranteed to be lower than or equal to
-     *   the timestamp of the earliest `config.startBlock` across all chains
-     *   in {@link ChainIndexingStandbyStatus} status.
+     * The strategy used for indexing one or more chains.
      */
-    omnichainIndexingCursor: UnixTimestamp;
+    strategy: typeof CrossChainIndexingStrategyIds.Omnichain;
+    /**
+     * The timestamp of the "slowest" latest indexed block timestamp
+     * across all indexed chains.
+     */
+    slowestChainIndexingCursor: UnixTimestamp;
     /**
-     * Indexing Status for each chain.
+     * The timestamp when the cross-chain indexing status snapshot was generated.
      *
-     * At least one chain is guaranteed to be in the "following" status.
-     * Each chain is guaranteed to have a status of either "unstarted",
-     * "backfill", "following" or "completed".
+     * 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).
      */
-    chains: Map<ChainId, ChainIndexingStatus>;
+    snapshotTime: UnixTimestamp;
     /**
-     * The maximum
-     * {@link ChainIndexingFollowingStatus.approxRealtimeDistance} value
-     * across all chains with status: 'following'.
+     * The omnichain indexing status snapshot for one or more chains.
      */
-    overallApproxRealtimeDistance: Duration;
+    omnichainSnapshot: OmnichainIndexingStatusSnapshot;
 }
 /**
- * ENSIndexer Overall Indexing Status: Error
+ * Cross-chain indexing status snapshot for one or more chains.
  *
- * Describes the state when ENSIndexer failed to return the indexing status for
- * all indexed chains.
+ * Use the `strategy` field to determine the specific type interpretation
+ * at runtime.
  *
- * This state suggests an error with the "primary" ENSIndexer.
+ * 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 ENSIndexerOverallIndexingErrorStatus {
-    /**
-     * Overall Indexing Status
-     */
-    overallStatus: typeof OverallIndexingStatusIds.IndexerError;
-}
+type CrossChainIndexingStatusSnapshot = CrossChainIndexingStatusSnapshotOmnichain;
 /**
- * ENSIndexer Overall Indexing Status
+ * A "realtime" indexing status projection based on worst-case assumptions
+ * from the `snapshot`.
  *
- * Describes the overall state of indexing operations.
+ * Invariants:
+ * - `projectedAt` is always >= `snapshot.snapshotTime`.
+ * - `worstCaseDistance` is always equal to
+ *   `projectedAt - snapshot.slowestChainIndexingCursor`.
  */
-type ENSIndexerOverallIndexingStatus = ENSIndexerOverallIndexingUnstartedStatus | ENSIndexerOverallIndexingBackfillStatus | ENSIndexerOverallIndexingCompletedStatus | ENSIndexerOverallIndexingFollowingStatus | ENSIndexerOverallIndexingErrorStatus;
+type RealtimeIndexingStatusProjection = {
+    /**
+     * The timestamp representing "now" as of the time this projection was generated.
+     */
+    projectedAt: UnixTimestamp;
+    /**
+     * 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`.
+     */
+    worstCaseDistance: Duration;
+    /**
+     * The {@link CrossChainIndexingStatusSnapshot} that this projection is based on.
+     */
+    snapshot: CrossChainIndexingStatusSnapshot;
+};
 
 /**
- * Serialized representation of {@link ENSIndexerOverallIndexingUnstartedStatus}
+ * Serialized representation of {@link ChainIndexingStatusSnapshot}
+ */
+type SerializedChainIndexingStatusSnapshot = ChainIndexingStatusSnapshot;
+/**
+ * Serialized representation of {@link ChainIndexingStatusSnapshotQueued}
  */
-interface SerializedENSIndexerOverallIndexingUnstartedStatus extends Omit<ENSIndexerOverallIndexingUnstartedStatus, "chains"> {
-    chains: Record<ChainIdString, ChainIndexingUnstartedStatus>;
+type SerializedChainIndexingStatusSnapshotQueued = ChainIndexingStatusSnapshotQueued;
+/**
+ * Serialized representation of {@link ChainIndexingStatusSnapshotBackfill}
+ */
+type SerializedChainIndexingStatusSnapshotBackfill = ChainIndexingStatusSnapshotBackfill;
+/**
+ * Serialized representation of {@link ChainIndexingStatusSnapshotCompleted}
+ */
+type SerializedChainIndexingStatusSnapshotCompleted = ChainIndexingStatusSnapshotCompleted;
+/**
+ * Serialized representation of {@link ChainIndexingStatusSnapshotFollowing}
+ */
+type SerializedChainIndexingStatusSnapshotFollowing = ChainIndexingStatusSnapshotFollowing;
+/**
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshotUnstarted}
+ */
+interface SerializedOmnichainIndexingStatusSnapshotUnstarted extends Omit<OmnichainIndexingStatusSnapshotUnstarted, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatusSnapshotQueued>;
 }
 /**
- * Serialized representation of {@link ENSIndexerOverallIndexingBackfillStatus}
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshotBackfill}
  */
-interface SerializedENSIndexerOverallIndexingBackfillStatus extends Omit<ENSIndexerOverallIndexingBackfillStatus, "chains"> {
-    chains: Record<ChainIdString, ChainIndexingStatusForBackfillOverallStatus>;
+interface SerializedOmnichainIndexingStatusSnapshotBackfill extends Omit<OmnichainIndexingStatusSnapshotBackfill, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill>;
 }
 /**
- * Serialized representation of {@link ENSIndexerOverallIndexingCompletedStatus}
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshotCompleted}
  */
-interface SerializedENSIndexerOverallIndexingCompletedStatus extends Omit<ENSIndexerOverallIndexingCompletedStatus, "chains"> {
-    chains: Record<ChainIdString, ChainIndexingCompletedStatus>;
+interface SerializedOmnichainIndexingStatusSnapshotCompleted extends Omit<OmnichainIndexingStatusSnapshotCompleted, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatusSnapshotCompleted>;
 }
 /**
- * Serialized representation of {@link ENSIndexerOverallIndexingFollowingStatus}
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshotFollowing}
  */
-interface SerializedENSIndexerOverallIndexingFollowingStatus extends Omit<ENSIndexerOverallIndexingFollowingStatus, "chains"> {
-    chains: Record<ChainIdString, ChainIndexingStatus>;
+interface SerializedOmnichainIndexingStatusSnapshotFollowing extends Omit<OmnichainIndexingStatusSnapshotFollowing, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatusSnapshot>;
 }
 /**
- * Serialized representation of {@link ENSIndexerOverallIndexingErrorStatus}
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshot}
  */
-interface SerializedENSIndexerOverallIndexingErrorStatus extends ENSIndexerOverallIndexingErrorStatus {
+type SerializedOmnichainIndexingStatusSnapshot = SerializedOmnichainIndexingStatusSnapshotUnstarted | SerializedOmnichainIndexingStatusSnapshotBackfill | SerializedOmnichainIndexingStatusSnapshotCompleted | SerializedOmnichainIndexingStatusSnapshotFollowing;
+/**
+ * Serialized representation of {@link CrossChainIndexingStatusSnapshotOmnichain}
+ */
+interface SerializedCrossChainIndexingStatusSnapshotOmnichain extends Omit<CrossChainIndexingStatusSnapshotOmnichain, "omnichainSnapshot"> {
+    omnichainSnapshot: SerializedOmnichainIndexingStatusSnapshot;
 }
 /**
- * Serialized representation of {@link ENSIndexerOverallIndexingStatus}
+ * Serialized representation of {@link CrossChainIndexingStatusSnapshot}
  */
-type SerializedENSIndexerOverallIndexingStatus = SerializedENSIndexerOverallIndexingUnstartedStatus | SerializedENSIndexerOverallIndexingBackfillStatus | SerializedENSIndexerOverallIndexingCompletedStatus | SerializedENSIndexerOverallIndexingFollowingStatus | SerializedENSIndexerOverallIndexingErrorStatus;
-
+type SerializedCrossChainIndexingStatusSnapshot = SerializedCrossChainIndexingStatusSnapshotOmnichain;
 /**
- * Serialize a {@link ENSIndexerOverallIndexingStatus} object.
+ * Serialized representation of {@link RealtimeIndexingStatusProjection}
  */
-declare function deserializeENSIndexerIndexingStatus(maybeStatus: SerializedENSIndexerOverallIndexingStatus, valueLabel?: string): ENSIndexerOverallIndexingStatus;
+interface SerializedCurrentIndexingProjectionOmnichain extends Omit<RealtimeIndexingStatusProjection, "snapshot"> {
+    snapshot: SerializedOmnichainIndexingStatusSnapshot;
+}
+/**
+ * Serialized representation of {@link RealtimeIndexingStatusProjection}
+ */
+interface SerializedRealtimeIndexingStatusProjection extends Omit<RealtimeIndexingStatusProjection, "snapshot"> {
+    snapshot: SerializedCrossChainIndexingStatusSnapshot;
+}
 
 /**
- * Get {@link OverallIndexingStatusId} based on indexed chains' statuses.
- *
- * This function decides what is the current overall indexing status,
- * based on provided chain indexing statuses. The fact that chain indexing
- * statuses were provided to this function guarantees there was no indexer
- * error, and that the overall indexing status is never
- * an {@link OverallIndexingStatusIds.IndexerError}
+ * Deserialize into a {@link ChainIndexingSnapshot} object.
  */
-declare function getOverallIndexingStatus(chains: ChainIndexingStatus[]): Exclude<OverallIndexingStatusId, typeof OverallIndexingStatusIds.IndexerError>;
+declare function deserializeChainIndexingStatusSnapshot(maybeSnapshot: SerializedChainIndexingStatusSnapshot, valueLabel?: string): ChainIndexingStatusSnapshot;
 /**
- * Get overall approximate realtime distance across all indexed chains.
- *
- * @throws an error if none of the indexed chains was in the 'following' status.
+ * Deserialize an {@link OmnichainIndexingStatusSnapshot} object.
  */
-declare function getOverallApproxRealtimeDistance(chains: ChainIndexingStatus[]): Duration;
+declare function deserializeOmnichainIndexingStatusSnapshot(maybeSnapshot: SerializedOmnichainIndexingStatusSnapshot, valueLabel?: string): OmnichainIndexingStatusSnapshot;
 /**
- * Get lowest of the highest end block across all chains which status is
- * {@link ChainIndexingStatus}.
+ * Deserialize an {@link CrossChainIndexingStatusSnapshot} object.
  */
-declare function getTimestampForLowestOmnichainStartBlock(chains: ChainIndexingStatus[]): UnixTimestamp;
+declare function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot: SerializedCrossChainIndexingStatusSnapshot, valueLabel?: string): CrossChainIndexingStatusSnapshot;
 /**
- * Get timestamp of the highest known block across all chains which status is
- * {@link ChainIndexingStatusForBackfillOverallStatus}.
+ * Deserialize into a {@link RealtimeIndexingStatusProjection} object.
+ */
+declare function deserializeRealtimeIndexingStatusProjection(maybeProjection: SerializedRealtimeIndexingStatusProjection, valueLabel?: string): RealtimeIndexingStatusProjection;
+
+/**
+ * Get {@link OmnichainIndexingStatusId} based on indexed chains' statuses.
+ *
+ * This function decides what is the `OmnichainIndexingStatusId` is,
+ * based on provided chain indexing statuses.
+ *
+ * @throws an error if unable to determine overall indexing status
  */
-declare function getTimestampForHighestOmnichainKnownBlock(chains: ChainIndexingStatus[]): UnixTimestamp;
+declare function getOmnichainIndexingStatus(chains: ChainIndexingStatusSnapshot[]): OmnichainIndexingStatusId;
 /**
- * Get Omnichain Indexing Cursor across all chains which status is
- * {@link ChainIndexingActiveStatus}.
+ * 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.
  */
-declare function getOmnichainIndexingCursor(chains: ChainIndexingActiveStatus[]): UnixTimestamp;
+declare function getTimestampForLowestOmnichainStartBlock(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
 /**
- * Get all chains which status is {@link ChainIndexingActiveStatus}.
+ * 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,
+ * - `backfillEndBlock` for a "backfill" chain,
+ * - `latestIndexedBlock` for a "completed" chain,
+ * - `latestKnownBlock` for a "following" chain.
  */
-declare function getActiveChains(chains: ChainIndexingStatus[]): ChainIndexingActiveStatus[];
+declare function getTimestampForHighestOmnichainKnownBlock(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
 /**
- * Get all chains which status is {@link ChainIndexingStandbyStatus}.
+ * 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
  */
-declare function getStandbyChains(chains: ChainIndexingStatus[]): ChainIndexingStandbyStatus[];
+declare function getOmnichainIndexingCursor(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
 /**
  * Create {@link ChainIndexingConfig} for given block refs.
  *
@@ -1200,55 +1673,63 @@ declare function getStandbyChains(chains: ChainIndexingStatus[]): ChainIndexingS
  */
 declare function createIndexingConfig(startBlock: BlockRef, endBlock: BlockRef | null): ChainIndexingConfig;
 /**
- * Check if Chain Indexing Statuses fit the 'unstarted' overall status
- * requirements:
- * - All chains are guaranteed to have a status of "unstarted".
+ * 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 ChainIndexingStatus} type to
- * {@link ChainIndexingUnstartedStatus}.
+ * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
+ * {@link ChainIndexingStatusSnapshotQueued}.
  */
-declare function checkChainIndexingStatusesForUnstartedOverallStatus(chains: ChainIndexingStatus[]): chains is ChainIndexingUnstartedStatus[];
+declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotQueued[];
 /**
- * Check if Chain Indexing Statuses fit the 'backfill' overall status
- * requirements:
+ * 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 "unstarted",
+ * - Each chain is guaranteed to have a status of either "queued",
  *   "backfill" or "completed".
  *
- * Note: This function narrows the {@linkChainIndexingStatus} type to
- * {@link ChainIndexingStatusForBackfillOverallStatus}.
+ * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
+ * {@link ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill}.
  */
-declare function checkChainIndexingStatusesForBackfillOverallStatus(chains: ChainIndexingStatus[]): chains is ChainIndexingStatusForBackfillOverallStatus[];
+declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill[];
 /**
- * Checks if Chain Indexing Statuses fit the 'completed' overall status
- * requirements:
+ * 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 {@linkChainIndexingStatus} type to
- * {@link ChainIndexingCompletedStatus}.
+ * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
+ * {@link ChainIndexingStatusSnapshotCompleted}.
  */
-declare function checkChainIndexingStatusesForCompletedOverallStatus(chains: ChainIndexingStatus[]): chains is ChainIndexingCompletedStatus[];
+declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotCompleted[];
 /**
- * Checks Chain Indexing Statuses fit the 'following' overall status
- * requirements:
+ * 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 checkChainIndexingStatusesForFollowingOverallStatus(chains: ChainIndexingStatus[]): chains is ChainIndexingStatus[];
+declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshot[];
 /**
- * Sort a list of [{@link ChainId}, {@link ChainIndexingStatus}] tuples
+ * Sort a list of [{@link ChainId}, {@link ChainIndexingStatusSnapshot}] tuples
  * by the omnichain start block timestamp in ascending order.
  */
-declare function sortAscChainStatusesByStartBlock<ChainStatusType extends ChainIndexingStatus>(chains: [ChainId, ChainStatusType][]): [ChainId, ChainStatusType][];
+declare function sortChainStatusesByStartBlockAsc<ChainStatusType extends ChainIndexingStatusSnapshot>(chains: [ChainId, ChainStatusType][]): [ChainId, ChainStatusType][];
 
 /**
- * Serialize chain indexing statuses.
+ * Create realtime indexing status projection from
+ * a {@link CrossChainIndexingStatusSnapshot}.
  */
-declare function serializeChainIndexingStatuses<ChainIndexingStatusType extends ChainIndexingStatus>(chainIndexingStatuses: Map<ChainId, ChainIndexingStatusType>): Record<ChainIdString, ChainIndexingStatusType>;
+declare function createRealtimeIndexingStatusProjection(snapshot: CrossChainIndexingStatusSnapshot, now: UnixTimestamp): RealtimeIndexingStatusProjection;
+
+declare function serializeCrossChainIndexingStatusSnapshotOmnichain({ strategy, slowestChainIndexingCursor, snapshotTime, omnichainSnapshot, }: CrossChainIndexingStatusSnapshot): SerializedCrossChainIndexingStatusSnapshot;
+declare function serializeRealtimeIndexingStatusProjection(indexingProjection: RealtimeIndexingStatusProjection): SerializedRealtimeIndexingStatusProjection;
 /**
- * Serialize a {@link ENSIndexerIndexingStatus} object.
+ * Serialize chain indexing snapshots.
  */
-declare function serializeENSIndexerIndexingStatus(indexingStatus: ENSIndexerOverallIndexingStatus): SerializedENSIndexerOverallIndexingStatus;
+declare function serializeChainIndexingSnapshots<ChainIndexingStatusSnapshotType extends ChainIndexingStatusSnapshot>(chains: Map<ChainId, ChainIndexingStatusSnapshotType>): Record<ChainIdString, ChainIndexingStatusSnapshotType>;
+/**
+ * Serialize a {@link OmnichainIndexingStatusSnapshot} object.
+ */
+declare function serializeOmnichainIndexingStatusSnapshot(indexingStatus: OmnichainIndexingStatusSnapshot): SerializedOmnichainIndexingStatusSnapshot;
 
 /**
  * Identifiers for each traceable ENS protocol.
@@ -1421,26 +1902,197 @@ interface MultichainPrimaryNameResolutionArgs {
  * The result of performing MultichainPrimaryNameResolution
  */
 type MultichainPrimaryNameResolutionResult = Record<ChainId, Name | null>;
+/**
+ * The resolution status for an `Identity`.
+ */
+declare const ResolutionStatusIds: {
+    /**
+     * Represents that the `Identity` is not resolved yet.
+     */
+    readonly Unresolved: "unresolved";
+    /**
+     * Represents that resolution of the `Identity` resulted in a named identity.
+     */
+    readonly Named: "named";
+    /**
+     * Represents that resolution of the `Identity` resulted in an unnamed identity.
+     */
+    readonly Unnamed: "unnamed";
+    /**
+     * Represents that attempted resolution of the `Identity` resulted in an error
+     * and therefore it is unknown if the `Identity` resolves to a named or unnamed identity.
+     */
+    readonly Unknown: "unknown";
+};
+/**
+ * The derived string union of possible {@link ResolutionStatusIds}.
+ */
+type ResolutionStatusId = (typeof ResolutionStatusIds)[keyof typeof ResolutionStatusIds];
+/**
+ * Represents an {@link Identity} that has not become a {@link ResolvedIdentity} yet.
+ *
+ * Invariants:
+ * - `resolutionStatus` is always {@link ResolutionStatusIds.Unresolved}.
+ */
+interface UnresolvedIdentity {
+    resolutionStatus: typeof ResolutionStatusIds.Unresolved;
+    /**
+     * The {@link DefaultableChainId} for an ENSIP-19 primary name lookup of the
+     * identity associated with `address`.
+     */
+    chainId: DefaultableChainId;
+    /**
+     * The {@link Address} of the identity.
+     */
+    address: Address;
+}
+/**
+ * Represents an `Identity` that resolved to a primary name.
+ *
+ * Invariants:
+ * - `resolutionStatus` is always {@link ResolutionStatusIds.Named}.
+ */
+interface NamedIdentity {
+    resolutionStatus: typeof ResolutionStatusIds.Named;
+    /**
+     * The {@link DefaultableChainId} for an ENSIP-19 primary name lookup of the
+     * identity associated with `address`.
+     */
+    chainId: DefaultableChainId;
+    /**
+     * The address of the identity.
+     */
+    address: Address;
+    /**
+     * The ENSIP-19 primary name lookup result of `address` on `chainId`.
+     */
+    name: Name;
+}
+/**
+ * Represents an `Identity` that did not resolve to a primary name.
+ *
+ * Invariants:
+ * - `resolutionStatus` is always {@link ResolutionStatusIds.Unnamed}.
+ * - `name` is always `null`.
+ */
+interface UnnamedIdentity {
+    resolutionStatus: typeof ResolutionStatusIds.Unnamed;
+    /**
+     * The {@link DefaultableChainId} for an ENSIP-19 primary name lookup of the
+     * identity associated with `address`.
+     */
+    chainId: DefaultableChainId;
+    /**
+     * The address of the identity.
+     */
+    address: Address;
+    /**
+     * The ENSIP-19 primary name lookup result of `address` on `chainId`.
+     */
+    name: null;
+}
+/**
+ * Represents an `Identity` that was attempted to be resolved but the resolution attempt
+ * resulted in an error and therefore it is unknown if the `Identity` resolves to a named
+ * or unnamed identity.
+ *
+ * Invariants:
+ * - `resolutionStatus` is always {@link ResolutionStatusIds.Unknown}.
+ */
+interface UnknownIdentity {
+    resolutionStatus: typeof ResolutionStatusIds.Unknown;
+    /**
+     * The {@link DefaultableChainId} for an ENSIP-19 primary name lookup of the
+     * identity associated with `address`.
+     */
+    chainId: DefaultableChainId;
+    /**
+     * The address of the identity.
+     */
+    address: Address;
+}
+/**
+ * Represents an ENSIP-19 identity resolution result.
+ *
+ * Use the `resolutionStatus` field to determine the specific type interpretation
+ * at runtime.
+ */
+type ResolvedIdentity = NamedIdentity | UnnamedIdentity | UnknownIdentity;
+/**
+ * Represents an ENSIP-19 identity resolution (which may or not have been
+ * resolved to a result yet).
+ *
+ * Use the `resolutionStatus` field to determine the specific type interpretation
+ * at runtime.
+ */
+type Identity = UnresolvedIdentity | ResolvedIdentity;
 
+declare const getCommonCoinTypes: (namespace: ENSNamespaceId) => CoinType[];
 declare const DefaultRecordsSelection: {
     readonly mainnet: {
-        readonly addresses: [_ensdomains_address_encoder.CoinType, ..._ensdomains_address_encoder.CoinType[]];
+        readonly addresses: CoinType[];
         readonly texts: ["url", "avatar", "header", "description", "email", "com.twitter", "com.farcaster", "com.github"];
     };
     readonly sepolia: {
-        readonly addresses: [_ensdomains_address_encoder.CoinType, ..._ensdomains_address_encoder.CoinType[]];
+        readonly addresses: CoinType[];
         readonly texts: ["url", "avatar", "header", "description", "email", "com.twitter", "com.farcaster", "com.github"];
     };
     readonly holesky: {
-        readonly addresses: [_ensdomains_address_encoder.CoinType, ..._ensdomains_address_encoder.CoinType[]];
+        readonly addresses: CoinType[];
         readonly texts: ["url", "avatar", "header", "description", "email", "com.twitter", "com.farcaster", "com.github"];
     };
     readonly "ens-test-env": {
-        readonly addresses: [_ensdomains_address_encoder.CoinType, ..._ensdomains_address_encoder.CoinType[]];
+        readonly addresses: CoinType[];
         readonly texts: ["url", "avatar", "header", "description", "email", "com.twitter", "com.farcaster", "com.github"];
     };
 };
 
+/**
+ * Gets the "chainId param" that should be used for a primary name resolution
+ * request.
+ *
+ * ENSIP-19 defines special rules for the "chainId param" used
+ * in primary name resolutions for the case that the `chainId` is the
+ * ENS Root Chain Id for the provided `namespaceId`.
+ *
+ * Whenever this case happens, ENSIP-19 requires that the
+ * "chainId param" is always set to chainId: 1 (mainnet), even if the
+ * `chainId` where the primary name lookup is actually happening
+ * on a non-mainnet ENS Root Chain, such as on a testnet or
+ * the ens-test-env.
+ *
+ * @param namespaceId The namespace id for the primary name lookup.
+ * @param chainId The chain id where the primary name lookup will actually happen.
+ * @returns The "chainId param" that should be used for the primary name lookup.
+ */
+declare const getResolvePrimaryNameChainIdParam: (chainId: DefaultableChainId, namespaceId: ENSNamespaceId) => DefaultableChainId;
+/**
+ * Translates a `DefaultableChainId` a `ChainId`
+ * such that if the provided `chainId` is `DEFAULT_EVM_CHAIN_ID`,
+ * the `ChainId` of the ENS Root Chain for the provided `namespaceId` is returned.
+ *
+ * @param chainId The `DefaultableChainId` to translate.
+ * @param namespaceId The namespace id for the translation.
+ * @returns the translated `ChainId`.
+ */
+declare const translateDefaultableChainIdToChainId: (chainId: DefaultableChainId, namespaceId: ENSNamespaceId) => ChainId;
+
+/**
+ * Builds an {@link UnresolvedIdentity} for the provided {@link Address},
+ * {@link DefaultableChainId} and {@link ENSNamespaceId}.
+ *
+ * If no `chainId` is provided, uses the ENS Root Chain Id for the provided
+ * `namespaceId`.
+ */
+declare function buildUnresolvedIdentity(address: Address, namespaceId: ENSNamespaceId, chainId?: DefaultableChainId): UnresolvedIdentity;
+/**
+ * Returns whether the provided {@link Identity} is a {@link ResolvedIdentity}.
+ *
+ * @param identity - The {@link Identity} to check.
+ * @returns Whether the provided {@link Identity} is a {@link ResolvedIdentity}.
+ */
+declare function isResolvedIdentity(identity: Identity): identity is ResolvedIdentity;
+
 /**
  * API Error Response Type
  */
@@ -1492,36 +2144,46 @@ interface ResolvePrimaryNamesResponse extends AcceleratableResponse, TraceableRe
  */
 type ConfigResponse = ENSIndexerPublicConfig;
 /**
- * ENSIndexer Overall Indexing Status Request
+ * Represents a request to Indexing Status API.
+ */
+type IndexingStatusRequest = {};
+/**
+ * A status code for indexing status responses.
  */
-interface IndexingStatusRequest {
+declare const IndexingStatusResponseCodes: {
     /**
-     * Max Realtime Distance (optional)
-     *
-     * A duration value in seconds, representing the max allowed distance
-     * between the latest indexed block of each chain and the “tip” of
-     * all indexed chains. Setting this parameter influences the HTTP response
-     * code as follows:
-     * - Success (200 OK): The latest indexed block of each chain
-     *   is within the requested distance from realtime.
-     * - Service Unavailable (503): The latest indexed block of each chain
-     *   is NOT within the requested distance from realtime.
-     */
-    maxRealtimeDistance?: Duration;
-}
+     * Represents that the indexing status is available.
+     */
+    readonly Ok: "ok";
+    /**
+     * Represents that the indexing status is unavailable.
+     */
+    readonly Error: "error";
+};
 /**
- * ENSIndexer Overall Indexing Status Response
+ * The derived string union of possible {@link IndexingStatusResponseCodes}.
  */
-type IndexingStatusResponse = ENSIndexerOverallIndexingStatus;
+type IndexingStatusResponseCode = (typeof IndexingStatusResponseCodes)[keyof typeof IndexingStatusResponseCodes];
 /**
- * ENSIndexer Overall Indexing Status Response Codes
- *
- * Define a custom response code for known responses.
+ * An indexing status response when the indexing status is available.
  */
-declare const IndexingStatusResponseCodes: {
-    readonly IndexerError: 512;
-    readonly RequestedDistanceNotAchievedError: 513;
+type IndexingStatusResponseOk = {
+    responseCode: typeof IndexingStatusResponseCodes.Ok;
+    realtimeProjection: RealtimeIndexingStatusProjection;
+};
+/**
+ * An indexing status response when the indexing status is unavailable.
+ */
+type IndexingStatusResponseError = {
+    responseCode: typeof IndexingStatusResponseCodes.Error;
 };
+/**
+ * Indexing status response.
+ *
+ * Use the `responseCode` field to determine the specific type interpretation
+ * at runtime.
+ */
+type IndexingStatusResponse = IndexingStatusResponseOk | IndexingStatusResponseError;
 
 /**
  * Default ENSNode API endpoint URL
@@ -1570,6 +2232,9 @@ declare class ENSNodeClient {
     /**
      * Resolves records for an ENS name (Forward Resolution).
      *
+     * The returned `name` field, if set, is guaranteed to be a [Normalized Name](https://ensnode.io/docs/reference/terminology#normalized-name).
+     * If the name record returned by the resolver is not normalized, `null` is returned as if no name record was set.
+     *
      * @param name The ENS Name whose records to resolve
      * @param selection selection of Resolver records
      * @param options additional options
@@ -1601,9 +2266,13 @@ declare class ENSNodeClient {
     /**
      * Resolves the primary name of a specified address (Reverse Resolution) on a specific chain.
      *
-     * If the `address` specifies a valid [ENSIP-19 Default Name](https://docs.ens.domains/ensip/19/#default-primary-name),
-     * the Default Name will be returned. You _may_ query the Default EVM Chain Id (`0`) in order to
-     * determine the `address`'s Default Name directly.
+     * If the chainId-specific Primary Name is not defined, but the `address` specifies a valid
+     * [ENSIP-19 Default Name](https://docs.ens.domains/ensip/19/#default-primary-name), the Default
+     * Name will be returned. You _may_ query the Default EVM Chain Id (`0`) in order to determine the
+     * `address`'s Default Name directly.
+     *
+     * The returned Primary Name, if set, is guaranteed to be a [Normalized Name](https://ensnode.io/docs/reference/terminology#normalized-name).
+     * If the primary name set for the address is not normalized, `null` is returned as if no primary name was set.
      *
      * @param address The Address whose Primary Name to resolve
      * @param chainId The chain id within which to query the address' ENSIP-19 Multichain Primary Name
@@ -1632,10 +2301,14 @@ declare class ENSNodeClient {
     /**
      * Resolves the primary names of a specified address across multiple chains.
      *
-     * If the `address` specifies a valid [ENSIP-19 Default Name](https://docs.ens.domains/ensip/19/#default-primary-name),
-     * the Default Name will be returned for all chainIds for which there is not a chain-specific
-     * Primary Name. To avoid misuse, you _may not_ query the Default EVM Chain Id (`0`) directly, and
-     * should rely on the aforementioned per-chain defaulting behavior.
+     * For each Primary Name, if the chainId-specific Primary Name is not defined, but the `address`
+     * specifies a valid [ENSIP-19 Default Name](https://docs.ens.domains/ensip/19/#default-primary-name),
+     * the Default Name will be returned. You _may not_ query the Default EVM Chain Id (`0`) directly,
+     * and should rely on the aforementioned per-chain defaulting behavior.
+     *
+     * Each returned Primary Name, if set, is guaranteed to be a [Normalized Name](https://ensnode.io/docs/reference/terminology#normalized-name).
+     * If the primary name set for the address on any chain is not normalized, `null` is returned for
+     * that chain as if no primary name was set.
      *
      * @param address The Address whose Primary Names to resolve
      * @param options additional options
@@ -1653,12 +2326,12 @@ declare class ENSNodeClient {
      *
      * console.log(names);
      * // {
-     * //   "1": "gregskril.eth",
-     * //   "10": "gregskril.eth",
-     * //   "8453": "greg.base.eth", // base-specific Primary Name!
-     * //   "42161": "gregskril.eth",
-     * //   "59144": "gregskril.eth",
-     * //   "534352": "gregskril.eth"
+     * //   "1": "gregskril.eth", // Default Primary Name
+     * //   "10": "gregskril.eth", // Default Primary Name
+     * //   "8453": "greg.base.eth", // Base-specific Primary Name!
+     * //   "42161": "gregskril.eth", // Default Primary Name
+     * //   "59144": "gregskril.eth", // Default Primary Name
+     * //   "534352": "gregskril.eth" // Default Primary Name
      * // }
      *
      * // Resolve the address' Primary Names on specific chain Ids
@@ -1687,27 +2360,34 @@ declare class ENSNodeClient {
     /**
      * Fetch ENSNode Indexing Status
      *
-     * Fetch the ENSNode's multichain indexing status.
-     *
-     * @param options additional options
-     * @param options.maxRealtimeDistance the max allowed distance between the
-     *  latest indexed block of each chain and the "tip" of all indexed chains.
-     *  Setting this parameter influences the HTTP response code as follows:
-     *  - Success (200 OK): The latest indexed block of each chain is within the
-     *    requested distance from realtime.
-     *  - Service Unavailable (503): The latest indexed block of each chain is NOT
-     *    within the requested distance from realtime.
-     *
      * @returns {IndexingStatusResponse}
      *
      * @throws if the ENSNode request fails
      * @throws if the ENSNode API returns an error response
      * @throws if the ENSNode response breaks required invariants
      */
-    indexingStatus(options?: IndexingStatusRequest): Promise<IndexingStatusResponse>;
+    indexingStatus(): Promise<IndexingStatusResponse>;
+}
+
+/**
+ * Serialized representation of {@link IndexingStatusResponseError}.
+ */
+type SerializedIndexingStatusResponseError = IndexingStatusResponseError;
+/**
+ * Serialized representation of {@link IndexingStatusResponseOk}.
+ */
+interface SerializedIndexingStatusResponseOk extends Omit<IndexingStatusResponseOk, "realtimeProjection"> {
+    realtimeProjection: SerializedRealtimeIndexingStatusProjection;
 }
+/**
+ * Serialized representation of {@link IndexingStatusResponse}.
+ */
+type SerializedIndexingStatusResponse = SerializedIndexingStatusResponseOk | SerializedIndexingStatusResponseError;
 
 declare function deserializeErrorResponse(maybeErrorResponse: unknown): ErrorResponse;
+declare function deserializeIndexingStatusResponse(maybeResponse: SerializedIndexingStatusResponse): IndexingStatusResponse;
+
+declare function serializeIndexingStatusResponse(response: IndexingStatusResponse): SerializedIndexingStatusResponse;
 
 declare class ClientError extends Error {
     details?: unknown;
@@ -1715,4 +2395,4 @@ declare class ClientError extends Error {
     static fromErrorResponse({ message, details }: ErrorResponse): ClientError;
 }
 
-export { ATTR_PROTOCOL_NAME, ATTR_PROTOCOL_STEP, ATTR_PROTOCOL_STEP_RESULT, type AcceleratableRequest, type AcceleratableResponse, type AccountId, BASENAMES_NODE, type BlockNumber, type BlockRef, type Blockrange, type Cache, type ChainId, type ChainIdString, type ChainIndexingActiveStatus, type ChainIndexingBackfillStatus, type ChainIndexingCompletedStatus, type ChainIndexingConfig, type ChainIndexingDefiniteConfig, type ChainIndexingFollowingStatus, type ChainIndexingIndefiniteConfig, type ChainIndexingStandbyStatus, type ChainIndexingStatus, type ChainIndexingStatusForBackfillOverallStatus, type ChainIndexingStatusId, ChainIndexingStatusIds, type ChainIndexingStrategyId, ChainIndexingStrategyIds, type ChainIndexingUnstartedStatus, ClientError, type ClientOptions, type ConfigResponse, DEFAULT_ENSNODE_API_URL, DEFAULT_EVM_CHAIN_ID, DEFAULT_EVM_COIN_TYPE, type Datetime, type DatetimeISO8601, type DeepPartial, DefaultRecordsSelection, type DependencyInfo, type Duration, type ENSIndexerOverallIndexingBackfillStatus, type ENSIndexerOverallIndexingCompletedStatus, type ENSIndexerOverallIndexingErrorStatus, type ENSIndexerOverallIndexingFollowingStatus, type ENSIndexerOverallIndexingStatus, type ENSIndexerOverallIndexingUnstartedStatus, type ENSIndexerPublicConfig, ENSNodeClient, ETH_COIN_TYPE, ETH_NODE, type EncodedLabelHash, type EnsRainbowClientLabelSet, type EnsRainbowServerLabelSet, type ErrorResponse, type ForwardResolutionArgs, ForwardResolutionProtocolStep, type ForwardResolutionResult, type IndexingStatusRequest, type IndexingStatusResponse, IndexingStatusResponseCodes, LINEANAMES_NODE, type Label, type LabelHash, type LabelSetId, type LabelSetVersion, LruCache, type MultichainPrimaryNameResolutionArgs, type MultichainPrimaryNameResolutionResult, type Name, type Node, type OverallIndexingStatusId, OverallIndexingStatusIds, PROTOCOL_ATTRIBUTE_PREFIX, PluginName, type ProtocolSpan, type ProtocolSpanTreeNode, type ProtocolTrace, REVERSE_ROOT_NODES, ROOT_NODE, type ResolvePrimaryNameRequest, type ResolvePrimaryNameResponse, type ResolvePrimaryNamesRequest, type ResolvePrimaryNamesResponse, type ResolveRecordsRequest, type ResolveRecordsResponse, type ResolverRecordsResponse, type ResolverRecordsResponseBase, type ResolverRecordsSelection, type ReverseResolutionArgs, ReverseResolutionProtocolStep, type ReverseResolutionResult, type RpcUrl, type SerializedENSIndexerOverallIndexingBackfillStatus, type SerializedENSIndexerOverallIndexingCompletedStatus, type SerializedENSIndexerOverallIndexingErrorStatus, type SerializedENSIndexerOverallIndexingFollowingStatus, type SerializedENSIndexerOverallIndexingStatus, type SerializedENSIndexerOverallIndexingUnstartedStatus, type SerializedENSIndexerPublicConfig, type SerializedIndexedChainIds, TraceableENSProtocol, type TraceableRequest, type TraceableResponse, type UnixTimestamp, type UrlString, accountIdEqual, addrReverseLabel, bigintToCoinType, buildEnsRainbowClientLabelSet, buildLabelSetId, buildLabelSetVersion, checkChainIndexingStatusesForBackfillOverallStatus, checkChainIndexingStatusesForCompletedOverallStatus, checkChainIndexingStatusesForFollowingOverallStatus, checkChainIndexingStatusesForUnstartedOverallStatus, coinTypeReverseLabel, coinTypeToEvmChainId, createIndexingConfig, deserializeBlockNumber, deserializeBlockRef, deserializeBlockrange, deserializeChainId, deserializeDatetime, deserializeDuration, deserializeENSIndexerIndexingStatus, deserializeENSIndexerPublicConfig, deserializeErrorResponse, deserializeUrl, evmChainIdToCoinType, getActiveChains, getNameHierarchy, getOmnichainIndexingCursor, getOverallApproxRealtimeDistance, getOverallIndexingStatus, getStandbyChains, getTimestampForHighestOmnichainKnownBlock, getTimestampForLowestOmnichainStartBlock, invariant_isSubgraphCompatibleRequirements, invariant_reverseResolversPluginNeedsResolverRecords, isLabelIndexable, isNormalized, isSelectionEmpty, isSubgraphCompatible, labelHashToBytes, makeDatabaseSchemaNameSchema, makeDependencyInfoSchema, makeENSIndexerPublicConfigSchema, makeFullyPinnedLabelSetSchema, makeIndexedChainIdsSchema, makeLabelSetIdSchema, makeLabelSetVersionSchema, makePluginsListSchema, makeSubdomainNode, maybeHealLabelByReverseAddress, parseNonNegativeInteger, parseReverseName, reverseName, serializeChainId, serializeChainIndexingStatuses, serializeDatetime, serializeENSIndexerIndexingStatus, serializeENSIndexerPublicConfig, serializeIndexedChainIds, serializeUrl, sortAscChainStatusesByStartBlock, uint256ToHex32, uniq, validateSupportedLabelSetAndVersion };
+export { ADDR_REVERSE_NODE, ATTR_PROTOCOL_NAME, ATTR_PROTOCOL_STEP, ATTR_PROTOCOL_STEP_RESULT, type AcceleratableRequest, type AcceleratableResponse, type AccountId, BASENAMES_NODE, type BlockNumber, type BlockRef, type Blockrange, type Cache, type ChainId, type ChainIdString, type ChainIndexingConfig, type ChainIndexingConfigDefinite, type ChainIndexingConfigIndefinite, type ChainIndexingConfigTypeId, ChainIndexingConfigTypeIds, 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, DEFAULT_ENSNODE_API_URL, DEFAULT_EVM_CHAIN_ID, DEFAULT_EVM_COIN_TYPE, type DNSEncodedLiteralName, type DNSEncodedName, type DNSEncodedPartiallyInterpretedName, type Datetime, type DatetimeISO8601, type DeepPartial, DefaultRecordsSelection, type DefaultableChainId, type Duration, type ENSIndexerPublicConfig, type ENSIndexerVersionInfo, ENSNodeClient, ETH_COIN_TYPE, ETH_NODE, type EncodedLabelHash, type EnsRainbowClientLabelSet, 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 LabelSetId, type LabelSetVersion, type LiteralLabel, type LiteralName, LruCache, type MultichainPrimaryNameResolutionArgs, type MultichainPrimaryNameResolutionResult, type Name, type NamedIdentity, type Node, type NormalizedName, type OmnichainIndexingStatusId, OmnichainIndexingStatusIds, type OmnichainIndexingStatusSnapshot, type OmnichainIndexingStatusSnapshotBackfill, type OmnichainIndexingStatusSnapshotCompleted, type OmnichainIndexingStatusSnapshotFollowing, type OmnichainIndexingStatusSnapshotUnstarted, PROTOCOL_ATTRIBUTE_PREFIX, PluginName, type ProtocolSpan, type ProtocolSpanTreeNode, type ProtocolTrace, ROOT_NODE, type RealtimeIndexingStatusProjection, type ResolutionStatusId, ResolutionStatusIds, type ResolvePrimaryNameRequest, type ResolvePrimaryNameResponse, type ResolvePrimaryNamesRequest, type ResolvePrimaryNamesResponse, type ResolveRecordsRequest, type ResolveRecordsResponse, type ResolvedIdentity, type ResolverRecordsResponse, type ResolverRecordsResponseBase, type ResolverRecordsSelection, type ReverseResolutionArgs, ReverseResolutionProtocolStep, type ReverseResolutionResult, type RpcUrl, type SerializedChainIndexingStatusSnapshot, type SerializedChainIndexingStatusSnapshotBackfill, type SerializedChainIndexingStatusSnapshotCompleted, type SerializedChainIndexingStatusSnapshotFollowing, type SerializedChainIndexingStatusSnapshotQueued, type SerializedCrossChainIndexingStatusSnapshot, type SerializedCrossChainIndexingStatusSnapshotOmnichain, type SerializedCurrentIndexingProjectionOmnichain, type SerializedENSIndexerPublicConfig, type SerializedENSIndexerVersionInfo, type SerializedIndexedChainIds, type SerializedIndexingStatusResponse, type SerializedIndexingStatusResponseError, type SerializedIndexingStatusResponseOk, type SerializedOmnichainIndexingStatusSnapshot, type SerializedOmnichainIndexingStatusSnapshotBackfill, type SerializedOmnichainIndexingStatusSnapshotCompleted, type SerializedOmnichainIndexingStatusSnapshotFollowing, type SerializedOmnichainIndexingStatusSnapshotUnstarted, type SerializedRealtimeIndexingStatusProjection, type SubgraphInterpretedLabel, type SubgraphInterpretedName, TraceableENSProtocol, type TraceableRequest, type TraceableResponse, type UnixTimestamp, type UnknownIdentity, type UnnamedIdentity, type UnresolvedIdentity, type UrlString, accountIdEqual, addrReverseLabel, asLowerCaseAddress, beautifyName, bigintToCoinType, buildEnsRainbowClientLabelSet, buildLabelSetId, buildLabelSetVersion, buildUnresolvedIdentity, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted, coinTypeReverseLabel, coinTypeToEvmChainId, createIndexingConfig, createRealtimeIndexingStatusProjection, decodeDNSEncodedLiteralName, decodeDNSEncodedName, deserializeBlockNumber, deserializeBlockRef, deserializeBlockrange, deserializeChainId, deserializeChainIndexingStatusSnapshot, deserializeCrossChainIndexingStatusSnapshot, deserializeDatetime, deserializeDuration, deserializeENSIndexerPublicConfig, deserializeErrorResponse, deserializeIndexingStatusResponse, deserializeOmnichainIndexingStatusSnapshot, deserializeRealtimeIndexingStatusProjection, deserializeUnixTimestamp, deserializeUrl, encodeLabelHash, evmChainIdToCoinType, getCommonCoinTypes, getNameHierarchy, getOmnichainIndexingCursor, getOmnichainIndexingStatus, getResolvePrimaryNameChainIdParam, getTimestampForHighestOmnichainKnownBlock, getTimestampForLowestOmnichainStartBlock, interpretedLabelsToInterpretedName, isHttpProtocol, isNormalizedLabel, isNormalizedName, isResolvedIdentity, isSelectionEmpty, isSubgraphCompatible, isWebSocketProtocol, labelHashToBytes, labelhashLiteralLabel, literalLabelToInterpretedLabel, literalLabelsToInterpretedName, literalLabelsToLiteralName, makeSubdomainNode, parseNonNegativeInteger, parseReverseName, reverseName, serializeChainId, serializeChainIndexingSnapshots, serializeCrossChainIndexingStatusSnapshotOmnichain, serializeDatetime, serializeENSIndexerPublicConfig, serializeIndexedChainIds, serializeIndexingStatusResponse, serializeOmnichainIndexingStatusSnapshot, serializeRealtimeIndexingStatusProjection, serializeUrl, sortChainStatusesByStartBlockAsc, translateDefaultableChainIdToChainId, uint256ToHex32, uniq, validateSupportedLabelSetAndVersion };