@ensnode/ensnode-sdk 1.2.0 → 1.3.1

package/dist/index.d.ts

@@ -1,12 +1,57 @@
 import z$1, { z } from 'zod/v4';
-import { ENSNamespaceId } from '@ensnode/datasources';
+import { ENSNamespaceId, DatasourceName } from '@ensnode/datasources';
 export { ENSNamespaceId, ENSNamespaceIds, getENSRootChainId } from '@ensnode/datasources';
 import { Hex, Address, ByteArray, Hash } from 'viem';
 import { CoinType, EvmCoinType } from '@ensdomains/address-encoder';
 export { CoinType, EvmCoinType } from '@ensdomains/address-encoder';
-import { EncodedReferrer, ReferrerLeaderboardPageParams, ReferrerLeaderboardPage, ReferrerDetail } from '@namehash/ens-referrals';
+import { UnixTimestamp as UnixTimestamp$1, EncodedReferrer, ReferrerLeaderboardPageParams, ReferrerLeaderboardPage, ReferrerDetail } from '@namehash/ens-referrals';
 export { EncodedReferrer, ZERO_ENCODED_REFERRER, decodeEncodedReferrer } from '@namehash/ens-referrals';
 
+/**
+ * The ETH coinType.
+ *
+ * @see https://docs.ens.domains/ensip/9
+ */
+declare const ETH_COIN_TYPE: CoinType;
+/**
+ * The 'default' chainId corresponding to the below {@link DEFAULT_EVM_COIN_TYPE} in the context of
+ * ENSIP-19.
+ *
+ * @see https://docs.ens.domains/ensip/19
+ */
+declare const DEFAULT_EVM_CHAIN_ID = 0;
+/**
+ * ENSIP-19 EVM CoinType representing the 'default' coinType for EVM chains in ENS.
+ *
+ * @see https://docs.ens.domains/ensip/19/#reverse-resolution
+ */
+declare const DEFAULT_EVM_COIN_TYPE: EvmCoinType;
+/**
+ * Converts a CoinType to an EVM Chain Id.
+ *
+ * NOTE: for whatever reason @ensdomains/address-encoder#coinTypeToEvmChainId doesn't handle the
+ * mainnet case so we implement that here
+ *
+ * @see https://docs.ens.domains/ensip/11/
+ */
+declare const coinTypeToEvmChainId: (coinType: CoinType) => ChainId;
+/**
+ * Converts an EVM Chain Id to a CoinType.
+ *
+ * NOTE: for whatever reason @ensdomains/address-encoder#evmChainIdToCoinType doesn't handle the
+ * mainnet case so we implement that here
+ */
+declare const evmChainIdToCoinType: (chainId: ChainId) => CoinType;
+/**
+ * Converts a bigint value representing a CoinType into a valid CoinType.
+ *
+ * This is useful when onchain events emit coinTypes as bigint but we want to constrain them to
+ * the CoinType type.
+ *
+ * @throws if `value` is too large to fit in Number.MAX_SAFE_INTEGER
+ */
+declare const bigintToCoinType: (value: bigint) => CoinType;
+
 /**
  * A hash value that uniquely identifies a single ENS name.
  * Result of `namehash` function as specified in ENSIP-1.
@@ -253,66 +298,6 @@ 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;
@@ -362,6 +347,21 @@ declare const encodeLabelHash: (labelHash: LabelHash) => EncodedLabelHash;
  */
 declare function isEncodedLabelHash(maybeEncodedLabelHash: string): maybeEncodedLabelHash is EncodedLabelHash;
 
+/**
+ * Determines whether the Name is normalized.
+ *
+ * @param name - The Name to check for normalization
+ * @returns True if the name is normalized according to ENS normalization rules, false otherwise
+ */
+declare function isNormalizedName(name: Name): name is NormalizedName;
+/**
+ * Determines whether the Label is normalized.
+ *
+ * @param label - The Label to check for normalization
+ * @returns True if the label is normalized according to ENS normalization rules, false otherwise
+ */
+declare function isNormalizedLabel(label: Label): boolean;
+
 /**
  * Checks if the input is a {@link LabelHash}.
  *
@@ -369,6 +369,10 @@ declare function isEncodedLabelHash(maybeEncodedLabelHash: string): maybeEncoded
  */
 declare function isLabelHash(maybeLabelHash: string): maybeLabelHash is LabelHash;
 
+/**
+ * Name for the ENS Root
+ */
+declare const ENS_ROOT: Name;
 /**
  * Constructs a name hierarchy from a given NormalizedName.
  *
@@ -381,6 +385,10 @@ declare function isLabelHash(maybeLabelHash: string): maybeLabelHash is LabelHas
  * on '.' and receive NormalizedNames as a result
  */
 declare const getNameHierarchy: (name: NormalizedName) => NormalizedName[];
+/**
+ * Get FQDN of parent for a name.
+ */
+declare const getParentNameFQDN: (name: Name) => Name;
 /**
  * Beautifies a name by converting each normalized label in the provided name to
  * its "beautified" form. Labels that are not normalized retain their original value.
@@ -647,61 +655,32 @@ declare class LruCache<KeyType extends string, ValueType> implements Cache<KeyTy
     get capacity(): number;
 }
 
-/**
- * Data structure for a single cached value.
- */
-interface CachedValue<ValueType> {
-    /**
-     * The cached value of type ValueType.
-     */
-    value: ValueType;
-    /**
-     * Unix timestamp indicating when the cached `value` was generated.
-     */
-    updatedAt: UnixTimestamp;
-}
 interface SWRCacheOptions<ValueType> {
     /**
-     * The async function generating a value of `ValueType` 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`.
+     * The async function generating a value of `ValueType` to wrap with SWR caching. It may throw an
+     * Error type.
      */
     fn: () => Promise<ValueType>;
     /**
-     * Time-to-live duration in seconds. After this duration, data in the `SWRCache` is
-     * considered stale but is still retained in the cache until successfully replaced with a new value.
+     * Time-to-live duration of a cached result in seconds. After this duration:
+     * - the currently cached result is considered "stale" but is still retained in the cache
+     *   until successfully replaced.
+     * - Each time the cache is read, if the cached result is "stale" and no background
+     *   revalidation attempt is already in progress, a new background revalidation
+     *   attempt will be made.
      */
     ttl: Duration;
     /**
-     * Optional time-to-proactively-revalidate duration in seconds. After this duration, automated attempts
-     * to asynchronously revalidate the cached value will be made in the background.
-     *
-     * If defined:
-     * - Proactive asynchronous revalidation attempts will be automatically triggered in the background
-     *   on this interval.
-     *
-     * If undefined:
-     * - Revalidation only occurs lazily when an explicit request for the cached value is
-     *   made after the `ttl` duration of the latest successfully cached value expires.
+     * Optional time-to-proactively-revalidate duration in seconds. After a cached result is
+     * initialized, and this duration has passed, attempts to asynchronously revalidate
+     * the cached result will be proactively made in the background on this interval.
      */
-    revalidationInterval?: Duration;
+    proactiveRevalidationInterval?: Duration;
     /**
-     * Proactively initialize
-     *
-     * Optional. Defaults to `false`.
+     * Optional proactive initialization. Defaults to `false`.
      *
-     * If `true`:
-     * - The SWR cache will proactively work to initialize itself, even before any explicit request to
-     *    access the cached value is made.
-     *
-     * If `false`:
-     * - The SWR cache will lazily wait to initialize itself only when one of the following occurs:
-     *    - Background revalidation occurred (if requested); or
-     *    - An explicit attempt to access the cached value is made.
+     * If `true`: The SWR cache will proactively initialize itself.
+     * If `false`: The SWR cache will lazily wait to initialize itself until the first read.
      */
     proactivelyInitialize?: boolean;
 }
@@ -712,81 +691,43 @@ interface SWRCacheOptions<ValueType> {
  * 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 (triggered lazily when new requests
- *   are made for the cached data or when the `revalidationInterval` is reached)
+ * - Automatic background updates via configurable intervals
  *
  * @example
  * ```typescript
- * const fetchExpensiveData = async () => {
- *   const response = await fetch('/api/data');
- *   return response.json();
- * };
- *
- * const cache = await SWRCache.create({
- *   fn: fetchExpensiveData,
+ * const cache = new SWRCache({
+ *   fn: async () => fetch('/api/data').then(r => r.json()),
  *   ttl: 60, // 1 minute TTL
- *   revalidationInterval: 5 * 60 // proactive revalidation after 5 minutes from latest cache update
+ *   proactiveRevalidationInterval: 300 // proactively revalidate every 5 minutes
  * });
  *
- * // [T0: 0] First call: fetches data (slow)
- * const firstRead = await cache.readCache();
- *
- * // [T1: T0 + 59s] Within TTL: returns data cache at T0 (fast)
- * const secondRead = await cache.readCache();
- *
- * // [T2: T0 + 1m30s] After TTL: returns stale data that was cached at T0 immediately
- * // revalidates asynchronously in the background
- * const thirdRead = await cache.readCache(); // Still fast!
+ * // Returns cached data or waits for initial fetch
+ * const data = await cache.read();
  *
- * // [T3: T2 + 90m] Background revalidation kicks in
- *
- * // [T4: T3 + 1m] Within TTL: returns data cache at T3 (fast)
- * const fourthRead = await cache.readCache(); // Still fast!
- *
- * // Please note how using `SWRCache` enabled action at T3 to happen.
- * // If no `revalidationInterval` value was set, the action at T3 would not happen.
- * // Therefore, the `fourthRead` would return stale data cached at T2.
+ * if (data instanceof Error) { ... }
+ * ```
  *
  * @link https://web.dev/stale-while-revalidate/
  * @link https://datatracker.ietf.org/doc/html/rfc5861
  */
 declare class SWRCache<ValueType> {
-    readonly options: SWRCacheOptions<ValueType>;
+    private readonly options;
     private cache;
-    /**
-     * Optional promise of the current in-progress attempt to revalidate the `cache`.
-     *
-     * If null, no revalidation attempt is currently in progress.
-     * If not null, identifies the revalidation attempt that is currently in progress.
-     *
-     * Used to enforce no concurrent revalidation attempts.
-     */
     private inProgressRevalidate;
+    private backgroundInterval;
+    constructor(options: SWRCacheOptions<ValueType>);
+    private revalidate;
     /**
-     * The callback function being managed by `BackgroundRevalidationScheduler`.
-     *
-     * If null, no background revalidation is scheduled.
-     * If not null, identifies the background revalidation that is currently scheduled.
-     *
-     * Used to enforce no concurrent background revalidation attempts.
-     */
-    private scheduledBackgroundRevalidate;
-    private constructor();
-    /**
-     * Asynchronously create a new `SWRCache` instance.
+     * Read the most recently cached result from the `SWRCache`.
      *
-     * @param options - The {@link SWRCacheOptions} for the SWR cache.
-     * @returns a new `SWRCache` instance.
+     * @returns a `ValueType` that was most recently successfully returned by `fn` or `Error` if `fn`
+     * has never successfully returned.
      */
-    static create<ValueType>(options: SWRCacheOptions<ValueType>): Promise<SWRCache<ValueType>>;
-    private revalidate;
+    read(): Promise<ValueType | Error>;
     /**
-     * Read the most recently cached `CachedValue` from the `SWRCache`.
-     *
-     * @returns a `CachedValue` holding 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,
+     * Destroys the background revalidation interval, if exists.
      */
-    readCache: () => Promise<CachedValue<ValueType> | null>;
+    destroy(): void;
 }
 
 /**
@@ -913,6 +854,35 @@ declare function isPriceEqual(priceA: Price, priceB: Price): boolean;
  */
 declare function addPrices<const PriceType extends Price = Price>(...prices: [PriceType, PriceType, ...PriceType[]]): PriceType;
 
+/**
+ * Gets the AccountId for the contract in the specified namespace, datasource, and
+ * contract name, or undefined if it is not defined or is not a single AccountId.
+ *
+ * This is useful when you want to retrieve the AccountId for a contract by its name
+ * where it may or may not actually be defined for the given namespace and datasource.
+ *
+ * @param namespaceId - The ENSNamespace identifier (e.g. 'mainnet', 'sepolia', 'holesky',
+ *                      'ens-test-env')
+ * @param datasourceName - The name of the Datasource to search for contractName in
+ * @param contractName - The name of the contract to retrieve
+ * @returns The AccountId of the contract with the given namespace, datasource,
+ *          and contract name, or undefined if it is not found or is not a single AccountId
+ */
+declare const maybeGetDatasourceContract: (namespaceId: ENSNamespaceId, datasourceName: DatasourceName, contractName: string) => AccountId | undefined;
+/**
+ * Gets the AccountId for the contract in the specified namespace, datasource, and
+ * contract name, or throws an error if it is not defined or is not a single AccountId.
+ *
+ * @param namespaceId - The ENSNamespace identifier (e.g. 'mainnet', 'sepolia', 'holesky',
+ *                      'ens-test-env')
+ * @param datasourceName - The name of the Datasource to search for contractName in
+ * @param contractName - The name of the contract to retrieve
+ * @returns The AccountId of the contract with the given namespace, datasource,
+ *          and contract name
+ * @throws Error if the contract is not found or is not a single AccountId
+ */
+declare const getDatasourceContract: (namespaceId: ENSNamespaceId, datasourceName: DatasourceName, contractName: string) => AccountId;
+
 /**
  * Duration between two moments in time.
  */
@@ -937,13 +907,13 @@ type DatetimeISO8601 = string;
  */
 type UrlString = string;
 /**
- * Serialized representation of {@link AccountId}.
+ * String representation of {@link AccountId}.
  *
  * Formatted as a fully lowercase CAIP-10 AccountId.
  *
  * @see https://chainagnostic.org/CAIPs/caip-10
  */
-type SerializedAccountId = string;
+type AccountIdString = string;
 
 declare function deserializeChainId(maybeChainId: ChainIdString, valueLabel?: string): ChainId;
 declare function deserializeDatetime(maybeDatetime: string, valueLabel?: string): Datetime;
@@ -956,7 +926,7 @@ declare function deserializeBlockrange(maybeBlockrange: Partial<Blockrange>, val
 };
 declare function deserializeBlockRef(maybeBlockRef: Partial<BlockRef>, valueLabel?: string): BlockRef;
 declare function deserializeDuration(maybeDuration: unknown, valueLabel?: string): Duration;
-declare function deserializeAccountId(maybeAccountId: unknown, valueLabel?: string): AccountId;
+declare function parseAccountId(maybeAccountId: unknown, valueLabel?: string): AccountId;
 
 /**
  * Interprets a Literal Label, producing an Interpreted Label.
@@ -1043,13 +1013,13 @@ declare function serializePrice(price: Price): SerializedPrice;
  */
 declare function serializePriceEth(price: PriceEth): SerializedPriceEth;
 /**
- * Serializes {@link AccountId} object.
+ * Format {@link AccountId} object as a string.
  *
  * Formatted as a fully lowercase CAIP-10 AccountId.
  *
  * @see https://chainagnostic.org/CAIPs/caip-10
  */
-declare function serializeAccountId(accountId: AccountId): SerializedAccountId;
+declare function formatAccountId(accountId: AccountId): AccountIdString;
 
 declare function isHttpProtocol(url: URL): boolean;
 declare function isWebSocketProtocol(url: URL): boolean;
@@ -2238,115 +2208,766 @@ type IndexingStatusRequest = {};
 declare function serializeIndexingStatusResponse(response: IndexingStatusResponse): SerializedIndexingStatusResponse;
 
 /**
- * Gets the SubregistryId (an AccountId) of the Ethnames Subregistry contract (this is the
- * "BaseRegistrar" contract for direct subnames of .eth) for the provided namespace.
- *
- * @param namespace The ENS namespace to get the Ethnames Subregistry ID for
- * @returns The AccountId for the Ethnames Subregistry contract for the provided namespace.
- * @throws Error if the contract is not found for the given namespace.
- */
-declare function getEthnamesSubregistryId(namespace: ENSNamespaceId): AccountId;
-
-/**
- * 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;
-}
-/**
- * Serialized representation of {@link Subregistry}.
+ * Deserialize a {@link NameTokensResponse} object.
  */
-interface SerializedSubregistry extends Omit<Subregistry, "subregistryId"> {
-    subregistryId: SerializedAccountId;
-}
-declare function serializeSubregistry(subregistry: Subregistry): SerializedSubregistry;
+declare function deserializedNameTokensResponse(maybeResponse: SerializedNameTokensResponse): NameTokensResponse;
 
-/**
- * Registration Lifecycle Stages
- *
- * Important: this definition should not be used anywhere.
- * It's only here to capture some ideas that were shared in the team.
- */
-declare const RegistrationLifecycleStages: {
+declare const nameTokensPrerequisites: Readonly<{
     /**
-     * Active
+     * Required plugins to enable Name Tokens API routes.
      *
-     * Happens when
-     * the current timestamp <= expiry.
+     * 1. `registrars` plugin is required so that data in the `registrationLifecycles`
+     *    table is populated.
+     * 2. `tokenscope` plugin is required so that data in the `nameTokens`
+     *    table is populated.
      */
-    readonly Active: "registrationLifecycle_active";
+    requiredPlugins: readonly [PluginName.Registrars, PluginName.TokenScope];
     /**
-     * Grace Period
-     *
-     * Happens when
-     * `expiry < the current timestamp <= expiry + 90 days`.
+     * Check if provided ENSApiPublicConfig supports the Name Tokens API.
      */
-    readonly GracePeriod: "registrationLifecycle_gracePeriod";
+    hasEnsIndexerConfigSupport(config: ENSIndexerPublicConfig): boolean;
     /**
-     * Released with Temporary Premium Price
+     * Required Indexing Status IDs
      *
-     * Happens when
-     * `expiry + 90 days < the current timestamp <= expiry + 120 days`.
+     * Database indexes are created by the time the omnichain indexing status
+     * is either `completed` or `following`.
      */
-    readonly ReleasedWithTempPrice: "registrationLifecycle_releasedWithTempPrice";
+    supportedIndexingStatusIds: ("omnichain-following" | "omnichain-completed")[];
     /**
-     * Fully Released (Regular Price)
-     *
-     * Happens when
-     * ` expiry + 120 days < the current timestamp`.
+     * Check if provided indexing status supports the Name Tokens API.
      */
-    readonly FullyReleased: "registrationLifecycle_fullyReleased";
-};
-type RegistrationLifecycleStage = (typeof RegistrationLifecycleStages)[keyof typeof RegistrationLifecycleStages];
+    hasIndexingStatusSupport(omnichainIndexingStatusId: OmnichainIndexingStatusId): boolean;
+}>;
+
 /**
- * Registration Lifecycle
+ * Represents request to Name Tokens API.
  */
-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;
+interface NameTokensRequestByDomainId {
+    domainId: Node;
     /**
-     * Expires at
-     *
-     * Identifies when the Registration Lifecycle is scheduled to expire.
+     * Name for which name tokens were requested.
      */
-    expiresAt: UnixTimestamp;
+    name?: undefined;
 }
 /**
- * Serialized representation of {@link RegistrationLifecycle}.
+ * Represents request to Name Tokens API.
  */
-interface SerializedRegistrationLifecycle extends Omit<RegistrationLifecycle, "subregistry"> {
-    subregistry: SerializedSubregistry;
+interface NameTokensRequestByName {
+    domainId?: undefined;
+    /**
+     * Name for which name tokens were requested.
+     */
+    name: Name;
 }
-declare function serializeRegistrationLifecycle(registrationLifecycle: RegistrationLifecycle): SerializedRegistrationLifecycle;
+type NameTokensRequest = NameTokensRequestByDomainId | NameTokensRequestByName;
 
 /**
- * Globally unique, deterministic ID of an indexed onchain event
+ * An enum representing the possible CAIP-19 Asset Namespace values.
+ */
+declare const AssetNamespaces: {
+    readonly ERC721: "erc721";
+    readonly ERC1155: "erc1155";
+};
+type AssetNamespace = (typeof AssetNamespaces)[keyof typeof AssetNamespaces];
+/**
+ * A uint256 value that identifies a specific NFT within a NFT contract.
+ */
+type TokenId = bigint;
+/**
+ * Serialized representation of {@link TokenId}.
+ */
+type SerializedTokenId = string;
+/**
+ * A globally unique reference to an NFT.
+ */
+interface AssetId {
+    assetNamespace: AssetNamespace;
+    contract: AccountId;
+    tokenId: TokenId;
+}
+/**
+ * Serialized representation of {@link AssetId}.
+ */
+interface SerializedAssetId extends Omit<AssetId, "tokenId"> {
+    tokenId: SerializedTokenId;
+}
+/**
+ * String representation of an {@link AssetId}.
+ *
+ * Formatted as a fully lowercase CAIP-19 AssetId.
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-19
+ * @example "eip155:1/erc721:0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85/0xaf2caa1c2ca1d027f1ac823b529d0a67cd144264b2789fa2ea4d63a67c7103cc"
+ *          for vitalik.eth in the eth base registrar on mainnet.
+ */
+type AssetIdString = string;
+/**
+ * Serializes {@link AssetId} object.
+ */
+declare function serializeAssetId(assetId: AssetId): SerializedAssetId;
+/**
+ * Deserialize a {@link AssetId} object.
+ */
+declare function deserializeAssetId(maybeAssetId: unknown, valueLabel?: string): AssetId;
+/**
+ * Format {@link AssetId} object as a string.
+ */
+declare function formatAssetId(assetId: AssetId): AssetIdString;
+/**
+ * Parse a stringified representation of {@link AssetId} object.
+ */
+declare function parseAssetId(maybeAssetId: AssetIdString, valueLabel?: string): AssetId;
+/**
+ * Builds an AssetId for the NFT represented by the given contract,
+ * tokenId, and assetNamespace.
+ *
+ * @param contract - The contract that manages the NFT
+ * @param tokenId - The tokenId of the NFT
+ * @param assetNamespace - The assetNamespace of the NFT
+ * @returns The AssetId for the NFT represented by the given contract,
+ *          tokenId, and assetNamespace
+ */
+declare const buildAssetId: (contract: AccountId, tokenId: TokenId, assetNamespace: AssetNamespace) => AssetId;
+/**
+ * A globally unique reference to an NFT tokenizing the ownership of a domain.
+ */
+interface DomainAssetId extends AssetId {
+    /**
+     * The namehash (node) of the domain who's ownership is tokenized by
+     * this `AssetId`.
+     */
+    domainId: Node;
+}
+/**
+ * Serialized representation of {@link DomainAssetId}.
+ */
+interface SerializedDomainAssetId extends SerializedAssetId {
+    domainId: Node;
+}
+declare function serializeDomainAssetId(domainAsset: DomainAssetId): SerializedDomainAssetId;
+/**
+ * An enum representing the mint status of a DomainAssetId.
+ *
+ * After we index a NFT we never delete it from our index. Instead, when an
+ * indexed NFT is burned onchain we retain its record and update its mint
+ * status as `burned`. If a NFT is minted again after it is burned its mint
+ * status is updated to `minted`.
+ */
+declare const NFTMintStatuses: {
+    readonly Minted: "minted";
+    readonly Burned: "burned";
+};
+type NFTMintStatus = (typeof NFTMintStatuses)[keyof typeof NFTMintStatuses];
+/**
+ * Metadata about a NFT transfer event.
+ *
+ * This metadata can be used for building more helpful messages when processing
+ * NFT transfer events.
+ */
+interface NFTTransferEventMetadata {
+    chainId: ChainId;
+    blockNumber: bigint;
+    transactionHash: Hex;
+    eventHandlerName: string;
+    nft: DomainAssetId;
+}
+declare const formatNFTTransferEventMetadata: (metadata: NFTTransferEventMetadata) => string;
+/**
+ * An enum representing the type of transfer that has occurred to a DomainAssetId.
+ */
+declare const NFTTransferTypes: {
+    /**
+     * Initial transfer from zeroAddress to a non-zeroAddress
+     * Can happen at most once to a NFT AssetId
+     *
+     * Invariants:
+     * - NFT is not indexed and therefore has no previous mint status or owner
+     * - new NFT mint status is `minted`
+     * - new NFT owner is a non-zeroAddress
+     */
+    readonly Mint: "mint";
+    /**
+     * Subsequent transfer from zeroAddress to a non-zeroAddress
+     * Can happen any number of times to a NFT AssetId as it passes in a cycle from
+     * mint -> burn -> remint -> burn -> remint -> ...
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous NFT mint status was `burned`
+     * - previous NFT owner is the zeroAddress
+     * - new NFT mint status is `minted`
+     * - new NFT owner is a non-zeroAddress
+     */
+    readonly Remint: "remint";
+    /**
+     * Special transfer type for improperly implemented NFT contracts that allow a NFT
+     * that is currently minted to be reminted before an intermediate burn.
+     *
+     * Transfer from zeroAddress to non-zeroAddress for an indexed NFT where the
+     * previously indexed nft had status `minted` with a non-zeroAddress owner.
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous NFT mint status was `minted`
+     * - previous NFT owner was a non-zeroAddress
+     * - new NFT mint status is `minted`
+     * - new NFT owner is a non-zeroAddress
+     */
+    readonly MintedRemint: "minted-remint";
+    /**
+     * Transfer from a non-zeroAddress to zeroAddress
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous NFT mint status was `minted`
+     * - previous NFT owner is a non-zeroAddress
+     * - new NFT mint status is `burned`
+     * - new NFT owner is the zeroAddress
+     */
+    readonly Burn: "burn";
+    /**
+     * Transfer from a non-zeroAddress to a distinct non-zeroAddress
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous and new NFT mint status is `minted`
+     * - previous and new NFT owner are distinct non-zeroAddress
+     */
+    readonly Transfer: "transfer";
+    /**
+     * Transfer from a non-zeroAddress to the same non-zeroAddress
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous and new NFT mint status is `minted`
+     * - previous and new NFT owner are equivalent non-zeroAddress
+     */
+    readonly SelfTransfer: "self-transfer";
+    /**
+     * Transfer from zeroAddress to zeroAddress for an indexed NFT
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous and new NFT mint status is `burned`
+     * - previous and new NFT owner are zeroAddress
+     */
+    readonly RemintBurn: "remint-burn";
+    /**
+     * Special transfer type for improperly implemented NFT contracts that allow a NFT
+     * that is currently minted to be reminted again before an intermediate burn.
+     *
+     * Transfer from zeroAddress to zeroAddress for an indexed NFT where the
+     * previously indexed nft had status `minted` with a non-zeroAddress owner.
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous NFT mint status was `minted`
+     * - previous NFT owner was a non-zeroAddress
+     * - new NFT mint status is `burned`
+     * - new NFT owner is the zeroAddress
+     */
+    readonly MintedRemintBurn: "minted-remint-burn";
+    /**
+     * Transfer from zeroAddress to zeroAddress for an unindexed NFT
+     *
+     * Invariants:
+     * - NFT is not indexed and therefore has no previous mint status or owner
+     * - NFT should remain unindexed and without any mint status or owner
+     */
+    readonly MintBurn: "mint-burn";
+};
+type NFTTransferType = (typeof NFTTransferTypes)[keyof typeof NFTTransferTypes];
+declare const getNFTTransferType: (from: Address, to: Address, allowMintedRemint: boolean, metadata: NFTTransferEventMetadata, currentlyIndexedOwner?: Address) => NFTTransferType;
+
+/**
+ * An enum representing the possible Name Token Ownership types.
+ */
+declare const NameTokenOwnershipTypes: {
+    /**
+     * Name Token is owned by NameWrapper account.
+     */
+    readonly NameWrapper: "namewrapper";
+    /**
+     * Name Token is owned fully onchain.
+     *
+     * This ownership type can only apply to direct subnames of `.eth`
+     */
+    readonly FullyOnchain: "fully-onchain";
+    /**
+     * Name Token ownership has been transferred to the null address.
+     */
+    readonly Burned: "burned";
+    /**
+     * Name Token ownership is unknown.
+     */
+    readonly Unknown: "unknown";
+};
+type NameTokenOwnershipType = (typeof NameTokenOwnershipTypes)[keyof typeof NameTokenOwnershipTypes];
+interface NameTokenOwnershipNameWrapper {
+    ownershipType: typeof NameTokenOwnershipTypes.NameWrapper;
+    /**
+     * Owner
+     *
+     * Guarantees:
+     * - `owner.address` is not the zero address.
+     * - `owner.chainId` is same as the chainId of the associated NFT,
+     *    even if that NFT has been burned.
+     */
+    owner: AccountId;
+}
+interface NameTokenOwnershipFullyOnchain {
+    ownershipType: typeof NameTokenOwnershipTypes.FullyOnchain;
+    /**
+     * Owner
+     *
+     * Guarantees:
+     * - `owner.address` is not the zero address.
+     * - `owner.chainId` is same as the chainId of the associated NFT,
+     *    even if that NFT has been burned.
+     */
+    owner: AccountId;
+}
+interface NameTokenOwnershipBurned {
+    ownershipType: typeof NameTokenOwnershipTypes.Burned;
+    /**
+     * Owner
+     *
+     * Guarantees:
+     * - `owner.address` is the zero address.
+     * - `owner.chainId` is same as the chainId of the associated NFT,
+     *    even if that NFT has been burned.
+     */
+    owner: AccountId;
+}
+interface NameTokenOwnershipUnknown {
+    ownershipType: typeof NameTokenOwnershipTypes.Unknown;
+    /**
+     * Owner
+     *
+     * Guarantees:
+     * - `owner.address` is the zero address.
+     * - `owner.chainId` is same as the chainId of the associated NFT,
+     *    even if that NFT has been burned.
+     */
+    owner: AccountId;
+}
+type NameTokenOwnership = NameTokenOwnershipNameWrapper | NameTokenOwnershipFullyOnchain | NameTokenOwnershipBurned | NameTokenOwnershipUnknown;
+interface NameToken {
+    /**
+     * Token
+     *
+     * References the NFT that currently or previously tokenized ownership of
+     * `name`.
+     */
+    token: AssetId;
+    /**
+     * Owner
+     *
+     * Identifies the ownership state of the token.
+     *
+     * Guarantees:
+     * - The `ownership.owner.chainId` of this address is the same as is referenced
+     *   in `domainAsset.contract.chainId`.
+     */
+    ownership: NameTokenOwnership;
+    /**
+     * The mint status of the token.
+     *
+     * After ENSNode indexes the token for a name, even if that token is burned,
+     * ENSNode will never forget how the token once represented the name.
+     * When the token for a name is burned, ENSNode remembers this token but
+     * updates its `mintStatus` to `burned`. If this token becomes minted again
+     * after it was burned, its `mintStatus` is updated to `minted` again.
+     *
+     * NOTE: Tokens managed by the .eth BaseRegistrar for
+     * direct subnames of .eth can only be burned when undergoing
+     * a state transition of `minted` -> `burned` -> `minted` all within
+     * the same registrar action for the case that a direct subname of .eth
+     * has expired and has been fully released and is now being registered again.
+     * Since all of those mint status state transitions are processed within
+     * a single block, once the token managed by the .eth BaseRegistrar for
+     * a direct subname of .eth has been minted, our state model will forever
+     * represent it as `minted`.
+     *
+     * Guarantees:
+     * - The `mintStatus` will be burned if and only
+     *   if `ownership.ownershipType` is `NameTokenOwnershipTypes.Burned`.
+     */
+    mintStatus: NFTMintStatus;
+}
+/**
+ * Serialized representation of {@link NameToken}.
+ */
+interface SerializedNameToken extends Omit<NameToken, "token"> {
+    token: SerializedAssetId;
+}
+declare function serializeNameToken(nameToken: NameToken): SerializedNameToken;
+/**
+ * Get all NameWrapper accounts within provided ENS Namespace.
+ *
+ * Guaranteed to return at least one account for ENSRoot Datasource.
+ */
+declare function getNameWrapperAccounts(namespaceId: ENSNamespaceId): [AccountId, ...AccountId[]];
+/**
+ * Get name token ownership for provided owner account within selected ENS Namespace.
+ */
+declare function getNameTokenOwnership(namespaceId: ENSNamespaceId, name: InterpretedName, owner: AccountId): NameTokenOwnership;
+
+/**
+ * Schema for {@link ErrorResponse}.
+ */
+declare const ErrorResponseSchema: z$1.ZodObject<{
+    message: z$1.ZodString;
+    details: z$1.ZodOptional<z$1.ZodUnknown>;
+}, z$1.core.$strip>;
+
+/**
+ * API Error Response Type
+ */
+type ErrorResponse = z$1.infer<typeof ErrorResponseSchema>;
+
+/**
+ * Deserialize a {@link ErrorResponse} object.
+ */
+declare function deserializeErrorResponse(maybeErrorResponse: unknown): ErrorResponse;
+
+/**
+ * A status code for Name Tokens API responses.
+ */
+declare const NameTokensResponseCodes: {
+    /**
+     * Represents a response when Name Tokens API can respond with requested data.
+     */
+    readonly Ok: "ok";
+    /**
+     * Represents a response when Name Tokens API could not respond with requested data.
+     */
+    readonly Error: "error";
+};
+/**
+ * The derived string union of possible {@link NameTokensResponseCodes}.
+ */
+type NameTokensResponseCode = (typeof NameTokensResponseCodes)[keyof typeof NameTokensResponseCodes];
+/**
+ * Error codes for Name Tokens API responses with 'error' response code.
+ */
+declare const NameTokensResponseErrorCodes: {
+    /**
+     * Name tokens not indexed
+     *
+     * Represents an error when tokens for the requested name are not indexed by
+     * the ENSNode instance's configuration.
+     */
+    readonly NameTokensNotIndexed: "name-tokens-not-indexed";
+    /**
+     * Unsupported ENSIndexer Config
+     *
+     * Represents a prerequisites error when connected ENSIndexer config lacks
+     * params required to enable Name Tokens API.
+     */
+    readonly EnsIndexerConfigUnsupported: "unsupported-ensindexer-config";
+    /**
+     * Unsupported Indexing Status
+     *
+     * Represents a prerequisites error when Indexing Status has not yet reached
+     * status required to enable Name Tokens API.
+     */
+    readonly IndexingStatusUnsupported: "unsupported-indexing-status";
+};
+/**
+ * The derived string union of possible {@link NameTokensResponseErrorCodes}.
+ */
+type NameTokensResponseErrorCode = (typeof NameTokensResponseErrorCodes)[keyof typeof NameTokensResponseErrorCodes];
+/**
+ * Name Tokens for a name who's tokens are configured to
+ * be indexed by the ENSNode instance's configuration.
+ */
+interface RegisteredNameTokens {
+    /**
+     * Domain ID
+     */
+    domainId: Node;
+    /**
+     * Name
+     *
+     * FQDN of the name associated with `domainId`.
+     *
+     * Guarantees:
+     * - `namehash(name)` is always `domainId`.
+     */
+    name: InterpretedName;
+    /**
+     * Name Tokens associated with the `domainId`.
+     *
+     * It contains every tokenized representation of `name` that
+     * has ever been indexed for the given name as of `accurateAsOf`,
+     * even if the given token has been burned or expired.
+     *
+     * Guarantees:
+     * - Always includes at least one name token.
+     * - When it includes more than one name token, it means that:
+     *   1) More than 1 distinct tokenized representation of the ownership of
+     *      the `name` has been indexed as of `accurateAsOf`.
+     *   2) All possible permutations of mint statuses of these tokens are
+     *      possible:
+     *      a) Multiple could be actively minted.
+     *      b) Multiple could be burned.
+     *      c) Some could be burned, others could be minted.
+     *  - Order of name tokens follows the order of onchain events that were
+     *    indexed when a token was minted, or burned.
+     *  - Each name token has a distinct `token` value which references
+     *    the NFT that currently or previously tokenized ownership of `name`.
+     *  - Each name token has ownership type (`ownership.ownershipType`) assigned:
+     *   - If there's a name token with ownership type
+     *     {@link NameTokenOwnershipTypes.NameWrapper}, it means that there must be also
+     *     another name token with ownership type either
+     *     {@link NameTokenOwnershipTypes.FullyOnchain}, or
+     *     {@link NameTokenOwnershipTypes.Unknown}.
+     *   - There can be at most one name token with ownership type
+     *     {@link NameTokenOwnershipTypes.FullyOnchain}.
+     *   - There can be any number of name tokens with ownership type
+     *     {@link NameTokenOwnershipTypes.Burned}.
+     *
+     * NOTE: It can be useful to get tokenized representations of the name that
+     * are now burned: This can be helpful for looking up historical activity for
+     * the name, including past buy orders, sell orders, and sales.
+     *
+     * How will the direct subnames of .eth that are wrapped by the NameWrapper
+     * be represented?
+     * 1) A direct subname of .eth that has been registered but
+     *    has never been wrapped by the NameWrapper, and:
+     *    a) Is still actively minted (independent of its expiry state).
+     *    b) Has been burned by sending it to the null address.
+     * 2) A direct subname of .eth that has been registered and
+     *    has been wrapped by the NameWrapper, and:
+     *    a) Is still actively wrapped by the NameWrapper (independent of its
+     *       expiry state).
+     *    b) Is no longer wrapped by the NameWrapper, but is still actively
+     *       minted by the BaseRegistrar (independent of its expiry state).
+     *    c) Is no longer wrapped by the NameWrapper, and is also no longer
+     *       minted by the BaseRegistrar (both tokens now burned by sending to
+     *       the null address).
+     */
+    tokens: NameToken[];
+    /**
+     * Expiry date for the Registration Lifecycle
+     *
+     * The latest Registration Lifecycle for a node referenced in `domainId`.
+     */
+    expiresAt: UnixTimestamp$1;
+    /**
+     * The {@link UnixTimestamp} of when the data used to build the {@link NameTokensResponseOk.nameTokens} was accurate as of.
+     */
+    accurateAsOf: UnixTimestamp$1;
+}
+/**
+ * A response when Name Tokens API can respond with requested data.
+ */
+type NameTokensResponseOk = {
+    responseCode: typeof NameTokensResponseCodes.Ok;
+    /**
+     * Name Tokens for the requested name.
+     */
+    registeredNameTokens: RegisteredNameTokens;
+};
+/**
+ * Represents an error response when requested name was not indexed by ENSNode.
+ */
+interface NameTokensResponseErrorNameTokensNotIndexed {
+    responseCode: typeof NameTokensResponseCodes.Error;
+    errorCode: typeof NameTokensResponseErrorCodes.NameTokensNotIndexed;
+    error: ErrorResponse;
+}
+/**
+ * Represents an error response when connected ENSIndexer config lacks
+ * params required to enable Name Tokens API.
+ */
+interface NameTokensResponseErrorEnsIndexerConfigUnsupported {
+    responseCode: typeof NameTokensResponseCodes.Error;
+    errorCode: typeof NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported;
+    error: ErrorResponse;
+}
+/**
+ * Represents an error response when Indexing Status has not yet reached
+ * status required to enable Name Tokens API.
+ */
+interface NameTokensResponseErrorIndexingStatusUnsupported {
+    responseCode: typeof NameTokensResponseCodes.Error;
+    errorCode: typeof NameTokensResponseErrorCodes.IndexingStatusUnsupported;
+    error: ErrorResponse;
+}
+type NameTokensResponseError = NameTokensResponseErrorNameTokensNotIndexed | NameTokensResponseErrorEnsIndexerConfigUnsupported | NameTokensResponseErrorIndexingStatusUnsupported;
+/**
+ * Name Tokens response.
+ *
+ * Use the `responseCode` field to determine the specific type interpretation
+ * at runtime.
+ */
+type NameTokensResponse = NameTokensResponseOk | NameTokensResponseError;
+
+/**
+ * Serialized representation of {@link NameTokensResponseError}.
+ */
+type SerializedNameTokensResponseError = NameTokensResponseError;
+/**
+ * Serialized representation of {@link RegisteredNameToken}.
+ */
+interface SerializedRegisteredNameTokens extends Omit<RegisteredNameTokens, "tokens"> {
+    tokens: SerializedNameToken[];
+}
+/**
+ * Serialized representation of {@link NameTokensResponseOk}.
+ */
+interface SerializedNameTokensResponseOk extends Omit<NameTokensResponseOk, "registeredNameTokens"> {
+    registeredNameTokens: SerializedRegisteredNameTokens;
+}
+/**
+ * Serialized representation of {@link NameTokensResponse}.
+ */
+type SerializedNameTokensResponse = SerializedNameTokensResponseOk | SerializedNameTokensResponseError;
+
+declare function serializeRegisteredNameTokens({ domainId, name, tokens, expiresAt, accurateAsOf, }: RegisteredNameTokens): SerializedRegisteredNameTokens;
+declare function serializeNameTokensResponse(response: NameTokensResponse): SerializedNameTokensResponse;
+
+/**
+ * Gets the SubregistryId (an AccountId) of the Basenames Subregistry contract (this is the
+ * "BaseRegistrar" contract for Basenames) for the provided namespace.
+ *
+ * @param namespace The ENS namespace to get the Basenames Subregistry ID for
+ * @returns The AccountId for the Basenames Subregistry contract for the provided namespace.
+ * @throws Error if the contract is not found for the given namespace.
+ */
+declare function getBasenamesSubregistryId(namespace: ENSNamespaceId): AccountId;
+/**
+ * Get the managed name for the Basenames subregistry for the selected ENS namespace.
+ *
+ * @param namespaceId
+ * @returns registrar managed name
+ * @throws an error when no registrar managed name could be returned
+ */
+declare function getBasenamesSubregistryManagedName(namespaceId: ENSNamespaceId): Name;
+
+/**
+ * Gets the SubregistryId (an AccountId) of the Ethnames Subregistry contract (this is the
+ * "BaseRegistrar" contract for direct subnames of .eth) for the provided namespace.
+ *
+ * @param namespace The ENS namespace to get the Ethnames Subregistry ID for
+ * @returns The AccountId for the Ethnames Subregistry contract for the provided namespace.
+ * @throws Error if the contract is not found for the given namespace.
+ */
+declare function getEthnamesSubregistryId(namespace: ENSNamespaceId): AccountId;
+/**
+ * Get the managed name for the Ethnames subregistry for the selected ENS namespace.
+ *
+ * @param namespaceId
+ * @returns registrar managed name
+ */
+declare function getEthnamesSubregistryManagedName(namespaceId: ENSNamespaceId): Name;
+
+/**
+ * Gets the SubregistryId (an AccountId) of the Lineanames Subregistry contract (this is the
+ * "BaseRegistrar" contract for Lineanames) for the provided namespace.
+ *
+ * @param namespace The ENS namespace to get the Lineanames Subregistry ID for
+ * @returns The AccountId for the Lineanames Subregistry contract for the provided namespace.
+ * @throws Error if the contract is not found for the given namespace.
+ */
+declare function getLineanamesSubregistryId(namespace: ENSNamespaceId): AccountId;
+/**
+ * Get the managed name for the Lineanames subregistry for the selected ENS namespace.
+ *
+ * @param namespaceId
+ * @returns registrar managed name
+ * @throws an error when no registrar managed name could be returned
+ */
+declare function getLineanamesSubregistryManagedName(namespaceId: ENSNamespaceId): Name;
+
+/**
+ * Subregistry
+ */
+interface Subregistry {
+    /**
+     * Subregistry ID
+     *
+     * The ID of the subregistry the "logical registrar action" was taken on.
+     *
+     * Identifies the chainId and address of the associated subregistry smart
+     * contract.
+     */
+    subregistryId: AccountId;
+    /**
+     * The node (namehash) of the name the subregistry manages subnames of.
+     * Example subregistry managed names:
+     * - `eth`
+     * - `base.eth`
+     * - `linea.eth`
+     */
+    node: Node;
+}
+
+/**
+ * Registration Lifecycle Stages
+ *
+ * Important: this definition should not be used anywhere.
+ * It's only here to capture some ideas that were shared in the team.
+ */
+declare const RegistrationLifecycleStages: {
+    /**
+     * Active
+     *
+     * Happens when
+     * the current timestamp <= expiry.
+     */
+    readonly Active: "registrationLifecycle_active";
+    /**
+     * Grace Period
+     *
+     * Happens when
+     * `expiry < the current timestamp <= expiry + 90 days`.
+     */
+    readonly GracePeriod: "registrationLifecycle_gracePeriod";
+    /**
+     * Released with Temporary Premium Price
+     *
+     * Happens when
+     * `expiry + 90 days < the current timestamp <= expiry + 120 days`.
+     */
+    readonly ReleasedWithTempPrice: "registrationLifecycle_releasedWithTempPrice";
+    /**
+     * Fully Released (Regular Price)
+     *
+     * Happens when
+     * ` expiry + 120 days < the current timestamp`.
+     */
+    readonly FullyReleased: "registrationLifecycle_fullyReleased";
+};
+type RegistrationLifecycleStage = (typeof RegistrationLifecycleStages)[keyof typeof RegistrationLifecycleStages];
+/**
+ * Registration Lifecycle
+ */
+interface RegistrationLifecycle {
+    /**
+     * Subregistry that manages this Registration Lifecycle.
+     */
+    subregistry: Subregistry;
+    /**
+     * The node (namehash) of the FQDN of the domain the registration lifecycle
+     * is associated with.
+     *
+     * Guaranteed to be a subname of the node (namehash) of the subregistry
+     * identified by `subregistryId.subregistryId`.
+     */
+    node: Node;
+    /**
+     * Expires at
+     *
+     * Identifies when the Registration Lifecycle is scheduled to expire.
+     */
+    expiresAt: UnixTimestamp;
+}
+
+/**
+ * Globally unique, deterministic ID of an indexed onchain event
  * associated with the "logical registrar action".
  */
 type RegistrarActionEventId = string;
@@ -2637,30 +3258,100 @@ type SerializedRegistrarActionPricing = SerializedRegistrarActionPricingAvailabl
 /**
  * Serialized representation of {@link RegistrarAction}.
  */
-interface SerializedRegistrarAction extends Omit<RegistrarAction, "registrationLifecycle" | "pricing"> {
-    registrationLifecycle: SerializedRegistrationLifecycle;
+interface SerializedRegistrarAction extends Omit<RegistrarAction, "pricing"> {
     pricing: SerializedRegistrarActionPricing;
 }
 declare function serializeRegistrarActionPricing(pricing: RegistrarActionPricing): SerializedRegistrarActionPricing;
 declare function serializeRegistrarAction(registrarAction: RegistrarAction): SerializedRegistrarAction;
 
+declare const RECORDS_PER_PAGE_DEFAULT = 10;
+declare const RECORDS_PER_PAGE_MAX = 100;
 /**
- * Schema for {@link ErrorResponse}.
+ * Request page params.
  */
-declare const ErrorResponseSchema: z$1.ZodObject<{
-    message: z$1.ZodString;
-    details: z$1.ZodOptional<z$1.ZodUnknown>;
-}, z$1.core.$strip>;
+interface RequestPageParams {
+    /**
+     * Requested page number (1-indexed)
+     * @invariant Must be a positive integer (>= 1)
+     * @default 1
+     */
+    page?: number;
+    /**
+     * Maximum number of records to return per page
+     * @invariant Must be a positive integer (>= 1) and less than or equal to {@link RECORDS_PER_PAGE_MAX}
+     * @default {@link RECORDS_PER_PAGE_DEFAULT}
+     */
+    recordsPerPage?: number;
+}
 
-/**
- * API Error Response Type
- */
-type ErrorResponse = z$1.infer<typeof ErrorResponseSchema>;
+interface ResponsePageContextWithNoRecords extends Required<RequestPageParams> {
+    /**
+     * Total number of records across all pages
+     */
+    totalRecords: 0;
+    /**
+     * Total number of pages
+     */
+    totalPages: 1;
+    /**
+     * Indicates if there is a next page available
+     */
+    hasNext: false;
+    /**
+     * Indicates if there is a previous page available
+     */
+    hasPrev: false;
+    /**
+     * The start index of the records on the page (0-indexed)
+     */
+    startIndex: undefined;
+    /**
+     * The end index of the records on the page (0-indexed)
+     */
+    endIndex: undefined;
+}
+interface ResponsePageContextWithRecords extends Required<RequestPageParams> {
+    /**
+     * Total number of records across all pages
+     * @invariant Guaranteed to be a positive integer (>= 1)
+     */
+    totalRecords: number;
+    /**
+     * Total number of pages
+     * @invariant Guaranteed to be a positive integer (>= 1)
+     */
+    totalPages: number;
+    /**
+     * Indicates if there is a next page available
+     * @invariant true if and only if (`page` * `recordsPerPage` < `totalRecords`)
+     */
+    hasNext: boolean;
+    /**
+     * Indicates if there is a previous page available
+     * @invariant true if and only if (`page` > 1)
+     */
+    hasPrev: boolean;
+    /**
+     * The start index of the records on the page (0-indexed)
+     *
+     * @invariant Guaranteed to be a non-negative integer (>= 0)
+     */
+    startIndex: number;
+    /**
+     * The end index of the records on the page (0-indexed)
+     *
+     * @invariant Guaranteed to be a non-negative integer (>= 0)
+     * @invariant Guaranteed to be greater than or equal to `startIndex`.
+     * @invariant Guaranteed to be less than `totalRecords`.
+     */
+    endIndex: number;
+}
+type ResponsePageContext = ResponsePageContextWithNoRecords | ResponsePageContextWithRecords;
 
 /**
- * Deserialize a {@link ErrorResponse} object.
+ * Build page context from request params and total records count.
  */
-declare function deserializeErrorResponse(maybeErrorResponse: unknown): ErrorResponse;
+declare function buildPageContext(page: number, recordsPerPage: number, totalRecords: number): ResponsePageContext;
 
 /**
  * A status code for Registrar Actions API responses.
@@ -2700,6 +3391,7 @@ interface NamedRegistrarAction {
 type RegistrarActionsResponseOk = {
     responseCode: typeof RegistrarActionsResponseCodes.Ok;
     registrarActions: NamedRegistrarAction[];
+    pageContext: ResponsePageContext;
 };
 /**
  * A response when Registrar Actions are unavailable.
@@ -2748,6 +3440,7 @@ declare function deserializeRegistrarActionsResponse(maybeResponse: SerializedRe
 declare const RegistrarActionsFilterTypes: {
     readonly BySubregistryNode: "bySubregistryNode";
     readonly WithEncodedReferral: "withEncodedReferral";
+    readonly ByDecodedReferrer: "byDecodedReferrer";
 };
 type RegistrarActionsFilterType = (typeof RegistrarActionsFilterTypes)[keyof typeof RegistrarActionsFilterTypes];
 type RegistrarActionsFilterBySubregistryNode = {
@@ -2757,7 +3450,11 @@ type RegistrarActionsFilterBySubregistryNode = {
 type RegistrarActionsFilterWithEncodedReferral = {
     filterType: typeof RegistrarActionsFilterTypes.WithEncodedReferral;
 };
-type RegistrarActionsFilter = RegistrarActionsFilterBySubregistryNode | RegistrarActionsFilterWithEncodedReferral;
+type RegistrarActionsFilterByDecodedReferrer = {
+    filterType: typeof RegistrarActionsFilterTypes.ByDecodedReferrer;
+    value: Address;
+};
+type RegistrarActionsFilter = RegistrarActionsFilterBySubregistryNode | RegistrarActionsFilterWithEncodedReferral | RegistrarActionsFilterByDecodedReferrer;
 /**
  * Records Orders
  */
@@ -2768,7 +3465,7 @@ type RegistrarActionsOrder = (typeof RegistrarActionsOrders)[keyof typeof Regist
 /**
  * Represents a request to Registrar Actions API.
  */
-type RegistrarActionsRequest = {
+interface RegistrarActionsRequest extends RequestPageParams {
     /**
      * Filters to be applied while generating results.
      */
@@ -2777,13 +3474,7 @@ type RegistrarActionsRequest = {
      * 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;
-};
+}
 
 /**
  * Build a "parent node" filter object for Registrar Actions query.
@@ -2795,9 +3486,15 @@ declare function byParentNode(parentNode: undefined): undefined;
  */
 declare function withReferral(withReferral: true): RegistrarActionsFilter;
 declare function withReferral(withReferral: false | undefined): undefined;
+/**
+ * Build a "decoded referrer" filter object for Registrar Actions query.
+ */
+declare function byDecodedReferrer(decodedReferrer: Address): RegistrarActionsFilter;
+declare function byDecodedReferrer(decodedReferrer: undefined): undefined;
 declare const registrarActionsFilter: {
     byParentNode: typeof byParentNode;
     withReferral: typeof withReferral;
+    byDecodedReferrer: typeof byDecodedReferrer;
 };
 
 declare const registrarActionsPrerequisites: Readonly<{
@@ -3114,6 +3811,10 @@ interface MultichainPrimaryNameResolutionArgs {
  */
 type MultichainPrimaryNameResolutionResult = Record<ChainId, Name | null>;
 
+declare const PROTOCOL_ATTRIBUTE_PREFIX = "ens";
+declare const ATTR_PROTOCOL_NAME = "ens.protocol";
+declare const ATTR_PROTOCOL_STEP = "ens.protocol.step";
+declare const ATTR_PROTOCOL_STEP_RESULT = "ens.protocol.step.result";
 /**
  * Identifiers for each traceable ENS protocol.
  */
@@ -3144,19 +3845,16 @@ declare enum ReverseResolutionProtocolStep {
     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 {
+
+interface TracingSpanAttributes {
     [key: string]: unknown;
 }
-interface SpanEvent {
+interface TracingSpanEvent {
     name: string;
-    attributes: SpanAttributes;
+    attributes: TracingSpanAttributes;
     time: number;
 }
-interface ProtocolSpan {
+interface TracingSpan {
     scope: string;
     id: string;
     traceId: string;
@@ -3167,23 +3865,23 @@ interface ProtocolSpan {
     name: string;
     timestamp: number;
     duration: number;
-    attributes: SpanAttributes;
+    attributes: TracingSpanAttributes;
     status: {
         code: number;
         message?: string;
     };
-    events: SpanEvent[];
+    events: TracingSpanEvent[];
 }
-type ProtocolSpanTreeNode = ProtocolSpan & {
-    children: ProtocolSpanTreeNode[];
+type TracingNode = TracingSpan & {
+    children: TracingNode[];
 };
-type ProtocolTrace = ProtocolSpanTreeNode[];
+type TracingTrace = TracingNode[];
 
 interface TraceableRequest {
     trace?: boolean;
 }
 interface TraceableResponse {
-    trace?: ProtocolTrace;
+    trace?: TracingTrace;
 }
 interface AcceleratableRequest {
     accelerate?: boolean;
@@ -3208,101 +3906,17 @@ interface ResolveRecordsResponse<SELECTION extends ResolverRecordsSelection> ext
  */
 interface ResolvePrimaryNameRequest extends ReverseResolutionArgs, AcceleratableRequest, TraceableRequest {
 }
-/**
- * Resolve Primary Name Response Type
- */
-interface ResolvePrimaryNameResponse extends AcceleratableResponse, TraceableResponse {
-    name: ReverseResolutionResult;
-}
-interface ResolvePrimaryNamesRequest extends MultichainPrimaryNameResolutionArgs, AcceleratableRequest, TraceableRequest {
-}
-interface ResolvePrimaryNamesResponse extends AcceleratableResponse, TraceableResponse {
-    names: MultichainPrimaryNameResolutionResult;
-}
-
-declare const RECORDS_PER_PAGE_DEFAULT = 10;
-declare const RECORDS_PER_PAGE_MAX = 100;
-/**
- * Request page params.
- */
-interface RequestPageParams {
-    /**
-     * Requested page number (1-indexed)
-     * @invariant Must be a positive integer (>= 1)
-     * @default 1
-     */
-    page?: number;
-    /**
-     * Maximum number of records to return per page
-     * @invariant Must be a positive integer (>= 1) and less than or equal to {@link RECORDS_PER_PAGE_MAX}
-     * @default {@link RECORDS_PER_PAGE_DEFAULT}
-     */
-    recordsPerPage?: number;
-}
-
-interface ResponsePageContextWithNoRecords extends Required<RequestPageParams> {
-    /**
-     * Total number of records across all pages
-     */
-    totalRecords: 0;
-    /**
-     * Total number of pages
-     */
-    totalPages: 1;
-    /**
-     * Indicates if there is a next page available
-     */
-    hasNext: false;
-    /**
-     * Indicates if there is a previous page available
-     */
-    hasPrev: false;
-    /**
-     * The start index of the records on the page (0-indexed)
-     */
-    startIndex: undefined;
-    /**
-     * The end index of the records on the page (0-indexed)
-     */
-    endIndex: undefined;
-}
-interface ResponsePageContextWithRecords extends Required<RequestPageParams> {
-    /**
-     * Total number of records across all pages
-     * @invariant Guaranteed to be a non-negative integer (>= 0)
-     */
-    totalRecords: number;
-    /**
-     * Total number of pages
-     * @invariant Guaranteed to be a positive integer (>= 1)
-     */
-    totalPages: number;
-    /**
-     * Indicates if there is a next page available
-     * @invariant true if and only if (`page` * `recordsPerPage` < `totalRecords`)
-     */
-    hasNext: boolean;
-    /**
-     * Indicates if there is a previous page available
-     * @invariant true if and only if (`page` > 1)
-     */
-    hasPrev: boolean;
-    /**
-     * The start index of the records on the page (0-indexed)
-     *
-     * @invariant Guaranteed to be a non-negative integer (>= 0)
-     */
-    startIndex: number;
-    /**
-     * The end index of the records on the page (0-indexed)
-     *
-     * @invariant Guaranteed to be a non-negative integer (>= 0)
-     * @invariant Guaranteed to be greater than or equal to `startIndex`.
-     * @invariant Guaranteed to be less than `totalRecords`.
-     */
-    endIndex: number;
+/**
+ * Resolve Primary Name Response Type
+ */
+interface ResolvePrimaryNameResponse extends AcceleratableResponse, TraceableResponse {
+    name: ReverseResolutionResult;
+}
+interface ResolvePrimaryNamesRequest extends MultichainPrimaryNameResolutionArgs, AcceleratableRequest, TraceableRequest {
+}
+interface ResolvePrimaryNamesResponse extends AcceleratableResponse, TraceableResponse {
+    names: MultichainPrimaryNameResolutionResult;
 }
-type ResponsePageContext = ResponsePageContextWithNoRecords | ResponsePageContextWithRecords;
 
 /**
  * Request parameters for a referrer leaderboard page query.
@@ -3656,7 +4270,7 @@ declare class ENSNodeClient {
      *
      * @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)
+     * @param request.recordsPerPage - Number of records per page (default: 25, max: 100)
      * @returns {ReferrerLeaderboardPageResponse}
      *
      * @throws if the ENSNode request fails
@@ -3665,28 +4279,28 @@ declare class ENSNodeClient {
      *
      * @example
      * ```typescript
-     * // Get first page with default page size (25 items)
+     * // Get first page with default page size (25 records)
      * const response = await client.getReferrerLeaderboardPage();
      * if (response.responseCode === ReferrerLeaderboardPageResponseCodes.Ok) {
      *   const {
      *     aggregatedMetrics,
      *     referrers,
      *     rules,
-     *     paginationContext,
+     *     pageContext,
      *     updatedAt
      *   } = response.data;
      *   console.log(aggregatedMetrics);
      *   console.log(referrers);
      *   console.log(rules);
      *   console.log(updatedAt);
-     *   console.log(`Page ${paginationContext.page} of ${paginationContext.totalPages}`);
+     *   console.log(`Page ${pageContext.page} of ${pageContext.totalPages}`);
      * }
      * ```
      *
      * @example
      * ```typescript
-     * // Get second page with 50 items per page
-     * const response = await client.getReferrerLeaderboardPage({ page: 2, itemsPerPage: 50 });
+     * // Get second page with 50 records per page
+     * const response = await client.getReferrerLeaderboardPage({ page: 2, recordsPerPage: 50 });
      * ```
      *
      * @example
@@ -3781,11 +4395,13 @@ declare class ENSNodeClient {
     /**
      * 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.
+     * Retrieves a paginated list of registrar actions with optional filters.
+     *
+     * @param request is a request configuration.
+     * @param request.page sets the page number to retrieve (1-indexed, default: 1)
+     * @param request.recordsPerPage sets the number of records per page (default: 10, max: 100)
+     * @param request.filters is an optional request filter configuration.
+     * @param request.order sets the order of results in the response by field and direction.
      * @returns {RegistrarActionsResponse}
      *
      * @throws if the ENSNode request fails
@@ -3795,23 +4411,25 @@ declare class ENSNodeClient {
      * @example
      * ```ts
      * import {
-     *   registrarActionsFilter,,
+     *   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 first page with default page size (10 records)
+     * const response = await client.registrarActions();
+     * if (response.responseCode === RegistrarActionsResponseCodes.Ok) {
+     *   const { registrarActions, pageContext } = response;
+     *   console.log(registrarActions);
+     *   console.log(`Page ${pageContext.page} of ${pageContext.totalPages}`);
+     * }
      *
-     * // get 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 second page with 25 records per page
+     * const response = await client.registrarActions({
+     *   page: 2,
+     *   recordsPerPage: 25,
      * });
      *
      * // get latest registrar action records associated with
@@ -3825,210 +4443,56 @@ declare class ENSNodeClient {
      *   filters: [registrarActionsFilter.withReferral(true)],
      * });
      *
+     * // get latest registrar action records for a specific decoded referrer
+     * await client.registrarActions({
+     *   filters: [registrarActionsFilter.byDecodedReferrer("0x1234567890123456789012345678901234567890")],
+     * });
+     *
      * // get latest 10 registrar action records associated with
      * // subregistry managing `base.eth` name
      * await client.registrarActions({
      *   filters: [registrarActionsFilter.byParentNode(namehash('base.eth'))],
-     *   limit: 10
+     *   recordsPerPage: 10
      * });
      * ```
      */
     registrarActions(request?: RegistrarActionsRequest): Promise<RegistrarActionsResponse>;
-}
-
-declare class ClientError extends Error {
-    details?: unknown;
-    constructor(message: string, details?: unknown);
-    static fromErrorResponse({ message, details }: ErrorResponse): ClientError;
-}
-
-/**
- * An enum representing the possible CAIP-19 Asset Namespace values.
- */
-declare const AssetNamespaces: {
-    readonly ERC721: "erc721";
-    readonly ERC1155: "erc1155";
-};
-type AssetNamespace = (typeof AssetNamespaces)[keyof typeof AssetNamespaces];
-/**
- * A uint256 value that identifies a specific NFT within a NFT contract.
- */
-type TokenId = bigint;
-/**
- * A globally unique reference to an NFT.
- */
-interface AssetId {
-    assetNamespace: AssetNamespace;
-    contract: AccountId;
-    tokenId: TokenId;
-}
-/**
- * Serialized representation of an {@link AssetId}.
- *
- * Formatted as a fully lowercase CAIP-19 AssetId.
- *
- * @see https://chainagnostic.org/CAIPs/caip-19
- * @example "eip155:1/erc721:0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85/0xaf2caa1c2ca1d027f1ac823b529d0a67cd144264b2789fa2ea4d63a67c7103cc"
- *          for vitalik.eth in the eth base registrar on mainnet.
- */
-type SerializedAssetId = string;
-/**
- * Serializes {@link AssetId} object.
- */
-declare function serializeAssetId(assetId: AssetId): SerializedAssetId;
-/**
- * Builds an AssetId for the NFT represented by the given contract,
- * tokenId, and assetNamespace.
- *
- * @param contract - The contract that manages the NFT
- * @param tokenId - The tokenId of the NFT
- * @param assetNamespace - The assetNamespace of the NFT
- * @returns The AssetId for the NFT represented by the given contract,
- *          tokenId, and assetNamespace
- */
-declare const buildAssetId: (contract: AccountId, tokenId: TokenId, assetNamespace: AssetNamespace) => AssetId;
-/**
- * A globally unique reference to an NFT tokenizing the ownership of a domain.
- */
-interface DomainAssetId extends AssetId {
-    /**
-     * The namehash (node) of the domain who's ownership is tokenized by
-     * this `AssetId`.
-     */
-    domainId: Node;
-}
-/**
- * An enum representing the mint status of a DomainAssetId.
- *
- * After we index a NFT we never delete it from our index. Instead, when an
- * indexed NFT is burned onchain we retain its record and update its mint
- * status as `burned`. If a NFT is minted again after it is burned its mint
- * status is updated to `minted`.
- */
-declare const NFTMintStatuses: {
-    readonly Minted: "minted";
-    readonly Burned: "burned";
-};
-type NFTMintStatus = (typeof NFTMintStatuses)[keyof typeof NFTMintStatuses];
-/**
- * Metadata about a NFT transfer event.
- *
- * This metadata can be used for building more helpful messages when processing
- * NFT transfer events.
- */
-interface NFTTransferEventMetadata {
-    chainId: ChainId;
-    blockNumber: bigint;
-    transactionHash: Hex;
-    eventHandlerName: string;
-    nft: DomainAssetId;
-}
-declare const formatNFTTransferEventMetadata: (metadata: NFTTransferEventMetadata) => string;
-/**
- * An enum representing the type of transfer that has occurred to a DomainAssetId.
- */
-declare const NFTTransferTypes: {
-    /**
-     * Initial transfer from zeroAddress to a non-zeroAddress
-     * Can happen at most once to a NFT AssetId
-     *
-     * Invariants:
-     * - NFT is not indexed and therefore has no previous mint status or owner
-     * - new NFT mint status is `minted`
-     * - new NFT owner is a non-zeroAddress
-     */
-    readonly Mint: "mint";
-    /**
-     * Subsequent transfer from zeroAddress to a non-zeroAddress
-     * Can happen any number of times to a NFT AssetId as it passes in a cycle from
-     * mint -> burn -> remint -> burn -> remint -> ...
-     *
-     * Invariants:
-     * - NFT is indexed
-     * - previous NFT mint status was `burned`
-     * - previous NFT owner is the zeroAddress
-     * - new NFT mint status is `minted`
-     * - new NFT owner is a non-zeroAddress
-     */
-    readonly Remint: "remint";
-    /**
-     * Special transfer type for improperly implemented NFT contracts that allow a NFT
-     * that is currently minted to be reminted before an intermediate burn.
-     *
-     * Transfer from zeroAddress to non-zeroAddress for an indexed NFT where the
-     * previously indexed nft had status `minted` with a non-zeroAddress owner.
-     *
-     * Invariants:
-     * - NFT is indexed
-     * - previous NFT mint status was `minted`
-     * - previous NFT owner was a non-zeroAddress
-     * - new NFT mint status is `minted`
-     * - new NFT owner is a non-zeroAddress
-     */
-    readonly MintedRemint: "minted-remint";
-    /**
-     * Transfer from a non-zeroAddress to zeroAddress
-     *
-     * Invariants:
-     * - NFT is indexed
-     * - previous NFT mint status was `minted`
-     * - previous NFT owner is a non-zeroAddress
-     * - new NFT mint status is `burned`
-     * - new NFT owner is the zeroAddress
-     */
-    readonly Burn: "burn";
     /**
-     * Transfer from a non-zeroAddress to a distinct non-zeroAddress
+     * Fetch Name Tokens for requested name.
      *
-     * Invariants:
-     * - NFT is indexed
-     * - previous and new NFT mint status is `minted`
-     * - previous and new NFT owner are distinct non-zeroAddress
-     */
-    readonly Transfer: "transfer";
-    /**
-     * Transfer from a non-zeroAddress to the same non-zeroAddress
+     * @param request.name - Name for which Name Tokens will be fetched.
+     * @returns {NameTokensResponse}
      *
-     * Invariants:
-     * - NFT is indexed
-     * - previous and new NFT mint status is `minted`
-     * - previous and new NFT owner are equivalent non-zeroAddress
-     */
-    readonly SelfTransfer: "self-transfer";
-    /**
-     * Transfer from zeroAddress to zeroAddress for an indexed NFT
+     * @throws if the ENSNode request fails
+     * @throws if the ENSNode API returns an error response
+     * @throws if the ENSNode response breaks required invariants
      *
-     * Invariants:
-     * - NFT is indexed
-     * - previous and new NFT mint status is `burned`
-     * - previous and new NFT owner are zeroAddress
-     */
-    readonly RemintBurn: "remint-burn";
-    /**
-     * Special transfer type for improperly implemented NFT contracts that allow a NFT
-     * that is currently minted to be reminted again before an intermediate burn.
+     * @example
+     * ```ts
+     * import {
+     *   ENSNodeClient,
+     * } from "@ensnode/ensnode-sdk";
+     * import { namehash } from "viem/ens";
      *
-     * Transfer from zeroAddress to zeroAddress for an indexed NFT where the
-     * previously indexed nft had status `minted` with a non-zeroAddress owner.
+     * const client: ENSNodeClient;
      *
-     * Invariants:
-     * - NFT is indexed
-     * - previous NFT mint status was `minted`
-     * - previous NFT owner was a non-zeroAddress
-     * - new NFT mint status is `burned`
-     * - new NFT owner is the zeroAddress
-     */
-    readonly MintedRemintBurn: "minted-remint-burn";
-    /**
-     * Transfer from zeroAddress to zeroAddress for an unindexed NFT
+     * // get latest name token records from the indexed subregistry based on the requested name
+     * const response = await client.nameTokens({
+     *   name: "vitalik.eth"
+     * });
      *
-     * Invariants:
-     * - NFT is not indexed and therefore has no previous mint status or owner
-     * - NFT should remain unindexed and without any mint status or owner
+     * const response = await client.nameTokens({
+     *   domainId: "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835" // namehash('vitalik.eth')
+     * })
+     * ```
      */
-    readonly MintBurn: "mint-burn";
-};
-type NFTTransferType = (typeof NFTTransferTypes)[keyof typeof NFTTransferTypes];
-declare const getNFTTransferType: (from: Address, to: Address, allowMintedRemint: boolean, metadata: NFTTransferEventMetadata, currentlyIndexedOwner?: Address) => NFTTransferType;
+    nameTokens(request: NameTokensRequest): Promise<NameTokensResponse>;
+}
+
+declare class ClientError extends Error {
+    details?: unknown;
+    constructor(message: string, details?: unknown);
+    static fromErrorResponse({ message, details }: ErrorResponse): ClientError;
+}
 
-export { ADDR_REVERSE_NODE, ATTR_PROTOCOL_NAME, ATTR_PROTOCOL_STEP, ATTR_PROTOCOL_STEP_RESULT, type AcceleratableRequest, type AcceleratableResponse, type AccountId, type AssetId, type AssetNamespace, AssetNamespaces, BASENAMES_NODE, type BlockNumber, type BlockRef, type Blockrange, type Cache, type CachedValue, type ChainId, type ChainIdString, type ChainIndexingConfig, type ChainIndexingConfigDefinite, type ChainIndexingConfigIndefinite, type ChainIndexingConfigTypeId, ChainIndexingConfigTypeIds, type ChainIndexingStatusId, ChainIndexingStatusIds, type ChainIndexingStatusSnapshot, type ChainIndexingStatusSnapshotBackfill, type ChainIndexingStatusSnapshotCompleted, type ChainIndexingStatusSnapshotFollowing, type ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill, type ChainIndexingStatusSnapshotQueued, ClientError, type ClientOptions, type ConfigResponse, type CrossChainIndexingStatusSnapshot, type CrossChainIndexingStatusSnapshotOmnichain, type CrossChainIndexingStrategyId, CrossChainIndexingStrategyIds, type CurrencyAmount, type CurrencyId, CurrencyIds, type CurrencyInfo, DEFAULT_EVM_CHAIN_ID, DEFAULT_EVM_COIN_TYPE, type DNSEncodedLiteralName, type DNSEncodedName, type DNSEncodedPartiallyInterpretedName, type Datetime, type DatetimeISO8601, type DeepPartial, type DefaultableChainId, type DomainAssetId, type Duration, type ENSApiPublicConfig, type ENSIndexerPublicConfig, type ENSIndexerVersionInfo, ENSNodeClient, ETH_COIN_TYPE, ETH_NODE, type EncodedLabelHash, type EnsRainbowClientLabelSet, type EnsRainbowServerLabelSet, type ErrorResponse, type ForwardResolutionArgs, ForwardResolutionProtocolStep, type ForwardResolutionResult, type Identity, type IndexingStatusRequest, type IndexingStatusResponse, type IndexingStatusResponseCode, IndexingStatusResponseCodes, type IndexingStatusResponseError, type IndexingStatusResponseOk, type InterpretedLabel, type InterpretedName, LINEANAMES_NODE, type Label, type LabelHash, type LabelSetId, type LabelSetVersion, type LiteralLabel, type LiteralName, LruCache, type MultichainPrimaryNameResolutionArgs, type MultichainPrimaryNameResolutionResult, type NFTMintStatus, NFTMintStatuses, type NFTTransferEventMetadata, type NFTTransferType, NFTTransferTypes, type Name, type NamedIdentity, type NamedRegistrarAction, type Node, type NormalizedName, type OmnichainIndexingStatusId, OmnichainIndexingStatusIds, type OmnichainIndexingStatusSnapshot, type OmnichainIndexingStatusSnapshotBackfill, type OmnichainIndexingStatusSnapshotCompleted, type OmnichainIndexingStatusSnapshotFollowing, type OmnichainIndexingStatusSnapshotUnstarted, PROTOCOL_ATTRIBUTE_PREFIX, PluginName, type Price, type PriceDai, type PriceEth, type PriceUsdc, type ProtocolSpan, type ProtocolSpanTreeNode, type ProtocolTrace, RECORDS_PER_PAGE_DEFAULT, RECORDS_PER_PAGE_MAX, ROOT_NODE, type RealtimeIndexingStatusProjection, type ReferrerDetailRequest, type ReferrerDetailResponse, type ReferrerDetailResponseCode, ReferrerDetailResponseCodes, type ReferrerDetailResponseError, type ReferrerDetailResponseOk, type ReferrerLeaderboardPageRequest, type ReferrerLeaderboardPageResponse, type ReferrerLeaderboardPageResponseCode, ReferrerLeaderboardPageResponseCodes, type ReferrerLeaderboardPageResponseError, type ReferrerLeaderboardPageResponseOk, type 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 RequestPageParams, type ResolutionStatusId, ResolutionStatusIds, type ResolvePrimaryNameRequest, type ResolvePrimaryNameResponse, type ResolvePrimaryNamesRequest, type ResolvePrimaryNamesResponse, type ResolveRecordsRequest, type ResolveRecordsResponse, type ResolvedIdentity, type ResolverRecordsResponse, type ResolverRecordsResponseBase, type ResolverRecordsSelection, type ResponsePageContext, type ResponsePageContextWithNoRecords, type ResponsePageContextWithRecords, type ReverseResolutionArgs, ReverseResolutionProtocolStep, type ReverseResolutionResult, type RpcUrl, SWRCache, type SWRCacheOptions, type SerializedAccountId, type SerializedAssetId, type SerializedChainIndexingStatusSnapshot, type SerializedChainIndexingStatusSnapshotBackfill, type SerializedChainIndexingStatusSnapshotCompleted, type SerializedChainIndexingStatusSnapshotFollowing, type SerializedChainIndexingStatusSnapshotQueued, type SerializedConfigResponse, 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 SerializedPrice, type SerializedPriceDai, type SerializedPriceEth, type SerializedPriceUsdc, type SerializedRealtimeIndexingStatusProjection, type SerializedReferrerDetailResponse, type SerializedReferrerDetailResponseError, type SerializedReferrerDetailResponseOk, type SerializedReferrerLeaderboardPageResponse, type SerializedReferrerLeaderboardPageResponseError, type SerializedReferrerLeaderboardPageResponseOk, 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, type TokenId, TraceableENSProtocol, type TraceableRequest, type TraceableResponse, TtlCache, type UnixTimestamp, type UnknownIdentity, type UnnamedIdentity, type UnresolvedIdentity, type UrlString, accountIdEqual, addDuration, addPrices, addrReverseLabel, asLowerCaseAddress, beautifyName, bigIntToNumber, bigintToCoinType, buildAssetId, buildEnsRainbowClientLabelSet, buildLabelSetId, buildLabelSetVersion, buildUnresolvedIdentity, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted, coinTypeReverseLabel, coinTypeToEvmChainId, createIndexingConfig, createRealtimeIndexingStatusProjection, decodeDNSEncodedLiteralName, decodeDNSEncodedName, deserializeAccountId, deserializeBlockNumber, deserializeBlockRef, deserializeBlockrange, deserializeChainId, deserializeChainIndexingStatusSnapshot, deserializeConfigResponse, deserializeCrossChainIndexingStatusSnapshot, deserializeDatetime, deserializeDuration, deserializeENSApiPublicConfig, deserializeENSIndexerPublicConfig, deserializeErrorResponse, deserializeIndexingStatusResponse, deserializeOmnichainIndexingStatusSnapshot, deserializeRealtimeIndexingStatusProjection, deserializeReferrerDetailResponse, deserializeReferrerLeaderboardPageResponse, deserializeRegistrarActionsResponse, deserializeUnixTimestamp, deserializeUrl, durationBetween, encodeLabelHash, evmChainIdToCoinType, formatNFTTransferEventMetadata, getCurrencyInfo, getEthnamesSubregistryId, getLatestIndexedBlockRef, getNFTTransferType, 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, serializeAssetId, serializeChainId, serializeChainIndexingSnapshots, serializeConfigResponse, serializeCrossChainIndexingStatusSnapshotOmnichain, serializeDatetime, serializeENSApiPublicConfig, serializeENSIndexerPublicConfig, serializeIndexedChainIds, serializeIndexingStatusResponse, serializeNamedRegistrarAction, serializeOmnichainIndexingStatusSnapshot, serializePrice, serializePriceEth, serializeRealtimeIndexingStatusProjection, serializeReferrerDetailResponse, serializeReferrerLeaderboardPageResponse, serializeRegistrarAction, serializeRegistrarActionPricing, serializeRegistrarActionsResponse, serializeRegistrationLifecycle, serializeSubregistry, serializeUrl, sortChainStatusesByStartBlockAsc, stripNullBytes, 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 AccountIdString, type AssetId, type AssetIdString, type AssetNamespace, AssetNamespaces, BASENAMES_NODE, type BlockNumber, type BlockRef, type Blockrange, type Cache, type ChainId, type ChainIdString, type ChainIndexingConfig, type ChainIndexingConfigDefinite, type ChainIndexingConfigIndefinite, type ChainIndexingConfigTypeId, ChainIndexingConfigTypeIds, type ChainIndexingStatusId, ChainIndexingStatusIds, type ChainIndexingStatusSnapshot, type ChainIndexingStatusSnapshotBackfill, type ChainIndexingStatusSnapshotCompleted, type ChainIndexingStatusSnapshotFollowing, type ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill, type ChainIndexingStatusSnapshotQueued, ClientError, type ClientOptions, type ConfigResponse, type CrossChainIndexingStatusSnapshot, type CrossChainIndexingStatusSnapshotOmnichain, type CrossChainIndexingStrategyId, CrossChainIndexingStrategyIds, type CurrencyAmount, type CurrencyId, CurrencyIds, type CurrencyInfo, DEFAULT_EVM_CHAIN_ID, DEFAULT_EVM_COIN_TYPE, type DNSEncodedLiteralName, type DNSEncodedName, type DNSEncodedPartiallyInterpretedName, type Datetime, type DatetimeISO8601, type DeepPartial, type DefaultableChainId, type DomainAssetId, type Duration, type ENSApiPublicConfig, type ENSIndexerPublicConfig, type ENSIndexerVersionInfo, ENSNodeClient, ENS_ROOT, ETH_COIN_TYPE, ETH_NODE, type EncodedLabelHash, type EnsRainbowClientLabelSet, type EnsRainbowServerLabelSet, type ErrorResponse, type ForwardResolutionArgs, ForwardResolutionProtocolStep, type ForwardResolutionResult, type Identity, type IndexingStatusRequest, type IndexingStatusResponse, type IndexingStatusResponseCode, IndexingStatusResponseCodes, type IndexingStatusResponseError, type IndexingStatusResponseOk, type InterpretedLabel, type InterpretedName, LINEANAMES_NODE, type Label, type LabelHash, type LabelSetId, type LabelSetVersion, type LiteralLabel, type LiteralName, LruCache, type MultichainPrimaryNameResolutionArgs, type MultichainPrimaryNameResolutionResult, type NFTMintStatus, NFTMintStatuses, type NFTTransferEventMetadata, type NFTTransferType, NFTTransferTypes, type Name, type NameToken, type NameTokenOwnership, type NameTokenOwnershipBurned, type NameTokenOwnershipFullyOnchain, type NameTokenOwnershipNameWrapper, type NameTokenOwnershipType, NameTokenOwnershipTypes, type NameTokenOwnershipUnknown, type NameTokensRequest, type NameTokensRequestByDomainId, type NameTokensRequestByName, type NameTokensResponse, type NameTokensResponseCode, NameTokensResponseCodes, type NameTokensResponseError, type NameTokensResponseErrorCode, NameTokensResponseErrorCodes, type NameTokensResponseErrorEnsIndexerConfigUnsupported, type NameTokensResponseErrorIndexingStatusUnsupported, type NameTokensResponseErrorNameTokensNotIndexed, type NameTokensResponseOk, type NamedIdentity, type NamedRegistrarAction, type Node, type NormalizedName, type OmnichainIndexingStatusId, OmnichainIndexingStatusIds, type OmnichainIndexingStatusSnapshot, type OmnichainIndexingStatusSnapshotBackfill, type OmnichainIndexingStatusSnapshotCompleted, type OmnichainIndexingStatusSnapshotFollowing, type OmnichainIndexingStatusSnapshotUnstarted, PROTOCOL_ATTRIBUTE_PREFIX, PluginName, type Price, type PriceDai, type PriceEth, type PriceUsdc, RECORDS_PER_PAGE_DEFAULT, RECORDS_PER_PAGE_MAX, ROOT_NODE, type RealtimeIndexingStatusProjection, type ReferrerDetailRequest, type ReferrerDetailResponse, type ReferrerDetailResponseCode, ReferrerDetailResponseCodes, type ReferrerDetailResponseError, type ReferrerDetailResponseOk, type ReferrerLeaderboardPageRequest, type ReferrerLeaderboardPageResponse, type ReferrerLeaderboardPageResponseCode, ReferrerLeaderboardPageResponseCodes, type ReferrerLeaderboardPageResponseError, type ReferrerLeaderboardPageResponseOk, type RegisteredNameTokens, type RegistrarAction, type RegistrarActionEventId, type RegistrarActionPricing, type RegistrarActionPricingAvailable, type RegistrarActionPricingUnknown, type RegistrarActionReferral, type RegistrarActionReferralAvailable, type RegistrarActionReferralNotApplicable, type RegistrarActionType, RegistrarActionTypes, type RegistrarActionsFilter, type RegistrarActionsFilterByDecodedReferrer, 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 RequestPageParams, type ResolutionStatusId, ResolutionStatusIds, type ResolvePrimaryNameRequest, type ResolvePrimaryNameResponse, type ResolvePrimaryNamesRequest, type ResolvePrimaryNamesResponse, type ResolveRecordsRequest, type ResolveRecordsResponse, type ResolvedIdentity, type ResolverRecordsResponse, type ResolverRecordsResponseBase, type ResolverRecordsSelection, type ResponsePageContext, type ResponsePageContextWithNoRecords, type ResponsePageContextWithRecords, type ReverseResolutionArgs, ReverseResolutionProtocolStep, type ReverseResolutionResult, type RpcUrl, SWRCache, type SWRCacheOptions, type SerializedAssetId, type SerializedChainIndexingStatusSnapshot, type SerializedChainIndexingStatusSnapshotBackfill, type SerializedChainIndexingStatusSnapshotCompleted, type SerializedChainIndexingStatusSnapshotFollowing, type SerializedChainIndexingStatusSnapshotQueued, type SerializedConfigResponse, type SerializedCrossChainIndexingStatusSnapshot, type SerializedCrossChainIndexingStatusSnapshotOmnichain, type SerializedCurrencyAmount, type SerializedCurrentIndexingProjectionOmnichain, type SerializedDomainAssetId, type SerializedENSApiPublicConfig, type SerializedENSIndexerPublicConfig, type SerializedENSIndexerVersionInfo, type SerializedIndexedChainIds, type SerializedIndexingStatusResponse, type SerializedIndexingStatusResponseError, type SerializedIndexingStatusResponseOk, type SerializedNameToken, type SerializedNameTokensResponse, type SerializedNameTokensResponseError, type SerializedNameTokensResponseOk, type SerializedNamedRegistrarAction, type SerializedOmnichainIndexingStatusSnapshot, type SerializedOmnichainIndexingStatusSnapshotBackfill, type SerializedOmnichainIndexingStatusSnapshotCompleted, type SerializedOmnichainIndexingStatusSnapshotFollowing, type SerializedOmnichainIndexingStatusSnapshotUnstarted, type SerializedPrice, type SerializedPriceDai, type SerializedPriceEth, type SerializedPriceUsdc, type SerializedRealtimeIndexingStatusProjection, type SerializedReferrerDetailResponse, type SerializedReferrerDetailResponseError, type SerializedReferrerDetailResponseOk, type SerializedReferrerLeaderboardPageResponse, type SerializedReferrerLeaderboardPageResponseError, type SerializedReferrerLeaderboardPageResponseOk, type SerializedRegisteredNameTokens, type SerializedRegistrarAction, type SerializedRegistrarActionPricing, type SerializedRegistrarActionPricingAvailable, type SerializedRegistrarActionPricingUnknown, type SerializedRegistrarActionsResponse, type SerializedRegistrarActionsResponseError, type SerializedRegistrarActionsResponseOk, type SerializedTokenId, type SubgraphInterpretedLabel, type SubgraphInterpretedName, type Subregistry, type TheGraphCannotFallbackReason, TheGraphCannotFallbackReasonSchema, type TheGraphFallback, TheGraphFallbackSchema, type TokenId, TraceableENSProtocol, type TraceableRequest, type TraceableResponse, type TracingNode, type TracingSpan, type TracingTrace, TtlCache, type UnixTimestamp, type UnknownIdentity, type UnnamedIdentity, type UnresolvedIdentity, type UrlString, accountIdEqual, addDuration, addPrices, addrReverseLabel, asLowerCaseAddress, beautifyName, bigIntToNumber, bigintToCoinType, buildAssetId, buildEnsRainbowClientLabelSet, buildLabelSetId, buildLabelSetVersion, buildPageContext, buildUnresolvedIdentity, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted, coinTypeReverseLabel, coinTypeToEvmChainId, createIndexingConfig, createRealtimeIndexingStatusProjection, decodeDNSEncodedLiteralName, decodeDNSEncodedName, deserializeAssetId, deserializeBlockNumber, deserializeBlockRef, deserializeBlockrange, deserializeChainId, deserializeChainIndexingStatusSnapshot, deserializeConfigResponse, deserializeCrossChainIndexingStatusSnapshot, deserializeDatetime, deserializeDuration, deserializeENSApiPublicConfig, deserializeENSIndexerPublicConfig, deserializeErrorResponse, deserializeIndexingStatusResponse, deserializeOmnichainIndexingStatusSnapshot, deserializeRealtimeIndexingStatusProjection, deserializeReferrerDetailResponse, deserializeReferrerLeaderboardPageResponse, deserializeRegistrarActionsResponse, deserializeUnixTimestamp, deserializeUrl, deserializedNameTokensResponse, durationBetween, encodeLabelHash, evmChainIdToCoinType, formatAccountId, formatAssetId, formatNFTTransferEventMetadata, getBasenamesSubregistryId, getBasenamesSubregistryManagedName, getCurrencyInfo, getDatasourceContract, getEthnamesSubregistryId, getEthnamesSubregistryManagedName, getLatestIndexedBlockRef, getLineanamesSubregistryId, getLineanamesSubregistryManagedName, getNFTTransferType, getNameHierarchy, getNameTokenOwnership, getNameWrapperAccounts, getOmnichainIndexingCursor, getOmnichainIndexingStatus, getParentNameFQDN, getResolvePrimaryNameChainIdParam, getTimestampForHighestOmnichainKnownBlock, getTimestampForLowestOmnichainStartBlock, hasNullByte, interpretedLabelsToInterpretedName, isEncodedLabelHash, isHttpProtocol, isLabelHash, isNormalizedLabel, isNormalizedName, isPriceCurrencyEqual, isPriceEqual, isRegistrarActionPricingAvailable, isRegistrarActionReferralAvailable, isResolvedIdentity, isSelectionEmpty, isSubgraphCompatible, isWebSocketProtocol, labelHashToBytes, labelhashLiteralLabel, literalLabelToInterpretedLabel, literalLabelsToInterpretedName, literalLabelsToLiteralName, makeENSApiPublicConfigSchema, makeSubdomainNode, maybeGetDatasourceContract, nameTokensPrerequisites, parseAccountId, parseAssetId, parseNonNegativeInteger, parseReverseName, priceDai, priceEth, priceUsdc, registrarActionsFilter, registrarActionsPrerequisites, reverseName, serializeAssetId, serializeChainId, serializeChainIndexingSnapshots, serializeConfigResponse, serializeCrossChainIndexingStatusSnapshotOmnichain, serializeDatetime, serializeDomainAssetId, serializeENSApiPublicConfig, serializeENSIndexerPublicConfig, serializeIndexedChainIds, serializeIndexingStatusResponse, serializeNameToken, serializeNameTokensResponse, serializeNamedRegistrarAction, serializeOmnichainIndexingStatusSnapshot, serializePrice, serializePriceEth, serializeRealtimeIndexingStatusProjection, serializeReferrerDetailResponse, serializeReferrerLeaderboardPageResponse, serializeRegisteredNameTokens, serializeRegistrarAction, serializeRegistrarActionPricing, serializeRegistrarActionsResponse, serializeUrl, sortChainStatusesByStartBlockAsc, stripNullBytes, translateDefaultableChainIdToChainId, uint256ToHex32, uniq, validateSupportedLabelSetAndVersion };