@ensnode/ensnode-sdk 0.36.0 → 1.0.0

package/dist/index.d.ts

@@ -1,6 +1,9 @@
-import { Hex, Address, ByteArray } from 'viem';
+import { Hex, Address, ByteArray, Hash } from 'viem';
 import { CoinType, EvmCoinType } from '@ensdomains/address-encoder';
 export { CoinType, EvmCoinType } from '@ensdomains/address-encoder';
+import { EncodedReferrer } from '@namehash/ens-referrals';
+export { EncodedReferrer, decodeEncodedReferrer, zeroEncodedReferrer } from '@namehash/ens-referrals';
+import z$1, { z } from 'zod/v4';
 import { ENSNamespaceId } from '@ensnode/datasources';
 export { ENSNamespaceId, ENSNamespaceIds, getENSRootChainId } from '@ensnode/datasources';
 
@@ -250,6 +253,66 @@ type DNSEncodedPartiallyInterpretedName = DNSEncodedName & {
     __brand: "DNSEncodedPartiallyInterpretedName";
 };
 
+/**
+ * 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;
+
+/**
+ * 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;
+
 declare const ROOT_NODE: Node;
 declare const ETH_NODE: Node;
 declare const BASENAMES_NODE: Node;
@@ -257,86 +320,145 @@ declare const LINEANAMES_NODE: Node;
 declare const ADDR_REVERSE_NODE: Node;
 
 /**
- * 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]).
+ * 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 const makeSubdomainNode: (labelHash: LabelHash, node: Node) => Node;
+declare function decodeDNSEncodedLiteralName(packet: DNSEncodedLiteralName): LiteralLabel[];
 /**
- * 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)
+ * 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 const uint256ToHex32: (num: bigint) => Hex;
+declare function decodeDNSEncodedName(packet: DNSEncodedName): string[];
 
 /**
- * Converts an EVM address to its lowercase representation.
+ * Formats a LabelHash as an Encoded LabelHash.
  *
- * @param address - EVM address to convert.
- * @returns The lowercase representation of the EVM address.
+ * @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 function asLowerCaseAddress(address: Address): Address;
+declare const encodeLabelHash: (labelHash: LabelHash) => EncodedLabelHash;
+/**
+ * Checks if the input value is an {@link EncodedLabelHash}.
+ */
+declare function isEncodedLabelHash(maybeEncodedLabelHash: string): maybeEncodedLabelHash is EncodedLabelHash;
 
 /**
- * Cache that maps from string -> ValueType.
+ * Checks if the input is a {@link LabelHash}.
+ *
+ * @see https://ensnode.io/docs/reference/terminology#label-processing-and-classification
  */
-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;
-}
+declare function isLabelHash(maybeLabelHash: string): maybeLabelHash is LabelHash;
+
 /**
- * Cache that maps from string -> ValueType with a LRU (least recently used) eviction policy.
+ * Constructs a name hierarchy from a given NormalizedName.
  *
- * `get` and `set` are O(1) operations.
+ * @example
+ * ```
+ * getNameHierarchy("sub.example.eth") -> ["sub.example.eth", "example.eth", "eth"]
+ * ```
  *
- * @link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
+ * @dev by restricting the input type to NormalizedName we guarantee that we can split and join
+ * on '.' and receive NormalizedNames as a result
  */
-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;
-}
+declare const getNameHierarchy: (name: NormalizedName) => NormalizedName[];
+/**
+ * Beautifies a name by converting each normalized label in the provided name to
+ * its "beautified" form. Labels that are not normalized retain their original value.
+ *
+ * Invariants:
+ * - The number of labels in the returned name is the same as the number of labels in the input name.
+ * - The order of the labels in the returned name is the same as the order of the labels in the input name.
+ * - If a label in the input is normalized, it is returned in its "beautified" form.
+ * - If a label in the input name is not normalized, it is returned without modification.
+ * - Therefore, the result of ens_normalize(beautifyName(name)) is the same as the result of ens_normalize(name).
+ *
+ * The "beautified form" of a normalized label converts special sequences of
+ * emojis and other special characters to their "beautified" equivalents. All
+ * such conversions transform X -> Y where Y is normalizable and normalizes back to X.
+ * Ex: '1⃣2⃣' (normalized) to '1️⃣2️⃣' (normalizable but not normalized).
+ * Ex: 'ξethereum' (normalized) to 'Ξethereum' (normalizable, but not normalized).
+ * Ex: 'abc' (normalized) to 'abc' (also normalized, no conversion).
+ * Ex: 'ABC' (normalizable but not normalized) to 'ABC' (no conversion).
+ * Ex: 'invalid|label' (not normalizable) to 'invalid|label' (no conversion).
+ * Ex: '' (unnormalized as a label) to '' (no conversion).
+ *
+ * @param name - The name to beautify.
+ * @returns The beautified name.
+ */
+declare const beautifyName: (name: Name) => Name;
 
 /**
- * Filter out duplicates.
+ * Parse the address and coinType out of an ENSIP-19 reverse name.
  */
-declare const uniq: <T>(arr: T[]) => T[];
+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
@@ -457,32 +579,287 @@ type DeepPartial<T> = {
 };
 
 /**
- * Serialized representation of {@link ChainId}.
- **/
-type ChainIdString = string;
+ * Determines where the provided AccountId values represent the same address on the same chain.
+ */
+declare const accountIdEqual: (a: AccountId, b: AccountId) => boolean;
+
 /**
- * Datetime value following the ISO 8601 standard.
+ * Converts an EVM address to its lowercase representation.
  *
- * @see https://www.iso.org/iso-8601-date-and-time-format.html
+ * @param address - EVM address to convert.
+ * @returns The lowercase representation of the EVM address.
  */
-type DatetimeISO8601 = string;
+declare function asLowerCaseAddress(address: Address): Address;
+
 /**
- * Serialized representation of a {@link URL}.
+ * Cache that maps from string -> ValueType.
  */
-type UrlString = string;
+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;
+}
+/**
+ * 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;
+}
+interface StaleWhileRevalidateOptions<ValueType> {
+    /**
+     * The async function to wrap with SWR caching.
+     * On success this function returns a value of type `ValueType` to store in the `SWRCache`.
+     * On error, this function throws an error and no changes will be made to the `SWRCache`.
+     */
+    fn: () => Promise<ValueType>;
+    /**
+     * Time-to-live duration in seconds. After this duration, data in the `SWRCache` is
+     * considered stale but is still retained in the cache until replaced with a new value.
+     */
+    ttl: Duration;
+}
+/**
+ * Stale-While-Revalidate (SWR) cache wrapper 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 (currently only triggered lazily when new requests
+ *   are made for the cached data after it becomes stale)
+ *
+ * Error Handling:
+ * - If a new invocation of the provided `fn` throws an error and a cached value exists
+ *   from a previous successfully invocation of the provided `fn`, the stale cached value is returned.
+ * - If a new invocation of the provided `fn` throws an error and NO cached value exists,
+ *   from any prior invocations of the provided `fn`, such that the provided `fn` has never
+ *   successfully returned a value for the lifetime of the `SWRCache`, then `null` is returned.
+ * - Therefore, errors occuring within the provided `fn` are handled internally within
+ *   `staleWhileRevalidate` and do not propagate to the caller.
+ *
+ * @example
+ * ```typescript
+ * const fetchExpensiveData = async () => {
+ *   const response = await fetch('/api/data');
+ *   return response.json();
+ * };
+ *
+ * const cachedFetch = staleWhileRevalidate(fetchExpensiveData, 60); // 60 second TTL
+ *
+ * // First call: fetches data (slow)
+ * const data1 = await cachedFetch();
+ *
+ * // Within TTL: returns cached data (fast)
+ * const data2 = await cachedFetch();
+ *
+ * // After TTL: returns stale data immediately, revalidates asynchronously in the background
+ * const data3 = await cachedFetch(); // Still fast!
+ * ```
+ *
+ * @param fn The async function to wrap with SWR caching
+ * @param ttl Time-to-live duration in seconds. After this duration, data is considered stale
+ * @returns a value of `ValueType` that was most recently successfully returned by `fn`
+ *          or `null` if `fn` has never successfully returned and has always thrown an error.
+ *
+ * @link https://web.dev/stale-while-revalidate/
+ * @link https://datatracker.ietf.org/doc/html/rfc5861
+ */
+declare function staleWhileRevalidate<ValueType>(options: StaleWhileRevalidateOptions<ValueType>): () => Promise<ValueType | null>;
 
 /**
- * Serializes a {@link ChainId} value into its string representation.
+ * Filter out duplicates.
  */
-declare function serializeChainId(chainId: ChainId): ChainIdString;
+declare const uniq: <T>(arr: T[]) => T[];
+
 /**
- * Serializes a {@link Datetime} value into its string representation.
+ * Identifiers for supported currencies.
+ *
+ * TODO: Add support for WETH
  */
-declare function serializeDatetime(datetime: Datetime): DatetimeISO8601;
+declare const CurrencyIds: {
+    readonly ETH: "ETH";
+    readonly USDC: "USDC";
+    readonly DAI: "DAI";
+};
+type CurrencyId = (typeof CurrencyIds)[keyof typeof CurrencyIds];
 /**
- * Serializes a {@link URL} value into its string representation.
+ * The amount of the currency in the smallest unit of the currency
+ * (see {@link CurrencyInfo.decimals} for the currency).
+ *
+ * Guaranteed to be non-negative.
  */
-declare function serializeUrl(url: URL): UrlString;
+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;
+
+/**
+ * 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;
+/**
+ * Serialized representation of {@link AccountId}.
+ *
+ * Formatted as a fully lowercase CAIP-10 AccountId.
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-10
+ */
+type SerializedAccountId = string;
 
 declare function deserializeChainId(maybeChainId: ChainIdString, valueLabel?: string): ChainId;
 declare function deserializeDatetime(maybeDatetime: string, valueLabel?: string): Datetime;
@@ -494,27 +871,8 @@ declare function deserializeBlockrange(maybeBlockrange: Partial<Blockrange>, val
     endBlock?: number | undefined;
 };
 declare function deserializeBlockRef(maybeBlockRef: Partial<BlockRef>, valueLabel?: string): BlockRef;
-declare function deserializeDuration(maybeDuration: string, valueLabel?: string): Duration;
-
-/**
- * Determines whether the Name is normalized.
- *
- * @param name - The Name to check for normalization
- * @returns True if the name is normalized according to ENS normalization rules, false otherwise
- */
-declare function isNormalizedName(name: Name): name is NormalizedName;
-/**
- * Determines whether the Label is normalized.
- *
- * @param label - The Label to check for normalization
- * @returns True if the label is normalized according to ENS normalization rules, false otherwise
- */
-declare function isNormalizedLabel(label: Label): boolean;
-
-/**
- * Determines where the provided AccountId values represent the same address on the same chain.
- */
-declare const accountIdEqual: (a: AccountId, b: AccountId) => boolean;
+declare function deserializeDuration(maybeDuration: unknown, valueLabel?: string): Duration;
+declare function deserializeAccountId(maybeAccountId: unknown, valueLabel?: string): AccountId;
 
 /**
  * Interprets a Literal Label, producing an Interpreted Label.
@@ -569,169 +927,48 @@ declare function literalLabelsToLiteralName(labels: LiteralLabel[]): LiteralName
  */
 declare const labelhashLiteralLabel: (label: LiteralLabel) => LabelHash;
 
-declare function isHttpProtocol(url: URL): boolean;
-declare function isWebSocketProtocol(url: URL): boolean;
+declare const hasNullByte: (value: string) => boolean;
+declare const stripNullBytes: (value: string) => string;
 
 /**
- * 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.
+ * Converts a bigint value into a number value.
  *
- * @see https://docs.ens.domains/ensip/19/#reverse-resolution
+ * @throws when value is outside the range of `Number.MIN_SAFE_INTEGER` and
+ * `Number.MAX_SAFE_INTEGER`.
  */
-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;
+declare function bigIntToNumber(n: bigint): number;
 
 /**
- * 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[];
-/**
- * Beautifies a name by converting each normalized label in the provided name to
- * its "beautified" form. Labels that are not normalized retain their original value.
- *
- * Invariants:
- * - The number of labels in the returned name is the same as the number of labels in the input name.
- * - The order of the labels in the returned name is the same as the order of the labels in the input name.
- * - If a label in the input is normalized, it is returned in its "beautified" form.
- * - If a label in the input name is not normalized, it is returned without modification.
- * - Therefore, the result of ens_normalize(beautifyName(name)) is the same as the result of ens_normalize(name).
- *
- * The "beautified form" of a normalized label converts special sequences of
- * emojis and other special characters to their "beautified" equivalents. All
- * such conversions transform X -> Y where Y is normalizable and normalizes back to X.
- * Ex: '1⃣2⃣' (normalized) to '1️⃣2️⃣' (normalizable but not normalized).
- * Ex: 'ξethereum' (normalized) to 'Ξethereum' (normalizable, but not normalized).
- * Ex: 'abc' (normalized) to 'abc' (also normalized, no conversion).
- * Ex: 'ABC' (normalizable but not normalized) to 'ABC' (no conversion).
- * Ex: 'invalid|label' (not normalizable) to 'invalid|label' (no conversion).
- * Ex: '' (unnormalized as a label) to '' (no conversion).
- *
- * @param name - The name to beautify.
- * @returns The beautified name.
- */
-declare const beautifyName: (name: Name) => Name;
-
-/**
- * Gets the Label used for the reverse names of subnames as per ENSIP-11 & ENSIP-19.
- *
- * @see https://docs.ens.domains/ensip/19/#reverse-resolution
- */
-declare const addrReverseLabel: (address: Address) => LiteralLabel;
-/**
- * Converts `coinType` to prefix-free hex string.
- *
- * @see https://docs.ens.domains/ensip/19
+ * Serializes a {@link ChainId} value into its string representation.
  */
-declare const coinTypeReverseLabel: (coinType: CoinType) => Label;
+declare function serializeChainId(chainId: ChainId): ChainIdString;
 /**
- * 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"
- * ```
+ * Serializes a {@link Datetime} value into its string representation.
  */
-declare function reverseName(address: Address, coinType: CoinType): Name;
-
+declare function serializeDatetime(datetime: Datetime): DatetimeISO8601;
 /**
- * Parse the address and coinType out of an ENSIP-19 reverse name.
+ * Serializes a {@link URL} value into its string representation.
  */
-declare function parseReverseName(name: Name): {
-    address: Address;
-    coinType: CoinType;
-} | null;
-
+declare function serializeUrl(url: URL): UrlString;
 /**
- * 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]`
+ * Serializes a {@link Price} object.
  */
-declare const encodeLabelHash: (labelHash: LabelHash) => EncodedLabelHash;
-
+declare function serializePrice(price: Price): SerializedPrice;
 /**
- * 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
+ * Serializes a {@link PriceEth} object.
  */
-declare function decodeDNSEncodedLiteralName(packet: DNSEncodedLiteralName): LiteralLabel[];
+declare function serializePriceEth(price: PriceEth): SerializedPriceEth;
 /**
- * Decodes a DNS-Encoded Name into an ordered list of string segments.
- *
- * For discussion on DNS-Encoding, see the {@link DNSEncodedName} type.
+ * Serializes {@link AccountId} object.
  *
- * 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.
+ * Formatted as a fully lowercase CAIP-10 AccountId.
  *
- * @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
+ * @see https://chainagnostic.org/CAIPs/caip-10
  */
-declare function decodeDNSEncodedName(packet: DNSEncodedName): string[];
+declare function serializeAccountId(accountId: AccountId): SerializedAccountId;
+
+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.
@@ -794,7 +1031,7 @@ declare enum PluginName {
     Lineanames = "lineanames",
     ThreeDNS = "threedns",
     ProtocolAcceleration = "protocol-acceleration",
-    Referrals = "referrals",
+    Registrars = "registrars",
     TokenScope = "tokenscope"
 }
 /**
@@ -959,13 +1196,12 @@ declare function deserializeENSIndexerPublicConfig(maybeConfig: SerializedENSInd
 declare function isSubgraphCompatible(config: Pick<ENSIndexerPublicConfig, "namespace" | "plugins" | "labelSet">): boolean;
 
 /**
- * Serializes a {@link ChainConfig} object.
- */
-declare function serializeIndexedChainIds(indexedChainIds: Set<ChainId>): SerializedIndexedChainIds;
-/**
- * Serialize a {@link ENSIndexerPublicConfig} object.
+ * 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 serializeENSIndexerPublicConfig(config: ENSIndexerPublicConfig): SerializedENSIndexerPublicConfig;
+declare function labelHashToBytes(labelHash: LabelHash): ByteArray;
 
 /**
  * Builds a valid LabelSetId from a string.
@@ -997,14 +1233,6 @@ declare function buildEnsRainbowClientLabelSet(labelSetId?: LabelSetId, labelSet
  */
 declare function validateSupportedLabelSetAndVersion(serverSet: EnsRainbowServerLabelSet, clientSet: EnsRainbowClientLabelSet): void;
 
-/**
- * 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;
-
 /**
  * Parses a string into a non-negative integer.
  * @param input The string to parse
@@ -1013,6 +1241,15 @@ declare function labelHashToBytes(labelHash: LabelHash): ByteArray;
  */
 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.
  */
@@ -1046,10 +1283,6 @@ interface ChainIndexingConfigIndefinite {
      * 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?: null;
 }
 /**
  * Chain indexing config for a chain whose indexing config `configType` is
@@ -1732,176 +1965,515 @@ declare function serializeChainIndexingSnapshots<ChainIndexingStatusSnapshotType
 declare function serializeOmnichainIndexingStatusSnapshot(indexingStatus: OmnichainIndexingStatusSnapshot): SerializedOmnichainIndexingStatusSnapshot;
 
 /**
- * Identifiers for each traceable ENS protocol.
+ * 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 enum TraceableENSProtocol {
-    ForwardResolution = "forward-resolution",
-    ReverseResolution = "reverse-resolution"
+declare function getEthnamesSubregistryId(namespace: ENSNamespaceId): AccountId;
+
+/**
+ * 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;
 }
 /**
- * Encodes the set of well-known steps in the ENS Forward Resolution protocol.
+ * Serialized representation of {@link Subregistry}.
  */
-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"
+interface SerializedSubregistry extends Omit<Subregistry, "subregistryId"> {
+    subregistryId: SerializedAccountId;
 }
+declare function serializeSubregistry(subregistry: Subregistry): SerializedSubregistry;
+
 /**
- * Encodes the set of well-known steps in the ENS Reverse Resolution protocol.
+ * 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 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"
+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;
 }
-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";
-interface SpanAttributes {
-    [key: string]: unknown;
+/**
+ * Serialized representation of {@link RegistrationLifecycle}.
+ */
+interface SerializedRegistrationLifecycle extends Omit<RegistrationLifecycle, "subregistry"> {
+    subregistry: SerializedSubregistry;
 }
-interface SpanEvent {
-    name: string;
-    attributes: SpanAttributes;
-    time: number;
+declare function serializeRegistrationLifecycle(registrationLifecycle: RegistrationLifecycle): SerializedRegistrationLifecycle;
+
+/**
+ * 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;
 }
-interface ProtocolSpan {
-    scope: string;
-    id: string;
-    traceId: string;
-    parentSpanContext: {
-        traceId: string;
-        spanId: string;
-    } | undefined;
-    name: string;
-    timestamp: number;
-    duration: number;
-    attributes: SpanAttributes;
-    status: {
-        code: number;
-        message?: string;
-    };
-    events: SpanEvent[];
+/**
+ * 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 ProtocolSpanTreeNode = ProtocolSpan & {
-    children: ProtocolSpanTreeNode[];
-};
-type ProtocolTrace = ProtocolSpanTreeNode[];
-
+type RegistrarActionPricing = RegistrarActionPricingAvailable | RegistrarActionPricingUnknown;
+declare function isRegistrarActionPricingAvailable(registrarActionPricing: RegistrarActionPricing): registrarActionPricing is RegistrarActionPricingAvailable;
 /**
- * Encodes a selection of Resolver records in the context of a specific Name.
+ * * Referral information for performing a "logical registrar action".
  */
-interface ResolverRecordsSelection {
+interface RegistrarActionReferralAvailable {
     /**
-     * Whether to fetch the name's `name` record. This value is primarily used in the context of
-     * Reverse Resolution.
+     * Encoded Referrer
      *
-     * @see https://docs.ens.domains/ensip/19/#reverse-resolution
+     * Represents the "raw" 32-byte "referrer" value emitted onchain in
+     * association with the registrar action.
      */
-    name?: boolean;
+    encodedReferrer: EncodedReferrer;
     /**
-     * Which coinTypes to fetch address records for.
+     * 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.
      */
-    addresses?: CoinType[];
+    decodedReferrer: Address;
+}
+/**
+ * Referral information for performing a "logical registrar action" when
+ * registrar controller does not implement referrals.
+ */
+interface RegistrarActionReferralNotApplicable {
     /**
-     * Which keys to fetch text records for.
+     * Encoded Referrer
+     *
+     * Represents the "raw" 32-byte "referrer" value emitted onchain in
+     * association with the registrar action.
      */
-    texts?: string[];
+    encodedReferrer: null;
+    /**
+     * Decoded Referrer
+     *
+     * Decoded referrer according to the subjective interpretation of
+     * `encodedReferrer` defined for ENS Holiday Awards.
+     *
+     */
+    decodedReferrer: null;
 }
-declare const isSelectionEmpty: (selection: ResolverRecordsSelection) => boolean;
-
+type RegistrarActionReferral = RegistrarActionReferralAvailable | RegistrarActionReferralNotApplicable;
+declare function isRegistrarActionReferralAvailable(registrarActionReferral: RegistrarActionReferral): registrarActionReferral is RegistrarActionReferralAvailable;
 /**
- * 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.
+ * "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.
  */
-type ResolverRecordsResponseBase = {
+interface RegistrarAction {
     /**
-     * The name record, relevant in the context of Reverse Resolution.
-     * Null if no name record is set.
+     * "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.
      */
-    name: Name | null;
+    id: RegistrarActionEventId;
+    /**
+     * The type of the "logical registrar action".
+     */
+    type: RegistrarActionType;
     /**
-     * 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.
+     * 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.
      */
-    addresses: Record<CoinType, string | null>;
+    incrementalDuration: Duration;
     /**
-     * Text records, keyed by key.
-     * Value is null if no record for the specified key is set.
+     * 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".
      */
-    texts: Record<string, string | null>;
-};
+    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[]];
+}
 /**
- * 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>;
- * }
- * ```
+ * Serialized representation of {@link RegistrarActionPricingUnknown}.
  */
-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];
-};
-
+type SerializedRegistrarActionPricingUnknown = RegistrarActionPricingUnknown;
 /**
- * Arguments required to perform Forward Resolution
+ * Serialized representation of {@link RegistrarActionPricingAvailable}.
  */
-interface ForwardResolutionArgs<SELECTION extends ResolverRecordsSelection> {
-    name: Name;
-    selection: SELECTION;
+interface SerializedRegistrarActionPricingAvailable {
+    baseCost: SerializedPriceEth;
+    premium: SerializedPriceEth;
+    total: SerializedPriceEth;
 }
 /**
- * The result of performing ForwardResolution
+ * Serialized representation of {@link RegistrarActionPricing}.
  */
-type ForwardResolutionResult<SELECTION extends ResolverRecordsSelection> = ResolverRecordsResponse<SELECTION>;
+type SerializedRegistrarActionPricing = SerializedRegistrarActionPricingAvailable | SerializedRegistrarActionPricingUnknown;
 /**
- * Arguments required to perform Reverse Resolution
+ * Serialized representation of {@link RegistrarAction}.
  */
-interface ReverseResolutionArgs {
-    address: Address;
-    chainId: ChainId;
+interface SerializedRegistrarAction extends Omit<RegistrarAction, "registrationLifecycle" | "pricing"> {
+    registrationLifecycle: SerializedRegistrationLifecycle;
+    pricing: SerializedRegistrarActionPricing;
 }
+declare function serializeRegistrarActionPricing(pricing: RegistrarActionPricing): SerializedRegistrarActionPricing;
+declare function serializeRegistrarAction(registrarAction: RegistrarAction): SerializedRegistrarAction;
+
+declare const TheGraphCannotFallbackReasonSchema: z.ZodEnum<{
+    readonly NotSubgraphCompatible: "not-subgraph-compatible";
+    readonly NoApiKey: "no-api-key";
+    readonly NoSubgraphUrl: "no-subgraph-url";
+}>;
+declare const TheGraphFallbackSchema: z.ZodObject<{
+    canFallback: z.ZodBoolean;
+    reason: z.ZodNullable<z.ZodEnum<{
+        readonly NotSubgraphCompatible: "not-subgraph-compatible";
+        readonly NoApiKey: "no-api-key";
+        readonly NoSubgraphUrl: "no-subgraph-url";
+    }>>;
+}, z.core.$strict>;
+/**
+ * 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.ZodObject<{
+        canFallback: z.ZodBoolean;
+        reason: z.ZodNullable<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>;
+
+type TheGraphCannotFallbackReason = z.infer<typeof TheGraphCannotFallbackReasonSchema>;
+type TheGraphFallback = z.infer<typeof TheGraphFallbackSchema>;
 /**
- * The result of performing ReverseResolution
+ * Complete public configuration object for ENSApi.
+ *
+ * Contains ENSApi-specific configuration at the top level and
+ * embeds the complete ENSIndexer public configuration.
  */
-type ReverseResolutionResult = Name | null;
+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;
+}
+
 /**
- * Arguments required to perform Multichain Primary Name Resolution
+ * Serialized representation of {@link ENSApiPublicConfig}
  */
-interface MultichainPrimaryNameResolutionArgs {
-    address: Address;
-    chainIds?: ChainId[];
+interface SerializedENSApiPublicConfig extends Omit<ENSApiPublicConfig, "ensIndexerPublicConfig"> {
+    /**
+     * Serialized representation of {@link ENSApiPublicConfig.ensIndexerPublicConfig}.
+     */
+    ensIndexerPublicConfig: SerializedENSIndexerPublicConfig;
 }
+
 /**
- * The result of performing MultichainPrimaryNameResolution
+ * Deserialize a {@link ENSApiPublicConfig} object.
  */
-type MultichainPrimaryNameResolutionResult = Record<ChainId, Name | null>;
+declare function deserializeENSApiPublicConfig(maybeConfig: SerializedENSApiPublicConfig, valueLabel?: string): ENSApiPublicConfig;
+
+/**
+ * Serialize a {@link ENSApiPublicConfig} object.
+ */
+declare function serializeENSApiPublicConfig(config: ENSApiPublicConfig): SerializedENSApiPublicConfig;
+
 /**
  * The resolution status for an `Identity`.
  */
@@ -2027,25 +2599,21 @@ type ResolvedIdentity = NamedIdentity | UnnamedIdentity | UnknownIdentity;
  */
 type Identity = UnresolvedIdentity | ResolvedIdentity;
 
-declare const getCommonCoinTypes: (namespace: ENSNamespaceId) => CoinType[];
-declare const DefaultRecordsSelection: {
-    readonly mainnet: {
-        readonly addresses: CoinType[];
-        readonly texts: ["url", "avatar", "header", "description", "email", "com.twitter", "com.farcaster", "com.github"];
-    };
-    readonly sepolia: {
-        readonly addresses: CoinType[];
-        readonly texts: ["url", "avatar", "header", "description", "email", "com.twitter", "com.farcaster", "com.github"];
-    };
-    readonly holesky: {
-        readonly addresses: CoinType[];
-        readonly texts: ["url", "avatar", "header", "description", "email", "com.twitter", "com.farcaster", "com.github"];
-    };
-    readonly "ens-test-env": {
-        readonly addresses: CoinType[];
-        readonly texts: ["url", "avatar", "header", "description", "email", "com.twitter", "com.farcaster", "com.github"];
-    };
-};
+/**
+ * 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
@@ -2077,29 +2645,187 @@ declare const getResolvePrimaryNameChainIdParam: (chainId: DefaultableChainId, n
  */
 declare const translateDefaultableChainIdToChainId: (chainId: DefaultableChainId, namespaceId: ENSNamespaceId) => ChainId;
 
-/**
- * Builds an {@link UnresolvedIdentity} for the provided {@link Address},
- * {@link DefaultableChainId} and {@link ENSNamespaceId}.
- *
- * If no `chainId` is provided, uses the ENS Root Chain Id for the provided
- * `namespaceId`.
- */
-declare function buildUnresolvedIdentity(address: Address, namespaceId: ENSNamespaceId, chainId?: DefaultableChainId): UnresolvedIdentity;
-/**
- * Returns whether the provided {@link Identity} is a {@link ResolvedIdentity}.
- *
- * @param identity - The {@link Identity} to check.
- * @returns Whether the provided {@link Identity} is a {@link ResolvedIdentity}.
- */
-declare function isResolvedIdentity(identity: Identity): identity is ResolvedIdentity;
+/**
+ * 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>;
+
+/**
+ * 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"
+}
+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";
+interface SpanAttributes {
+    [key: string]: unknown;
+}
+interface SpanEvent {
+    name: string;
+    attributes: SpanAttributes;
+    time: number;
+}
+interface ProtocolSpan {
+    scope: string;
+    id: string;
+    traceId: string;
+    parentSpanContext: {
+        traceId: string;
+        spanId: string;
+    } | undefined;
+    name: string;
+    timestamp: number;
+    duration: number;
+    attributes: SpanAttributes;
+    status: {
+        code: number;
+        message?: string;
+    };
+    events: SpanEvent[];
+}
+type ProtocolSpanTreeNode = ProtocolSpan & {
+    children: ProtocolSpanTreeNode[];
+};
+type ProtocolTrace = ProtocolSpanTreeNode[];
+
+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
  */
-interface ErrorResponse {
-    message: string;
-    details?: unknown;
-}
+type ErrorResponse = z$1.infer<typeof ErrorResponseSchema>;
 interface TraceableRequest {
     trace?: boolean;
 }
@@ -2110,6 +2836,7 @@ interface AcceleratableRequest {
     accelerate?: boolean;
 }
 interface AcceleratableResponse {
+    accelerationRequested: boolean;
     accelerationAttempted: boolean;
 }
 /**
@@ -2142,7 +2869,7 @@ interface ResolvePrimaryNamesResponse extends AcceleratableResponse, TraceableRe
 /**
  * ENSIndexer Public Config Response
  */
-type ConfigResponse = ENSIndexerPublicConfig;
+type ConfigResponse = ENSApiPublicConfig;
 /**
  * Represents a request to Indexing Status API.
  */
@@ -2184,11 +2911,373 @@ type IndexingStatusResponseError = {
  * at runtime.
  */
 type IndexingStatusResponse = IndexingStatusResponseOk | IndexingStatusResponseError;
+/**
+ * Registrar Actions response
+ */
+/**
+ * Records Filters: Filter Types
+ */
+declare const RegistrarActionsFilterTypes: {
+    readonly BySubregistryNode: "bySubregistryNode";
+    readonly WithEncodedReferral: "withEncodedReferral";
+};
+type RegistrarActionsFilterType = (typeof RegistrarActionsFilterTypes)[keyof typeof RegistrarActionsFilterTypes];
+type RegistrarActionsFilterBySubregistryNode = {
+    filterType: typeof RegistrarActionsFilterTypes.BySubregistryNode;
+    value: Node;
+};
+type RegistrarActionsFilterWithEncodedReferral = {
+    filterType: typeof RegistrarActionsFilterTypes.WithEncodedReferral;
+};
+type RegistrarActionsFilter = RegistrarActionsFilterBySubregistryNode | RegistrarActionsFilterWithEncodedReferral;
+/**
+ * Records Orders
+ */
+declare const RegistrarActionsOrders: {
+    readonly LatestRegistrarActions: "orderBy[timestamp]=desc";
+};
+type RegistrarActionsOrder = (typeof RegistrarActionsOrders)[keyof typeof RegistrarActionsOrders];
+/**
+ * Represents a request to Registrar Actions API.
+ */
+type RegistrarActionsRequest = {
+    /**
+     * Filters to be applied while generating results.
+     */
+    filters?: RegistrarActionsFilter[];
+    /**
+     * Order applied while generating results.
+     */
+    order?: RegistrarActionsOrder;
+    /**
+     * Limit the count of items per page to selected count of records.
+     *
+     * Guaranteed to be a positive integer (if defined).
+     */
+    itemsPerPage?: number;
+};
+/**
+ * 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[];
+};
+/**
+ * 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 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;
+/**
+ * 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;
+
+declare function deserializeErrorResponse(maybeErrorResponse: unknown): ErrorResponse;
+declare function deserializeIndexingStatusResponse(maybeResponse: SerializedIndexingStatusResponse): IndexingStatusResponse;
+declare function deserializeRegistrarActionsResponse(maybeResponse: SerializedRegistrarActionsResponse): RegistrarActionsResponse;
+
+/**
+ * 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;
+declare const registrarActionsFilter: {
+    byParentNode: typeof byParentNode;
+    withReferral: typeof withReferral;
+};
+
+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 serializeIndexingStatusResponse(response: IndexingStatusResponse): SerializedIndexingStatusResponse;
+declare function serializeNamedRegistrarAction({ action, name, }: NamedRegistrarAction): SerializedNamedRegistrarAction;
+declare function serializeRegistrarActionsResponse(response: RegistrarActionsResponse): SerializedRegistrarActionsResponse;
+
+/**
+ * The default number of items per page for paginated aggregated referrer queries.
+ */
+declare const ITEMS_PER_PAGE_DEFAULT = 25;
+/**
+ * The maximum number of items per page for paginated aggregated referrer queries.
+ */
+declare const ITEMS_PER_PAGE_MAX = 100;
+/**
+ * Represents the aggregated metrics for a single referrer.
+ */
+interface AggregatedReferrerMetrics {
+    /** The Ethereum address of the referrer */
+    referrer: Address;
+    /**
+     * The total number of qualified referrals made by this referrer
+     * @invariant Guaranteed to be a positive integer (> 0)
+     */
+    totalReferrals: number;
+    /**
+     * The total incremental duration (in seconds) of all referrals made by this referrer
+     * @invariant Guaranteed to be a non-negative integer (>= 0), measured in seconds
+     */
+    totalIncrementalDuration: Duration;
+}
+/**
+ * Represents the aggregated metrics for a single referrer with contribution percentages.
+ * Extends {@link AggregatedReferrerMetrics} with additional fields that show the referrer's
+ * contribution as a percentage of the grand totals.
+ */
+interface AggregatedReferrerMetricsContribution extends AggregatedReferrerMetrics {
+    /**
+     * The referrer's contribution to the grand total referrals as a decimal between 0 and 1 (inclusive).
+     * Calculated as: totalReferrals / grandTotalReferrals
+     * @invariant 0 <= totalReferralsContribution <= 1
+     */
+    totalReferralsContribution: number;
+    /**
+     * The referrer's contribution to the grand total incremental duration as a decimal between 0 and 1 (inclusive).
+     * Calculated as: totalIncrementalDuration / grandTotalIncrementalDuration
+     * @invariant 0 <= totalIncrementalDurationContribution <= 1
+     */
+    totalIncrementalDurationContribution: number;
+}
+/**
+ * Base pagination parameters for paginated queries.
+ */
+interface PaginationParams {
+    /**
+     * Requested page number (1-indexed)
+     * @invariant Must be a positive integer (>= 1)
+     * @default 1
+     */
+    page?: number;
+    /**
+     * Maximum number of items per page
+     * @invariant Must be a positive integer (>= 1) and less than or equal to {@link ITEMS_PER_PAGE_MAX}
+     * @default {@link ITEMS_PER_PAGE_DEFAULT}
+     */
+    itemsPerPage?: number;
+}
+/**
+ * Request parameters for paginated aggregated referrers query.
+ */
+interface PaginatedAggregatedReferrersRequest extends PaginationParams {
+}
+/**
+ * Paginated aggregated referrers data with metadata.
+ */
+interface PaginatedAggregatedReferrers {
+    /**
+     * Array of aggregated referrers for the current page with contribution percentages
+     * @invariant Array may be empty for the first page if there are no qualified referrers.
+     */
+    referrers: AggregatedReferrerMetricsContribution[];
+    /**
+     * Total number of aggregated referrers across all pages
+     * @invariant Guaranteed to be a non-negative integer (>= 0)
+     */
+    total: number;
+    /**
+     * Pagination parameters
+     * @invariant Stores the pagination parameters from the request
+     */
+    paginationParams: PaginationParams;
+    /**
+     * Indicates whether there is a next page available
+     * @invariant true if and only if (page * itemsPerPage < total)
+     */
+    hasNext: boolean;
+    /**
+     * Indicates whether there is a previous page available
+     * @invariant true if and only if (page > 1)
+     */
+    hasPrev: boolean;
+    /** Unix timestamp of when the leaderboard was last updated */
+    updatedAt: UnixTimestamp;
+}
+/**
+ * A status code for paginated aggregated referrers API responses.
+ */
+declare const PaginatedAggregatedReferrersResponseCodes: {
+    /**
+     * Represents that the aggregated referrers data is available.
+     * @note The response may contain an empty array for the first page if there are no qualified referrers.
+     * When the array is empty, total will be 0, page will be 1, and both hasNext and hasPrev will be false.
+     */
+    readonly Ok: "ok";
+    /**
+     * Represents that the aggregated referrers data is not available.
+     */
+    readonly Error: "error";
+};
+/**
+ * The derived string union of possible {@link PaginatedAggregatedReferrersResponseCodes}.
+ */
+type PaginatedAggregatedReferrersResponseCode = (typeof PaginatedAggregatedReferrersResponseCodes)[keyof typeof PaginatedAggregatedReferrersResponseCodes];
+/**
+ * A paginated aggregated referrers response when the data is available.
+ */
+type PaginatedAggregatedReferrersResponseOk = {
+    responseCode: typeof PaginatedAggregatedReferrersResponseCodes.Ok;
+    data: PaginatedAggregatedReferrers;
+};
+/**
+ * A paginated aggregated referrers response when the data is not available.
+ */
+type PaginatedAggregatedReferrersResponseError = {
+    responseCode: typeof PaginatedAggregatedReferrersResponseCodes.Error;
+    error: string;
+    errorMessage: string;
+};
+/**
+ * A paginated aggregated referrers API response.
+ *
+ * Use the `responseCode` field to determine the specific type interpretation
+ * at runtime.
+ */
+type PaginatedAggregatedReferrersResponse = PaginatedAggregatedReferrersResponseOk | PaginatedAggregatedReferrersResponseError;
+
+/**
+ * Serialized representation of {@link PaginatedAggregatedReferrersResponseError}.
+ *
+ * Note: All fields are already serializable, so this type is identical to the source type.
+ */
+type SerializedPaginatedAggregatedReferrersResponseError = PaginatedAggregatedReferrersResponseError;
+/**
+ * Serialized representation of {@link PaginatedAggregatedReferrersResponseOk}.
+ *
+ * Note: All fields are already serializable, so this type is identical to the source type.
+ */
+type SerializedPaginatedAggregatedReferrersResponseOk = PaginatedAggregatedReferrersResponseOk;
+/**
+ * Serialized representation of {@link PaginatedAggregatedReferrersResponse}.
+ */
+type SerializedPaginatedAggregatedReferrersResponse = SerializedPaginatedAggregatedReferrersResponseOk | SerializedPaginatedAggregatedReferrersResponseError;
+
+/**
+ * Deserialize a {@link PaginatedAggregatedReferrersResponse} object.
+ *
+ * Note: While the serialized and deserialized types are identical (all fields
+ * are primitives), this function performs critical validation using Zod schemas
+ * to enforce invariants on the data. This ensures data integrity when receiving
+ * responses from the API.
+ */
+declare function deserializePaginatedAggregatedReferrersResponse(maybeResponse: SerializedPaginatedAggregatedReferrersResponse, valueLabel?: string): PaginatedAggregatedReferrersResponse;
 
 /**
- * Default ENSNode API endpoint URL
+ * Serialize a {@link PaginatedAggregatedReferrersResponse} object.
+ *
+ * Note: Since all fields in PaginatedAggregatedReferrersResponse are already
+ * serializable primitives, this function performs an identity transformation.
+ * It exists to maintain consistency with the serialization pattern used
+ * throughout the codebase.
  */
-declare const DEFAULT_ENSNODE_API_URL: "https://api.alpha.ensnode.io";
+declare function serializePaginatedAggregatedReferrersResponse(response: PaginatedAggregatedReferrersResponse): SerializedPaginatedAggregatedReferrersResponse;
+
 /**
  * Configuration options for ENSNode API client
  */
@@ -2201,6 +3290,7 @@ interface ClientOptions {
  *
  * Provides access to the following ENSNode APIs:
  * - Resolution API
+ * - ENSAnalytics API
  * - 🚧 Configuration API
  * - 🚧 Indexing Status API
  *
@@ -2367,32 +3457,100 @@ declare class ENSNodeClient {
      * @throws if the ENSNode response breaks required invariants
      */
     indexingStatus(): Promise<IndexingStatusResponse>;
+    /**
+     * Fetch Paginated Aggregated Referrers
+     *
+     * Retrieves a paginated list of aggregated referrer 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.itemsPerPage - Number of items per page (default: 25, max: 100)
+     * @returns {PaginatedAggregatedReferrersResponse}
+     *
+     * @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 items)
+     * const response = await client.getAggregatedReferrers();
+     * if (response.responseCode === 'ok') {
+     *   console.log(response.data.referrers);
+     *   console.log(`Page ${response.data.paginationParams.page} of ${Math.ceil(response.data.total / response.data.paginationParams.itemsPerPage)}`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Get second page with 50 items per page
+     * const response = await client.getAggregatedReferrers({ page: 2, itemsPerPage: 50 });
+     * ```
+     */
+    getAggregatedReferrers(request?: PaginatedAggregatedReferrersRequest): Promise<PaginatedAggregatedReferrersResponse>;
+    /**
+     * Fetch ENSNode Registrar Actions
+     *
+     * @param {RegistrarActionsRequestFilter} request.filter is
+     *        an optional request filter configuration.
+     * @param {number} request.limit sets the maximum count of results in the response.
+     * @param {RegistrarActionsRequestOrder} 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 latest registrar action records across all indexed subregistries
+     * // NOTE: when no `limit` value is passed,
+     * //       the default RESPONSE_ITEMS_PER_PAGE_DEFAULT applies.
+     * const registrarActions = await client.registrarActions();
+     *
+     * // get latest 5 registrar action records across all indexed subregistries
+     * // NOTE: when a `limit` value is passed, it must be lower than or equal to
+     * //       the RESPONSE_ITEMS_PER_PAGE_MAX value.
+     * const registrarActions = await client.registrarActions({
+     *   limit: 5,
+     * });
+     *
+     * // 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 10 registrar action records associated with
+     * // subregistry managing `base.eth` name
+     * await client.registrarActions({
+     *   filters: [registrarActionsFilter.byParentNode(namehash('base.eth'))],
+     *   limit: 10
+     * });
+     * ```
+     */
+    registrarActions(request?: RegistrarActionsRequest): Promise<RegistrarActionsResponse>;
 }
 
-/**
- * Serialized representation of {@link IndexingStatusResponseError}.
- */
-type SerializedIndexingStatusResponseError = IndexingStatusResponseError;
-/**
- * Serialized representation of {@link IndexingStatusResponseOk}.
- */
-interface SerializedIndexingStatusResponseOk extends Omit<IndexingStatusResponseOk, "realtimeProjection"> {
-    realtimeProjection: SerializedRealtimeIndexingStatusProjection;
-}
-/**
- * Serialized representation of {@link IndexingStatusResponse}.
- */
-type SerializedIndexingStatusResponse = SerializedIndexingStatusResponseOk | SerializedIndexingStatusResponseError;
-
-declare function deserializeErrorResponse(maybeErrorResponse: unknown): ErrorResponse;
-declare function deserializeIndexingStatusResponse(maybeResponse: SerializedIndexingStatusResponse): IndexingStatusResponse;
-
-declare function serializeIndexingStatusResponse(response: IndexingStatusResponse): SerializedIndexingStatusResponse;
-
 declare class ClientError extends Error {
     details?: unknown;
     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, BASENAMES_NODE, type BlockNumber, type BlockRef, type Blockrange, type Cache, type ChainId, type ChainIdString, type ChainIndexingConfig, type ChainIndexingConfigDefinite, type ChainIndexingConfigIndefinite, type ChainIndexingConfigTypeId, ChainIndexingConfigTypeIds, type ChainIndexingStatusId, ChainIndexingStatusIds, type ChainIndexingStatusSnapshot, type ChainIndexingStatusSnapshotBackfill, type ChainIndexingStatusSnapshotCompleted, type ChainIndexingStatusSnapshotFollowing, type ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill, type ChainIndexingStatusSnapshotQueued, ClientError, type ClientOptions, type ConfigResponse, type CrossChainIndexingStatusSnapshot, type CrossChainIndexingStatusSnapshotOmnichain, type CrossChainIndexingStrategyId, CrossChainIndexingStrategyIds, DEFAULT_ENSNODE_API_URL, DEFAULT_EVM_CHAIN_ID, DEFAULT_EVM_COIN_TYPE, type DNSEncodedLiteralName, type DNSEncodedName, type DNSEncodedPartiallyInterpretedName, type Datetime, type DatetimeISO8601, type DeepPartial, DefaultRecordsSelection, type DefaultableChainId, type Duration, type ENSIndexerPublicConfig, type ENSIndexerVersionInfo, ENSNodeClient, ETH_COIN_TYPE, ETH_NODE, type EncodedLabelHash, type EnsRainbowClientLabelSet, type EnsRainbowServerLabelSet, type ErrorResponse, type ForwardResolutionArgs, ForwardResolutionProtocolStep, type ForwardResolutionResult, type Identity, type IndexingStatusRequest, type IndexingStatusResponse, type IndexingStatusResponseCode, IndexingStatusResponseCodes, type IndexingStatusResponseError, type IndexingStatusResponseOk, type InterpretedLabel, type InterpretedName, LINEANAMES_NODE, type Label, type LabelHash, type LabelSetId, type LabelSetVersion, type LiteralLabel, type LiteralName, LruCache, type MultichainPrimaryNameResolutionArgs, type MultichainPrimaryNameResolutionResult, type Name, type NamedIdentity, type Node, type NormalizedName, type OmnichainIndexingStatusId, OmnichainIndexingStatusIds, type OmnichainIndexingStatusSnapshot, type OmnichainIndexingStatusSnapshotBackfill, type OmnichainIndexingStatusSnapshotCompleted, type OmnichainIndexingStatusSnapshotFollowing, type OmnichainIndexingStatusSnapshotUnstarted, PROTOCOL_ATTRIBUTE_PREFIX, PluginName, type ProtocolSpan, type ProtocolSpanTreeNode, type ProtocolTrace, ROOT_NODE, type RealtimeIndexingStatusProjection, type ResolutionStatusId, ResolutionStatusIds, type ResolvePrimaryNameRequest, type ResolvePrimaryNameResponse, type ResolvePrimaryNamesRequest, type ResolvePrimaryNamesResponse, type ResolveRecordsRequest, type ResolveRecordsResponse, type ResolvedIdentity, type ResolverRecordsResponse, type ResolverRecordsResponseBase, type ResolverRecordsSelection, type ReverseResolutionArgs, ReverseResolutionProtocolStep, type ReverseResolutionResult, type RpcUrl, type SerializedChainIndexingStatusSnapshot, type SerializedChainIndexingStatusSnapshotBackfill, type SerializedChainIndexingStatusSnapshotCompleted, type SerializedChainIndexingStatusSnapshotFollowing, type SerializedChainIndexingStatusSnapshotQueued, type SerializedCrossChainIndexingStatusSnapshot, type SerializedCrossChainIndexingStatusSnapshotOmnichain, type SerializedCurrentIndexingProjectionOmnichain, type SerializedENSIndexerPublicConfig, type SerializedENSIndexerVersionInfo, type SerializedIndexedChainIds, type SerializedIndexingStatusResponse, type SerializedIndexingStatusResponseError, type SerializedIndexingStatusResponseOk, type SerializedOmnichainIndexingStatusSnapshot, type SerializedOmnichainIndexingStatusSnapshotBackfill, type SerializedOmnichainIndexingStatusSnapshotCompleted, type SerializedOmnichainIndexingStatusSnapshotFollowing, type SerializedOmnichainIndexingStatusSnapshotUnstarted, type SerializedRealtimeIndexingStatusProjection, type SubgraphInterpretedLabel, type SubgraphInterpretedName, TraceableENSProtocol, type TraceableRequest, type TraceableResponse, type UnixTimestamp, type UnknownIdentity, type UnnamedIdentity, type UnresolvedIdentity, type UrlString, accountIdEqual, addrReverseLabel, asLowerCaseAddress, beautifyName, bigintToCoinType, buildEnsRainbowClientLabelSet, buildLabelSetId, buildLabelSetVersion, buildUnresolvedIdentity, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted, coinTypeReverseLabel, coinTypeToEvmChainId, createIndexingConfig, createRealtimeIndexingStatusProjection, decodeDNSEncodedLiteralName, decodeDNSEncodedName, deserializeBlockNumber, deserializeBlockRef, deserializeBlockrange, deserializeChainId, deserializeChainIndexingStatusSnapshot, deserializeCrossChainIndexingStatusSnapshot, deserializeDatetime, deserializeDuration, deserializeENSIndexerPublicConfig, deserializeErrorResponse, deserializeIndexingStatusResponse, deserializeOmnichainIndexingStatusSnapshot, deserializeRealtimeIndexingStatusProjection, deserializeUnixTimestamp, deserializeUrl, encodeLabelHash, evmChainIdToCoinType, getCommonCoinTypes, getNameHierarchy, getOmnichainIndexingCursor, getOmnichainIndexingStatus, getResolvePrimaryNameChainIdParam, getTimestampForHighestOmnichainKnownBlock, getTimestampForLowestOmnichainStartBlock, interpretedLabelsToInterpretedName, isHttpProtocol, isNormalizedLabel, isNormalizedName, isResolvedIdentity, isSelectionEmpty, isSubgraphCompatible, isWebSocketProtocol, labelHashToBytes, labelhashLiteralLabel, literalLabelToInterpretedLabel, literalLabelsToInterpretedName, literalLabelsToLiteralName, makeSubdomainNode, parseNonNegativeInteger, parseReverseName, reverseName, serializeChainId, serializeChainIndexingSnapshots, serializeCrossChainIndexingStatusSnapshotOmnichain, serializeDatetime, serializeENSIndexerPublicConfig, serializeIndexedChainIds, serializeIndexingStatusResponse, serializeOmnichainIndexingStatusSnapshot, serializeRealtimeIndexingStatusProjection, serializeUrl, sortChainStatusesByStartBlockAsc, translateDefaultableChainIdToChainId, uint256ToHex32, uniq, validateSupportedLabelSetAndVersion };
+export { ADDR_REVERSE_NODE, ATTR_PROTOCOL_NAME, ATTR_PROTOCOL_STEP, ATTR_PROTOCOL_STEP_RESULT, type AcceleratableRequest, type AcceleratableResponse, type AccountId, type AggregatedReferrerMetrics, type AggregatedReferrerMetricsContribution, 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 Duration, type ENSApiPublicConfig, type ENSIndexerPublicConfig, type ENSIndexerVersionInfo, ENSNodeClient, ETH_COIN_TYPE, ETH_NODE, type EncodedLabelHash, type EnsRainbowClientLabelSet, type EnsRainbowServerLabelSet, type ErrorResponse, type ForwardResolutionArgs, ForwardResolutionProtocolStep, type ForwardResolutionResult, ITEMS_PER_PAGE_DEFAULT, ITEMS_PER_PAGE_MAX, type Identity, type IndexingStatusRequest, type IndexingStatusResponse, type IndexingStatusResponseCode, IndexingStatusResponseCodes, type IndexingStatusResponseError, type IndexingStatusResponseOk, type InterpretedLabel, type InterpretedName, LINEANAMES_NODE, type Label, type LabelHash, type LabelSetId, type LabelSetVersion, type LiteralLabel, type LiteralName, LruCache, type MultichainPrimaryNameResolutionArgs, type MultichainPrimaryNameResolutionResult, type Name, type NamedIdentity, type NamedRegistrarAction, type Node, type NormalizedName, type OmnichainIndexingStatusId, OmnichainIndexingStatusIds, type OmnichainIndexingStatusSnapshot, type OmnichainIndexingStatusSnapshotBackfill, type OmnichainIndexingStatusSnapshotCompleted, type OmnichainIndexingStatusSnapshotFollowing, type OmnichainIndexingStatusSnapshotUnstarted, PROTOCOL_ATTRIBUTE_PREFIX, type PaginatedAggregatedReferrers, type PaginatedAggregatedReferrersRequest, type PaginatedAggregatedReferrersResponse, type PaginatedAggregatedReferrersResponseCode, PaginatedAggregatedReferrersResponseCodes, type PaginatedAggregatedReferrersResponseError, type PaginatedAggregatedReferrersResponseOk, type PaginationParams, PluginName, type Price, type PriceDai, type PriceEth, type PriceUsdc, type ProtocolSpan, type ProtocolSpanTreeNode, type ProtocolTrace, ROOT_NODE, type RealtimeIndexingStatusProjection, type RegistrarAction, type RegistrarActionEventId, type RegistrarActionPricing, type RegistrarActionPricingAvailable, type RegistrarActionPricingUnknown, type RegistrarActionReferral, type RegistrarActionReferralAvailable, type RegistrarActionReferralNotApplicable, type RegistrarActionType, RegistrarActionTypes, type RegistrarActionsFilter, type RegistrarActionsFilterBySubregistryNode, type RegistrarActionsFilterType, RegistrarActionsFilterTypes, type RegistrarActionsFilterWithEncodedReferral, type RegistrarActionsOrder, RegistrarActionsOrders, type RegistrarActionsRequest, type RegistrarActionsResponse, type RegistrarActionsResponseCode, RegistrarActionsResponseCodes, type RegistrarActionsResponseError, type RegistrarActionsResponseOk, type RegistrationLifecycle, type RegistrationLifecycleStage, type ResolutionStatusId, ResolutionStatusIds, type ResolvePrimaryNameRequest, type ResolvePrimaryNameResponse, type ResolvePrimaryNamesRequest, type ResolvePrimaryNamesResponse, type ResolveRecordsRequest, type ResolveRecordsResponse, type ResolvedIdentity, type ResolverRecordsResponse, type ResolverRecordsResponseBase, type ResolverRecordsSelection, type ReverseResolutionArgs, ReverseResolutionProtocolStep, type ReverseResolutionResult, type RpcUrl, type SerializedAccountId, type SerializedChainIndexingStatusSnapshot, type SerializedChainIndexingStatusSnapshotBackfill, type SerializedChainIndexingStatusSnapshotCompleted, type SerializedChainIndexingStatusSnapshotFollowing, type SerializedChainIndexingStatusSnapshotQueued, type SerializedCrossChainIndexingStatusSnapshot, type SerializedCrossChainIndexingStatusSnapshotOmnichain, type SerializedCurrencyAmount, type SerializedCurrentIndexingProjectionOmnichain, type SerializedENSApiPublicConfig, type SerializedENSIndexerPublicConfig, type SerializedENSIndexerVersionInfo, type SerializedIndexedChainIds, type SerializedIndexingStatusResponse, type SerializedIndexingStatusResponseError, type SerializedIndexingStatusResponseOk, type SerializedNamedRegistrarAction, type SerializedOmnichainIndexingStatusSnapshot, type SerializedOmnichainIndexingStatusSnapshotBackfill, type SerializedOmnichainIndexingStatusSnapshotCompleted, type SerializedOmnichainIndexingStatusSnapshotFollowing, type SerializedOmnichainIndexingStatusSnapshotUnstarted, type SerializedPaginatedAggregatedReferrersResponse, type SerializedPaginatedAggregatedReferrersResponseError, type SerializedPaginatedAggregatedReferrersResponseOk, type SerializedPrice, type SerializedPriceDai, type SerializedPriceEth, type SerializedPriceUsdc, type SerializedRealtimeIndexingStatusProjection, type SerializedRegistrarAction, type SerializedRegistrarActionPricing, type SerializedRegistrarActionPricingAvailable, type SerializedRegistrarActionPricingUnknown, type SerializedRegistrarActionsResponse, type SerializedRegistrarActionsResponseError, type SerializedRegistrarActionsResponseOk, type SerializedRegistrationLifecycle, type SerializedSubregistry, type SubgraphInterpretedLabel, type SubgraphInterpretedName, type Subregistry, type TheGraphCannotFallbackReason, TheGraphCannotFallbackReasonSchema, type TheGraphFallback, TheGraphFallbackSchema, TraceableENSProtocol, type TraceableRequest, type TraceableResponse, TtlCache, type UnixTimestamp, type UnknownIdentity, type UnnamedIdentity, type UnresolvedIdentity, type UrlString, accountIdEqual, addDuration, addPrices, addrReverseLabel, asLowerCaseAddress, beautifyName, bigIntToNumber, bigintToCoinType, buildEnsRainbowClientLabelSet, buildLabelSetId, buildLabelSetVersion, buildUnresolvedIdentity, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted, coinTypeReverseLabel, coinTypeToEvmChainId, createIndexingConfig, createRealtimeIndexingStatusProjection, decodeDNSEncodedLiteralName, decodeDNSEncodedName, deserializeAccountId, deserializeBlockNumber, deserializeBlockRef, deserializeBlockrange, deserializeChainId, deserializeChainIndexingStatusSnapshot, deserializeCrossChainIndexingStatusSnapshot, deserializeDatetime, deserializeDuration, deserializeENSApiPublicConfig, deserializeENSIndexerPublicConfig, deserializeErrorResponse, deserializeIndexingStatusResponse, deserializeOmnichainIndexingStatusSnapshot, deserializePaginatedAggregatedReferrersResponse, deserializeRealtimeIndexingStatusProjection, deserializeRegistrarActionsResponse, deserializeUnixTimestamp, deserializeUrl, durationBetween, encodeLabelHash, evmChainIdToCoinType, getCurrencyInfo, getEthnamesSubregistryId, getNameHierarchy, getOmnichainIndexingCursor, getOmnichainIndexingStatus, 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, parseNonNegativeInteger, parseReverseName, priceDai, priceEth, priceUsdc, registrarActionsFilter, registrarActionsPrerequisites, reverseName, serializeAccountId, serializeChainId, serializeChainIndexingSnapshots, serializeCrossChainIndexingStatusSnapshotOmnichain, serializeDatetime, serializeENSApiPublicConfig, serializeENSIndexerPublicConfig, serializeIndexedChainIds, serializeIndexingStatusResponse, serializeNamedRegistrarAction, serializeOmnichainIndexingStatusSnapshot, serializePaginatedAggregatedReferrersResponse, serializePrice, serializePriceEth, serializeRealtimeIndexingStatusProjection, serializeRegistrarAction, serializeRegistrarActionPricing, serializeRegistrarActionsResponse, serializeRegistrationLifecycle, serializeSubregistry, serializeUrl, sortChainStatusesByStartBlockAsc, staleWhileRevalidate, stripNullBytes, translateDefaultableChainIdToChainId, uint256ToHex32, uniq, validateSupportedLabelSetAndVersion };