@ensnode/ensnode-sdk 0.0.0-next-20260102143513

package/dist/index.d.ts

@@ -0,0 +1,4592 @@
+import z$1, { z } from 'zod/v4';
+import { ENSNamespaceId, DatasourceName } from '@ensnode/datasources';
+export { ENSNamespaceId, ENSNamespaceIds, getENSRootChainId } from '@ensnode/datasources';
+import { Hex, Address, ByteArray, Hash } from 'viem';
+import { CoinType, EvmCoinType } from '@ensdomains/address-encoder';
+export { CoinType, EvmCoinType } from '@ensdomains/address-encoder';
+import { UnixTimestamp as UnixTimestamp$1, EncodedReferrer, ReferrerLeaderboardPageParams, ReferrerLeaderboardPage, ReferrerDetail, AwardedReferrerMetrics, AggregatedReferrerMetrics, ReferrerDetailRanked, ReferrerDetailUnranked, UnrankedReferrerMetrics, ReferralProgramRules } from '@namehash/ens-referrals';
+export { EncodedReferrer, ZERO_ENCODED_REFERRER, decodeEncodedReferrer } from '@namehash/ens-referrals';
+
+/**
+ * The ETH coinType.
+ *
+ * @see https://docs.ens.domains/ensip/9
+ */
+declare const ETH_COIN_TYPE: CoinType;
+/**
+ * The 'default' chainId corresponding to the below {@link DEFAULT_EVM_COIN_TYPE} in the context of
+ * ENSIP-19.
+ *
+ * @see https://docs.ens.domains/ensip/19
+ */
+declare const DEFAULT_EVM_CHAIN_ID = 0;
+/**
+ * ENSIP-19 EVM CoinType representing the 'default' coinType for EVM chains in ENS.
+ *
+ * @see https://docs.ens.domains/ensip/19/#reverse-resolution
+ */
+declare const DEFAULT_EVM_COIN_TYPE: EvmCoinType;
+/**
+ * Converts a CoinType to an EVM Chain Id.
+ *
+ * NOTE: for whatever reason @ensdomains/address-encoder#coinTypeToEvmChainId doesn't handle the
+ * mainnet case so we implement that here
+ *
+ * @see https://docs.ens.domains/ensip/11/
+ */
+declare const coinTypeToEvmChainId: (coinType: CoinType) => ChainId;
+/**
+ * Converts an EVM Chain Id to a CoinType.
+ *
+ * NOTE: for whatever reason @ensdomains/address-encoder#evmChainIdToCoinType doesn't handle the
+ * mainnet case so we implement that here
+ */
+declare const evmChainIdToCoinType: (chainId: ChainId) => CoinType;
+/**
+ * Converts a bigint value representing a CoinType into a valid CoinType.
+ *
+ * This is useful when onchain events emit coinTypes as bigint but we want to constrain them to
+ * the CoinType type.
+ *
+ * @throws if `value` is too large to fit in Number.MAX_SAFE_INTEGER
+ */
+declare const bigintToCoinType: (value: bigint) => CoinType;
+
+/**
+ * A hash value that uniquely identifies a single ENS name.
+ * Result of `namehash` function as specified in ENSIP-1.
+ *
+ * @example
+ * ```
+ * namehash("vitalik.eth") === "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835"
+ * ```
+ * @see https://docs.ens.domains/ensip/1#namehash-algorithm
+ * @see https://ensnode.io/docs/reference/terminology#name-node-namehash
+ */
+type Node = Hex;
+/**
+ * An ENS Name that may or may not be normalized.
+ *
+ * @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.
+ *
+ * @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.
+ *
+ * @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 formatted
+ * as a non-0x prefixed 32-byte hex string enclosed in square brackets.
+ *
+ * Care should be taken to distinguish Label values formatted as an
+ * EncodedLabelHash as either a LiteralLabel or an InterpretedLabel:
+ * - If a LiteralLabel is formatted as an EncodedLabelHash it does NOT
+ *   symbolically represent the encoding of a LabelHash literal.
+ * - If an InterpretedLabel is formatted as an EncodedLabelHash it should be
+ *   interpreted as encoding a LabelHash literal.
+ *
+ * An InterpretedLabel may be formatted as an EncodedLabelHash if the related
+ * LiteralLabel is:
+ * - not a normalized label
+ * - is an unknown value that could not be healed.
+ * - is too long for DNS-Encoding in contexts where DNS-Encoding was required.
+ *
+ * @example [af2caa1c2ca1d027f1ac823b529d0a67cd144264b2789fa2ea4d63a67c7103cc]
+ *
+ * @see https://ensnode.io/docs/reference/terminology#encoded-labelhash
+ */
+type EncodedLabelHash = `[${string}]`;
+/**
+ * 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
+ *
+ * @dev nominally typed to enforce usage & enhance codebase clarity
+ */
+type DNSEncodedPartiallyInterpretedName = DNSEncodedName & {
+    __brand: "DNSEncodedPartiallyInterpretedName";
+};
+
+declare const ROOT_NODE: Node;
+declare const ETH_NODE: Node;
+declare const BASENAMES_NODE: Node;
+declare const LINEANAMES_NODE: Node;
+declare const ADDR_REVERSE_NODE: Node;
+
+/**
+ * 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[];
+
+/**
+ * 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;
+/**
+ * Checks if the input value is an {@link EncodedLabelHash}.
+ */
+declare function isEncodedLabelHash(maybeEncodedLabelHash: string): maybeEncodedLabelHash is EncodedLabelHash;
+
+/**
+ * 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;
+
+/**
+ * Checks if the input is a {@link LabelHash}.
+ *
+ * @see https://ensnode.io/docs/reference/terminology#label-processing-and-classification
+ */
+declare function isLabelHash(maybeLabelHash: string): maybeLabelHash is LabelHash;
+
+/**
+ * Name for the ENS Root
+ */
+declare const ENS_ROOT: Name;
+/**
+ * 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: NormalizedName) => NormalizedName[];
+/**
+ * Get FQDN of parent for a name.
+ */
+declare const getParentNameFQDN: (name: Name) => Name;
+/**
+ * Beautifies a name by converting each normalized label in the provided name to
+ * its "beautified" form. Labels that are not normalized retain their original value.
+ *
+ * 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;
+
+/**
+ * Parse the address and coinType out of an ENSIP-19 reverse name.
+ */
+declare function parseReverseName(name: Name): {
+    address: Address;
+    coinType: CoinType;
+} | null;
+
+/**
+ * Gets the Label used for the reverse names of subnames as per ENSIP-11 & ENSIP-19.
+ *
+ * @see https://docs.ens.domains/ensip/19/#reverse-resolution
+ */
+declare const addrReverseLabel: (address: Address) => LiteralLabel;
+/**
+ * Converts `coinType` to prefix-free hex string.
+ *
+ * @see https://docs.ens.domains/ensip/19
+ */
+declare const coinTypeReverseLabel: (coinType: CoinType) => Label;
+/**
+ * Gets the reverse name for an address according to ENSIP-11 & ENSIP-19.
+ *
+ * @see https://docs.ens.domains/ensip/11#specification
+ * @see https://docs.ens.domains/ensip/19#specification
+ *
+ * @param address - The address to get the reverse name for
+ * @param coinType - The coin type to use for the reverse name
+ * @returns The reverse name for the address
+ *
+ * @example
+ * ```ts
+ * reverseName("0x1234", BigInt(ETH_COIN_TYPE)) // "1234.addr.reverse"
+ * reverseName("0x1234", BigInt(0x80000000)) // "1234.default.reverse"
+ * reverseName("0x1234", BigInt(0x5678)) // "1234.5678.reverse"
+ * ```
+ */
+declare function reverseName(address: Address, coinType: CoinType): Name;
+
+/**
+ * Implements one step of the namehash algorithm, combining `labelHash` with `node` to produce
+ * the `node` of a given subdomain. Note that the order of the arguments is 'reversed' (as compared to
+ * the actual concatenation) in order to improve readability (i.e. read as [labelHash].[node]).
+ */
+declare const makeSubdomainNode: (labelHash: LabelHash, node: Node) => Node;
+/**
+ * Encodes a uint256 bigint as hex string sized to 32 bytes.
+ * Uses include, in the context of ENS, decoding the uint256-encoded tokenId of NFT-issuing contracts
+ * into Node or LabelHash, which is a common behavior in the ENS ecosystem.
+ * (see NameWrapper, ETHRegistrarController)
+ */
+declare const uint256ToHex32: (num: bigint) => Hex;
+
+/**
+ * Chain ID
+ *
+ * Represents a unique identifier for a chain.
+ * 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`.
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-10
+ */
+interface AccountId {
+    chainId: ChainId;
+    address: Address;
+}
+/**
+ * Block Number
+ *
+ * Guaranteed to be a non-negative integer.
+ */
+type BlockNumber = number;
+/**
+ * Datetime value
+ */
+type Datetime = Date;
+/**
+ * Unix timestamp value
+ *
+ * Represents the number of seconds that have elapsed
+ * since January 1, 1970 (midnight UTC/GMT).
+ *
+ * Guaranteed to be an integer. May be zero or negative to represent a time at or
+ * before Jan 1, 1970.
+ */
+type UnixTimestamp = number;
+/**
+ * Represents a URL that is used for RPC endpoints.
+ */
+type RpcUrl = URL;
+/**
+ * BlockRef
+ *
+ * Describes a block.
+ *
+ * We use parameter types to maintain fields layout and documentation across
+ * the domain model and its serialized counterpart.
+ */
+interface BlockRef {
+    /** Block number (height) */
+    number: BlockNumber;
+    /** Block timestamp */
+    timestamp: UnixTimestamp;
+}
+/**
+ * Block range
+ *
+ * Represents a range of blocks
+ */
+interface Blockrange<BlockType = BlockNumber> {
+    /** Start block number */
+    startBlock?: BlockType;
+    /** End block number */
+    endBlock?: BlockType;
+}
+/**
+ * Duration
+ *
+ * Representing a duration in seconds.
+ *
+ * Guaranteed to be a non-negative integer.
+ */
+type Duration = number;
+/**
+ * A utility type that makes all properties of a type optional recursively,
+ * including nested objects and arrays.
+ *
+ * @example
+ * ```typescript
+ * type Config = {
+ *   a: string;
+ *   b: {
+ *     x: number;
+ *     y: { z: boolean };
+ *   };
+ *   c: { id: string }[];
+ * }
+ *
+ * type PartialConfig = DeepPartial<Config>;
+ * // Results in:
+ * // {
+ * //   a?: string;
+ * //   b?: {
+ * //     x?: number;
+ * //     y?: { z?: boolean };
+ * //   };
+ * //   c?: { id?: string }[];
+ * // }
+ *
+ * // Usage:
+ * const update: PartialConfig = { b: { y: { z: true } } };
+ * ```
+ */
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? DeepPartial<U>[] : T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
+/**
+ * Determines where the provided AccountId values represent the same address on the same chain.
+ */
+declare const accountIdEqual: (a: AccountId, b: AccountId) => boolean;
+
+/**
+ * Converts an EVM address to its lowercase representation.
+ *
+ * @param address - EVM address to convert.
+ * @returns The lowercase representation of the EVM address.
+ */
+declare function asLowerCaseAddress(address: Address): Address;
+
+/**
+ * Cache that maps from string -> ValueType.
+ */
+interface Cache<KeyType extends string, ValueType> {
+    /**
+     * Store a value in the cache with the given key.
+     *
+     * @param key Cache key
+     * @param value Value to store
+     */
+    set(key: KeyType, value: ValueType): void;
+    /**
+     * Retrieve a value from the cache with the given key.
+     *
+     * @param key Cache key
+     * @returns The cached value if it exists, otherwise undefined
+     */
+    get(key: KeyType): ValueType | undefined;
+    /**
+     * Clear the cache.
+     */
+    clear(): void;
+    /**
+     * The current number of items in the cache. Always a non-negative integer.
+     */
+    get size(): number;
+    /**
+     * The maximum number of items in the cache. Always a non-negative integer that is >= size().
+     */
+    get capacity(): number;
+}
+
+/**
+ * Cache that maps from string -> ValueType with a LRU (least recently used) eviction policy.
+ *
+ * `get` and `set` are O(1) operations.
+ *
+ * @link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
+ */
+declare class LruCache<KeyType extends string, ValueType> implements Cache<KeyType, ValueType> {
+    private readonly _cache;
+    private readonly _capacity;
+    /**
+     * Create a new LRU cache with the given capacity.
+     *
+     * @param capacity The maximum number of items in the cache. If set to 0, the cache is effectively disabled.
+     * @throws Error if capacity is not a non-negative integer.
+     */
+    constructor(capacity: number);
+    set(key: string, value: ValueType): void;
+    get(key: string): ValueType | undefined;
+    clear(): void;
+    get size(): number;
+    get capacity(): number;
+}
+
+interface SWRCacheOptions<ValueType> {
+    /**
+     * The async function generating a value of `ValueType` to wrap with SWR caching. It may throw an
+     * Error type.
+     */
+    fn: () => Promise<ValueType>;
+    /**
+     * Time-to-live duration of a cached result in seconds. After this duration:
+     * - the currently cached result is considered "stale" but is still retained in the cache
+     *   until successfully replaced.
+     * - Each time the cache is read, if the cached result is "stale" and no background
+     *   revalidation attempt is already in progress, a new background revalidation
+     *   attempt will be made.
+     */
+    ttl: Duration;
+    /**
+     * Optional time-to-proactively-revalidate duration in seconds. After a cached result is
+     * initialized, and this duration has passed, attempts to asynchronously revalidate
+     * the cached result will be proactively made in the background on this interval.
+     */
+    proactiveRevalidationInterval?: Duration;
+    /**
+     * Optional proactive initialization. Defaults to `false`.
+     *
+     * If `true`: The SWR cache will proactively initialize itself.
+     * If `false`: The SWR cache will lazily wait to initialize itself until the first read.
+     */
+    proactivelyInitialize?: boolean;
+}
+/**
+ * Stale-While-Revalidate (SWR) cache for async functions.
+ *
+ * This caching strategy serves cached data immediately (even if stale) while
+ * asynchronously revalidating the cache in the background. This provides:
+ * - Sub-millisecond response times (after first fetch)
+ * - Always available data (serves stale data during revalidation)
+ * - Automatic background updates via configurable intervals
+ *
+ * @example
+ * ```typescript
+ * const cache = new SWRCache({
+ *   fn: async () => fetch('/api/data').then(r => r.json()),
+ *   ttl: 60, // 1 minute TTL
+ *   proactiveRevalidationInterval: 300 // proactively revalidate every 5 minutes
+ * });
+ *
+ * // Returns cached data or waits for initial fetch
+ * const data = await cache.read();
+ *
+ * if (data instanceof Error) { ... }
+ * ```
+ *
+ * @link https://web.dev/stale-while-revalidate/
+ * @link https://datatracker.ietf.org/doc/html/rfc5861
+ */
+declare class SWRCache<ValueType> {
+    private readonly options;
+    private cache;
+    private inProgressRevalidate;
+    private backgroundInterval;
+    constructor(options: SWRCacheOptions<ValueType>);
+    private revalidate;
+    /**
+     * Read the most recently cached result from the `SWRCache`.
+     *
+     * @returns a `ValueType` that was most recently successfully returned by `fn` or `Error` if `fn`
+     * has never successfully returned.
+     */
+    read(): Promise<ValueType | Error>;
+    /**
+     * Destroys the background revalidation interval, if exists.
+     */
+    destroy(): void;
+}
+
+/**
+ * Cache that maps from string -> ValueType with TTL (time-to-live) expiration.
+ *
+ * Items are automatically removed when they expire.
+ */
+declare class TtlCache<KeyType extends string, ValueType> implements Cache<KeyType, ValueType> {
+    private readonly _cache;
+    private readonly _ttl;
+    /**
+     * Create a new TTL cache with the given TTL.
+     *
+     * @param ttl Time-to-live duration in seconds. Items expire after this duration.
+     */
+    constructor(ttl: Duration);
+    private _cleanup;
+    set(key: string, value: ValueType): void;
+    get(key: string): ValueType | undefined;
+    clear(): void;
+    get size(): number;
+    get capacity(): number;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+}
+
+/**
+ * Filter out duplicates.
+ */
+declare const uniq: <T>(arr: T[]) => T[];
+
+/**
+ * Identifiers for supported currencies.
+ *
+ * TODO: Add support for WETH
+ */
+declare const CurrencyIds: {
+    readonly ETH: "ETH";
+    readonly USDC: "USDC";
+    readonly DAI: "DAI";
+};
+type CurrencyId = (typeof CurrencyIds)[keyof typeof CurrencyIds];
+/**
+ * The amount of the currency in the smallest unit of the currency
+ * (see {@link CurrencyInfo.decimals} for the currency).
+ *
+ * Guaranteed to be non-negative.
+ */
+type CurrencyAmount = bigint;
+/**
+ * Serialized representation of {@link CurrencyAmount}.
+ */
+type SerializedCurrencyAmount = string;
+interface PriceEth {
+    currency: typeof CurrencyIds.ETH;
+    amount: CurrencyAmount;
+}
+interface PriceDai {
+    currency: typeof CurrencyIds.DAI;
+    amount: CurrencyAmount;
+}
+interface PriceUsdc {
+    currency: typeof CurrencyIds.USDC;
+    amount: CurrencyAmount;
+}
+type Price = PriceEth | PriceDai | PriceUsdc;
+/**
+ * Serialized representation of {@link PriceEth}.
+ */
+interface SerializedPriceEth extends Omit<PriceEth, "amount"> {
+    amount: SerializedCurrencyAmount;
+}
+/**
+ * Serialized representation of {@link PriceDai}.
+ */
+interface SerializedPriceDai extends Omit<PriceDai, "amount"> {
+    amount: SerializedCurrencyAmount;
+}
+/**
+ * Serialized representation of {@link PriceUsdc}.
+ */
+interface SerializedPriceUsdc extends Omit<PriceUsdc, "amount"> {
+    amount: SerializedCurrencyAmount;
+}
+/**
+ * Serialized representation of {@link Price}.
+ */
+type SerializedPrice = SerializedPriceEth | SerializedPriceDai | SerializedPriceUsdc;
+interface CurrencyInfo {
+    id: CurrencyId;
+    name: string;
+    decimals: number;
+}
+/**
+ * Get currency info for a provided currency.
+ */
+declare function getCurrencyInfo(currencyId: CurrencyId): CurrencyInfo;
+/**
+ * Create price in ETH for given amount.
+ */
+declare function priceEth(amount: Price["amount"]): PriceEth;
+/**
+ * Create price in USDC for given amount.
+ */
+declare function priceUsdc(amount: Price["amount"]): PriceUsdc;
+/**
+ * Create price in DAI for given amount.
+ */
+declare function priceDai(amount: Price["amount"]): PriceDai;
+/**
+ * Check if two prices have the same currency.
+ */
+declare function isPriceCurrencyEqual(priceA: Price, priceB: Price): boolean;
+/**
+ * Check if two {@link Price} values have the same currency and amount.
+ */
+declare function isPriceEqual(priceA: Price, priceB: Price): boolean;
+/**
+ * Add prices
+ *
+ * @param prices at least two {@link Price} values to be added together.
+ * @returns total of all prices.
+ * @throws if not all prices have the same currency.
+ */
+declare function addPrices<const PriceType extends Price = Price>(...prices: [PriceType, PriceType, ...PriceType[]]): PriceType;
+
+/**
+ * Gets the AccountId for the contract in the specified namespace, datasource, and
+ * contract name, or undefined if it is not defined or is not a single AccountId.
+ *
+ * This is useful when you want to retrieve the AccountId for a contract by its name
+ * where it may or may not actually be defined for the given namespace and datasource.
+ *
+ * @param namespaceId - The ENSNamespace identifier (e.g. 'mainnet', 'sepolia', 'holesky',
+ *                      'ens-test-env')
+ * @param datasourceName - The name of the Datasource to search for contractName in
+ * @param contractName - The name of the contract to retrieve
+ * @returns The AccountId of the contract with the given namespace, datasource,
+ *          and contract name, or undefined if it is not found or is not a single AccountId
+ */
+declare const maybeGetDatasourceContract: (namespaceId: ENSNamespaceId, datasourceName: DatasourceName, contractName: string) => AccountId | undefined;
+/**
+ * Gets the AccountId for the contract in the specified namespace, datasource, and
+ * contract name, or throws an error if it is not defined or is not a single AccountId.
+ *
+ * @param namespaceId - The ENSNamespace identifier (e.g. 'mainnet', 'sepolia', 'holesky',
+ *                      'ens-test-env')
+ * @param datasourceName - The name of the Datasource to search for contractName in
+ * @param contractName - The name of the contract to retrieve
+ * @returns The AccountId of the contract with the given namespace, datasource,
+ *          and contract name
+ * @throws Error if the contract is not found or is not a single AccountId
+ */
+declare const getDatasourceContract: (namespaceId: ENSNamespaceId, datasourceName: DatasourceName, contractName: string) => AccountId;
+
+/**
+ * Duration between two moments in time.
+ */
+declare function durationBetween(start: UnixTimestamp, end: UnixTimestamp): Duration;
+/**
+ * Add a duration to a timestamp.
+ */
+declare function addDuration(timestamp: UnixTimestamp, duration: Duration): UnixTimestamp;
+
+/**
+ * Serialized representation of {@link ChainId}.
+ **/
+type ChainIdString = string;
+/**
+ * Datetime value following the ISO 8601 standard.
+ *
+ * @see https://www.iso.org/iso-8601-date-and-time-format.html
+ */
+type DatetimeISO8601 = string;
+/**
+ * Serialized representation of a {@link URL}.
+ */
+type UrlString = string;
+/**
+ * String representation of {@link AccountId}.
+ *
+ * Formatted as a fully lowercase CAIP-10 AccountId.
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-10
+ */
+type AccountIdString = string;
+
+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): {
+    startBlock?: number | undefined;
+    endBlock?: number | undefined;
+};
+declare function deserializeBlockRef(maybeBlockRef: Partial<BlockRef>, valueLabel?: string): BlockRef;
+declare function deserializeDuration(maybeDuration: unknown, valueLabel?: string): Duration;
+declare function parseAccountId(maybeAccountId: unknown, valueLabel?: string): AccountId;
+
+/**
+ * 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 const hasNullByte: (value: string) => boolean;
+declare const stripNullBytes: (value: string) => string;
+
+/**
+ * Converts a bigint value into a number value.
+ *
+ * @throws when value is outside the range of `Number.MIN_SAFE_INTEGER` and
+ * `Number.MAX_SAFE_INTEGER`.
+ */
+declare function bigIntToNumber(n: bigint): number;
+
+/**
+ * Serializes a {@link ChainId} value into its string representation.
+ */
+declare function serializeChainId(chainId: ChainId): ChainIdString;
+/**
+ * Serializes a {@link Datetime} value into its string representation.
+ */
+declare function serializeDatetime(datetime: Datetime): DatetimeISO8601;
+/**
+ * Serializes a {@link URL} value into its string representation.
+ */
+declare function serializeUrl(url: URL): UrlString;
+/**
+ * Serializes a {@link Price} object.
+ */
+declare function serializePrice(price: Price): SerializedPrice;
+/**
+ * Serializes a {@link PriceEth} object.
+ */
+declare function serializePriceEth(price: PriceEth): SerializedPriceEth;
+/**
+ * Format {@link AccountId} object as a string.
+ *
+ * Formatted as a fully lowercase CAIP-10 AccountId.
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-10
+ */
+declare function formatAccountId(accountId: AccountId): AccountIdString;
+
+declare function isHttpProtocol(url: URL): boolean;
+declare function isWebSocketProtocol(url: URL): boolean;
+
+/**
+ * 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,
+ * ensuring that both are operating on the same version of data.
+ *
+ * It is guaranteed to be 1 to 50 characters long and contain only lowercase letters (a-z)
+ * and hyphens (-).
+ */
+type LabelSetId = string;
+/**
+ * A label set version identifies a specific version of a label set. It allows clients to
+ * request data from a specific snapshot in time, ensuring deterministic results.
+ *
+ * It is guaranteed to be a non-negative integer.
+ */
+type LabelSetVersion = number;
+/**
+ * The label set preferences of an ENSRainbow client.
+ */
+interface EnsRainbowClientLabelSet {
+    /**
+     * Optional label set ID that the ENSRainbow server is expected to use. If provided, heal
+     * operations will validate the ENSRainbow server is using this labelSetId.
+     * Required if `labelSetVersion` is defined.
+     */
+    labelSetId?: LabelSetId;
+    /**
+     * Optional highest label set version of label set id to query. Enables deterministic heal
+     * results across time even if the ENSRainbow server ingests label sets with greater versions
+     * than this value. If provided, only labels from label sets with versions less than or equal to this
+     * value will be returned. If not provided, the server will use the latest available version.
+     * When `labelSetVersion` is defined, `labelSetId` must also be defined.
+     */
+    labelSetVersion?: LabelSetVersion;
+}
+/**
+ * The state of label sets managed by an ENSRainbow server.
+ */
+interface EnsRainbowServerLabelSet {
+    /**
+     * The LabelSetId managed by the ENSRainbow server.
+     */
+    labelSetId: LabelSetId;
+    /**
+     * The highest label set version available on the ENSRainbow server for the current
+     * label set ID. This represents the most recent version of the label set that the
+     * server has ingested and can provide label healing results for.
+     */
+    highestLabelSetVersion: LabelSetVersion;
+}
+
+/**
+ * A PluginName is a unique id for a 'plugin': we use the notion of
+ * 'plugins' to describe bundles of indexing logic.
+ */
+declare enum PluginName {
+    Subgraph = "subgraph",
+    Basenames = "basenames",
+    Lineanames = "lineanames",
+    ThreeDNS = "threedns",
+    ProtocolAcceleration = "protocol-acceleration",
+    Registrars = "registrars",
+    TokenScope = "tokenscope"
+}
+/**
+ * Version info about ENSIndexer and its dependencies.
+ */
+interface ENSIndexerVersionInfo {
+    /**
+     * Node.js runtime version
+     *
+     * @see https://nodejs.org/en/about/previous-releases
+     **/
+    nodejs: string;
+    /**
+     * Ponder framework version
+     *
+     * @see https://www.npmjs.com/package/ponder
+     **/
+    ponder: string;
+    /**
+     * ENSDb service version
+     *
+     * Guaranteed to be the same as {@link ENSIndexerVersionInfo.ensIndexer}.
+     * */
+    ensDb: string;
+    /**
+     * ENSIndexer service version
+     *
+     * @see https://ghcr.io/namehash/ensnode/ensindexer
+     **/
+    ensIndexer: string;
+    /**
+     * ENSRainbow service version
+     *
+     * @see https://ghcr.io/namehash/ensnode/ensindexer
+     **/
+    ensRainbow: string;
+    /**
+     * 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.
+ *
+ * We use parameter types to maintain fields layout and documentation across
+ * the domain model and its serialized counterpart.
+ */
+interface ENSIndexerPublicConfig {
+    /**
+     * The ENS namespace that ENSNode operates in the context of.
+     *
+     * See {@link ENSNamespaceIds} for available namespace identifiers.
+     */
+    namespace: ENSNamespaceId;
+    /**
+     * The "fully pinned" label set reference that ENSIndexer will request ENSRainbow use for deterministic label healing across time. This label set reference is "fully pinned" as it requires both the labelSetId and labelSetVersion fields to be defined.
+     */
+    labelSet: Required<EnsRainbowClientLabelSet>;
+    /**
+     * A Postgres database schema name. This instance of ENSIndexer will write
+     * indexed data to the tables in this schema.
+     *
+     * Invariants:
+     * - Must be a non-empty string that is a valid Postgres database schema
+     *   identifier.
+     */
+    databaseSchemaName: string;
+    /**
+     * A set of strings referring to the names of plugins that are active.
+     *
+     * For future-proofing, this is a list of strings that may or may
+     * not be currently valid {@link PluginName} values.
+     *
+     * Invariants:
+     * - A set of strings with at least one value.
+     */
+    plugins: string[];
+    /**
+     * Indexed Chain IDs
+     *
+     * Includes the {@link ChainId} for each chain being indexed.
+     */
+    indexedChainIds: Set<ChainId>;
+    /**
+     * A feature flag to enable/disable ENSIndexer's Subgraph Compatible Indexing Behavior.
+     *
+     * If {@link isSubgraphCompatible} is true, indexing behavior will match that of the legacy ENS
+     * Subgraph.
+     *
+     * ENSIndexer will store and return Literal Labels and Literal Names without further interpretation.
+     * @see https://ensnode.io/docs/reference/terminology#literal-label
+     * @see https://ensnode.io/docs/reference/terminology#literal-name
+     *
+     * If {@link isSubgraphCompatible} is true, the following invariants are true for the ENSIndexerConfig:
+     * 1. only the 'subgraph' plugin is enabled, and
+     * 2. the labelSet must be { labelSetId: 'subgraph', labelSetVersion: 0 }
+     *
+     * If {@link isSubgraphCompatible} is false, ENSIndexer will additionally:
+     *
+     * 1. ENSIndexer will heal all subnames of addr.reverse on the ENS Root Chain.
+     *
+     * 2. ENSIndexer will track both the keys and the values of Resolver records.
+     *
+     * WARNING: Special care must be taken when interacting with indexed resolver record values. It
+     * is unsafe to naively assume that indexed resolver record values are equivalent to the
+     * resolver record values that would be returned through dynamic lookups via the ENS protocol.
+     * For example, if a resolver implements CCIP-Read, the resolver records may not be
+     * discoverable through onchain indexing.
+     *
+     * 3. Literal Labels and Literal Names encountered by ENSIndexer will be Interpreted.
+     * @see https://ensnode.io/docs/reference/terminology#interpreted-label
+     * @see https://ensnode.io/docs/reference/terminology#interpreted-name
+     *
+     * That is,
+     * a) all Labels stored and returned by ENSIndexer will be Interpreted Labels, which are either:
+     *    i. normalized, or
+     *    ii. represented as an Encoded LabelHash of the Literal Label value found onchain, and
+     * b) all Names stored and returned by ENSIndexer will be Interpreted Names, which are exclusively
+     *   composed of Interpreted Labels.
+     */
+    isSubgraphCompatible: boolean;
+    /**
+     * Version info about ENSIndexer.
+     */
+    versionInfo: ENSIndexerVersionInfo;
+}
+
+type SerializedIndexedChainIds = Array<ChainId>;
+/**
+ * Serialized representation of {@link ENSIndexerPublicConfig}
+ */
+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.
+ */
+declare function deserializeENSIndexerPublicConfig(maybeConfig: SerializedENSIndexerPublicConfig, valueLabel?: string): ENSIndexerPublicConfig;
+
+/**
+ * Determines if the provided `config` results in indexing behavior compatible with the legacy ENS
+ * Subgraph.
+ *
+ * @see https://ensnode.io/docs/reference/subgraph-compatibility/
+ */
+declare function isSubgraphCompatible(config: Pick<ENSIndexerPublicConfig, "namespace" | "plugins" | "labelSet">): boolean;
+
+/**
+ * Converts a Labelhash to bytes, with validation
+ * @param labelHash The Labelhash to convert
+ * @returns A ByteArray containing the bytes
+ * @throws Error if `labelHash` is not a valid 32-byte hex string
+ */
+declare function labelHashToBytes(labelHash: LabelHash): ByteArray;
+
+/**
+ * Builds a valid LabelSetId from a string.
+ * @param maybeLabelSetId - The string to validate and convert to a LabelSetId.
+ * @returns A valid LabelSetId.
+ * @throws If the input string is not a valid LabelSetId.
+ */
+declare function buildLabelSetId(maybeLabelSetId: string): LabelSetId;
+/**
+ * Builds a valid LabelSetVersion from a number or string.
+ * @param maybeLabelSetVersion - The number or string to validate and convert to a LabelSetVersion.
+ * @returns A valid LabelSetVersion.
+ * @throws If the input is not a valid LabelSetVersion.
+ */
+declare function buildLabelSetVersion(maybeLabelSetVersion: number | string): LabelSetVersion;
+/**
+ * Builds an EnsRainbowClientLabelSet.
+ * @param labelSetId - The label set ID.
+ * @param labelSetVersion - The label set version.
+ * @returns A valid EnsRainbowClientLabelSet object.
+ * @throws If `labelSetVersion` is defined without `labelSetId`.
+ */
+declare function buildEnsRainbowClientLabelSet(labelSetId?: LabelSetId, labelSetVersion?: LabelSetVersion): EnsRainbowClientLabelSet;
+/**
+ * Validates that the server's label set is compatible with the client's requested label set.
+ * @param serverSet - The label set provided by the server.
+ * @param clientSet - The label set requested by the client.
+ * @throws If the server set is not compatible with the client set.
+ */
+declare function validateSupportedLabelSetAndVersion(serverSet: EnsRainbowServerLabelSet, clientSet: EnsRainbowClientLabelSet): void;
+
+/**
+ * Parses a string into a non-negative integer.
+ * @param input The string to parse
+ * @returns The parsed non-negative integer
+ * @throws Error if the input is not a valid non-negative integer
+ */
+declare function parseNonNegativeInteger(maybeNumber: string): number;
+
+/**
+ * Serializes a {@link ChainConfig} object.
+ */
+declare function serializeIndexedChainIds(indexedChainIds: Set<ChainId>): SerializedIndexedChainIds;
+/**
+ * Serialize a {@link ENSIndexerPublicConfig} object.
+ */
+declare function serializeENSIndexerPublicConfig(config: ENSIndexerPublicConfig): SerializedENSIndexerPublicConfig;
+
+/**
+ * The type of indexing configuration for a chain.
+ */
+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";
+};
+/**
+ * The derived string union of possible {@link ChainIndexingConfigTypeIds}.
+ */
+type ChainIndexingConfigTypeId = (typeof ChainIndexingConfigTypeIds)[keyof typeof ChainIndexingConfigTypeIds];
+/**
+ * Chain indexing config for a chain whose indexing config `configType` is
+ * {@link ChainIndexingConfigTypeIds.Indefinite}.
+ *
+ * Invariants:
+ * - `configType` is always `ChainIndexingConfigTypeIds.Indefinite`.
+ */
+interface ChainIndexingConfigIndefinite {
+    /**
+     * The type of chain indexing config.
+     */
+    configType: typeof ChainIndexingConfigTypeIds.Indefinite;
+    /**
+     * A {@link BlockRef} to the block where indexing of the chain should start.
+     */
+    startBlock: BlockRef;
+}
+/**
+ * Chain indexing config for a chain whose indexing config `configType` is
+ * {@link ChainIndexingConfigTypeIds.Definite}.
+ *
+ * Invariants:
+ * - `configType` is always `ChainIndexingConfigTypeIds.Definite`.
+ * - `startBlock` is always before or the same as `endBlock`.
+ */
+interface ChainIndexingConfigDefinite {
+    /**
+     * The type of chain indexing config.
+     */
+    configType: typeof ChainIndexingConfigTypeIds.Definite;
+    /**
+     * A {@link BlockRef} to the block where indexing of the chain should start.
+     */
+    startBlock: BlockRef;
+    /**
+     * A {@link BlockRef} to the block where indexing of the chain should end.
+     */
+    endBlock: BlockRef;
+}
+/**
+ * Indexing configuration for a chain.
+ *
+ * Use the `configType` field to determine the specific type interpretation
+ * at runtime.
+ */
+type ChainIndexingConfig = ChainIndexingConfigIndefinite | ChainIndexingConfigDefinite;
+/**
+ * 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}.
+ *
+ * Invariants:
+ * - `chainStatus` is always {@link ChainIndexingStatusIds.Queued}.
+ */
+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 snapshot for a chain whose `chainStatus` is
+ * {@link ChainIndexingStatusIds.Backfill}.
+ *
+ * During a backfill, special performance optimizations are applied to
+ * index all blocks between `config.startBlock` and `backfillEndBlock`
+ * as fast as possible.
+ *
+ * Note how `backfillEndBlock` is a "fixed target" that does not change during
+ * the lifetime of an ENSIndexer process instance:
+ * - If the `config` is {@link 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`
+ * - `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 ChainIndexingStatusSnapshotBackfill {
+    /**
+     * The status of indexing the chain at the time the indexing status snapshot
+     * was captured.
+     */
+    chainStatus: typeof ChainIndexingStatusIds.Backfill;
+    /**
+     * The indexing configuration of the chain.
+     */
+    config: ChainIndexingConfig;
+    /**
+     * A {@link BlockRef} to the block that was most recently indexed as of the time the
+     * indexing status snapshot was captured.
+     */
+    latestIndexedBlock: BlockRef;
+    /**
+     * A {@link BlockRef} to the block where the backfill will end.
+     */
+    backfillEndBlock: BlockRef;
+}
+/**
+ * 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 ChainIndexingStatusSnapshotFollowing {
+    /**
+     * The status of indexing the chain at the time the indexing status snapshot
+     * was captured.
+     */
+    chainStatus: typeof ChainIndexingStatusIds.Following;
+    /**
+     * The indexing configuration of the chain.
+     */
+    config: ChainIndexingConfigIndefinite;
+    /**
+     * A {@link BlockRef} to the block that was most recently indexed as of the time the
+     * indexing status snapshot was captured.
+     */
+    latestIndexedBlock: BlockRef;
+    /**
+     * A {@link BlockRef} to the "highest" block that has been discovered by RPCs
+     * and stored in the RPC cache as of the time the indexing status snapshot was
+     * captured.
+     */
+    latestKnownBlock: BlockRef;
+}
+/**
+ * Chain indexing status snapshot for a chain whose `chainStatus` is
+ * {@link ChainIndexingStatusIds.Completed}.
+ *
+ * After the backfill of a chain is completed, if the chain was configured
+ * to be indexed for a definite range, the chain indexing status will transition to
+ * {@link ChainIndexingStatusIds.Completed}.
+ *
+ * Invariants:
+ * - `chainStatus` is always {@link ChainIndexingStatusIds.Completed}.
+ * - `config` is always {@link ChainIndexingConfigDefinite}
+ * - `config.startBlock` is always before or the same as `latestIndexedBlock`
+ * - `latestIndexedBlock` is always the same as `config.endBlock`.
+ */
+interface ChainIndexingStatusSnapshotCompleted {
+    /**
+     * The status of indexing the chain at the time the indexing status snapshot
+     * was captured.
+     */
+    chainStatus: typeof ChainIndexingStatusIds.Completed;
+    /**
+     * The indexing configuration of the chain.
+     */
+    config: ChainIndexingConfigDefinite;
+    /**
+     * A {@link BlockRef} to the block that was most recently indexed as of the time the
+     * indexing status snapshot was captured.
+     */
+    latestIndexedBlock: BlockRef;
+}
+/**
+ * Indexing status snapshot for a single chain.
+ *
+ * Use the `chainStatus` field to determine the specific type interpretation
+ * at runtime.
+ */
+type ChainIndexingStatusSnapshot = ChainIndexingStatusSnapshotQueued | ChainIndexingStatusSnapshotBackfill | ChainIndexingStatusSnapshotFollowing | ChainIndexingStatusSnapshotCompleted;
+/**
+ * The status of omnichain indexing at the time an omnichain indexing status
+ * snapshot is captured.
+ */
+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";
+};
+/**
+ * The derived string union of possible {@link OmnichainIndexingStatusIds}.
+ */
+type OmnichainIndexingStatusId = (typeof OmnichainIndexingStatusIds)[keyof typeof OmnichainIndexingStatusIds];
+/**
+ * Omnichain indexing status snapshot when the overall `omnichainStatus` is
+ * {@link OmnichainIndexingStatusIds.Unstarted}.
+ *
+ * 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 OmnichainIndexingStatusSnapshotUnstarted {
+    /**
+     * The status of omnichain indexing.
+     */
+    omnichainStatus: typeof OmnichainIndexingStatusIds.Unstarted;
+    /**
+     * The indexing status snapshot for each indexed chain.
+     */
+    chains: Map<ChainId, ChainIndexingStatusSnapshotQueued>;
+    /**
+     * The timestamp of omnichain indexing progress across all indexed chains.
+     */
+    omnichainIndexingCursor: UnixTimestamp;
+}
+/**
+ * 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 ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill = ChainIndexingStatusSnapshotQueued | ChainIndexingStatusSnapshotBackfill | ChainIndexingStatusSnapshotCompleted;
+/**
+ * Omnichain indexing status snapshot when the `omnichainStatus` is
+ * {@link OmnichainIndexingStatusIds.Backfill}.
+ *
+ * Invariants:
+ * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Backfill}.
+ * - `chains` is guaranteed to contain at least one chain with a `chainStatus` of
+ *   {@link ChainIndexingStatusIds.Backfill}.
+ * - `chains` is guaranteed to not to contain any chain with a `chainStatus` of
+ *   {@link ChainIndexingStatusIds.Following}
+ * - `omnichainIndexingCursor` is always < the `config.startBlock.timestamp` for all
+ *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Queued}.
+ * - `omnichainIndexingCursor` is always <= the `backfillEndBlock.timestamp` for all
+ *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Backfill}.
+ * - `omnichainIndexingCursor` is always >= the `latestIndexedBlock.timestamp` for all
+ *    chains with `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
+ * - `omnichainIndexingCursor` is always equal to the timestamp of the highest
+ *   `latestIndexedBlock` across all chains that have started indexing
+ *   (`chainStatus` is not {@link ChainIndexingStatusIds.Queued}).
+ */
+interface OmnichainIndexingStatusSnapshotBackfill {
+    /**
+     * The status of omnichain indexing.
+     */
+    omnichainStatus: typeof OmnichainIndexingStatusIds.Backfill;
+    /**
+     * The indexing status snapshot for each indexed chain.
+     */
+    chains: Map<ChainId, ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill>;
+    /**
+     * The timestamp of omnichain indexing progress across all indexed chains.
+     */
+    omnichainIndexingCursor: UnixTimestamp;
+}
+/**
+ * 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 {
+    /**
+     * The status of omnichain indexing.
+     */
+    omnichainStatus: typeof OmnichainIndexingStatusIds.Following;
+    /**
+     * The indexing status snapshot for each indexed chain.
+     */
+    chains: Map<ChainId, ChainIndexingStatusSnapshot>;
+    /**
+     * The timestamp of omnichain indexing progress across all indexed chains.
+     */
+    omnichainIndexingCursor: UnixTimestamp;
+}
+/**
+ * Omnichain indexing status snapshot when the overall `omnichainStatus` is
+ * {@link OmnichainIndexingStatusIds.Completed}.
+ *
+ * Invariants:
+ * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Completed}.
+ * - `chains` is always a map to {@link ChainIndexingStatusSnapshotCompleted} values exclusively.
+ * - `omnichainIndexingCursor` is always equal to the highest
+ *   `latestIndexedBlock.timestamp` for all chains.
+ */
+interface OmnichainIndexingStatusSnapshotCompleted {
+    /**
+     * The status of omnichain indexing.
+     */
+    omnichainStatus: typeof OmnichainIndexingStatusIds.Completed;
+    /**
+     * The indexing status snapshot for each indexed chain.
+     */
+    chains: Map<ChainId, ChainIndexingStatusSnapshotCompleted>;
+    /**
+     * The timestamp of omnichain indexing progress across all indexed chains.
+     */
+    omnichainIndexingCursor: UnixTimestamp;
+}
+/**
+ * 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.
+ *
+ * @see https://ponder.sh/docs/api-reference/ponder/config#parameters
+ */
+declare const CrossChainIndexingStrategyIds: {
+    /**
+     * Represents that the indexing of events across all indexed chains will
+     * proceed in a deterministic "omnichain" ordering by block timestamp, chain ID,
+     * and block number.
+     *
+     * This strategy is "deterministic" in that the order of processing cross-chain indexed
+     * events and each resulting indexed data state transition recorded in ENSDb is always
+     * the same for each ENSIndexer instance operating with an equivalent
+     * `ENSIndexerConfig` and ENSIndexer version. However it also has the drawbacks of:
+     * - increased indexing latency that must wait for the slowest indexed chain to
+     *   add new blocks or to discover new blocks through the configured RPCs.
+     * - if any indexed chain gets "stuck" due to chain or RPC failures, all indexed chains
+     *   will be affected.
+     */
+    readonly Omnichain: "omnichain";
+};
+/**
+ * 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 {
+    /**
+     * The strategy used for indexing one or more chains.
+     */
+    strategy: typeof CrossChainIndexingStrategyIds.Omnichain;
+    /**
+     * The timestamp of the "slowest" latest indexed block timestamp
+     * across all indexed chains.
+     */
+    slowestChainIndexingCursor: UnixTimestamp;
+    /**
+     * The timestamp when the cross-chain indexing status snapshot was generated.
+     *
+     * Due to possible clock skew between different systems this value must be set
+     * to the max of each of the following values to ensure all invariants are followed:
+     * - the current system time of the system generating this cross-chain indexing
+     *   status snapshot.
+     * - the "highest known block timestamp" (see invariants above for full definition).
+     */
+    snapshotTime: UnixTimestamp;
+    /**
+     * The omnichain indexing status snapshot for one or more chains.
+     */
+    omnichainSnapshot: OmnichainIndexingStatusSnapshot;
+}
+/**
+ * Cross-chain indexing status snapshot for one or more chains.
+ *
+ * Use the `strategy` field to determine the specific type interpretation
+ * at runtime.
+ *
+ * Currently, only omnichain indexing is supported. This type could theoretically
+ * be extended to support other cross-chain indexing strategies in the future,
+ * such as Ponder's "multichain" indexing strategy that indexes each chain
+ * independently without deterministic ordering.
+ */
+type CrossChainIndexingStatusSnapshot = CrossChainIndexingStatusSnapshotOmnichain;
+/**
+ * A "realtime" indexing status projection based on worst-case assumptions
+ * from the `snapshot`.
+ *
+ * Invariants:
+ * - `projectedAt` is always >= `snapshot.snapshotTime`.
+ * - `worstCaseDistance` is always equal to
+ *   `projectedAt - snapshot.slowestChainIndexingCursor`.
+ */
+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 ChainIndexingStatusSnapshot}
+ */
+type SerializedChainIndexingStatusSnapshot = ChainIndexingStatusSnapshot;
+/**
+ * Serialized representation of {@link ChainIndexingStatusSnapshotQueued}
+ */
+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 OmnichainIndexingStatusSnapshotBackfill}
+ */
+interface SerializedOmnichainIndexingStatusSnapshotBackfill extends Omit<OmnichainIndexingStatusSnapshotBackfill, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill>;
+}
+/**
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshotCompleted}
+ */
+interface SerializedOmnichainIndexingStatusSnapshotCompleted extends Omit<OmnichainIndexingStatusSnapshotCompleted, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatusSnapshotCompleted>;
+}
+/**
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshotFollowing}
+ */
+interface SerializedOmnichainIndexingStatusSnapshotFollowing extends Omit<OmnichainIndexingStatusSnapshotFollowing, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatusSnapshot>;
+}
+/**
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshot}
+ */
+type SerializedOmnichainIndexingStatusSnapshot = SerializedOmnichainIndexingStatusSnapshotUnstarted | SerializedOmnichainIndexingStatusSnapshotBackfill | SerializedOmnichainIndexingStatusSnapshotCompleted | SerializedOmnichainIndexingStatusSnapshotFollowing;
+/**
+ * Serialized representation of {@link CrossChainIndexingStatusSnapshotOmnichain}
+ */
+interface SerializedCrossChainIndexingStatusSnapshotOmnichain extends Omit<CrossChainIndexingStatusSnapshotOmnichain, "omnichainSnapshot"> {
+    omnichainSnapshot: SerializedOmnichainIndexingStatusSnapshot;
+}
+/**
+ * Serialized representation of {@link CrossChainIndexingStatusSnapshot}
+ */
+type SerializedCrossChainIndexingStatusSnapshot = SerializedCrossChainIndexingStatusSnapshotOmnichain;
+/**
+ * Serialized representation of {@link RealtimeIndexingStatusProjection}
+ */
+interface SerializedCurrentIndexingProjectionOmnichain extends Omit<RealtimeIndexingStatusProjection, "snapshot"> {
+    snapshot: SerializedOmnichainIndexingStatusSnapshot;
+}
+/**
+ * Serialized representation of {@link RealtimeIndexingStatusProjection}
+ */
+interface SerializedRealtimeIndexingStatusProjection extends Omit<RealtimeIndexingStatusProjection, "snapshot"> {
+    snapshot: SerializedCrossChainIndexingStatusSnapshot;
+}
+
+/**
+ * Deserialize into a {@link ChainIndexingSnapshot} object.
+ */
+declare function deserializeChainIndexingStatusSnapshot(maybeSnapshot: SerializedChainIndexingStatusSnapshot, valueLabel?: string): ChainIndexingStatusSnapshot;
+/**
+ * Deserialize an {@link OmnichainIndexingStatusSnapshot} object.
+ */
+declare function deserializeOmnichainIndexingStatusSnapshot(maybeSnapshot: SerializedOmnichainIndexingStatusSnapshot, valueLabel?: string): OmnichainIndexingStatusSnapshot;
+/**
+ * Deserialize an {@link CrossChainIndexingStatusSnapshot} object.
+ */
+declare function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot: SerializedCrossChainIndexingStatusSnapshot, valueLabel?: string): CrossChainIndexingStatusSnapshot;
+/**
+ * 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 getOmnichainIndexingStatus(chains: ChainIndexingStatusSnapshot[]): OmnichainIndexingStatusId;
+/**
+ * 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 getTimestampForLowestOmnichainStartBlock(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
+/**
+ * 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 getTimestampForHighestOmnichainKnownBlock(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
+/**
+ * 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 getOmnichainIndexingCursor(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
+/**
+ * Create {@link ChainIndexingConfig} for given block refs.
+ *
+ * @param startBlock required block ref
+ * @param endBlock optional block ref
+ */
+declare function createIndexingConfig(startBlock: BlockRef, endBlock: BlockRef | null): ChainIndexingConfig;
+/**
+ * Check if Chain Indexing Status Snapshots fit the 'unstarted' overall status
+ * snapshot requirements:
+ * - All chains are guaranteed to have a status of "queued".
+ *
+ * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
+ * {@link ChainIndexingStatusSnapshotQueued}.
+ */
+declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotQueued[];
+/**
+ * Check if Chain Indexing Status Snapshots fit the 'backfill' overall status
+ * snapshot requirements:
+ * - At least one chain is guaranteed to be in the "backfill" status.
+ * - Each chain is guaranteed to have a status of either "queued",
+ *   "backfill" or "completed".
+ *
+ * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
+ * {@link ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill}.
+ */
+declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill[];
+/**
+ * Checks if Chain Indexing Status Snapshots fit the 'completed' overall status
+ * snapshot requirements:
+ * - All chains are guaranteed to have a status of "completed".
+ *
+ * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
+ * {@link ChainIndexingStatusSnapshotCompleted}.
+ */
+declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotCompleted[];
+/**
+ * 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 checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshot[];
+/**
+ * Sort a list of [{@link ChainId}, {@link ChainIndexingStatusSnapshot}] tuples
+ * by the omnichain start block timestamp in ascending order.
+ */
+declare function sortChainStatusesByStartBlockAsc<ChainStatusType extends ChainIndexingStatusSnapshot>(chains: [ChainId, ChainStatusType][]): [ChainId, ChainStatusType][];
+/**
+ * Gets the latest indexed {@link BlockRef} for the given {@link ChainId}.
+ *
+ * @returns the latest indexed {@link BlockRef} for the given {@link ChainId}, or null if the chain
+ *          isn't being indexed at all or is queued and therefore hasn't started indexing yet.
+ */
+declare function getLatestIndexedBlockRef(indexingStatus: CrossChainIndexingStatusSnapshot, chainId: ChainId): BlockRef | null;
+
+/**
+ * Create realtime indexing status projection from
+ * a {@link CrossChainIndexingStatusSnapshot}.
+ */
+declare function createRealtimeIndexingStatusProjection(snapshot: CrossChainIndexingStatusSnapshot, now: UnixTimestamp): RealtimeIndexingStatusProjection;
+
+declare function serializeCrossChainIndexingStatusSnapshotOmnichain({ strategy, slowestChainIndexingCursor, snapshotTime, omnichainSnapshot, }: CrossChainIndexingStatusSnapshot): SerializedCrossChainIndexingStatusSnapshot;
+declare function serializeRealtimeIndexingStatusProjection(indexingProjection: RealtimeIndexingStatusProjection): SerializedRealtimeIndexingStatusProjection;
+/**
+ * Serialize chain indexing snapshots.
+ */
+declare function serializeChainIndexingSnapshots<ChainIndexingStatusSnapshotType extends ChainIndexingStatusSnapshot>(chains: Map<ChainId, ChainIndexingStatusSnapshotType>): Record<ChainIdString, ChainIndexingStatusSnapshotType>;
+/**
+ * Serialize a {@link OmnichainIndexingStatusSnapshot} object.
+ */
+declare function serializeOmnichainIndexingStatusSnapshot(indexingStatus: OmnichainIndexingStatusSnapshot): SerializedOmnichainIndexingStatusSnapshot;
+
+/**
+ * Reasons why TheGraph fallback cannot be used.
+ */
+declare const TheGraphCannotFallbackReasonSchema: z.ZodEnum<{
+    readonly NotSubgraphCompatible: "not-subgraph-compatible";
+    readonly NoApiKey: "no-api-key";
+    readonly NoSubgraphUrl: "no-subgraph-url";
+}>;
+type TheGraphCannotFallbackReason = z.infer<typeof TheGraphCannotFallbackReasonSchema>;
+/**
+ * Configuration for TheGraph fallback behavior.
+ * Indicates whether fallback to TheGraph is possible and the reason if not.
+ */
+declare const TheGraphFallbackSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    canFallback: z.ZodLiteral<true>;
+    url: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    canFallback: z.ZodLiteral<false>;
+    reason: z.ZodEnum<{
+        readonly NotSubgraphCompatible: "not-subgraph-compatible";
+        readonly NoApiKey: "no-api-key";
+        readonly NoSubgraphUrl: "no-subgraph-url";
+    }>;
+}, z.core.$strict>]>;
+type TheGraphFallback = z.infer<typeof TheGraphFallbackSchema>;
+
+/**
+ * Complete public configuration object for ENSApi.
+ *
+ * Contains ENSApi-specific configuration at the top level and
+ * embeds the complete ENSIndexer public configuration.
+ */
+interface ENSApiPublicConfig {
+    /**
+     * ENSApi service version
+     *
+     * @see https://ghcr.io/namehash/ensnode/ensapi
+     */
+    version: string;
+    /**
+     * The Graph Fallback-related info.
+     */
+    theGraphFallback: TheGraphFallback;
+    /**
+     * Complete ENSIndexer public configuration
+     *
+     * Contains all ENSIndexer public configuration including
+     * namespace, plugins, version info, etc.
+     */
+    ensIndexerPublicConfig: ENSIndexerPublicConfig;
+}
+
+/**
+ * Serialized representation of {@link ENSApiPublicConfig}
+ */
+interface SerializedENSApiPublicConfig extends Omit<ENSApiPublicConfig, "ensIndexerPublicConfig"> {
+    /**
+     * Serialized representation of {@link ENSApiPublicConfig.ensIndexerPublicConfig}.
+     */
+    ensIndexerPublicConfig: SerializedENSIndexerPublicConfig;
+}
+
+/**
+ * Deserialize a {@link ENSApiPublicConfig} object.
+ */
+declare function deserializeENSApiPublicConfig(maybeConfig: SerializedENSApiPublicConfig, valueLabel?: string): ENSApiPublicConfig;
+
+/**
+ * Serialize a {@link ENSApiPublicConfig} object.
+ */
+declare function serializeENSApiPublicConfig(config: ENSApiPublicConfig): SerializedENSApiPublicConfig;
+
+/**
+ * Create a Zod schema for validating a serialized ENSApiPublicConfig.
+ *
+ * @param valueLabel - Optional label for the value being validated (used in error messages)
+ */
+declare function makeENSApiPublicConfigSchema(valueLabel?: string): z.ZodObject<{
+    version: z.ZodString;
+    theGraphFallback: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        canFallback: z.ZodLiteral<true>;
+        url: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        canFallback: z.ZodLiteral<false>;
+        reason: z.ZodEnum<{
+            readonly NotSubgraphCompatible: "not-subgraph-compatible";
+            readonly NoApiKey: "no-api-key";
+            readonly NoSubgraphUrl: "no-subgraph-url";
+        }>;
+    }, z.core.$strict>]>;
+    ensIndexerPublicConfig: z.ZodObject<{
+        labelSet: z.ZodObject<{
+            labelSetId: z.ZodString;
+            labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<unknown>, z.ZodInt>;
+        }, z.core.$strip>;
+        indexedChainIds: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>, 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.ZodString>;
+        databaseSchemaName: z.ZodString;
+        versionInfo: z.ZodObject<{
+            nodejs: z.ZodString;
+            ponder: z.ZodString;
+            ensDb: z.ZodString;
+            ensIndexer: z.ZodString;
+            ensNormalize: z.ZodString;
+            ensRainbow: z.ZodString;
+            ensRainbowSchema: z.ZodInt;
+        }, z.core.$strict>;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+
+/**
+ * ENSApi Public Config Response
+ */
+type ConfigResponse = ENSApiPublicConfig;
+
+type SerializedConfigResponse = SerializedENSApiPublicConfig;
+
+/**
+ * Deserialize a {@link ConfigResponse} object.
+ */
+declare function deserializeConfigResponse(serializedResponse: SerializedConfigResponse): ConfigResponse;
+
+declare function serializeConfigResponse(response: ConfigResponse): SerializedConfigResponse;
+
+/**
+ * A status code for indexing status responses.
+ */
+declare const IndexingStatusResponseCodes: {
+    /**
+     * Represents that the indexing status is available.
+     */
+    readonly Ok: "ok";
+    /**
+     * Represents that the indexing status is unavailable.
+     */
+    readonly Error: "error";
+};
+/**
+ * The derived string union of possible {@link IndexingStatusResponseCodes}.
+ */
+type IndexingStatusResponseCode = (typeof IndexingStatusResponseCodes)[keyof typeof IndexingStatusResponseCodes];
+/**
+ * An indexing status response when the indexing status is available.
+ */
+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;
+
+/**
+ * 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;
+
+/**
+ * Deserialize a {@link IndexingStatusResponse} object.
+ */
+declare function deserializeIndexingStatusResponse(maybeResponse: SerializedIndexingStatusResponse): IndexingStatusResponse;
+
+/**
+ * Represents a request to Indexing Status API.
+ */
+type IndexingStatusRequest = {};
+
+declare function serializeIndexingStatusResponse(response: IndexingStatusResponse): SerializedIndexingStatusResponse;
+
+/**
+ * Deserialize a {@link NameTokensResponse} object.
+ */
+declare function deserializedNameTokensResponse(maybeResponse: SerializedNameTokensResponse): NameTokensResponse;
+
+declare const nameTokensPrerequisites: Readonly<{
+    /**
+     * Required plugins to enable Name Tokens API routes.
+     *
+     * 1. `registrars` plugin is required so that data in the `registrationLifecycles`
+     *    table is populated.
+     * 2. `tokenscope` plugin is required so that data in the `nameTokens`
+     *    table is populated.
+     */
+    requiredPlugins: readonly [PluginName.Registrars, PluginName.TokenScope];
+    /**
+     * Check if provided ENSApiPublicConfig supports the Name Tokens API.
+     */
+    hasEnsIndexerConfigSupport(config: ENSIndexerPublicConfig): boolean;
+    /**
+     * Required Indexing Status IDs
+     *
+     * Database indexes are created by the time the omnichain indexing status
+     * is either `completed` or `following`.
+     */
+    supportedIndexingStatusIds: ("omnichain-following" | "omnichain-completed")[];
+    /**
+     * Check if provided indexing status supports the Name Tokens API.
+     */
+    hasIndexingStatusSupport(omnichainIndexingStatusId: OmnichainIndexingStatusId): boolean;
+}>;
+
+/**
+ * Represents request to Name Tokens API.
+ *
+ * Either `domainId` or `name` must be provided, but not both.
+ */
+interface NameTokensRequest {
+    /**
+     * Domain ID (namehash) for which name tokens were requested.
+     */
+    domainId?: Node;
+    /**
+     * Name for which name tokens were requested.
+     */
+    name?: Name;
+}
+
+/**
+ * An enum representing the possible CAIP-19 Asset Namespace values.
+ */
+declare const AssetNamespaces: {
+    readonly ERC721: "erc721";
+    readonly ERC1155: "erc1155";
+};
+type AssetNamespace = (typeof AssetNamespaces)[keyof typeof AssetNamespaces];
+/**
+ * A uint256 value that identifies a specific NFT within a NFT contract.
+ */
+type TokenId = bigint;
+/**
+ * Serialized representation of {@link TokenId}.
+ */
+type SerializedTokenId = string;
+/**
+ * A globally unique reference to an NFT.
+ */
+interface AssetId {
+    assetNamespace: AssetNamespace;
+    contract: AccountId;
+    tokenId: TokenId;
+}
+/**
+ * Serialized representation of {@link AssetId}.
+ */
+interface SerializedAssetId extends Omit<AssetId, "tokenId"> {
+    tokenId: SerializedTokenId;
+}
+/**
+ * String representation of an {@link AssetId}.
+ *
+ * Formatted as a fully lowercase CAIP-19 AssetId.
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-19
+ * @example "eip155:1/erc721:0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85/0xaf2caa1c2ca1d027f1ac823b529d0a67cd144264b2789fa2ea4d63a67c7103cc"
+ *          for vitalik.eth in the eth base registrar on mainnet.
+ */
+type AssetIdString = string;
+/**
+ * Serializes {@link AssetId} object.
+ */
+declare function serializeAssetId(assetId: AssetId): SerializedAssetId;
+/**
+ * Deserialize a {@link AssetId} object.
+ */
+declare function deserializeAssetId(maybeAssetId: unknown, valueLabel?: string): AssetId;
+/**
+ * Format {@link AssetId} object as a string.
+ */
+declare function formatAssetId(assetId: AssetId): AssetIdString;
+/**
+ * Parse a stringified representation of {@link AssetId} object.
+ */
+declare function parseAssetId(maybeAssetId: AssetIdString, valueLabel?: string): AssetId;
+/**
+ * Builds an AssetId for the NFT represented by the given contract,
+ * tokenId, and assetNamespace.
+ *
+ * @param contract - The contract that manages the NFT
+ * @param tokenId - The tokenId of the NFT
+ * @param assetNamespace - The assetNamespace of the NFT
+ * @returns The AssetId for the NFT represented by the given contract,
+ *          tokenId, and assetNamespace
+ */
+declare const buildAssetId: (contract: AccountId, tokenId: TokenId, assetNamespace: AssetNamespace) => AssetId;
+/**
+ * A globally unique reference to an NFT tokenizing the ownership of a domain.
+ */
+interface DomainAssetId extends AssetId {
+    /**
+     * The namehash (node) of the domain who's ownership is tokenized by
+     * this `AssetId`.
+     */
+    domainId: Node;
+}
+/**
+ * Serialized representation of {@link DomainAssetId}.
+ */
+interface SerializedDomainAssetId extends SerializedAssetId {
+    domainId: Node;
+}
+declare function serializeDomainAssetId(domainAsset: DomainAssetId): SerializedDomainAssetId;
+/**
+ * An enum representing the mint status of a DomainAssetId.
+ *
+ * After we index a NFT we never delete it from our index. Instead, when an
+ * indexed NFT is burned onchain we retain its record and update its mint
+ * status as `burned`. If a NFT is minted again after it is burned its mint
+ * status is updated to `minted`.
+ */
+declare const NFTMintStatuses: {
+    readonly Minted: "minted";
+    readonly Burned: "burned";
+};
+type NFTMintStatus = (typeof NFTMintStatuses)[keyof typeof NFTMintStatuses];
+/**
+ * Metadata about a NFT transfer event.
+ *
+ * This metadata can be used for building more helpful messages when processing
+ * NFT transfer events.
+ */
+interface NFTTransferEventMetadata {
+    chainId: ChainId;
+    blockNumber: bigint;
+    transactionHash: Hex;
+    eventHandlerName: string;
+    nft: DomainAssetId;
+}
+declare const formatNFTTransferEventMetadata: (metadata: NFTTransferEventMetadata) => string;
+/**
+ * An enum representing the type of transfer that has occurred to a DomainAssetId.
+ */
+declare const NFTTransferTypes: {
+    /**
+     * Initial transfer from zeroAddress to a non-zeroAddress
+     * Can happen at most once to a NFT AssetId
+     *
+     * Invariants:
+     * - NFT is not indexed and therefore has no previous mint status or owner
+     * - new NFT mint status is `minted`
+     * - new NFT owner is a non-zeroAddress
+     */
+    readonly Mint: "mint";
+    /**
+     * Subsequent transfer from zeroAddress to a non-zeroAddress
+     * Can happen any number of times to a NFT AssetId as it passes in a cycle from
+     * mint -> burn -> remint -> burn -> remint -> ...
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous NFT mint status was `burned`
+     * - previous NFT owner is the zeroAddress
+     * - new NFT mint status is `minted`
+     * - new NFT owner is a non-zeroAddress
+     */
+    readonly Remint: "remint";
+    /**
+     * Special transfer type for improperly implemented NFT contracts that allow a NFT
+     * that is currently minted to be reminted before an intermediate burn.
+     *
+     * Transfer from zeroAddress to non-zeroAddress for an indexed NFT where the
+     * previously indexed nft had status `minted` with a non-zeroAddress owner.
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous NFT mint status was `minted`
+     * - previous NFT owner was a non-zeroAddress
+     * - new NFT mint status is `minted`
+     * - new NFT owner is a non-zeroAddress
+     */
+    readonly MintedRemint: "minted-remint";
+    /**
+     * Transfer from a non-zeroAddress to zeroAddress
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous NFT mint status was `minted`
+     * - previous NFT owner is a non-zeroAddress
+     * - new NFT mint status is `burned`
+     * - new NFT owner is the zeroAddress
+     */
+    readonly Burn: "burn";
+    /**
+     * Transfer from a non-zeroAddress to a distinct non-zeroAddress
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous and new NFT mint status is `minted`
+     * - previous and new NFT owner are distinct non-zeroAddress
+     */
+    readonly Transfer: "transfer";
+    /**
+     * Transfer from a non-zeroAddress to the same non-zeroAddress
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous and new NFT mint status is `minted`
+     * - previous and new NFT owner are equivalent non-zeroAddress
+     */
+    readonly SelfTransfer: "self-transfer";
+    /**
+     * Transfer from zeroAddress to zeroAddress for an indexed NFT
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous and new NFT mint status is `burned`
+     * - previous and new NFT owner are zeroAddress
+     */
+    readonly RemintBurn: "remint-burn";
+    /**
+     * Special transfer type for improperly implemented NFT contracts that allow a NFT
+     * that is currently minted to be reminted again before an intermediate burn.
+     *
+     * Transfer from zeroAddress to zeroAddress for an indexed NFT where the
+     * previously indexed nft had status `minted` with a non-zeroAddress owner.
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous NFT mint status was `minted`
+     * - previous NFT owner was a non-zeroAddress
+     * - new NFT mint status is `burned`
+     * - new NFT owner is the zeroAddress
+     */
+    readonly MintedRemintBurn: "minted-remint-burn";
+    /**
+     * Transfer from zeroAddress to zeroAddress for an unindexed NFT
+     *
+     * Invariants:
+     * - NFT is not indexed and therefore has no previous mint status or owner
+     * - NFT should remain unindexed and without any mint status or owner
+     */
+    readonly MintBurn: "mint-burn";
+};
+type NFTTransferType = (typeof NFTTransferTypes)[keyof typeof NFTTransferTypes];
+declare const getNFTTransferType: (from: Address, to: Address, allowMintedRemint: boolean, metadata: NFTTransferEventMetadata, currentlyIndexedOwner?: Address) => NFTTransferType;
+
+/**
+ * An enum representing the possible Name Token Ownership types.
+ */
+declare const NameTokenOwnershipTypes: {
+    /**
+     * Name Token is owned by NameWrapper account.
+     */
+    readonly NameWrapper: "namewrapper";
+    /**
+     * Name Token is owned fully onchain.
+     *
+     * This ownership type can only apply to direct subnames of `.eth`
+     */
+    readonly FullyOnchain: "fully-onchain";
+    /**
+     * Name Token ownership has been transferred to the null address.
+     */
+    readonly Burned: "burned";
+    /**
+     * Name Token ownership is unknown.
+     */
+    readonly Unknown: "unknown";
+};
+type NameTokenOwnershipType = (typeof NameTokenOwnershipTypes)[keyof typeof NameTokenOwnershipTypes];
+interface NameTokenOwnershipNameWrapper {
+    ownershipType: typeof NameTokenOwnershipTypes.NameWrapper;
+    /**
+     * Owner
+     *
+     * Guarantees:
+     * - `owner.address` is not the zero address.
+     * - `owner.chainId` is same as the chainId of the associated NFT,
+     *    even if that NFT has been burned.
+     */
+    owner: AccountId;
+}
+interface NameTokenOwnershipFullyOnchain {
+    ownershipType: typeof NameTokenOwnershipTypes.FullyOnchain;
+    /**
+     * Owner
+     *
+     * Guarantees:
+     * - `owner.address` is not the zero address.
+     * - `owner.chainId` is same as the chainId of the associated NFT,
+     *    even if that NFT has been burned.
+     */
+    owner: AccountId;
+}
+interface NameTokenOwnershipBurned {
+    ownershipType: typeof NameTokenOwnershipTypes.Burned;
+    /**
+     * Owner
+     *
+     * Guarantees:
+     * - `owner.address` is the zero address.
+     * - `owner.chainId` is same as the chainId of the associated NFT,
+     *    even if that NFT has been burned.
+     */
+    owner: AccountId;
+}
+interface NameTokenOwnershipUnknown {
+    ownershipType: typeof NameTokenOwnershipTypes.Unknown;
+    /**
+     * Owner
+     *
+     * Guarantees:
+     * - `owner.address` is the zero address.
+     * - `owner.chainId` is same as the chainId of the associated NFT,
+     *    even if that NFT has been burned.
+     */
+    owner: AccountId;
+}
+type NameTokenOwnership = NameTokenOwnershipNameWrapper | NameTokenOwnershipFullyOnchain | NameTokenOwnershipBurned | NameTokenOwnershipUnknown;
+interface NameToken {
+    /**
+     * Token
+     *
+     * References the NFT that currently or previously tokenized ownership of
+     * `name`.
+     */
+    token: AssetId;
+    /**
+     * Owner
+     *
+     * Identifies the ownership state of the token.
+     *
+     * Guarantees:
+     * - The `ownership.owner.chainId` of this address is the same as is referenced
+     *   in `domainAsset.contract.chainId`.
+     */
+    ownership: NameTokenOwnership;
+    /**
+     * The mint status of the token.
+     *
+     * After ENSNode indexes the token for a name, even if that token is burned,
+     * ENSNode will never forget how the token once represented the name.
+     * When the token for a name is burned, ENSNode remembers this token but
+     * updates its `mintStatus` to `burned`. If this token becomes minted again
+     * after it was burned, its `mintStatus` is updated to `minted` again.
+     *
+     * NOTE: Tokens managed by the .eth BaseRegistrar for
+     * direct subnames of .eth can only be burned when undergoing
+     * a state transition of `minted` -> `burned` -> `minted` all within
+     * the same registrar action for the case that a direct subname of .eth
+     * has expired and has been fully released and is now being registered again.
+     * Since all of those mint status state transitions are processed within
+     * a single block, once the token managed by the .eth BaseRegistrar for
+     * a direct subname of .eth has been minted, our state model will forever
+     * represent it as `minted`.
+     *
+     * Guarantees:
+     * - The `mintStatus` will be burned if and only
+     *   if `ownership.ownershipType` is `NameTokenOwnershipTypes.Burned`.
+     */
+    mintStatus: NFTMintStatus;
+}
+/**
+ * Serialized representation of {@link NameToken}.
+ */
+interface SerializedNameToken extends Omit<NameToken, "token"> {
+    token: SerializedAssetId;
+}
+declare function serializeNameToken(nameToken: NameToken): SerializedNameToken;
+/**
+ * Get all NameWrapper accounts within provided ENS Namespace.
+ *
+ * Guaranteed to return at least one account for ENSRoot Datasource.
+ */
+declare function getNameWrapperAccounts(namespaceId: ENSNamespaceId): [AccountId, ...AccountId[]];
+/**
+ * Get name token ownership for provided owner account within selected ENS Namespace.
+ */
+declare function getNameTokenOwnership(namespaceId: ENSNamespaceId, name: InterpretedName, owner: AccountId): NameTokenOwnership;
+
+/**
+ * Schema for {@link ErrorResponse}.
+ */
+declare const ErrorResponseSchema: z$1.ZodObject<{
+    message: z$1.ZodString;
+    details: z$1.ZodOptional<z$1.ZodUnknown>;
+}, z$1.core.$strip>;
+
+/**
+ * API Error Response Type
+ */
+type ErrorResponse = z$1.infer<typeof ErrorResponseSchema>;
+
+/**
+ * Deserialize a {@link ErrorResponse} object.
+ */
+declare function deserializeErrorResponse(maybeErrorResponse: unknown): ErrorResponse;
+
+/**
+ * A status code for Name Tokens API responses.
+ */
+declare const NameTokensResponseCodes: {
+    /**
+     * Represents a response when Name Tokens API can respond with requested data.
+     */
+    readonly Ok: "ok";
+    /**
+     * Represents a response when Name Tokens API could not respond with requested data.
+     */
+    readonly Error: "error";
+};
+/**
+ * The derived string union of possible {@link NameTokensResponseCodes}.
+ */
+type NameTokensResponseCode = (typeof NameTokensResponseCodes)[keyof typeof NameTokensResponseCodes];
+/**
+ * Error codes for Name Tokens API responses with 'error' response code.
+ */
+declare const NameTokensResponseErrorCodes: {
+    /**
+     * Name tokens not indexed
+     *
+     * Represents an error when tokens for the requested name are not indexed by
+     * the ENSNode instance's configuration.
+     */
+    readonly NameTokensNotIndexed: "name-tokens-not-indexed";
+    /**
+     * Unsupported ENSIndexer Config
+     *
+     * Represents a prerequisites error when connected ENSIndexer config lacks
+     * params required to enable Name Tokens API.
+     */
+    readonly EnsIndexerConfigUnsupported: "unsupported-ensindexer-config";
+    /**
+     * Unsupported Indexing Status
+     *
+     * Represents a prerequisites error when Indexing Status has not yet reached
+     * status required to enable Name Tokens API.
+     */
+    readonly IndexingStatusUnsupported: "unsupported-indexing-status";
+};
+/**
+ * The derived string union of possible {@link NameTokensResponseErrorCodes}.
+ */
+type NameTokensResponseErrorCode = (typeof NameTokensResponseErrorCodes)[keyof typeof NameTokensResponseErrorCodes];
+/**
+ * Name Tokens for a name who's tokens are configured to
+ * be indexed by the ENSNode instance's configuration.
+ */
+interface RegisteredNameTokens {
+    /**
+     * Domain ID
+     */
+    domainId: Node;
+    /**
+     * Name
+     *
+     * FQDN of the name associated with `domainId`.
+     *
+     * Guarantees:
+     * - `namehash(name)` is always `domainId`.
+     */
+    name: InterpretedName;
+    /**
+     * Name Tokens associated with the `domainId`.
+     *
+     * It contains every tokenized representation of `name` that
+     * has ever been indexed for the given name as of `accurateAsOf`,
+     * even if the given token has been burned or expired.
+     *
+     * Guarantees:
+     * - Always includes at least one name token.
+     * - When it includes more than one name token, it means that:
+     *   1) More than 1 distinct tokenized representation of the ownership of
+     *      the `name` has been indexed as of `accurateAsOf`.
+     *   2) All possible permutations of mint statuses of these tokens are
+     *      possible:
+     *      a) Multiple could be actively minted.
+     *      b) Multiple could be burned.
+     *      c) Some could be burned, others could be minted.
+     *  - Order of name tokens follows the order of onchain events that were
+     *    indexed when a token was minted, or burned.
+     *  - Each name token has a distinct `token` value which references
+     *    the NFT that currently or previously tokenized ownership of `name`.
+     *  - Each name token has ownership type (`ownership.ownershipType`) assigned:
+     *   - If there's a name token with ownership type
+     *     {@link NameTokenOwnershipTypes.NameWrapper}, it means that there must be also
+     *     another name token with ownership type either
+     *     {@link NameTokenOwnershipTypes.FullyOnchain}, or
+     *     {@link NameTokenOwnershipTypes.Unknown}.
+     *   - There can be at most one name token with ownership type
+     *     {@link NameTokenOwnershipTypes.FullyOnchain}.
+     *   - There can be any number of name tokens with ownership type
+     *     {@link NameTokenOwnershipTypes.Burned}.
+     *
+     * NOTE: It can be useful to get tokenized representations of the name that
+     * are now burned: This can be helpful for looking up historical activity for
+     * the name, including past buy orders, sell orders, and sales.
+     *
+     * How will the direct subnames of .eth that are wrapped by the NameWrapper
+     * be represented?
+     * 1) A direct subname of .eth that has been registered but
+     *    has never been wrapped by the NameWrapper, and:
+     *    a) Is still actively minted (independent of its expiry state).
+     *    b) Has been burned by sending it to the null address.
+     * 2) A direct subname of .eth that has been registered and
+     *    has been wrapped by the NameWrapper, and:
+     *    a) Is still actively wrapped by the NameWrapper (independent of its
+     *       expiry state).
+     *    b) Is no longer wrapped by the NameWrapper, but is still actively
+     *       minted by the BaseRegistrar (independent of its expiry state).
+     *    c) Is no longer wrapped by the NameWrapper, and is also no longer
+     *       minted by the BaseRegistrar (both tokens now burned by sending to
+     *       the null address).
+     */
+    tokens: NameToken[];
+    /**
+     * Expiry date for the Registration Lifecycle
+     *
+     * The latest Registration Lifecycle for a node referenced in `domainId`.
+     */
+    expiresAt: UnixTimestamp$1;
+    /**
+     * The {@link UnixTimestamp} of when the data used to build the {@link NameTokensResponseOk.nameTokens} was accurate as of.
+     */
+    accurateAsOf: UnixTimestamp$1;
+}
+/**
+ * A response when Name Tokens API can respond with requested data.
+ */
+type NameTokensResponseOk = {
+    responseCode: typeof NameTokensResponseCodes.Ok;
+    /**
+     * Name Tokens for the requested name.
+     */
+    registeredNameTokens: RegisteredNameTokens;
+};
+/**
+ * Represents an error response when requested name was not indexed by ENSNode.
+ */
+interface NameTokensResponseErrorNameTokensNotIndexed {
+    responseCode: typeof NameTokensResponseCodes.Error;
+    errorCode: typeof NameTokensResponseErrorCodes.NameTokensNotIndexed;
+    error: ErrorResponse;
+}
+/**
+ * Represents an error response when connected ENSIndexer config lacks
+ * params required to enable Name Tokens API.
+ */
+interface NameTokensResponseErrorEnsIndexerConfigUnsupported {
+    responseCode: typeof NameTokensResponseCodes.Error;
+    errorCode: typeof NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported;
+    error: ErrorResponse;
+}
+/**
+ * Represents an error response when Indexing Status has not yet reached
+ * status required to enable Name Tokens API.
+ */
+interface NameTokensResponseErrorIndexingStatusUnsupported {
+    responseCode: typeof NameTokensResponseCodes.Error;
+    errorCode: typeof NameTokensResponseErrorCodes.IndexingStatusUnsupported;
+    error: ErrorResponse;
+}
+type NameTokensResponseError = NameTokensResponseErrorNameTokensNotIndexed | NameTokensResponseErrorEnsIndexerConfigUnsupported | NameTokensResponseErrorIndexingStatusUnsupported;
+/**
+ * Name Tokens response.
+ *
+ * Use the `responseCode` field to determine the specific type interpretation
+ * at runtime.
+ */
+type NameTokensResponse = NameTokensResponseOk | NameTokensResponseError;
+
+/**
+ * Serialized representation of {@link NameTokensResponseError}.
+ */
+type SerializedNameTokensResponseError = NameTokensResponseError;
+/**
+ * Serialized representation of {@link RegisteredNameToken}.
+ */
+interface SerializedRegisteredNameTokens extends Omit<RegisteredNameTokens, "tokens"> {
+    tokens: SerializedNameToken[];
+}
+/**
+ * Serialized representation of {@link NameTokensResponseOk}.
+ */
+interface SerializedNameTokensResponseOk extends Omit<NameTokensResponseOk, "registeredNameTokens"> {
+    registeredNameTokens: SerializedRegisteredNameTokens;
+}
+/**
+ * Serialized representation of {@link NameTokensResponse}.
+ */
+type SerializedNameTokensResponse = SerializedNameTokensResponseOk | SerializedNameTokensResponseError;
+
+declare function serializeRegisteredNameTokens({ domainId, name, tokens, expiresAt, accurateAsOf, }: RegisteredNameTokens): SerializedRegisteredNameTokens;
+declare function serializeNameTokensResponse(response: NameTokensResponse): SerializedNameTokensResponse;
+
+/**
+ * Gets the SubregistryId (an AccountId) of the Basenames Subregistry contract (this is the
+ * "BaseRegistrar" contract for Basenames) for the provided namespace.
+ *
+ * @param namespace The ENS namespace to get the Basenames Subregistry ID for
+ * @returns The AccountId for the Basenames Subregistry contract for the provided namespace.
+ * @throws Error if the contract is not found for the given namespace.
+ */
+declare function getBasenamesSubregistryId(namespace: ENSNamespaceId): AccountId;
+/**
+ * Get the managed name for the Basenames subregistry for the selected ENS namespace.
+ *
+ * @param namespaceId
+ * @returns registrar managed name
+ * @throws an error when no registrar managed name could be returned
+ */
+declare function getBasenamesSubregistryManagedName(namespaceId: ENSNamespaceId): Name;
+
+/**
+ * Gets the SubregistryId (an AccountId) of the Ethnames Subregistry contract (this is the
+ * "BaseRegistrar" contract for direct subnames of .eth) for the provided namespace.
+ *
+ * @param namespace The ENS namespace to get the Ethnames Subregistry ID for
+ * @returns The AccountId for the Ethnames Subregistry contract for the provided namespace.
+ * @throws Error if the contract is not found for the given namespace.
+ */
+declare function getEthnamesSubregistryId(namespace: ENSNamespaceId): AccountId;
+/**
+ * Get the managed name for the Ethnames subregistry for the selected ENS namespace.
+ *
+ * @param namespaceId
+ * @returns registrar managed name
+ */
+declare function getEthnamesSubregistryManagedName(namespaceId: ENSNamespaceId): Name;
+
+/**
+ * Gets the SubregistryId (an AccountId) of the Lineanames Subregistry contract (this is the
+ * "BaseRegistrar" contract for Lineanames) for the provided namespace.
+ *
+ * @param namespace The ENS namespace to get the Lineanames Subregistry ID for
+ * @returns The AccountId for the Lineanames Subregistry contract for the provided namespace.
+ * @throws Error if the contract is not found for the given namespace.
+ */
+declare function getLineanamesSubregistryId(namespace: ENSNamespaceId): AccountId;
+/**
+ * Get the managed name for the Lineanames subregistry for the selected ENS namespace.
+ *
+ * @param namespaceId
+ * @returns registrar managed name
+ * @throws an error when no registrar managed name could be returned
+ */
+declare function getLineanamesSubregistryManagedName(namespaceId: ENSNamespaceId): Name;
+
+/**
+ * Subregistry
+ */
+interface Subregistry {
+    /**
+     * Subregistry ID
+     *
+     * The ID of the subregistry the "logical registrar action" was taken on.
+     *
+     * Identifies the chainId and address of the associated subregistry smart
+     * contract.
+     */
+    subregistryId: AccountId;
+    /**
+     * The node (namehash) of the name the subregistry manages subnames of.
+     * Example subregistry managed names:
+     * - `eth`
+     * - `base.eth`
+     * - `linea.eth`
+     */
+    node: Node;
+}
+
+/**
+ * Registration Lifecycle Stages
+ *
+ * Important: this definition should not be used anywhere.
+ * It's only here to capture some ideas that were shared in the team.
+ */
+declare const RegistrationLifecycleStages: {
+    /**
+     * Active
+     *
+     * Happens when
+     * the current timestamp <= expiry.
+     */
+    readonly Active: "registrationLifecycle_active";
+    /**
+     * Grace Period
+     *
+     * Happens when
+     * `expiry < the current timestamp <= expiry + 90 days`.
+     */
+    readonly GracePeriod: "registrationLifecycle_gracePeriod";
+    /**
+     * Released with Temporary Premium Price
+     *
+     * Happens when
+     * `expiry + 90 days < the current timestamp <= expiry + 120 days`.
+     */
+    readonly ReleasedWithTempPrice: "registrationLifecycle_releasedWithTempPrice";
+    /**
+     * Fully Released (Regular Price)
+     *
+     * Happens when
+     * ` expiry + 120 days < the current timestamp`.
+     */
+    readonly FullyReleased: "registrationLifecycle_fullyReleased";
+};
+type RegistrationLifecycleStage = (typeof RegistrationLifecycleStages)[keyof typeof RegistrationLifecycleStages];
+/**
+ * Registration Lifecycle
+ */
+interface RegistrationLifecycle {
+    /**
+     * Subregistry that manages this Registration Lifecycle.
+     */
+    subregistry: Subregistry;
+    /**
+     * The node (namehash) of the FQDN of the domain the registration lifecycle
+     * is associated with.
+     *
+     * Guaranteed to be a subname of the node (namehash) of the subregistry
+     * identified by `subregistryId.subregistryId`.
+     */
+    node: Node;
+    /**
+     * Expires at
+     *
+     * Identifies when the Registration Lifecycle is scheduled to expire.
+     */
+    expiresAt: UnixTimestamp;
+}
+
+/**
+ * Globally unique, deterministic ID of an indexed onchain event
+ * associated with the "logical registrar action".
+ */
+type RegistrarActionEventId = string;
+/**
+ * Types of "logical registrar action".
+ */
+declare const RegistrarActionTypes: {
+    readonly Registration: "registration";
+    readonly Renewal: "renewal";
+};
+type RegistrarActionType = (typeof RegistrarActionTypes)[keyof typeof RegistrarActionTypes];
+/**
+ * Pricing information for a "logical registrar action".
+ */
+interface RegistrarActionPricingAvailable {
+    /**
+     * Base cost
+     *
+     * Base cost (before any `premium`) of Ether measured in units of Wei
+     * paid to execute the "logical registrar action".
+     *
+     * May be 0.
+     */
+    baseCost: PriceEth;
+    /**
+     * Premium
+     *
+     * "premium" cost (in excesses of the `baseCost`) of Ether measured in
+     * units of Wei paid to execute the "logical registrar action".
+     *
+     * May be 0.
+     */
+    premium: PriceEth;
+    /**
+     * Total
+     *
+     * Total cost of Ether measured in units of Wei paid to execute
+     * the "logical registrar action".
+     *
+     * May be 0.
+     */
+    total: PriceEth;
+}
+/**
+ * Pricing information for a "logical registrar action" when
+ * there is no known pricing data.
+ */
+interface RegistrarActionPricingUnknown {
+    /**
+     * Base cost
+     *
+     * Base cost (before any `premium`) of Ether measured in units of Wei
+     * paid to execute the "logical registrar action".
+     */
+    baseCost: null;
+    /**
+     * Premium
+     *
+     * "premium" cost (in excesses of the `baseCost`) of Ether measured in
+     * units of Wei paid to execute the "logical registrar action".
+     */
+    premium: null;
+    /**
+     * Total
+     *
+     * Total cost of Ether measured in units of Wei paid to execute
+     * the "logical registrar action".
+     */
+    total: null;
+}
+type RegistrarActionPricing = RegistrarActionPricingAvailable | RegistrarActionPricingUnknown;
+declare function isRegistrarActionPricingAvailable(registrarActionPricing: RegistrarActionPricing): registrarActionPricing is RegistrarActionPricingAvailable;
+/**
+ * * Referral information for performing a "logical registrar action".
+ */
+interface RegistrarActionReferralAvailable {
+    /**
+     * Encoded Referrer
+     *
+     * Represents the "raw" 32-byte "referrer" value emitted onchain in
+     * association with the registrar action.
+     */
+    encodedReferrer: EncodedReferrer;
+    /**
+     * Decoded Referrer
+     *
+     * Decoded referrer according to the subjective interpretation of
+     * `encodedReferrer` defined for ENS Holiday Awards.
+     *
+     * Identifies the interpreted address of the referrer.
+     * The "chainId" of this address is the same as is referenced in
+     * `subregistryId`.
+     *
+     * May be the "zero address" to represent that an `encodedReferrer` is
+     * defined but that it is interpreted as no referrer.
+     */
+    decodedReferrer: Address;
+}
+/**
+ * Referral information for performing a "logical registrar action" when
+ * registrar controller does not implement referrals.
+ */
+interface RegistrarActionReferralNotApplicable {
+    /**
+     * Encoded Referrer
+     *
+     * Represents the "raw" 32-byte "referrer" value emitted onchain in
+     * association with the registrar action.
+     */
+    encodedReferrer: null;
+    /**
+     * Decoded Referrer
+     *
+     * Decoded referrer according to the subjective interpretation of
+     * `encodedReferrer` defined for ENS Holiday Awards.
+     *
+     */
+    decodedReferrer: null;
+}
+type RegistrarActionReferral = RegistrarActionReferralAvailable | RegistrarActionReferralNotApplicable;
+declare function isRegistrarActionReferralAvailable(registrarActionReferral: RegistrarActionReferral): registrarActionReferral is RegistrarActionReferralAvailable;
+/**
+ * "Logical registrar action"
+ *
+ * Represents a state of "logical registrar action". May be built using data
+ * from multiple events within the same "logical" registration / renewal action.
+ */
+interface RegistrarAction {
+    /**
+     * "Logical registrar action" ID
+     *
+     * The `id` value is a deterministic and globally unique identifier for
+     * the "logical registrar action".
+     *
+     * The `id` value represents the *initial* onchain event associated with
+     * the "logical registrar action", but the full state of
+     * the "logical registrar action" is an aggregate across each of
+     * the onchain events referenced in the `eventIds` field.
+     *
+     * Guaranteed to be the very first element in `eventIds` array.
+     */
+    id: RegistrarActionEventId;
+    /**
+     * The type of the "logical registrar action".
+     */
+    type: RegistrarActionType;
+    /**
+     *
+     * Incremental Duration
+     *
+     * If `type` is "registration":
+     *   - Represents the duration between `block.timestamp` and
+     *     the initial `registrationLifecycle.expiresAt` value that the associated
+     *     "registration lifecycle" will be initialized with.
+     * If `type` is "renewal":
+     *   - Represents the incremental increase in duration made to
+     *     the `registrationLifecycle.expiresAt` value in the associated
+     *     "registration lifecycle".
+     *
+     * A "registration lifecycle" may be extended via renewal even after it
+     * expires if it is still within its grace period.
+     *
+     * Consider the following scenario:
+     *
+     * The "registration lifecycle" of a direct subname of .eth is scheduled to
+     * expire on Jan 1, midnight UTC. It is currently 30 days after this
+     * expiration time. Therefore, there are currently another 60 days of grace
+     * period remaining for this name. Anyone can still make a renewal to
+     * extend the "registration lifecycle" of this name.
+     *
+     * Given this scenario, consider the following examples:
+     *
+     * 1. If a renewal is made with 10 days incremental duration,
+     *    the "registration lifecycle" for this name will remain in
+     *    an "expired" state, but it will now have another 70 days of
+     *    grace period remaining.
+     *
+     * 2. If a renewal is made with 50 days incremental duration,
+     *    the "registration lifecycle" for this name will no longer be
+     *    "expired" and will become "active", but the "registration lifecycle"
+     *    will now be scheduled to expire again in 20 days.
+     *
+     * After the "registration lifecycle" for a name becomes expired by more
+     * than its grace period, it can no longer be renewed by anyone and is
+     * considered "released". The name must first be registered again, starting
+     * a new "registration lifecycle" of
+     * active / expired / grace period / released.
+     *
+     * May be 0.
+     *
+     * Guaranteed to be a non-negative bigint value.
+     */
+    incrementalDuration: Duration;
+    /**
+     * Registrant
+     *
+     * Identifies the address that initiated the "logical registrar action" and
+     * is paying the `pricing.total` cost (if applicable).
+     *
+     * It may not be the owner of the name:
+     * 1. When a name is registered, the initial owner of the name may be
+     *    distinct from the registrant.
+     * 2. There are no restrictions on who may renew a name.
+     *    Therefore the owner of the name may be distinct from the registrant.
+     *
+     * The "chainId" of this address is the same as is referenced in
+     * `registrationLifecycle.subregistry.subregistryId`.
+     */
+    registrant: Address;
+    /**
+     * Registration Lifecycle associated with this "logical registrar action".
+     */
+    registrationLifecycle: RegistrationLifecycle;
+    /**
+     * Pricing information associated with this "logical registrar action".
+     */
+    pricing: RegistrarActionPricing;
+    /**
+     * Referral information associated with this "logical registrar action".
+     */
+    referral: RegistrarActionReferral;
+    /**
+     * Block ref
+     *
+     * References the block where the "logical registrar action" was executed.
+     *
+     * The "chainId" of this block is the same as is referenced in
+     * `registrationLifecycle.subregistry.subregistryId`.
+     */
+    block: BlockRef;
+    /**
+     * Transaction hash
+     *
+     * Transaction hash of the transaction associated with
+     * the "logical registrar action".
+     *
+     * The "chainId" of this transaction is the same as is referenced in
+     * `registrationLifecycle.subregistry.subregistryId`.
+     *
+     * Note that a single transaction may be associated with any number of
+     * "logical registrar actions".
+     */
+    transactionHash: Hash;
+    /**
+     * Event IDs
+     *
+     * Array of the eventIds that have contributed to the state of
+     * the "logical registrar action" record.
+     *
+     * Each eventId is a deterministic and globally unique onchain event
+     * identifier.
+     *
+     * Guarantees:
+     * - Each eventId is of events that occurred within the block
+     *   referenced by `block.number`.
+     * - At least 1 eventId.
+     * - Ordered chronologically (ascending) by logIndex within `block.number`.
+     * - The first element in the array is equal to the `id` of
+     *   the overall "logical registrar action" record.
+     *
+     * The following ideas are not generalized for ENS overall but happen to
+     * be a characteristic of the scope of our current indexing logic:
+     * 1. These id's always reference events emitted by
+     *    a related "BaseRegistrar" contract.
+     * 2. These id's optionally reference events emitted by
+     *    a related "Registrar Controller" contract. This is because our
+     *    current indexing logic doesn't guarantee to index
+     *    all "Registrar Controller" contracts.
+     */
+    eventIds: [RegistrarActionEventId, ...RegistrarActionEventId[]];
+}
+/**
+ * Serialized representation of {@link RegistrarActionPricingUnknown}.
+ */
+type SerializedRegistrarActionPricingUnknown = RegistrarActionPricingUnknown;
+/**
+ * Serialized representation of {@link RegistrarActionPricingAvailable}.
+ */
+interface SerializedRegistrarActionPricingAvailable {
+    baseCost: SerializedPriceEth;
+    premium: SerializedPriceEth;
+    total: SerializedPriceEth;
+}
+/**
+ * Serialized representation of {@link RegistrarActionPricing}.
+ */
+type SerializedRegistrarActionPricing = SerializedRegistrarActionPricingAvailable | SerializedRegistrarActionPricingUnknown;
+/**
+ * Serialized representation of {@link RegistrarAction}.
+ */
+interface SerializedRegistrarAction extends Omit<RegistrarAction, "pricing"> {
+    pricing: SerializedRegistrarActionPricing;
+}
+declare function serializeRegistrarActionPricing(pricing: RegistrarActionPricing): SerializedRegistrarActionPricing;
+declare function serializeRegistrarAction(registrarAction: RegistrarAction): SerializedRegistrarAction;
+
+declare const RECORDS_PER_PAGE_DEFAULT = 10;
+declare const RECORDS_PER_PAGE_MAX = 100;
+/**
+ * Request page params.
+ */
+interface RequestPageParams {
+    /**
+     * Requested page number (1-indexed)
+     * @invariant Must be a positive integer (>= 1)
+     * @default 1
+     */
+    page?: number;
+    /**
+     * Maximum number of records to return per page
+     * @invariant Must be a positive integer (>= 1) and less than or equal to {@link RECORDS_PER_PAGE_MAX}
+     * @default {@link RECORDS_PER_PAGE_DEFAULT}
+     */
+    recordsPerPage?: number;
+}
+
+interface ResponsePageContextWithNoRecords extends Required<RequestPageParams> {
+    /**
+     * Total number of records across all pages
+     */
+    totalRecords: 0;
+    /**
+     * Total number of pages
+     */
+    totalPages: 1;
+    /**
+     * Indicates if there is a next page available
+     */
+    hasNext: false;
+    /**
+     * Indicates if there is a previous page available
+     */
+    hasPrev: false;
+    /**
+     * The start index of the records on the page (0-indexed)
+     */
+    startIndex: undefined;
+    /**
+     * The end index of the records on the page (0-indexed)
+     */
+    endIndex: undefined;
+}
+interface ResponsePageContextWithRecords extends Required<RequestPageParams> {
+    /**
+     * Total number of records across all pages
+     * @invariant Guaranteed to be a positive integer (>= 1)
+     */
+    totalRecords: number;
+    /**
+     * Total number of pages
+     * @invariant Guaranteed to be a positive integer (>= 1)
+     */
+    totalPages: number;
+    /**
+     * Indicates if there is a next page available
+     * @invariant true if and only if (`page` * `recordsPerPage` < `totalRecords`)
+     */
+    hasNext: boolean;
+    /**
+     * Indicates if there is a previous page available
+     * @invariant true if and only if (`page` > 1)
+     */
+    hasPrev: boolean;
+    /**
+     * The start index of the records on the page (0-indexed)
+     *
+     * @invariant Guaranteed to be a non-negative integer (>= 0)
+     */
+    startIndex: number;
+    /**
+     * The end index of the records on the page (0-indexed)
+     *
+     * @invariant Guaranteed to be a non-negative integer (>= 0)
+     * @invariant Guaranteed to be greater than or equal to `startIndex`.
+     * @invariant Guaranteed to be less than `totalRecords`.
+     */
+    endIndex: number;
+}
+type ResponsePageContext = ResponsePageContextWithNoRecords | ResponsePageContextWithRecords;
+
+/**
+ * Build page context from request params and total records count.
+ */
+declare function buildPageContext(page: number, recordsPerPage: number, totalRecords: number): ResponsePageContext;
+
+/**
+ * A status code for Registrar Actions API responses.
+ */
+declare const RegistrarActionsResponseCodes: {
+    /**
+     * Represents that Registrar Actions are available.
+     */
+    readonly Ok: "ok";
+    /**
+     * Represents that Registrar Actions are unavailable.
+     */
+    readonly Error: "error";
+};
+/**
+ * The derived string union of possible {@link RegistrarActionsResponseCodes}.
+ */
+type RegistrarActionsResponseCode = (typeof RegistrarActionsResponseCodes)[keyof typeof RegistrarActionsResponseCodes];
+/**
+ * "Logical registrar action" with its associated name.
+ */
+interface NamedRegistrarAction {
+    action: RegistrarAction;
+    /**
+     * Name
+     *
+     * FQDN of the name associated with `action`.
+     *
+     * Guarantees:
+     * - `namehash(name)` is always `action.registrationLifecycle.node`.
+     */
+    name: InterpretedName;
+}
+/**
+ * A response when Registrar Actions are available.
+ */
+type RegistrarActionsResponseOk = {
+    responseCode: typeof RegistrarActionsResponseCodes.Ok;
+    registrarActions: NamedRegistrarAction[];
+    pageContext: ResponsePageContext;
+};
+/**
+ * A response when Registrar Actions are unavailable.
+ */
+interface RegistrarActionsResponseError {
+    responseCode: typeof IndexingStatusResponseCodes.Error;
+    error: ErrorResponse;
+}
+/**
+ * Registrar Actions response.
+ *
+ * Use the `responseCode` field to determine the specific type interpretation
+ * at runtime.
+ */
+type RegistrarActionsResponse = RegistrarActionsResponseOk | RegistrarActionsResponseError;
+
+/**
+ * Serialized representation of {@link RegistrarActionsResponseError}.
+ */
+type SerializedRegistrarActionsResponseError = RegistrarActionsResponseError;
+/**
+ * Serialized representation of {@link NamedRegistrarAction}.
+ */
+interface SerializedNamedRegistrarAction extends Omit<NamedRegistrarAction, "action"> {
+    action: SerializedRegistrarAction;
+}
+/**
+ * Serialized representation of {@link RegistrarActionsResponseOk}.
+ */
+interface SerializedRegistrarActionsResponseOk extends Omit<RegistrarActionsResponseOk, "registrarActions"> {
+    registrarActions: SerializedNamedRegistrarAction[];
+}
+/**
+ * Serialized representation of {@link SerializedRegistrarActionsResponse}.
+ */
+type SerializedRegistrarActionsResponse = SerializedRegistrarActionsResponseOk | SerializedRegistrarActionsResponseError;
+
+/**
+ * Deserialize a {@link RegistrarActionsResponse} object.
+ */
+declare function deserializeRegistrarActionsResponse(maybeResponse: SerializedRegistrarActionsResponse): RegistrarActionsResponse;
+
+/**
+ * Records Filters: Filter Types
+ */
+declare const RegistrarActionsFilterTypes: {
+    readonly BySubregistryNode: "bySubregistryNode";
+    readonly WithEncodedReferral: "withEncodedReferral";
+    readonly ByDecodedReferrer: "byDecodedReferrer";
+    readonly BeginTimestamp: "beginTimestamp";
+    readonly EndTimestamp: "endTimestamp";
+};
+type RegistrarActionsFilterType = (typeof RegistrarActionsFilterTypes)[keyof typeof RegistrarActionsFilterTypes];
+type RegistrarActionsFilterBySubregistryNode = {
+    filterType: typeof RegistrarActionsFilterTypes.BySubregistryNode;
+    value: Node;
+};
+type RegistrarActionsFilterWithEncodedReferral = {
+    filterType: typeof RegistrarActionsFilterTypes.WithEncodedReferral;
+};
+type RegistrarActionsFilterByDecodedReferrer = {
+    filterType: typeof RegistrarActionsFilterTypes.ByDecodedReferrer;
+    value: Address;
+};
+type RegistrarActionsFilterBeginTimestamp = {
+    filterType: typeof RegistrarActionsFilterTypes.BeginTimestamp;
+    value: UnixTimestamp;
+};
+type RegistrarActionsFilterEndTimestamp = {
+    filterType: typeof RegistrarActionsFilterTypes.EndTimestamp;
+    value: UnixTimestamp;
+};
+type RegistrarActionsFilter = RegistrarActionsFilterBySubregistryNode | RegistrarActionsFilterWithEncodedReferral | RegistrarActionsFilterByDecodedReferrer | RegistrarActionsFilterBeginTimestamp | RegistrarActionsFilterEndTimestamp;
+/**
+ * Records Orders
+ */
+declare const RegistrarActionsOrders: {
+    readonly LatestRegistrarActions: "orderBy[timestamp]=desc";
+};
+type RegistrarActionsOrder = (typeof RegistrarActionsOrders)[keyof typeof RegistrarActionsOrders];
+/**
+ * Represents a request to Registrar Actions API.
+ */
+interface RegistrarActionsRequest extends RequestPageParams {
+    /**
+     * Filters to be applied while generating results.
+     */
+    filters?: RegistrarActionsFilter[];
+    /**
+     * Order applied while generating results.
+     */
+    order?: RegistrarActionsOrder;
+}
+
+/**
+ * Build a "parent node" filter object for Registrar Actions query.
+ */
+declare function byParentNode(parentNode: Node): RegistrarActionsFilter;
+declare function byParentNode(parentNode: undefined): undefined;
+/**
+ * Build a "with referral" filter object for Registrar Actions query.
+ */
+declare function withReferral(withReferral: true): RegistrarActionsFilter;
+declare function withReferral(withReferral: false | undefined): undefined;
+/**
+ * Build a "decoded referrer" filter object for Registrar Actions query.
+ */
+declare function byDecodedReferrer(decodedReferrer: Address): RegistrarActionsFilter;
+declare function byDecodedReferrer(decodedReferrer: undefined): undefined;
+/**
+ * Build a "begin timestamp" filter object for Registrar Actions query.
+ *
+ * Filters registrar actions to only include those at or after the specified timestamp (inclusive).
+ */
+declare function beginTimestamp(timestamp: UnixTimestamp): RegistrarActionsFilter;
+declare function beginTimestamp(timestamp: undefined): undefined;
+/**
+ * Build an "end timestamp" filter object for Registrar Actions query.
+ *
+ * Filters registrar actions to only include those at or before the specified timestamp (inclusive).
+ */
+declare function endTimestamp(timestamp: UnixTimestamp): RegistrarActionsFilter;
+declare function endTimestamp(timestamp: undefined): undefined;
+declare const registrarActionsFilter: {
+    byParentNode: typeof byParentNode;
+    withReferral: typeof withReferral;
+    byDecodedReferrer: typeof byDecodedReferrer;
+    beginTimestamp: typeof beginTimestamp;
+    endTimestamp: typeof endTimestamp;
+};
+
+declare const registrarActionsPrerequisites: Readonly<{
+    /**
+     * Required plugins to enable Registrar Actions API routes.
+     *
+     * 1. `registrars` plugin is required so that data in the `registrarActions`
+     *    table is populated.
+     * 2. `subgraph`, `basenames`, and `lineanames` are required to get the data
+     *    for the name associated with each registrar action.
+     * 3. In theory not all of `subgraph`, `basenames`, and `lineanames` plugins
+     *    might be required. Ex: At least one, but the current logic in
+     *    the `registrars` plugin always indexes registrar actions across
+     *    Ethnames (subgraph), Basenames, and Lineanames and therefore we need to
+     *    ensure each value in the registrar actions table has
+     *    an associated record in the domains table.
+     */
+    requiredPlugins: readonly [PluginName.Subgraph, PluginName.Basenames, PluginName.Lineanames, PluginName.Registrars];
+    /**
+     * Check if provided ENSApiPublicConfig supports the Registrar Actions API.
+     */
+    hasEnsIndexerConfigSupport(config: ENSIndexerPublicConfig): boolean;
+    /**
+     * Required Indexing Status IDs
+     *
+     * Database indexes are created by the time the omnichain indexing status
+     * is either `completed` or `following`.
+     */
+    supportedIndexingStatusIds: ("omnichain-following" | "omnichain-completed")[];
+    /**
+     * Check if provided indexing status supports the Registrar Actions API.
+     */
+    hasIndexingStatusSupport(omnichainIndexingStatusId: OmnichainIndexingStatusId): boolean;
+}>;
+
+declare function serializeNamedRegistrarAction({ action, name, }: NamedRegistrarAction): SerializedNamedRegistrarAction;
+declare function serializeRegistrarActionsResponse(response: RegistrarActionsResponse): SerializedRegistrarActionsResponse;
+
+/**
+ * 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;
+
+/**
+ * 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;
+
+/**
+ * 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;
+
+/**
+ * Encodes a selection of Resolver records in the context of a specific Name.
+ */
+interface ResolverRecordsSelection {
+    /**
+     * Whether to fetch the name's `name` record. This value is primarily used in the context of
+     * Reverse Resolution.
+     *
+     * @see https://docs.ens.domains/ensip/19/#reverse-resolution
+     */
+    name?: boolean;
+    /**
+     * Which coinTypes to fetch address records for.
+     */
+    addresses?: CoinType[];
+    /**
+     * Which keys to fetch text records for.
+     */
+    texts?: string[];
+}
+declare const isSelectionEmpty: (selection: ResolverRecordsSelection) => boolean;
+
+/**
+ * An internal type representing a non-inferred ResolverRecordsResponse, used in situations where
+ * access to the more specific inferred type (ResolverRecordsResponse<SELECTION>) is difficult or
+ * unnecessary.
+ */
+type ResolverRecordsResponseBase = {
+    /**
+     * The name record, relevant in the context of Reverse Resolution.
+     * Null if no name record is set.
+     */
+    name: Name | null;
+    /**
+     * Address records, keyed by CoinType.
+     * Value is null if no record for the specified CoinType is set.
+     *
+     * NOTE: ENS resolver address records can store arbitrary string values,
+     * including non-EVM addresses — always validate the record value against
+     * the format your application expects.
+     */
+    addresses: Record<CoinType, string | null>;
+    /**
+     * Text records, keyed by key.
+     * Value is null if no record for the specified key is set.
+     */
+    texts: Record<string, string | null>;
+};
+/**
+ * Represents the strongly-typed set of records based on the provided SELECTION
+ *
+ * @example
+ * ```typescript
+ * const selection = {
+ *   name: true,
+ *   addresses: [60],
+ *   texts: ["com.twitter", "avatar"],
+ * } as const satisfies ResolverRecordsSelection;
+ *
+ * type Response = ResolverRecordsResponse<typeof selection>;
+ *
+ * // results in the following type
+ * type Response = {
+ *   readonly name: Name | null;
+ *   readonly addresses: Record<"60", string | null>;
+ *   readonly texts: Record<"avatar" | "com.twitter", string | null>;
+ * }
+ * ```
+ */
+type ResolverRecordsResponse<T extends ResolverRecordsSelection = ResolverRecordsSelection> = {
+    [K in keyof T as T[K] extends true | any[] ? K : never]: K extends "addresses" ? Record<`${T["addresses"] extends readonly CoinType[] ? T["addresses"][number] : never}`, string | null> : K extends "texts" ? Record<T["texts"] extends readonly string[] ? T["texts"][number] : never, string | null> : ResolverRecordsResponseBase[K & keyof ResolverRecordsResponseBase];
+};
+
+/**
+ * Arguments required to perform Forward Resolution
+ */
+interface ForwardResolutionArgs<SELECTION extends ResolverRecordsSelection> {
+    name: Name;
+    selection: SELECTION;
+}
+/**
+ * The result of performing ForwardResolution
+ */
+type ForwardResolutionResult<SELECTION extends ResolverRecordsSelection> = ResolverRecordsResponse<SELECTION>;
+/**
+ * Arguments required to perform Reverse Resolution
+ */
+interface ReverseResolutionArgs {
+    address: Address;
+    chainId: ChainId;
+}
+/**
+ * The result of performing ReverseResolution
+ */
+type ReverseResolutionResult = Name | null;
+/**
+ * Arguments required to perform Multichain Primary Name Resolution
+ */
+interface MultichainPrimaryNameResolutionArgs {
+    address: Address;
+    chainIds?: ChainId[];
+}
+/**
+ * The result of performing MultichainPrimaryNameResolution
+ */
+type MultichainPrimaryNameResolutionResult = Record<ChainId, Name | null>;
+
+declare const PROTOCOL_ATTRIBUTE_PREFIX = "ens";
+declare const ATTR_PROTOCOL_NAME = "ens.protocol";
+declare const ATTR_PROTOCOL_STEP = "ens.protocol.step";
+declare const ATTR_PROTOCOL_STEP_RESULT = "ens.protocol.step.result";
+/**
+ * Identifiers for each traceable ENS protocol.
+ */
+declare enum TraceableENSProtocol {
+    ForwardResolution = "forward-resolution",
+    ReverseResolution = "reverse-resolution"
+}
+/**
+ * Encodes the set of well-known steps in the ENS Forward Resolution protocol.
+ */
+declare enum ForwardResolutionProtocolStep {
+    Operation = "forward-resolution",
+    FindResolver = "find-resolver",
+    ActiveResolverExists = "active-resolver-exists",
+    AccelerateENSIP19ReverseResolver = "accelerate-ensip-19-reverse-resolver",
+    AccelerateKnownOffchainLookupResolver = "accelerate-known-offchain-lookup-resolver",
+    AccelerateKnownOnchainStaticResolver = "accelerate-known-onchain-static-resolver",
+    RequireResolver = "require-resolver",
+    ExecuteResolveCalls = "execute-resolve-calls"
+}
+/**
+ * Encodes the set of well-known steps in the ENS Reverse Resolution protocol.
+ */
+declare enum ReverseResolutionProtocolStep {
+    Operation = "reverse-resolution",
+    ResolveReverseName = "resolve-reverse-name",
+    NameRecordExists = "name-record-exists-check",
+    ForwardResolveAddressRecord = "forward-resolve-address-record",
+    VerifyResolvedAddressMatchesAddress = "verify-resolved-address-matches-address"
+}
+
+interface TracingSpanAttributes {
+    [key: string]: unknown;
+}
+interface TracingSpanEvent {
+    name: string;
+    attributes: TracingSpanAttributes;
+    time: number;
+}
+interface TracingSpan {
+    scope: string;
+    id: string;
+    traceId: string;
+    parentSpanContext: {
+        traceId: string;
+        spanId: string;
+    } | undefined;
+    name: string;
+    timestamp: number;
+    duration: number;
+    attributes: TracingSpanAttributes;
+    status: {
+        code: number;
+        message?: string;
+    };
+    events: TracingSpanEvent[];
+}
+type TracingNode = TracingSpan & {
+    children: TracingNode[];
+};
+type TracingTrace = TracingNode[];
+
+interface TraceableRequest {
+    trace?: boolean;
+}
+interface TraceableResponse {
+    trace?: TracingTrace;
+}
+interface AcceleratableRequest {
+    accelerate?: boolean;
+}
+interface AcceleratableResponse {
+    accelerationRequested: boolean;
+    accelerationAttempted: boolean;
+}
+/**
+ * Resolve Records Request Type
+ */
+interface ResolveRecordsRequest<SELECTION extends ResolverRecordsSelection> extends ForwardResolutionArgs<SELECTION>, AcceleratableRequest, TraceableRequest {
+}
+/**
+ * Resolve Records Response Type
+ */
+interface ResolveRecordsResponse<SELECTION extends ResolverRecordsSelection> extends AcceleratableResponse, TraceableResponse {
+    records: ResolverRecordsResponse<SELECTION>;
+}
+/**
+ * Resolve Primary Name Request Type
+ */
+interface ResolvePrimaryNameRequest extends ReverseResolutionArgs, AcceleratableRequest, TraceableRequest {
+}
+/**
+ * Resolve Primary Name Response Type
+ */
+interface ResolvePrimaryNameResponse extends AcceleratableResponse, TraceableResponse {
+    name: ReverseResolutionResult;
+}
+interface ResolvePrimaryNamesRequest extends MultichainPrimaryNameResolutionArgs, AcceleratableRequest, TraceableRequest {
+}
+interface ResolvePrimaryNamesResponse extends AcceleratableResponse, TraceableResponse {
+    names: MultichainPrimaryNameResolutionResult;
+}
+
+/**
+ * Request parameters for a referrer leaderboard page query.
+ */
+interface ReferrerLeaderboardPageRequest extends ReferrerLeaderboardPageParams {
+}
+/**
+ * A status code for a referrer leaderboard page API response.
+ */
+declare const ReferrerLeaderboardPageResponseCodes: {
+    /**
+     * Represents that the requested referrer leaderboard page is available.
+     */
+    readonly Ok: "ok";
+    /**
+     * Represents that the referrer leaderboard data is not available.
+     */
+    readonly Error: "error";
+};
+/**
+ * The derived string union of possible {@link ReferrerLeaderboardPageResponseCodes}.
+ */
+type ReferrerLeaderboardPageResponseCode = (typeof ReferrerLeaderboardPageResponseCodes)[keyof typeof ReferrerLeaderboardPageResponseCodes];
+/**
+ * A referrer leaderboard page response when the data is available.
+ */
+type ReferrerLeaderboardPageResponseOk = {
+    responseCode: typeof ReferrerLeaderboardPageResponseCodes.Ok;
+    data: ReferrerLeaderboardPage;
+};
+/**
+ * A referrer leaderboard page response when the data is not available.
+ */
+type ReferrerLeaderboardPageResponseError = {
+    responseCode: typeof ReferrerLeaderboardPageResponseCodes.Error;
+    error: string;
+    errorMessage: string;
+};
+/**
+ * A referrer leaderboard page API response.
+ *
+ * Use the `responseCode` field to determine the specific type interpretation
+ * at runtime.
+ */
+type ReferrerLeaderboardPageResponse = ReferrerLeaderboardPageResponseOk | ReferrerLeaderboardPageResponseError;
+/**
+ * Request parameters for referrer detail query.
+ */
+interface ReferrerDetailRequest {
+    /** The Ethereum address of the referrer to query */
+    referrer: Address;
+}
+/**
+ * A status code for referrer detail API responses.
+ */
+declare const ReferrerDetailResponseCodes: {
+    /**
+     * Represents that the referrer detail data is available.
+     */
+    readonly Ok: "ok";
+    /**
+     * Represents that an error occurred while fetching the data.
+     */
+    readonly Error: "error";
+};
+/**
+ * The derived string union of possible {@link ReferrerDetailResponseCodes}.
+ */
+type ReferrerDetailResponseCode = (typeof ReferrerDetailResponseCodes)[keyof typeof ReferrerDetailResponseCodes];
+/**
+ * A referrer detail response when the data is available for a referrer on the leaderboard.
+ */
+type ReferrerDetailResponseOk = {
+    responseCode: typeof ReferrerDetailResponseCodes.Ok;
+    data: ReferrerDetail;
+};
+/**
+ * A referrer detail response when an error occurs.
+ */
+type ReferrerDetailResponseError = {
+    responseCode: typeof ReferrerDetailResponseCodes.Error;
+    error: string;
+    errorMessage: string;
+};
+/**
+ * A referrer detail API response.
+ *
+ * Use the `responseCode` field to determine the specific type interpretation
+ * at runtime.
+ */
+type ReferrerDetailResponse = ReferrerDetailResponseOk | ReferrerDetailResponseError;
+
+/**
+ * Serialized representation of {@link RevenueContribution}.
+ *
+ * RevenueContribution is a bigint, which is serialized as a string for JSON compatibility.
+ */
+type SerializedRevenueContribution = string;
+/**
+ * Serialized representation of {@link ReferralProgramRules}.
+ *
+ * Note: All fields are already serializable primitives, so this type is identical to the source type.
+ */
+type SerializedReferralProgramRules = ReferralProgramRules;
+/**
+ * Serialized representation of {@link AwardedReferrerMetrics}.
+ */
+interface SerializedAwardedReferrerMetrics extends Omit<AwardedReferrerMetrics, "totalRevenueContribution"> {
+    totalRevenueContribution: SerializedRevenueContribution;
+}
+/**
+ * Serialized representation of {@link UnrankedReferrerMetrics}.
+ */
+interface SerializedUnrankedReferrerMetrics extends Omit<UnrankedReferrerMetrics, "totalRevenueContribution"> {
+    totalRevenueContribution: SerializedRevenueContribution;
+}
+/**
+ * Serialized representation of {@link AggregatedReferrerMetrics}.
+ */
+interface SerializedAggregatedReferrerMetrics extends Omit<AggregatedReferrerMetrics, "grandTotalRevenueContribution"> {
+    grandTotalRevenueContribution: SerializedRevenueContribution;
+}
+/**
+ * Serialized representation of {@link ReferrerLeaderboardPage}.
+ */
+interface SerializedReferrerLeaderboardPage extends Omit<ReferrerLeaderboardPage, "referrers" | "aggregatedMetrics"> {
+    referrers: SerializedAwardedReferrerMetrics[];
+    aggregatedMetrics: SerializedAggregatedReferrerMetrics;
+}
+/**
+ * Serialized representation of {@link ReferrerDetailRanked}.
+ */
+interface SerializedReferrerDetailRanked extends Omit<ReferrerDetailRanked, "referrer" | "aggregatedMetrics"> {
+    referrer: SerializedAwardedReferrerMetrics;
+    aggregatedMetrics: SerializedAggregatedReferrerMetrics;
+}
+/**
+ * Serialized representation of {@link ReferrerDetailUnranked}.
+ */
+interface SerializedReferrerDetailUnranked extends Omit<ReferrerDetailUnranked, "referrer" | "aggregatedMetrics"> {
+    referrer: SerializedUnrankedReferrerMetrics;
+    aggregatedMetrics: SerializedAggregatedReferrerMetrics;
+}
+/**
+ * Serialized representation of {@link ReferrerDetail} (union of ranked and unranked).
+ */
+type SerializedReferrerDetail = SerializedReferrerDetailRanked | SerializedReferrerDetailUnranked;
+/**
+ * Serialized representation of {@link ReferrerLeaderboardPageResponseError}.
+ *
+ * Note: All fields are already serializable, so this type is identical to the source type.
+ */
+type SerializedReferrerLeaderboardPageResponseError = ReferrerLeaderboardPageResponseError;
+/**
+ * Serialized representation of {@link ReferrerLeaderboardPageResponseOk}.
+ */
+interface SerializedReferrerLeaderboardPageResponseOk extends Omit<ReferrerLeaderboardPageResponseOk, "data"> {
+    data: SerializedReferrerLeaderboardPage;
+}
+/**
+ * Serialized representation of {@link ReferrerLeaderboardPageResponse}.
+ */
+type SerializedReferrerLeaderboardPageResponse = SerializedReferrerLeaderboardPageResponseOk | SerializedReferrerLeaderboardPageResponseError;
+/**
+ * Serialized representation of {@link ReferrerDetailResponseError}.
+ *
+ * Note: All fields are already serializable, so this type is identical to the source type.
+ */
+type SerializedReferrerDetailResponseError = ReferrerDetailResponseError;
+/**
+ * Serialized representation of {@link ReferrerDetailResponseOk}.
+ */
+interface SerializedReferrerDetailResponseOk extends Omit<ReferrerDetailResponseOk, "data"> {
+    data: SerializedReferrerDetail;
+}
+/**
+ * Serialized representation of {@link ReferrerDetailResponse}.
+ */
+type SerializedReferrerDetailResponse = SerializedReferrerDetailResponseOk | SerializedReferrerDetailResponseError;
+
+/**
+ * Deserialize a {@link ReferrerLeaderboardPageResponse} object.
+ *
+ * Note: This function explicitly deserializes each subobject to convert string
+ * RevenueContribution values back to bigint, then validates using Zod schemas
+ * to enforce invariants on the data.
+ */
+declare function deserializeReferrerLeaderboardPageResponse(maybeResponse: SerializedReferrerLeaderboardPageResponse, valueLabel?: string): ReferrerLeaderboardPageResponse;
+/**
+ * Deserialize a {@link ReferrerDetailResponse} object.
+ *
+ * Note: This function explicitly deserializes each subobject to convert string
+ * RevenueContribution values back to bigint, then validates using Zod schemas
+ * to enforce invariants on the data.
+ */
+declare function deserializeReferrerDetailResponse(maybeResponse: SerializedReferrerDetailResponse, valueLabel?: string): ReferrerDetailResponse;
+
+/**
+ * Serialize a {@link ReferrerLeaderboardPageResponse} object.
+ */
+declare function serializeReferrerLeaderboardPageResponse(response: ReferrerLeaderboardPageResponse): SerializedReferrerLeaderboardPageResponse;
+/**
+ * Serialize a {@link ReferrerDetailResponse} object.
+ */
+declare function serializeReferrerDetailResponse(response: ReferrerDetailResponse): SerializedReferrerDetailResponse;
+
+/**
+ * Configuration options for ENSNode API client
+ */
+interface ClientOptions {
+    /** The ENSNode API URL */
+    url: URL;
+}
+/**
+ * ENSNode API Client
+ *
+ * Provides access to the following ENSNode APIs:
+ * - Resolution API
+ * - ENSAnalytics API
+ * - 🚧 Configuration API
+ * - 🚧 Indexing Status API
+ *
+ * @example
+ * ```typescript
+ * // Create client with default options
+ * const client = new ENSNodeClient();
+ *
+ * // Use resolution methods
+ * const { records } = await client.resolveRecords("jesse.base.eth", {
+ *   addresses: [60],
+ *   texts: ["avatar"]
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Custom configuration
+ * const client = new ENSNodeClient({
+ *   url: new URL("https://my-ensnode-instance.com"),
+ * });
+ * ```
+ */
+declare class ENSNodeClient {
+    private readonly options;
+    static defaultOptions(): ClientOptions;
+    constructor(options?: Partial<ClientOptions>);
+    getOptions(): Readonly<ClientOptions>;
+    /**
+     * 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
+     * @param options.accelerate whether to attempt Protocol Acceleration (default false)
+     * @param options.trace whether to include a trace in the response (default false)
+     * @returns ResolveRecordsResponse<SELECTION>
+     * @throws If the request fails or the ENSNode API returns an error response
+     *
+     * @example
+     * ```typescript
+     * const { records } = await client.resolveRecords("jesse.base.eth", {
+     *   addresses: [60],
+     *   texts: ["avatar", "com.twitter"]
+     * });
+     *
+     * console.log(records);
+     * // {
+     * //   addresses: {
+     * //     60: "0xabcd..."
+     * //   },
+     * //   texts: {
+     * //     avatar: "https://example.com/image.jpg",
+     * //     "com.twitter": null, // if not set, for example
+     * //   }
+     * // }
+     * ```
+     */
+    resolveRecords<SELECTION extends ResolverRecordsSelection>(name: ResolveRecordsRequest<SELECTION>["name"], selection: ResolveRecordsRequest<SELECTION>["selection"], options?: Omit<ResolveRecordsRequest<SELECTION>, "name" | "selection">): Promise<ResolveRecordsResponse<SELECTION>>;
+    /**
+     * Resolves the primary name of a specified address (Reverse Resolution) on a specific chain.
+     *
+     * 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
+     * @param options additional options
+     * @param options.accelerate whether to attempt Protocol Acceleration (default false)
+     * @param options.trace whether to include a trace in the response (default false)
+     * @returns ResolvePrimaryNameResponse
+     * @throws If the request fails or the ENSNode API returns an error response
+     *
+     * @example
+     * ```typescript
+     * // Resolve the address' Primary Name on Ethereum Mainnet
+     * const { name } = await client.resolvePrimaryName("0x179A862703a4adfb29896552DF9e307980D19285", 1);
+     * // name === 'gregskril.eth'
+     *
+     * // Resolve the address' Primary Name on Base
+     * const { name } = await client.resolvePrimaryName("0x179A862703a4adfb29896552DF9e307980D19285", 8453);
+     * // name === 'greg.base.eth'
+     *
+     * // Resolve the address' Default Primary Name
+     * const { name } = await client.resolvePrimaryName("0x179A862703a4adfb29896552DF9e307980D19285", 0);
+     * // name === 'gregskril.eth'
+     * ```
+     */
+    resolvePrimaryName(address: ResolvePrimaryNameRequest["address"], chainId: ResolvePrimaryNameRequest["chainId"], options?: Omit<ResolvePrimaryNameRequest, "address" | "chainId">): Promise<ResolvePrimaryNameResponse>;
+    /**
+     * Resolves the primary names of a specified address across multiple chains.
+     *
+     * 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
+     * @param options.chainIds The set of chain ids within which to query the address' ENSIP-19
+     *  Multichain Primary Name (default: all ENSIP-19 supported chains)
+     * @param options.accelerate whether to attempt Protocol Acceleration (default: true)
+     * @param options.trace whether to include a trace in the response (default: false)
+     * @returns ResolvePrimaryNamesResponse
+     * @throws If the request fails or the ENSNode API returns an error response
+     *
+     * @example
+     * ```typescript
+     * // Resolve the address' Primary Names on all ENSIP-19 supported chain ids
+     * const { names } = await client.resolvePrimaryNames("0x179A862703a4adfb29896552DF9e307980D19285");
+     *
+     * console.log(names);
+     * // {
+     * //   "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
+     * const { names } = await client.resolvePrimaryNames("0xabcd...", [1, 8453]);
+     *
+     * console.log(names);
+     * // {
+     * //   "1": "gregskril.eth",
+     * //   "8453": "greg.base.eth", // base-specific Primary Name!
+     * // }
+     * ```
+     */
+    resolvePrimaryNames(address: ResolvePrimaryNamesRequest["address"], options?: Omit<ResolvePrimaryNamesRequest, "address">): Promise<ResolvePrimaryNamesResponse>;
+    /**
+     * Fetch ENSNode Config
+     *
+     * Fetch the ENSNode's configuration.
+     *
+     * @returns {ConfigResponse}
+     *
+     * @throws if the ENSNode request fails
+     * @throws if the ENSNode API returns an error response
+     * @throws if the ENSNode response breaks required invariants
+     */
+    config(): Promise<ConfigResponse>;
+    /**
+     * Fetch ENSNode Indexing Status
+     *
+     * @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(): Promise<IndexingStatusResponse>;
+    /**
+     * Fetch Referrer Leaderboard Page
+     *
+     * Retrieves a paginated list of referrer leaderboard metrics with contribution percentages.
+     * Each referrer's contribution is calculated as a percentage of the grand totals across all referrers.
+     *
+     * @param request - Pagination parameters
+     * @param request.page - The page number to retrieve (1-indexed, default: 1)
+     * @param request.recordsPerPage - Number of records per page (default: 25, max: 100)
+     * @returns {ReferrerLeaderboardPageResponse}
+     *
+     * @throws if the ENSNode request fails
+     * @throws if the ENSNode API returns an error response
+     * @throws if the ENSNode response breaks required invariants
+     *
+     * @example
+     * ```typescript
+     * // Get first page with default page size (25 records)
+     * const response = await client.getReferrerLeaderboardPage();
+     * if (response.responseCode === ReferrerLeaderboardPageResponseCodes.Ok) {
+     *   const {
+     *     aggregatedMetrics,
+     *     referrers,
+     *     rules,
+     *     pageContext,
+     *     updatedAt
+     *   } = response.data;
+     *   console.log(aggregatedMetrics);
+     *   console.log(referrers);
+     *   console.log(rules);
+     *   console.log(updatedAt);
+     *   console.log(`Page ${pageContext.page} of ${pageContext.totalPages}`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Get second page with 50 records per page
+     * const response = await client.getReferrerLeaderboardPage({ page: 2, recordsPerPage: 50 });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Handle error response, ie. when Referrer Leaderboard is not currently available.
+     * const response = await client.getReferrerLeaderboardPage();
+     *
+     * if (response.responseCode === ReferrerLeaderboardPageResponseCodes.Error) {
+     *   console.error(response.error);
+     *   console.error(response.errorMessage);
+     * }
+     * ```
+     */
+    getReferrerLeaderboardPage(request?: ReferrerLeaderboardPageRequest): Promise<ReferrerLeaderboardPageResponse>;
+    /**
+     * Fetch Referrer Detail
+     *
+     * Retrieves detailed information about a specific referrer, whether they are on the
+     * leaderboard or not.
+     *
+     * The response data is a discriminated union type with a `type` field:
+     *
+     * **For referrers on the leaderboard** (`ReferrerDetailRanked`):
+     * - `type`: {@link ReferrerDetailTypeIds.Ranked}
+     * - `referrer`: The `AwardedReferrerMetrics` from @namehash/ens-referrals
+     * - `rules`: The referral program rules
+     * - `aggregatedMetrics`: Aggregated metrics for all referrers on the leaderboard
+     * - `accurateAsOf`: Unix timestamp indicating when the data was last updated
+     *
+     * **For referrers NOT on the leaderboard** (`ReferrerDetailUnranked`):
+     * - `type`: {@link ReferrerDetailTypeIds.Unranked}
+     * - `referrer`: The `UnrankedReferrerMetrics` from @namehash/ens-referrals
+     * - `rules`: The referral program rules
+     * - `aggregatedMetrics`: Aggregated metrics for all referrers on the leaderboard
+     * - `accurateAsOf`: Unix timestamp indicating when the data was last updated
+     *
+     * @see {@link https://www.npmjs.com/package/@namehash/ens-referrals|@namehash/ens-referrals} for calculation details
+     *
+     * @param request The referrer address to query
+     * @returns {ReferrerDetailResponse} Returns the referrer detail response
+     *
+     * @throws if the ENSNode request fails
+     * @throws if the response data is malformed
+     *
+     * @example
+     * ```typescript
+     * // Get referrer detail for a specific address
+     * const response = await client.getReferrerDetail({
+     *   referrer: "0x1234567890123456789012345678901234567890"
+     * });
+     * if (response.responseCode === ReferrerDetailResponseCodes.Ok) {
+     *   const { type, referrer, rules, aggregatedMetrics, accurateAsOf } = response.data;
+     *   console.log(type); // ReferrerDetailTypeIds.Ranked or ReferrerDetailTypeIds.Unranked
+     *   console.log(referrer);
+     *   console.log(accurateAsOf);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Use discriminated union to check if referrer is ranked
+     * const response = await client.getReferrerDetail({
+     *   referrer: "0x1234567890123456789012345678901234567890"
+     * });
+     * if (response.responseCode === ReferrerDetailResponseCodes.Ok) {
+     *   if (response.data.type === ReferrerDetailTypeIds.Ranked) {
+     *     // TypeScript knows this is ReferrerDetailRanked
+     *     console.log(`Rank: ${response.data.referrer.rank}`);
+     *     console.log(`Qualified: ${response.data.referrer.isQualified}`);
+     *     console.log(`Award Pool Share: ${response.data.referrer.awardPoolShare * 100}%`);
+     *   } else {
+     *     // TypeScript knows this is ReferrerDetailUnranked
+     *     console.log("Referrer is not on the leaderboard (no referrals yet)");
+     *   }
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Handle error response, ie. when Referrer Detail is not currently available.
+     * const response = await client.getReferrerDetail({
+     *   referrer: "0x1234567890123456789012345678901234567890"
+     * });
+     *
+     * if (response.responseCode === ReferrerDetailResponseCodes.Error) {
+     *   console.error(response.error);
+     *   console.error(response.errorMessage);
+     * }
+     * ```
+     */
+    getReferrerDetail(request: ReferrerDetailRequest): Promise<ReferrerDetailResponse>;
+    /**
+     * Fetch ENSNode Registrar Actions
+     *
+     * Retrieves a paginated list of registrar actions with optional filters.
+     *
+     * @param request is a request configuration.
+     * @param request.page sets the page number to retrieve (1-indexed, default: 1)
+     * @param request.recordsPerPage sets the number of records per page (default: 10, max: 100)
+     * @param request.filters is an optional request filter configuration.
+     * @param request.order sets the order of results in the response by field and direction.
+     * @returns {RegistrarActionsResponse}
+     *
+     * @throws if the ENSNode request fails
+     * @throws if the ENSNode API returns an error response
+     * @throws if the ENSNode response breaks required invariants
+     *
+     * @example
+     * ```ts
+     * import {
+     *   registrarActionsFilter,
+     *   ENSNodeClient,
+     * } from "@ensnode/ensnode-sdk";
+     * import { namehash } from "viem/ens";
+     *
+     * const client: ENSNodeClient;
+     *
+     * // Get first page with default page size (10 records)
+     * const response = await client.registrarActions();
+     * if (response.responseCode === RegistrarActionsResponseCodes.Ok) {
+     *   const { registrarActions, pageContext } = response;
+     *   console.log(registrarActions);
+     *   console.log(`Page ${pageContext.page} of ${pageContext.totalPages}`);
+     * }
+     *
+     * // Get second page with 25 records per page
+     * const response = await client.registrarActions({
+     *   page: 2,
+     *   recordsPerPage: 25,
+     * });
+     *
+     * // get latest registrar action records associated with
+     * // subregistry managing `eth` name
+     * await client.registrarActions({
+     *   filters: [registrarActionsFilter.byParentNode(namehash('eth'))],
+     * });
+     *
+     * // get latest registrar action records which include referral info
+     * await client.registrarActions({
+     *   filters: [registrarActionsFilter.withReferral(true)],
+     * });
+     *
+     * // get latest registrar action records for a specific decoded referrer
+     * await client.registrarActions({
+     *   filters: [registrarActionsFilter.byDecodedReferrer("0x1234567890123456789012345678901234567890")],
+     * });
+     *
+     * // get latest 10 registrar action records associated with
+     * // subregistry managing `base.eth` name
+     * await client.registrarActions({
+     *   filters: [registrarActionsFilter.byParentNode(namehash('base.eth'))],
+     *   recordsPerPage: 10
+     * });
+     *
+     * // get registrar actions within a specific time range
+     * const beginTimestamp = 1764547200; // Dec 1, 2025, 00:00:00 UTC
+     * const endTimestamp = 1767225600; // Jan 1, 2026, 00:00:00 UTC
+     * await client.registrarActions({
+     *   filters: [
+     *     registrarActionsFilter.beginTimestamp(beginTimestamp),
+     *     registrarActionsFilter.endTimestamp(endTimestamp),
+     *   ],
+     * });
+     *
+     * // get registrar actions from a specific timestamp onwards
+     * await client.registrarActions({
+     *   filters: [registrarActionsFilter.beginTimestamp(1764547200)],
+     * });
+     *
+     * // get registrar actions up to a specific timestamp
+     * await client.registrarActions({
+     *   filters: [registrarActionsFilter.endTimestamp(1767225600)],
+     * });
+     * ```
+     */
+    registrarActions(request?: RegistrarActionsRequest): Promise<RegistrarActionsResponse>;
+    /**
+     * Fetch Name Tokens for requested name.
+     *
+     * @param request.name - Name for which Name Tokens will be fetched.
+     * @returns {NameTokensResponse}
+     *
+     * @throws if the ENSNode request fails
+     * @throws if the ENSNode API returns an error response
+     * @throws if the ENSNode response breaks required invariants
+     *
+     * @example
+     * ```ts
+     * import {
+     *   ENSNodeClient,
+     * } from "@ensnode/ensnode-sdk";
+     * import { namehash } from "viem/ens";
+     *
+     * const client: ENSNodeClient;
+     *
+     * // get latest name token records from the indexed subregistry based on the requested name
+     * const response = await client.nameTokens({
+     *   name: "vitalik.eth"
+     * });
+     *
+     * const response = await client.nameTokens({
+     *   domainId: "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835" // namehash('vitalik.eth')
+     * })
+     * ```
+     */
+    nameTokens(request: NameTokensRequest): Promise<NameTokensResponse>;
+}
+
+declare class ClientError extends Error {
+    details?: unknown;
+    constructor(message: string, details?: unknown);
+    static fromErrorResponse({ message, details }: ErrorResponse): ClientError;
+}
+
+export { ADDR_REVERSE_NODE, ATTR_PROTOCOL_NAME, ATTR_PROTOCOL_STEP, ATTR_PROTOCOL_STEP_RESULT, type AcceleratableRequest, type AcceleratableResponse, type AccountId, type AccountIdString, type AssetId, type AssetIdString, type AssetNamespace, AssetNamespaces, BASENAMES_NODE, type BlockNumber, type 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, type CurrencyAmount, type CurrencyId, CurrencyIds, type CurrencyInfo, DEFAULT_EVM_CHAIN_ID, DEFAULT_EVM_COIN_TYPE, type DNSEncodedLiteralName, type DNSEncodedName, type DNSEncodedPartiallyInterpretedName, type Datetime, type DatetimeISO8601, type DeepPartial, type DefaultableChainId, type DomainAssetId, type Duration, type ENSApiPublicConfig, type ENSIndexerPublicConfig, type ENSIndexerVersionInfo, ENSNodeClient, ENS_ROOT, 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 NFTMintStatus, NFTMintStatuses, type NFTTransferEventMetadata, type NFTTransferType, NFTTransferTypes, type Name, type NameToken, type NameTokenOwnership, type NameTokenOwnershipBurned, type NameTokenOwnershipFullyOnchain, type NameTokenOwnershipNameWrapper, type NameTokenOwnershipType, NameTokenOwnershipTypes, type NameTokenOwnershipUnknown, type NameTokensRequest, type NameTokensResponse, type NameTokensResponseCode, NameTokensResponseCodes, type NameTokensResponseError, type NameTokensResponseErrorCode, NameTokensResponseErrorCodes, type NameTokensResponseErrorEnsIndexerConfigUnsupported, type NameTokensResponseErrorIndexingStatusUnsupported, type NameTokensResponseErrorNameTokensNotIndexed, type NameTokensResponseOk, type NamedIdentity, type NamedRegistrarAction, type Node, type NormalizedName, type OmnichainIndexingStatusId, OmnichainIndexingStatusIds, type OmnichainIndexingStatusSnapshot, type OmnichainIndexingStatusSnapshotBackfill, type OmnichainIndexingStatusSnapshotCompleted, type OmnichainIndexingStatusSnapshotFollowing, type OmnichainIndexingStatusSnapshotUnstarted, PROTOCOL_ATTRIBUTE_PREFIX, PluginName, type Price, type PriceDai, type PriceEth, type PriceUsdc, RECORDS_PER_PAGE_DEFAULT, RECORDS_PER_PAGE_MAX, ROOT_NODE, type RealtimeIndexingStatusProjection, type ReferrerDetailRequest, type ReferrerDetailResponse, type ReferrerDetailResponseCode, ReferrerDetailResponseCodes, type ReferrerDetailResponseError, type ReferrerDetailResponseOk, type ReferrerLeaderboardPageRequest, type ReferrerLeaderboardPageResponse, type ReferrerLeaderboardPageResponseCode, ReferrerLeaderboardPageResponseCodes, type ReferrerLeaderboardPageResponseError, type ReferrerLeaderboardPageResponseOk, type RegisteredNameTokens, type RegistrarAction, type RegistrarActionEventId, type RegistrarActionPricing, type RegistrarActionPricingAvailable, type RegistrarActionPricingUnknown, type RegistrarActionReferral, type RegistrarActionReferralAvailable, type RegistrarActionReferralNotApplicable, type RegistrarActionType, RegistrarActionTypes, type RegistrarActionsFilter, type RegistrarActionsFilterBeginTimestamp, type RegistrarActionsFilterByDecodedReferrer, type RegistrarActionsFilterBySubregistryNode, type RegistrarActionsFilterEndTimestamp, type RegistrarActionsFilterType, RegistrarActionsFilterTypes, type RegistrarActionsFilterWithEncodedReferral, type RegistrarActionsOrder, RegistrarActionsOrders, type RegistrarActionsRequest, type RegistrarActionsResponse, type RegistrarActionsResponseCode, RegistrarActionsResponseCodes, type RegistrarActionsResponseError, type RegistrarActionsResponseOk, type RegistrationLifecycle, type RegistrationLifecycleStage, type RequestPageParams, type ResolutionStatusId, ResolutionStatusIds, type ResolvePrimaryNameRequest, type ResolvePrimaryNameResponse, type ResolvePrimaryNamesRequest, type ResolvePrimaryNamesResponse, type ResolveRecordsRequest, type ResolveRecordsResponse, type ResolvedIdentity, type ResolverRecordsResponse, type ResolverRecordsResponseBase, type ResolverRecordsSelection, type ResponsePageContext, type ResponsePageContextWithNoRecords, type ResponsePageContextWithRecords, type ReverseResolutionArgs, ReverseResolutionProtocolStep, type ReverseResolutionResult, type RpcUrl, SWRCache, type SWRCacheOptions, type SerializedAggregatedReferrerMetrics, type SerializedAssetId, type SerializedAwardedReferrerMetrics, type SerializedChainIndexingStatusSnapshot, type SerializedChainIndexingStatusSnapshotBackfill, type SerializedChainIndexingStatusSnapshotCompleted, type SerializedChainIndexingStatusSnapshotFollowing, type SerializedChainIndexingStatusSnapshotQueued, type SerializedConfigResponse, type SerializedCrossChainIndexingStatusSnapshot, type SerializedCrossChainIndexingStatusSnapshotOmnichain, type SerializedCurrencyAmount, type SerializedCurrentIndexingProjectionOmnichain, type SerializedDomainAssetId, type SerializedENSApiPublicConfig, type SerializedENSIndexerPublicConfig, type SerializedENSIndexerVersionInfo, type SerializedIndexedChainIds, type SerializedIndexingStatusResponse, type SerializedIndexingStatusResponseError, type SerializedIndexingStatusResponseOk, type SerializedNameToken, type SerializedNameTokensResponse, type SerializedNameTokensResponseError, type SerializedNameTokensResponseOk, type SerializedNamedRegistrarAction, type SerializedOmnichainIndexingStatusSnapshot, type SerializedOmnichainIndexingStatusSnapshotBackfill, type SerializedOmnichainIndexingStatusSnapshotCompleted, type SerializedOmnichainIndexingStatusSnapshotFollowing, type SerializedOmnichainIndexingStatusSnapshotUnstarted, type SerializedPrice, type SerializedPriceDai, type SerializedPriceEth, type SerializedPriceUsdc, type SerializedRealtimeIndexingStatusProjection, type SerializedReferralProgramRules, type SerializedReferrerDetail, type SerializedReferrerDetailRanked, type SerializedReferrerDetailResponse, type SerializedReferrerDetailResponseError, type SerializedReferrerDetailResponseOk, type SerializedReferrerDetailUnranked, type SerializedReferrerLeaderboardPage, type SerializedReferrerLeaderboardPageResponse, type SerializedReferrerLeaderboardPageResponseError, type SerializedReferrerLeaderboardPageResponseOk, type SerializedRegisteredNameTokens, type SerializedRegistrarAction, type SerializedRegistrarActionPricing, type SerializedRegistrarActionPricingAvailable, type SerializedRegistrarActionPricingUnknown, type SerializedRegistrarActionsResponse, type SerializedRegistrarActionsResponseError, type SerializedRegistrarActionsResponseOk, type SerializedRevenueContribution, type SerializedTokenId, type SerializedUnrankedReferrerMetrics, type SubgraphInterpretedLabel, type SubgraphInterpretedName, type Subregistry, type TheGraphCannotFallbackReason, TheGraphCannotFallbackReasonSchema, type TheGraphFallback, TheGraphFallbackSchema, type TokenId, TraceableENSProtocol, type TraceableRequest, type TraceableResponse, type TracingNode, type TracingSpan, type TracingTrace, TtlCache, type UnixTimestamp, type UnknownIdentity, type UnnamedIdentity, type UnresolvedIdentity, type UrlString, accountIdEqual, addDuration, addPrices, addrReverseLabel, asLowerCaseAddress, beautifyName, bigIntToNumber, bigintToCoinType, buildAssetId, buildEnsRainbowClientLabelSet, buildLabelSetId, buildLabelSetVersion, buildPageContext, buildUnresolvedIdentity, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted, coinTypeReverseLabel, coinTypeToEvmChainId, createIndexingConfig, createRealtimeIndexingStatusProjection, decodeDNSEncodedLiteralName, decodeDNSEncodedName, deserializeAssetId, deserializeBlockNumber, deserializeBlockRef, deserializeBlockrange, deserializeChainId, deserializeChainIndexingStatusSnapshot, deserializeConfigResponse, deserializeCrossChainIndexingStatusSnapshot, deserializeDatetime, deserializeDuration, deserializeENSApiPublicConfig, deserializeENSIndexerPublicConfig, deserializeErrorResponse, deserializeIndexingStatusResponse, deserializeOmnichainIndexingStatusSnapshot, deserializeRealtimeIndexingStatusProjection, deserializeReferrerDetailResponse, deserializeReferrerLeaderboardPageResponse, deserializeRegistrarActionsResponse, deserializeUnixTimestamp, deserializeUrl, deserializedNameTokensResponse, durationBetween, encodeLabelHash, evmChainIdToCoinType, formatAccountId, formatAssetId, formatNFTTransferEventMetadata, getBasenamesSubregistryId, getBasenamesSubregistryManagedName, getCurrencyInfo, getDatasourceContract, getEthnamesSubregistryId, getEthnamesSubregistryManagedName, getLatestIndexedBlockRef, getLineanamesSubregistryId, getLineanamesSubregistryManagedName, getNFTTransferType, getNameHierarchy, getNameTokenOwnership, getNameWrapperAccounts, getOmnichainIndexingCursor, getOmnichainIndexingStatus, getParentNameFQDN, getResolvePrimaryNameChainIdParam, getTimestampForHighestOmnichainKnownBlock, getTimestampForLowestOmnichainStartBlock, hasNullByte, interpretedLabelsToInterpretedName, isEncodedLabelHash, isHttpProtocol, isLabelHash, isNormalizedLabel, isNormalizedName, isPriceCurrencyEqual, isPriceEqual, isRegistrarActionPricingAvailable, isRegistrarActionReferralAvailable, isResolvedIdentity, isSelectionEmpty, isSubgraphCompatible, isWebSocketProtocol, labelHashToBytes, labelhashLiteralLabel, literalLabelToInterpretedLabel, literalLabelsToInterpretedName, literalLabelsToLiteralName, makeENSApiPublicConfigSchema, makeSubdomainNode, maybeGetDatasourceContract, nameTokensPrerequisites, parseAccountId, parseAssetId, parseNonNegativeInteger, parseReverseName, priceDai, priceEth, priceUsdc, registrarActionsFilter, registrarActionsPrerequisites, reverseName, serializeAssetId, serializeChainId, serializeChainIndexingSnapshots, serializeConfigResponse, serializeCrossChainIndexingStatusSnapshotOmnichain, serializeDatetime, serializeDomainAssetId, serializeENSApiPublicConfig, serializeENSIndexerPublicConfig, serializeIndexedChainIds, serializeIndexingStatusResponse, serializeNameToken, serializeNameTokensResponse, serializeNamedRegistrarAction, serializeOmnichainIndexingStatusSnapshot, serializePrice, serializePriceEth, serializeRealtimeIndexingStatusProjection, serializeReferrerDetailResponse, serializeReferrerLeaderboardPageResponse, serializeRegisteredNameTokens, serializeRegistrarAction, serializeRegistrarActionPricing, serializeRegistrarActionsResponse, serializeUrl, sortChainStatusesByStartBlockAsc, stripNullBytes, translateDefaultableChainIdToChainId, uint256ToHex32, uniq, validateSupportedLabelSetAndVersion };