@ensnode/ensnode-sdk 1.1.0 → 1.3.0

package/dist/index.d.cts

@@ -1,11 +1,56 @@
+import z$1, { z } from 'zod/v4';
+import { ENSNamespaceId, DatasourceName } from '@ensnode/datasources';
+export { ENSNamespaceId, ENSNamespaceIds, getENSRootChainId } from '@ensnode/datasources';
 import { Hex, Address, ByteArray, Hash } from 'viem';
 import { CoinType, EvmCoinType } from '@ensdomains/address-encoder';
 export { CoinType, EvmCoinType } from '@ensdomains/address-encoder';
-import { EncodedReferrer, ReferrerLeaderboardPaginationParams, ReferrerLeaderboardPage } 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';
-import z$1, { z } from 'zod/v4';
-import { ENSNamespaceId } from '@ensnode/datasources';
-export { ENSNamespaceId, ENSNamespaceIds, getENSRootChainId } from '@ensnode/datasources';
+
+/**
+ * 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.
@@ -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.
@@ -913,6 +921,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 +974,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 +993,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 +1080,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;
@@ -2055,1147 +2092,1902 @@ declare function serializeChainIndexingSnapshots<ChainIndexingStatusSnapshotType
  */
 declare function serializeOmnichainIndexingStatusSnapshot(indexingStatus: OmnichainIndexingStatusSnapshot): SerializedOmnichainIndexingStatusSnapshot;
 
+declare const TheGraphCannotFallbackReasonSchema: z.ZodEnum<{
+    readonly NotSubgraphCompatible: "not-subgraph-compatible";
+    readonly NoApiKey: "no-api-key";
+    readonly NoSubgraphUrl: "no-subgraph-url";
+}>;
+declare const TheGraphFallbackSchema: z.ZodObject<{
+    canFallback: z.ZodBoolean;
+    reason: z.ZodNullable<z.ZodEnum<{
+        readonly NotSubgraphCompatible: "not-subgraph-compatible";
+        readonly NoApiKey: "no-api-key";
+        readonly NoSubgraphUrl: "no-subgraph-url";
+    }>>;
+}, z.core.$strict>;
 /**
- * Gets the SubregistryId (an AccountId) of the Ethnames Subregistry contract (this is the
- * "BaseRegistrar" contract for direct subnames of .eth) for the provided namespace.
+ * Create a Zod schema for validating a serialized ENSApiPublicConfig.
  *
- * @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.
+ * @param valueLabel - Optional label for the value being validated (used in error messages)
  */
-declare function getEthnamesSubregistryId(namespace: ENSNamespaceId): AccountId;
+declare function makeENSApiPublicConfigSchema(valueLabel?: string): z.ZodObject<{
+    version: z.ZodString;
+    theGraphFallback: z.ZodObject<{
+        canFallback: z.ZodBoolean;
+        reason: z.ZodNullable<z.ZodEnum<{
+            readonly NotSubgraphCompatible: "not-subgraph-compatible";
+            readonly NoApiKey: "no-api-key";
+            readonly NoSubgraphUrl: "no-subgraph-url";
+        }>>;
+    }, z.core.$strict>;
+    ensIndexerPublicConfig: z.ZodObject<{
+        labelSet: z.ZodObject<{
+            labelSetId: z.ZodString;
+            labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<unknown>, z.ZodInt>;
+        }, z.core.$strip>;
+        indexedChainIds: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>, z.ZodTransform<Set<number>, number[]>>;
+        isSubgraphCompatible: z.ZodBoolean;
+        namespace: z.ZodEnum<{
+            readonly Mainnet: "mainnet";
+            readonly Sepolia: "sepolia";
+            readonly Holesky: "holesky";
+            readonly EnsTestEnv: "ens-test-env";
+        }>;
+        plugins: z.ZodArray<z.ZodString>;
+        databaseSchemaName: z.ZodString;
+        versionInfo: z.ZodObject<{
+            nodejs: z.ZodString;
+            ponder: z.ZodString;
+            ensDb: z.ZodString;
+            ensIndexer: z.ZodString;
+            ensNormalize: z.ZodString;
+            ensRainbow: z.ZodString;
+            ensRainbowSchema: z.ZodInt;
+        }, z.core.$strict>;
+    }, z.core.$strip>;
+}, z.core.$strict>;
 
+type TheGraphCannotFallbackReason = z.infer<typeof TheGraphCannotFallbackReasonSchema>;
+type TheGraphFallback = z.infer<typeof TheGraphFallbackSchema>;
 /**
- * Subregistry
+ * Complete public configuration object for ENSApi.
+ *
+ * Contains ENSApi-specific configuration at the top level and
+ * embeds the complete ENSIndexer public configuration.
  */
-interface Subregistry {
+interface ENSApiPublicConfig {
     /**
-     * Subregistry ID
-     *
-     * The ID of the subregistry the "logical registrar action" was taken on.
+     * ENSApi service version
      *
-     * Identifies the chainId and address of the associated subregistry smart
-     * contract.
+     * @see https://ghcr.io/namehash/ensnode/ensapi
      */
-    subregistryId: AccountId;
+    version: string;
     /**
-     * The node (namehash) of the name the subregistry manages subnames of.
-     * Example subregistry managed names:
-     * - `eth`
-     * - `base.eth`
-     * - `linea.eth`
+     * The Graph Fallback-related info.
      */
-    node: Node;
+    theGraphFallback: TheGraphFallback;
+    /**
+     * Complete ENSIndexer public configuration
+     *
+     * Contains all ENSIndexer public configuration including
+     * namespace, plugins, version info, etc.
+     */
+    ensIndexerPublicConfig: ENSIndexerPublicConfig;
 }
+
 /**
- * Serialized representation of {@link Subregistry}.
+ * Serialized representation of {@link ENSApiPublicConfig}
  */
-interface SerializedSubregistry extends Omit<Subregistry, "subregistryId"> {
-    subregistryId: SerializedAccountId;
+interface SerializedENSApiPublicConfig extends Omit<ENSApiPublicConfig, "ensIndexerPublicConfig"> {
+    /**
+     * Serialized representation of {@link ENSApiPublicConfig.ensIndexerPublicConfig}.
+     */
+    ensIndexerPublicConfig: SerializedENSIndexerPublicConfig;
 }
-declare function serializeSubregistry(subregistry: Subregistry): SerializedSubregistry;
 
 /**
- * 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.
+ * Deserialize a {@link ENSApiPublicConfig} object.
  */
-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`.
+declare function deserializeENSApiPublicConfig(maybeConfig: SerializedENSApiPublicConfig, valueLabel?: string): ENSApiPublicConfig;
+
+/**
+ * Serialize a {@link ENSApiPublicConfig} object.
+ */
+declare function serializeENSApiPublicConfig(config: ENSApiPublicConfig): SerializedENSApiPublicConfig;
+
+/**
+ * ENSApi Public Config Response
+ */
+type ConfigResponse = ENSApiPublicConfig;
+
+type SerializedConfigResponse = SerializedENSApiPublicConfig;
+
+/**
+ * Deserialize a {@link ConfigResponse} object.
+ */
+declare function deserializeConfigResponse(serializedResponse: SerializedConfigResponse): ConfigResponse;
+
+declare function serializeConfigResponse(response: ConfigResponse): SerializedConfigResponse;
+
+/**
+ * A status code for indexing status responses.
+ */
+declare const IndexingStatusResponseCodes: {
+    /**
+     * Represents that the indexing status is available.
      */
-    readonly ReleasedWithTempPrice: "registrationLifecycle_releasedWithTempPrice";
+    readonly Ok: "ok";
     /**
-     * Fully Released (Regular Price)
-     *
-     * Happens when
-     * ` expiry + 120 days < the current timestamp`.
+     * Represents that the indexing status is unavailable.
      */
-    readonly FullyReleased: "registrationLifecycle_fullyReleased";
+    readonly Error: "error";
 };
-type RegistrationLifecycleStage = (typeof RegistrationLifecycleStages)[keyof typeof RegistrationLifecycleStages];
 /**
- * Registration Lifecycle
+ * The derived string union of possible {@link IndexingStatusResponseCodes}.
  */
-interface RegistrationLifecycle {
+type IndexingStatusResponseCode = (typeof IndexingStatusResponseCodes)[keyof typeof IndexingStatusResponseCodes];
+/**
+ * An indexing status response when the indexing status is available.
+ */
+type IndexingStatusResponseOk = {
+    responseCode: typeof IndexingStatusResponseCodes.Ok;
+    realtimeProjection: RealtimeIndexingStatusProjection;
+};
+/**
+ * An indexing status response when the indexing status is unavailable.
+ */
+type IndexingStatusResponseError = {
+    responseCode: typeof IndexingStatusResponseCodes.Error;
+};
+/**
+ * Indexing status response.
+ *
+ * Use the `responseCode` field to determine the specific type interpretation
+ * at runtime.
+ */
+type IndexingStatusResponse = IndexingStatusResponseOk | IndexingStatusResponseError;
+
+/**
+ * Serialized representation of {@link IndexingStatusResponseError}.
+ */
+type SerializedIndexingStatusResponseError = IndexingStatusResponseError;
+/**
+ * Serialized representation of {@link IndexingStatusResponseOk}.
+ */
+interface SerializedIndexingStatusResponseOk extends Omit<IndexingStatusResponseOk, "realtimeProjection"> {
+    realtimeProjection: SerializedRealtimeIndexingStatusProjection;
+}
+/**
+ * Serialized representation of {@link IndexingStatusResponse}.
+ */
+type SerializedIndexingStatusResponse = SerializedIndexingStatusResponseOk | SerializedIndexingStatusResponseError;
+
+/**
+ * Deserialize a {@link IndexingStatusResponse} object.
+ */
+declare function deserializeIndexingStatusResponse(maybeResponse: SerializedIndexingStatusResponse): IndexingStatusResponse;
+
+/**
+ * Represents a request to Indexing Status API.
+ */
+type IndexingStatusRequest = {};
+
+declare function serializeIndexingStatusResponse(response: IndexingStatusResponse): SerializedIndexingStatusResponse;
+
+/**
+ * Deserialize a {@link NameTokensResponse} object.
+ */
+declare function deserializedNameTokensResponse(maybeResponse: SerializedNameTokensResponse): NameTokensResponse;
+
+declare const nameTokensPrerequisites: Readonly<{
     /**
-     * Subregistry that manages this Registration Lifecycle.
+     * Required plugins to enable Name Tokens API routes.
+     *
+     * 1. `registrars` plugin is required so that data in the `registrationLifecycles`
+     *    table is populated.
+     * 2. `tokenscope` plugin is required so that data in the `nameTokens`
+     *    table is populated.
      */
-    subregistry: Subregistry;
+    requiredPlugins: readonly [PluginName.Registrars, PluginName.TokenScope];
     /**
-     * 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`.
+     * Check if provided ENSApiPublicConfig supports the Name Tokens API.
      */
-    node: Node;
+    hasEnsIndexerConfigSupport(config: ENSIndexerPublicConfig): boolean;
     /**
-     * Expires at
+     * Required Indexing Status IDs
      *
-     * Identifies when the Registration Lifecycle is scheduled to expire.
+     * Database indexes are created by the time the omnichain indexing status
+     * is either `completed` or `following`.
      */
-    expiresAt: UnixTimestamp;
+    supportedIndexingStatusIds: ("omnichain-following" | "omnichain-completed")[];
+    /**
+     * Check if provided indexing status supports the Name Tokens API.
+     */
+    hasIndexingStatusSupport(omnichainIndexingStatusId: OmnichainIndexingStatusId): boolean;
+}>;
+
+/**
+ * Represents request to Name Tokens API.
+ */
+interface NameTokensRequestByDomainId {
+    domainId: Node;
+    /**
+     * Name for which name tokens were requested.
+     */
+    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
- * associated with the "logical registrar action".
+ * An enum representing the possible CAIP-19 Asset Namespace values.
  */
-type RegistrarActionEventId = string;
+declare const AssetNamespaces: {
+    readonly ERC721: "erc721";
+    readonly ERC1155: "erc1155";
+};
+type AssetNamespace = (typeof AssetNamespaces)[keyof typeof AssetNamespaces];
 /**
- * Types of "logical registrar action".
+ * A uint256 value that identifies a specific NFT within a NFT contract.
  */
-declare const RegistrarActionTypes: {
-    readonly Registration: "registration";
-    readonly Renewal: "renewal";
+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 RegistrarActionType = (typeof RegistrarActionTypes)[keyof typeof RegistrarActionTypes];
+type NFTMintStatus = (typeof NFTMintStatuses)[keyof typeof NFTMintStatuses];
 /**
- * Pricing information for a "logical registrar action".
+ * Metadata about a NFT transfer event.
+ *
+ * This metadata can be used for building more helpful messages when processing
+ * NFT transfer events.
  */
-interface RegistrarActionPricingAvailable {
+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: {
     /**
-     * Base cost
-     *
-     * Base cost (before any `premium`) of Ether measured in units of Wei
-     * paid to execute the "logical registrar action".
+     * Initial transfer from zeroAddress to a non-zeroAddress
+     * Can happen at most once to a NFT AssetId
      *
-     * May be 0.
+     * 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
      */
-    baseCost: PriceEth;
+    readonly Mint: "mint";
     /**
-     * Premium
-     *
-     * "premium" cost (in excesses of the `baseCost`) of Ether measured in
-     * units of Wei paid to execute the "logical registrar action".
+     * 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 -> ...
      *
-     * May be 0.
+     * 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
      */
-    premium: PriceEth;
+    readonly Remint: "remint";
     /**
-     * Total
+     * Special transfer type for improperly implemented NFT contracts that allow a NFT
+     * that is currently minted to be reminted before an intermediate burn.
      *
-     * Total cost of Ether measured in units of Wei paid to execute
-     * the "logical registrar action".
+     * Transfer from zeroAddress to non-zeroAddress for an indexed NFT where the
+     * previously indexed nft had status `minted` with a non-zeroAddress owner.
      *
-     * May be 0.
+     * 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
      */
-    total: PriceEth;
-}
-/**
- * Pricing information for a "logical registrar action" when
- * there is no known pricing data.
- */
-interface RegistrarActionPricingUnknown {
+    readonly MintedRemint: "minted-remint";
     /**
-     * Base cost
+     * Transfer from a non-zeroAddress to zeroAddress
      *
-     * Base cost (before any `premium`) of Ether measured in units of Wei
-     * paid to execute the "logical registrar action".
+     * 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
      */
-    baseCost: null;
+    readonly Burn: "burn";
     /**
-     * Premium
+     * Transfer from a non-zeroAddress to a distinct non-zeroAddress
      *
-     * "premium" cost (in excesses of the `baseCost`) of Ether measured in
-     * units of Wei paid to execute the "logical registrar action".
+     * Invariants:
+     * - NFT is indexed
+     * - previous and new NFT mint status is `minted`
+     * - previous and new NFT owner are distinct non-zeroAddress
      */
-    premium: null;
+    readonly Transfer: "transfer";
     /**
-     * Total
+     * Transfer from a non-zeroAddress to the same non-zeroAddress
      *
-     * Total cost of Ether measured in units of Wei paid to execute
-     * the "logical registrar action".
+     * Invariants:
+     * - NFT is indexed
+     * - previous and new NFT mint status is `minted`
+     * - previous and new NFT owner are equivalent non-zeroAddress
      */
-    total: null;
-}
-type RegistrarActionPricing = RegistrarActionPricingAvailable | RegistrarActionPricingUnknown;
-declare function isRegistrarActionPricingAvailable(registrarActionPricing: RegistrarActionPricing): registrarActionPricing is RegistrarActionPricingAvailable;
-/**
- * * Referral information for performing a "logical registrar action".
- */
-interface RegistrarActionReferralAvailable {
+    readonly SelfTransfer: "self-transfer";
     /**
-     * Encoded Referrer
+     * Transfer from zeroAddress to zeroAddress for an indexed NFT
      *
-     * Represents the "raw" 32-byte "referrer" value emitted onchain in
-     * association with the registrar action.
+     * Invariants:
+     * - NFT is indexed
+     * - previous and new NFT mint status is `burned`
+     * - previous and new NFT owner are zeroAddress
      */
-    encodedReferrer: EncodedReferrer;
+    readonly RemintBurn: "remint-burn";
     /**
-     * Decoded Referrer
+     * Special transfer type for improperly implemented NFT contracts that allow a NFT
+     * that is currently minted to be reminted again before an intermediate burn.
      *
-     * Decoded referrer according to the subjective interpretation of
-     * `encodedReferrer` defined for ENS Holiday Awards.
+     * Transfer from zeroAddress to zeroAddress for an indexed NFT where the
+     * previously indexed nft had status `minted` with a non-zeroAddress owner.
      *
-     * Identifies the interpreted address of the referrer.
-     * The "chainId" of this address is the same as is referenced in
-     * `subregistryId`.
+     * 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
      *
-     * May be the "zero address" to represent that an `encodedReferrer` is
-     * defined but that it is interpreted as no referrer.
+     * 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
      */
-    decodedReferrer: Address;
-}
+    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;
+
 /**
- * Referral information for performing a "logical registrar action" when
- * registrar controller does not implement referrals.
+ * An enum representing the possible Name Token Ownership types.
  */
-interface RegistrarActionReferralNotApplicable {
+declare const NameTokenOwnershipTypes: {
     /**
-     * Encoded Referrer
-     *
-     * Represents the "raw" 32-byte "referrer" value emitted onchain in
-     * association with the registrar action.
+     * Name Token is owned by NameWrapper account.
      */
-    encodedReferrer: null;
+    readonly NameWrapper: "namewrapper";
     /**
-     * Decoded Referrer
-     *
-     * Decoded referrer according to the subjective interpretation of
-     * `encodedReferrer` defined for ENS Holiday Awards.
+     * Name Token is owned fully onchain.
      *
+     * This ownership type can only apply to direct subnames of `.eth`
      */
-    decodedReferrer: null;
-}
-type RegistrarActionReferral = RegistrarActionReferralAvailable | RegistrarActionReferralNotApplicable;
-declare function isRegistrarActionReferralAvailable(registrarActionReferral: RegistrarActionReferral): registrarActionReferral is RegistrarActionReferralAvailable;
-/**
- * "Logical registrar action"
- *
- * Represents a state of "logical registrar action". May be built using data
- * from multiple events within the same "logical" registration / renewal action.
- */
-interface RegistrarAction {
+    readonly FullyOnchain: "fully-onchain";
     /**
-     * "Logical registrar action" ID
-     *
-     * The `id` value is a deterministic and globally unique identifier for
-     * the "logical registrar action".
-     *
-     * The `id` value represents the *initial* onchain event associated with
-     * the "logical registrar action", but the full state of
-     * the "logical registrar action" is an aggregate across each of
-     * the onchain events referenced in the `eventIds` field.
-     *
-     * Guaranteed to be the very first element in `eventIds` array.
+     * Name Token ownership has been transferred to the null address.
      */
-    id: RegistrarActionEventId;
+    readonly Burned: "burned";
     /**
-     * The type of the "logical registrar action".
+     * Name Token ownership is unknown.
      */
-    type: RegistrarActionType;
+    readonly Unknown: "unknown";
+};
+type NameTokenOwnershipType = (typeof NameTokenOwnershipTypes)[keyof typeof NameTokenOwnershipTypes];
+interface NameTokenOwnershipNameWrapper {
+    ownershipType: typeof NameTokenOwnershipTypes.NameWrapper;
     /**
+     * Owner
      *
-     * Incremental Duration
-     *
-     * If `type` is "registration":
-     *   - Represents the duration between `block.timestamp` and
-     *     the initial `registrationLifecycle.expiresAt` value that the associated
-     *     "registration lifecycle" will be initialized with.
-     * If `type` is "renewal":
-     *   - Represents the incremental increase in duration made to
-     *     the `registrationLifecycle.expiresAt` value in the associated
-     *     "registration lifecycle".
-     *
-     * A "registration lifecycle" may be extended via renewal even after it
-     * expires if it is still within its grace period.
-     *
-     * Consider the following scenario:
-     *
-     * The "registration lifecycle" of a direct subname of .eth is scheduled to
-     * expire on Jan 1, midnight UTC. It is currently 30 days after this
-     * expiration time. Therefore, there are currently another 60 days of grace
-     * period remaining for this name. Anyone can still make a renewal to
-     * extend the "registration lifecycle" of this name.
-     *
-     * Given this scenario, consider the following examples:
-     *
-     * 1. If a renewal is made with 10 days incremental duration,
-     *    the "registration lifecycle" for this name will remain in
-     *    an "expired" state, but it will now have another 70 days of
-     *    grace period remaining.
-     *
-     * 2. If a renewal is made with 50 days incremental duration,
-     *    the "registration lifecycle" for this name will no longer be
-     *    "expired" and will become "active", but the "registration lifecycle"
-     *    will now be scheduled to expire again in 20 days.
-     *
-     * After the "registration lifecycle" for a name becomes expired by more
-     * than its grace period, it can no longer be renewed by anyone and is
-     * considered "released". The name must first be registered again, starting
-     * a new "registration lifecycle" of
-     * active / expired / grace period / released.
-     *
-     * May be 0.
-     *
-     * Guaranteed to be a non-negative bigint value.
+     * 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.
      */
-    incrementalDuration: Duration;
+    owner: AccountId;
+}
+interface NameTokenOwnershipFullyOnchain {
+    ownershipType: typeof NameTokenOwnershipTypes.FullyOnchain;
     /**
-     * Registrant
-     *
-     * Identifies the address that initiated the "logical registrar action" and
-     * is paying the `pricing.total` cost (if applicable).
-     *
-     * It may not be the owner of the name:
-     * 1. When a name is registered, the initial owner of the name may be
-     *    distinct from the registrant.
-     * 2. There are no restrictions on who may renew a name.
-     *    Therefore the owner of the name may be distinct from the registrant.
+     * Owner
      *
-     * The "chainId" of this address is the same as is referenced in
-     * `registrationLifecycle.subregistry.subregistryId`.
-     */
-    registrant: Address;
-    /**
-     * Registration Lifecycle associated with this "logical registrar action".
+     * 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.
      */
-    registrationLifecycle: RegistrationLifecycle;
+    owner: AccountId;
+}
+interface NameTokenOwnershipBurned {
+    ownershipType: typeof NameTokenOwnershipTypes.Burned;
     /**
-     * Pricing information associated with this "logical registrar action".
+     * 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.
      */
-    pricing: RegistrarActionPricing;
+    owner: AccountId;
+}
+interface NameTokenOwnershipUnknown {
+    ownershipType: typeof NameTokenOwnershipTypes.Unknown;
     /**
-     * Referral information associated with this "logical registrar action".
+     * 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.
      */
-    referral: RegistrarActionReferral;
+    owner: AccountId;
+}
+type NameTokenOwnership = NameTokenOwnershipNameWrapper | NameTokenOwnershipFullyOnchain | NameTokenOwnershipBurned | NameTokenOwnershipUnknown;
+interface NameToken {
     /**
-     * Block ref
-     *
-     * References the block where the "logical registrar action" was executed.
+     * Token
      *
-     * The "chainId" of this block is the same as is referenced in
-     * `registrationLifecycle.subregistry.subregistryId`.
+     * References the NFT that currently or previously tokenized ownership of
+     * `name`.
      */
-    block: BlockRef;
+    token: AssetId;
     /**
-     * Transaction hash
-     *
-     * Transaction hash of the transaction associated with
-     * the "logical registrar action".
+     * Owner
      *
-     * The "chainId" of this transaction is the same as is referenced in
-     * `registrationLifecycle.subregistry.subregistryId`.
+     * Identifies the ownership state of the token.
      *
-     * Note that a single transaction may be associated with any number of
-     * "logical registrar actions".
+     * Guarantees:
+     * - The `ownership.owner.chainId` of this address is the same as is referenced
+     *   in `domainAsset.contract.chainId`.
      */
-    transactionHash: Hash;
+    ownership: NameTokenOwnership;
     /**
-     * Event IDs
+     * The mint status of the token.
      *
-     * Array of the eventIds that have contributed to the state of
-     * the "logical registrar action" record.
+     * 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.
      *
-     * Each eventId is a deterministic and globally unique onchain event
-     * identifier.
+     * 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:
-     * - Each eventId is of events that occurred within the block
-     *   referenced by `block.number`.
-     * - At least 1 eventId.
-     * - Ordered chronologically (ascending) by logIndex within `block.number`.
-     * - The first element in the array is equal to the `id` of
-     *   the overall "logical registrar action" record.
-     *
-     * The following ideas are not generalized for ENS overall but happen to
-     * be a characteristic of the scope of our current indexing logic:
-     * 1. These id's always reference events emitted by
-     *    a related "BaseRegistrar" contract.
-     * 2. These id's optionally reference events emitted by
-     *    a related "Registrar Controller" contract. This is because our
-     *    current indexing logic doesn't guarantee to index
-     *    all "Registrar Controller" contracts.
+     * - The `mintStatus` will be burned if and only
+     *   if `ownership.ownershipType` is `NameTokenOwnershipTypes.Burned`.
      */
-    eventIds: [RegistrarActionEventId, ...RegistrarActionEventId[]];
+    mintStatus: NFTMintStatus;
 }
 /**
- * Serialized representation of {@link RegistrarActionPricingUnknown}.
+ * Serialized representation of {@link NameToken}.
  */
-type SerializedRegistrarActionPricingUnknown = RegistrarActionPricingUnknown;
+interface SerializedNameToken extends Omit<NameToken, "token"> {
+    token: SerializedAssetId;
+}
+declare function serializeNameToken(nameToken: NameToken): SerializedNameToken;
 /**
- * Serialized representation of {@link RegistrarActionPricingAvailable}.
+ * Get all NameWrapper accounts within provided ENS Namespace.
+ *
+ * Guaranteed to return at least one account for ENSRoot Datasource.
  */
-interface SerializedRegistrarActionPricingAvailable {
-    baseCost: SerializedPriceEth;
-    premium: SerializedPriceEth;
-    total: SerializedPriceEth;
-}
+declare function getNameWrapperAccounts(namespaceId: ENSNamespaceId): [AccountId, ...AccountId[]];
 /**
- * Serialized representation of {@link RegistrarActionPricing}.
+ * Get name token ownership for provided owner account within selected ENS Namespace.
  */
-type SerializedRegistrarActionPricing = SerializedRegistrarActionPricingAvailable | SerializedRegistrarActionPricingUnknown;
+declare function getNameTokenOwnership(namespaceId: ENSNamespaceId, name: InterpretedName, owner: AccountId): NameTokenOwnership;
+
 /**
- * Serialized representation of {@link RegistrarAction}.
+ * Schema for {@link ErrorResponse}.
  */
-interface SerializedRegistrarAction extends Omit<RegistrarAction, "registrationLifecycle" | "pricing"> {
-    registrationLifecycle: SerializedRegistrationLifecycle;
-    pricing: SerializedRegistrarActionPricing;
-}
-declare function serializeRegistrarActionPricing(pricing: RegistrarActionPricing): SerializedRegistrarActionPricing;
-declare function serializeRegistrarAction(registrarAction: RegistrarAction): SerializedRegistrarAction;
+declare const ErrorResponseSchema: z$1.ZodObject<{
+    message: z$1.ZodString;
+    details: z$1.ZodOptional<z$1.ZodUnknown>;
+}, z$1.core.$strip>;
 
-declare const TheGraphCannotFallbackReasonSchema: z.ZodEnum<{
-    readonly NotSubgraphCompatible: "not-subgraph-compatible";
-    readonly NoApiKey: "no-api-key";
-    readonly NoSubgraphUrl: "no-subgraph-url";
-}>;
-declare const TheGraphFallbackSchema: z.ZodObject<{
-    canFallback: z.ZodBoolean;
-    reason: z.ZodNullable<z.ZodEnum<{
-        readonly NotSubgraphCompatible: "not-subgraph-compatible";
-        readonly NoApiKey: "no-api-key";
-        readonly NoSubgraphUrl: "no-subgraph-url";
-    }>>;
-}, z.core.$strict>;
 /**
- * Create a Zod schema for validating a serialized ENSApiPublicConfig.
- *
- * @param valueLabel - Optional label for the value being validated (used in error messages)
+ * API Error Response Type
  */
-declare function makeENSApiPublicConfigSchema(valueLabel?: string): z.ZodObject<{
-    version: z.ZodString;
-    theGraphFallback: z.ZodObject<{
-        canFallback: z.ZodBoolean;
-        reason: z.ZodNullable<z.ZodEnum<{
-            readonly NotSubgraphCompatible: "not-subgraph-compatible";
-            readonly NoApiKey: "no-api-key";
-            readonly NoSubgraphUrl: "no-subgraph-url";
-        }>>;
-    }, z.core.$strict>;
-    ensIndexerPublicConfig: z.ZodObject<{
-        labelSet: z.ZodObject<{
-            labelSetId: z.ZodString;
-            labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<unknown>, z.ZodInt>;
-        }, z.core.$strip>;
-        indexedChainIds: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>, z.ZodTransform<Set<number>, number[]>>;
-        isSubgraphCompatible: z.ZodBoolean;
-        namespace: z.ZodEnum<{
-            readonly Mainnet: "mainnet";
-            readonly Sepolia: "sepolia";
-            readonly Holesky: "holesky";
-            readonly EnsTestEnv: "ens-test-env";
-        }>;
-        plugins: z.ZodArray<z.ZodString>;
-        databaseSchemaName: z.ZodString;
-        versionInfo: z.ZodObject<{
-            nodejs: z.ZodString;
-            ponder: z.ZodString;
-            ensDb: z.ZodString;
-            ensIndexer: z.ZodString;
-            ensNormalize: z.ZodString;
-            ensRainbow: z.ZodString;
-            ensRainbowSchema: z.ZodInt;
-        }, z.core.$strict>;
-    }, z.core.$strip>;
-}, z.core.$strict>;
+type ErrorResponse = z$1.infer<typeof ErrorResponseSchema>;
 
-type TheGraphCannotFallbackReason = z.infer<typeof TheGraphCannotFallbackReasonSchema>;
-type TheGraphFallback = z.infer<typeof TheGraphFallbackSchema>;
 /**
- * Complete public configuration object for ENSApi.
- *
- * Contains ENSApi-specific configuration at the top level and
- * embeds the complete ENSIndexer public configuration.
+ * Deserialize a {@link ErrorResponse} object.
  */
-interface ENSApiPublicConfig {
+declare function deserializeErrorResponse(maybeErrorResponse: unknown): ErrorResponse;
+
+/**
+ * A status code for Name Tokens API responses.
+ */
+declare const NameTokensResponseCodes: {
     /**
-     * ENSApi service version
-     *
-     * @see https://ghcr.io/namehash/ensnode/ensapi
+     * Represents a response when Name Tokens API can respond with requested data.
      */
-    version: string;
+    readonly Ok: "ok";
     /**
-     * The Graph Fallback-related info.
+     * Represents a response when Name Tokens API could not respond with requested data.
      */
-    theGraphFallback: TheGraphFallback;
+    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: {
     /**
-     * Complete ENSIndexer public configuration
+     * Name tokens not indexed
      *
-     * Contains all ENSIndexer public configuration including
-     * namespace, plugins, version info, etc.
+     * Represents an error when tokens for the requested name are not indexed by
+     * the ENSNode instance's configuration.
      */
-    ensIndexerPublicConfig: ENSIndexerPublicConfig;
-}
-
-/**
- * Serialized representation of {@link ENSApiPublicConfig}
- */
-interface SerializedENSApiPublicConfig extends Omit<ENSApiPublicConfig, "ensIndexerPublicConfig"> {
+    readonly NameTokensNotIndexed: "name-tokens-not-indexed";
     /**
-     * Serialized representation of {@link ENSApiPublicConfig.ensIndexerPublicConfig}.
+     * Unsupported ENSIndexer Config
+     *
+     * Represents a prerequisites error when connected ENSIndexer config lacks
+     * params required to enable Name Tokens API.
      */
-    ensIndexerPublicConfig: SerializedENSIndexerPublicConfig;
-}
-
+    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";
+};
 /**
- * Deserialize a {@link ENSApiPublicConfig} object.
+ * The derived string union of possible {@link NameTokensResponseErrorCodes}.
  */
-declare function deserializeENSApiPublicConfig(maybeConfig: SerializedENSApiPublicConfig, valueLabel?: string): ENSApiPublicConfig;
-
+type NameTokensResponseErrorCode = (typeof NameTokensResponseErrorCodes)[keyof typeof NameTokensResponseErrorCodes];
 /**
- * Serialize a {@link ENSApiPublicConfig} object.
+ * Name Tokens for a name who's tokens are configured to
+ * be indexed by the ENSNode instance's configuration.
  */
-declare function serializeENSApiPublicConfig(config: ENSApiPublicConfig): SerializedENSApiPublicConfig;
-
-/**
- * The resolution status for an `Identity`.
- */
-declare const ResolutionStatusIds: {
+interface RegisteredNameTokens {
     /**
-     * Represents that the `Identity` is not resolved yet.
+     * Domain ID
      */
-    readonly Unresolved: "unresolved";
+    domainId: Node;
     /**
-     * Represents that resolution of the `Identity` resulted in a named identity.
+     * Name
+     *
+     * FQDN of the name associated with `domainId`.
+     *
+     * Guarantees:
+     * - `namehash(name)` is always `domainId`.
      */
-    readonly Named: "named";
+    name: InterpretedName;
     /**
-     * Represents that resolution of the `Identity` resulted in an unnamed identity.
-     */
-    readonly Unnamed: "unnamed";
+     * 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;
     /**
-     * Represents that attempted resolution of the `Identity` resulted in an error
-     * and therefore it is unknown if the `Identity` resolves to a named or unnamed identity.
+     * Name Tokens for the requested name.
      */
-    readonly Unknown: "unknown";
+    registeredNameTokens: RegisteredNameTokens;
 };
 /**
- * The derived string union of possible {@link ResolutionStatusIds}.
+ * Represents an error response when requested name was not indexed by ENSNode.
  */
-type ResolutionStatusId = (typeof ResolutionStatusIds)[keyof typeof ResolutionStatusIds];
+interface NameTokensResponseErrorNameTokensNotIndexed {
+    responseCode: typeof NameTokensResponseCodes.Error;
+    errorCode: typeof NameTokensResponseErrorCodes.NameTokensNotIndexed;
+    error: ErrorResponse;
+}
 /**
- * Represents an {@link Identity} that has not become a {@link ResolvedIdentity} yet.
- *
- * Invariants:
- * - `resolutionStatus` is always {@link ResolutionStatusIds.Unresolved}.
+ * Represents an error response when connected ENSIndexer config lacks
+ * params required to enable Name Tokens API.
  */
-interface UnresolvedIdentity {
-    resolutionStatus: typeof ResolutionStatusIds.Unresolved;
-    /**
-     * The {@link DefaultableChainId} for an ENSIP-19 primary name lookup of the
-     * identity associated with `address`.
-     */
-    chainId: DefaultableChainId;
-    /**
-     * The {@link Address} of the identity.
-     */
-    address: Address;
+interface NameTokensResponseErrorEnsIndexerConfigUnsupported {
+    responseCode: typeof NameTokensResponseCodes.Error;
+    errorCode: typeof NameTokensResponseErrorCodes.EnsIndexerConfigUnsupported;
+    error: ErrorResponse;
 }
 /**
- * Represents an `Identity` that resolved to a primary name.
- *
- * Invariants:
- * - `resolutionStatus` is always {@link ResolutionStatusIds.Named}.
+ * Represents an error response when Indexing Status has not yet reached
+ * status required to enable Name Tokens API.
  */
-interface NamedIdentity {
-    resolutionStatus: typeof ResolutionStatusIds.Named;
-    /**
-     * The {@link DefaultableChainId} for an ENSIP-19 primary name lookup of the
-     * identity associated with `address`.
-     */
-    chainId: DefaultableChainId;
-    /**
-     * The address of the identity.
-     */
-    address: Address;
-    /**
-     * The ENSIP-19 primary name lookup result of `address` on `chainId`.
-     */
-    name: Name;
+interface NameTokensResponseErrorIndexingStatusUnsupported {
+    responseCode: typeof NameTokensResponseCodes.Error;
+    errorCode: typeof NameTokensResponseErrorCodes.IndexingStatusUnsupported;
+    error: ErrorResponse;
 }
+type NameTokensResponseError = NameTokensResponseErrorNameTokensNotIndexed | NameTokensResponseErrorEnsIndexerConfigUnsupported | NameTokensResponseErrorIndexingStatusUnsupported;
 /**
- * Represents an `Identity` that did not resolve to a primary name.
+ * Name Tokens response.
  *
- * Invariants:
- * - `resolutionStatus` is always {@link ResolutionStatusIds.Unnamed}.
- * - `name` is always `null`.
+ * Use the `responseCode` field to determine the specific type interpretation
+ * at runtime.
  */
-interface UnnamedIdentity {
-    resolutionStatus: typeof ResolutionStatusIds.Unnamed;
-    /**
-     * The {@link DefaultableChainId} for an ENSIP-19 primary name lookup of the
-     * identity associated with `address`.
-     */
-    chainId: DefaultableChainId;
-    /**
-     * The address of the identity.
-     */
-    address: Address;
-    /**
-     * The ENSIP-19 primary name lookup result of `address` on `chainId`.
-     */
-    name: null;
+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[];
 }
 /**
- * Represents an `Identity` that was attempted to be resolved but the resolution attempt
- * resulted in an error and therefore it is unknown if the `Identity` resolves to a named
- * or unnamed identity.
- *
- * Invariants:
- * - `resolutionStatus` is always {@link ResolutionStatusIds.Unknown}.
+ * Serialized representation of {@link NameTokensResponseOk}.
  */
-interface UnknownIdentity {
-    resolutionStatus: typeof ResolutionStatusIds.Unknown;
-    /**
-     * The {@link DefaultableChainId} for an ENSIP-19 primary name lookup of the
-     * identity associated with `address`.
-     */
-    chainId: DefaultableChainId;
-    /**
-     * The address of the identity.
-     */
-    address: Address;
+interface SerializedNameTokensResponseOk extends Omit<NameTokensResponseOk, "registeredNameTokens"> {
+    registeredNameTokens: SerializedRegisteredNameTokens;
 }
 /**
- * Represents an ENSIP-19 identity resolution result.
+ * 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.
  *
- * Use the `resolutionStatus` field to determine the specific type interpretation
- * at runtime.
+ * @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.
  */
-type ResolvedIdentity = NamedIdentity | UnnamedIdentity | UnknownIdentity;
+declare function getBasenamesSubregistryId(namespace: ENSNamespaceId): AccountId;
 /**
- * Represents an ENSIP-19 identity resolution (which may or not have been
- * resolved to a result yet).
+ * Get the managed name for the Basenames subregistry for the selected ENS namespace.
  *
- * Use the `resolutionStatus` field to determine the specific type interpretation
- * at runtime.
+ * @param namespaceId
+ * @returns registrar managed name
+ * @throws an error when no registrar managed name could be returned
  */
-type Identity = UnresolvedIdentity | ResolvedIdentity;
+declare function getBasenamesSubregistryManagedName(namespaceId: ENSNamespaceId): Name;
 
 /**
- * Builds an {@link UnresolvedIdentity} for the provided {@link Address},
- * {@link DefaultableChainId} and {@link ENSNamespaceId}.
+ * Gets the SubregistryId (an AccountId) of the Ethnames Subregistry contract (this is the
+ * "BaseRegistrar" contract for direct subnames of .eth) for the provided namespace.
  *
- * If no `chainId` is provided, uses the ENS Root Chain Id for the provided
- * `namespaceId`.
+ * @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 buildUnresolvedIdentity(address: Address, namespaceId: ENSNamespaceId, chainId?: DefaultableChainId): UnresolvedIdentity;
+declare function getEthnamesSubregistryId(namespace: ENSNamespaceId): AccountId;
 /**
- * Returns whether the provided {@link Identity} is a {@link ResolvedIdentity}.
+ * Get the managed name for the Ethnames subregistry for the selected ENS namespace.
  *
- * @param identity - The {@link Identity} to check.
- * @returns Whether the provided {@link Identity} is a {@link ResolvedIdentity}.
+ * @param namespaceId
+ * @returns registrar managed name
  */
-declare function isResolvedIdentity(identity: Identity): identity is ResolvedIdentity;
+declare function getEthnamesSubregistryManagedName(namespaceId: ENSNamespaceId): Name;
 
 /**
- * Gets the "chainId param" that should be used for a primary name resolution
- * request.
- *
- * ENSIP-19 defines special rules for the "chainId param" used
- * in primary name resolutions for the case that the `chainId` is the
- * ENS Root Chain Id for the provided `namespaceId`.
- *
- * Whenever this case happens, ENSIP-19 requires that the
- * "chainId param" is always set to chainId: 1 (mainnet), even if the
- * `chainId` where the primary name lookup is actually happening
- * on a non-mainnet ENS Root Chain, such as on a testnet or
- * the ens-test-env.
+ * Gets the SubregistryId (an AccountId) of the Lineanames Subregistry contract (this is the
+ * "BaseRegistrar" contract for Lineanames) for the provided namespace.
  *
- * @param namespaceId The namespace id for the primary name lookup.
- * @param chainId The chain id where the primary name lookup will actually happen.
- * @returns The "chainId param" that should be used for the primary name lookup.
+ * @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 const getResolvePrimaryNameChainIdParam: (chainId: DefaultableChainId, namespaceId: ENSNamespaceId) => DefaultableChainId;
+declare function getLineanamesSubregistryId(namespace: ENSNamespaceId): AccountId;
 /**
- * Translates a `DefaultableChainId` a `ChainId`
- * such that if the provided `chainId` is `DEFAULT_EVM_CHAIN_ID`,
- * the `ChainId` of the ENS Root Chain for the provided `namespaceId` is returned.
+ * Get the managed name for the Lineanames subregistry for the selected ENS namespace.
  *
- * @param chainId The `DefaultableChainId` to translate.
- * @param namespaceId The namespace id for the translation.
- * @returns the translated `ChainId`.
+ * @param namespaceId
+ * @returns registrar managed name
+ * @throws an error when no registrar managed name could be returned
  */
-declare const translateDefaultableChainIdToChainId: (chainId: DefaultableChainId, namespaceId: ENSNamespaceId) => ChainId;
+declare function getLineanamesSubregistryManagedName(namespaceId: ENSNamespaceId): Name;
 
 /**
- * Encodes a selection of Resolver records in the context of a specific Name.
+ * Subregistry
  */
-interface ResolverRecordsSelection {
+interface Subregistry {
     /**
-     * Whether to fetch the name's `name` record. This value is primarily used in the context of
-     * Reverse Resolution.
+     * Subregistry ID
      *
-     * @see https://docs.ens.domains/ensip/19/#reverse-resolution
-     */
-    name?: boolean;
-    /**
-     * Which coinTypes to fetch address records for.
+     * The ID of the subregistry the "logical registrar action" was taken on.
+     *
+     * Identifies the chainId and address of the associated subregistry smart
+     * contract.
      */
-    addresses?: CoinType[];
+    subregistryId: AccountId;
     /**
-     * Which keys to fetch text records for.
+     * The node (namehash) of the name the subregistry manages subnames of.
+     * Example subregistry managed names:
+     * - `eth`
+     * - `base.eth`
+     * - `linea.eth`
      */
-    texts?: string[];
+    node: Node;
 }
-declare const isSelectionEmpty: (selection: ResolverRecordsSelection) => boolean;
 
 /**
- * An internal type representing a non-inferred ResolverRecordsResponse, used in situations where
- * access to the more specific inferred type (ResolverRecordsResponse<SELECTION>) is difficult or
- * unnecessary.
+ * 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.
  */
-type ResolverRecordsResponseBase = {
+declare const RegistrationLifecycleStages: {
     /**
-     * The name record, relevant in the context of Reverse Resolution.
-     * Null if no name record is set.
+     * Active
+     *
+     * Happens when
+     * the current timestamp <= expiry.
      */
-    name: Name | null;
+    readonly Active: "registrationLifecycle_active";
     /**
-     * Address records, keyed by CoinType.
-     * Value is null if no record for the specified CoinType is set.
+     * Grace Period
      *
-     * NOTE: ENS resolver address records can store arbitrary string values,
-     * including non-EVM addresses — always validate the record value against
-     * the format your application expects.
+     * Happens when
+     * `expiry < the current timestamp <= expiry + 90 days`.
      */
-    addresses: Record<CoinType, string | null>;
+    readonly GracePeriod: "registrationLifecycle_gracePeriod";
     /**
-     * Text records, keyed by key.
-     * Value is null if no record for the specified key is set.
+     * Released with Temporary Premium Price
+     *
+     * Happens when
+     * `expiry + 90 days < the current timestamp <= expiry + 120 days`.
      */
-    texts: Record<string, string | null>;
+    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];
 /**
- * Represents the strongly-typed set of records based on the provided SELECTION
- *
- * @example
- * ```typescript
- * const selection = {
- *   name: true,
- *   addresses: [60],
- *   texts: ["com.twitter", "avatar"],
- * } as const satisfies ResolverRecordsSelection;
- *
- * type Response = ResolverRecordsResponse<typeof selection>;
- *
- * // results in the following type
- * type Response = {
- *   readonly name: Name | null;
- *   readonly addresses: Record<"60", string | null>;
- *   readonly texts: Record<"avatar" | "com.twitter", string | null>;
- * }
- * ```
+ * Registration Lifecycle
  */
-type ResolverRecordsResponse<T extends ResolverRecordsSelection = ResolverRecordsSelection> = {
-    [K in keyof T as T[K] extends true | any[] ? K : never]: K extends "addresses" ? Record<`${T["addresses"] extends readonly CoinType[] ? T["addresses"][number] : never}`, string | null> : K extends "texts" ? Record<T["texts"] extends readonly string[] ? T["texts"][number] : never, string | null> : ResolverRecordsResponseBase[K & keyof ResolverRecordsResponseBase];
-};
+interface RegistrationLifecycle {
+    /**
+     * Subregistry that manages this Registration Lifecycle.
+     */
+    subregistry: Subregistry;
+    /**
+     * The node (namehash) of the FQDN of the domain the registration lifecycle
+     * is associated with.
+     *
+     * Guaranteed to be a subname of the node (namehash) of the subregistry
+     * identified by `subregistryId.subregistryId`.
+     */
+    node: Node;
+    /**
+     * Expires at
+     *
+     * Identifies when the Registration Lifecycle is scheduled to expire.
+     */
+    expiresAt: UnixTimestamp;
+}
+
+/**
+ * Globally unique, deterministic ID of an indexed onchain event
+ * associated with the "logical registrar action".
+ */
+type RegistrarActionEventId = string;
+/**
+ * Types of "logical registrar action".
+ */
+declare const RegistrarActionTypes: {
+    readonly Registration: "registration";
+    readonly Renewal: "renewal";
+};
+type RegistrarActionType = (typeof RegistrarActionTypes)[keyof typeof RegistrarActionTypes];
+/**
+ * Pricing information for a "logical registrar action".
+ */
+interface RegistrarActionPricingAvailable {
+    /**
+     * Base cost
+     *
+     * Base cost (before any `premium`) of Ether measured in units of Wei
+     * paid to execute the "logical registrar action".
+     *
+     * May be 0.
+     */
+    baseCost: PriceEth;
+    /**
+     * Premium
+     *
+     * "premium" cost (in excesses of the `baseCost`) of Ether measured in
+     * units of Wei paid to execute the "logical registrar action".
+     *
+     * May be 0.
+     */
+    premium: PriceEth;
+    /**
+     * Total
+     *
+     * Total cost of Ether measured in units of Wei paid to execute
+     * the "logical registrar action".
+     *
+     * May be 0.
+     */
+    total: PriceEth;
+}
+/**
+ * Pricing information for a "logical registrar action" when
+ * there is no known pricing data.
+ */
+interface RegistrarActionPricingUnknown {
+    /**
+     * Base cost
+     *
+     * Base cost (before any `premium`) of Ether measured in units of Wei
+     * paid to execute the "logical registrar action".
+     */
+    baseCost: null;
+    /**
+     * Premium
+     *
+     * "premium" cost (in excesses of the `baseCost`) of Ether measured in
+     * units of Wei paid to execute the "logical registrar action".
+     */
+    premium: null;
+    /**
+     * Total
+     *
+     * Total cost of Ether measured in units of Wei paid to execute
+     * the "logical registrar action".
+     */
+    total: null;
+}
+type RegistrarActionPricing = RegistrarActionPricingAvailable | RegistrarActionPricingUnknown;
+declare function isRegistrarActionPricingAvailable(registrarActionPricing: RegistrarActionPricing): registrarActionPricing is RegistrarActionPricingAvailable;
+/**
+ * * Referral information for performing a "logical registrar action".
+ */
+interface RegistrarActionReferralAvailable {
+    /**
+     * Encoded Referrer
+     *
+     * Represents the "raw" 32-byte "referrer" value emitted onchain in
+     * association with the registrar action.
+     */
+    encodedReferrer: EncodedReferrer;
+    /**
+     * Decoded Referrer
+     *
+     * Decoded referrer according to the subjective interpretation of
+     * `encodedReferrer` defined for ENS Holiday Awards.
+     *
+     * Identifies the interpreted address of the referrer.
+     * The "chainId" of this address is the same as is referenced in
+     * `subregistryId`.
+     *
+     * May be the "zero address" to represent that an `encodedReferrer` is
+     * defined but that it is interpreted as no referrer.
+     */
+    decodedReferrer: Address;
+}
+/**
+ * Referral information for performing a "logical registrar action" when
+ * registrar controller does not implement referrals.
+ */
+interface RegistrarActionReferralNotApplicable {
+    /**
+     * Encoded Referrer
+     *
+     * Represents the "raw" 32-byte "referrer" value emitted onchain in
+     * association with the registrar action.
+     */
+    encodedReferrer: null;
+    /**
+     * Decoded Referrer
+     *
+     * Decoded referrer according to the subjective interpretation of
+     * `encodedReferrer` defined for ENS Holiday Awards.
+     *
+     */
+    decodedReferrer: null;
+}
+type RegistrarActionReferral = RegistrarActionReferralAvailable | RegistrarActionReferralNotApplicable;
+declare function isRegistrarActionReferralAvailable(registrarActionReferral: RegistrarActionReferral): registrarActionReferral is RegistrarActionReferralAvailable;
+/**
+ * "Logical registrar action"
+ *
+ * Represents a state of "logical registrar action". May be built using data
+ * from multiple events within the same "logical" registration / renewal action.
+ */
+interface RegistrarAction {
+    /**
+     * "Logical registrar action" ID
+     *
+     * The `id` value is a deterministic and globally unique identifier for
+     * the "logical registrar action".
+     *
+     * The `id` value represents the *initial* onchain event associated with
+     * the "logical registrar action", but the full state of
+     * the "logical registrar action" is an aggregate across each of
+     * the onchain events referenced in the `eventIds` field.
+     *
+     * Guaranteed to be the very first element in `eventIds` array.
+     */
+    id: RegistrarActionEventId;
+    /**
+     * The type of the "logical registrar action".
+     */
+    type: RegistrarActionType;
+    /**
+     *
+     * Incremental Duration
+     *
+     * If `type` is "registration":
+     *   - Represents the duration between `block.timestamp` and
+     *     the initial `registrationLifecycle.expiresAt` value that the associated
+     *     "registration lifecycle" will be initialized with.
+     * If `type` is "renewal":
+     *   - Represents the incremental increase in duration made to
+     *     the `registrationLifecycle.expiresAt` value in the associated
+     *     "registration lifecycle".
+     *
+     * A "registration lifecycle" may be extended via renewal even after it
+     * expires if it is still within its grace period.
+     *
+     * Consider the following scenario:
+     *
+     * The "registration lifecycle" of a direct subname of .eth is scheduled to
+     * expire on Jan 1, midnight UTC. It is currently 30 days after this
+     * expiration time. Therefore, there are currently another 60 days of grace
+     * period remaining for this name. Anyone can still make a renewal to
+     * extend the "registration lifecycle" of this name.
+     *
+     * Given this scenario, consider the following examples:
+     *
+     * 1. If a renewal is made with 10 days incremental duration,
+     *    the "registration lifecycle" for this name will remain in
+     *    an "expired" state, but it will now have another 70 days of
+     *    grace period remaining.
+     *
+     * 2. If a renewal is made with 50 days incremental duration,
+     *    the "registration lifecycle" for this name will no longer be
+     *    "expired" and will become "active", but the "registration lifecycle"
+     *    will now be scheduled to expire again in 20 days.
+     *
+     * After the "registration lifecycle" for a name becomes expired by more
+     * than its grace period, it can no longer be renewed by anyone and is
+     * considered "released". The name must first be registered again, starting
+     * a new "registration lifecycle" of
+     * active / expired / grace period / released.
+     *
+     * May be 0.
+     *
+     * Guaranteed to be a non-negative bigint value.
+     */
+    incrementalDuration: Duration;
+    /**
+     * Registrant
+     *
+     * Identifies the address that initiated the "logical registrar action" and
+     * is paying the `pricing.total` cost (if applicable).
+     *
+     * It may not be the owner of the name:
+     * 1. When a name is registered, the initial owner of the name may be
+     *    distinct from the registrant.
+     * 2. There are no restrictions on who may renew a name.
+     *    Therefore the owner of the name may be distinct from the registrant.
+     *
+     * The "chainId" of this address is the same as is referenced in
+     * `registrationLifecycle.subregistry.subregistryId`.
+     */
+    registrant: Address;
+    /**
+     * Registration Lifecycle associated with this "logical registrar action".
+     */
+    registrationLifecycle: RegistrationLifecycle;
+    /**
+     * Pricing information associated with this "logical registrar action".
+     */
+    pricing: RegistrarActionPricing;
+    /**
+     * Referral information associated with this "logical registrar action".
+     */
+    referral: RegistrarActionReferral;
+    /**
+     * Block ref
+     *
+     * References the block where the "logical registrar action" was executed.
+     *
+     * The "chainId" of this block is the same as is referenced in
+     * `registrationLifecycle.subregistry.subregistryId`.
+     */
+    block: BlockRef;
+    /**
+     * Transaction hash
+     *
+     * Transaction hash of the transaction associated with
+     * the "logical registrar action".
+     *
+     * The "chainId" of this transaction is the same as is referenced in
+     * `registrationLifecycle.subregistry.subregistryId`.
+     *
+     * Note that a single transaction may be associated with any number of
+     * "logical registrar actions".
+     */
+    transactionHash: Hash;
+    /**
+     * Event IDs
+     *
+     * Array of the eventIds that have contributed to the state of
+     * the "logical registrar action" record.
+     *
+     * Each eventId is a deterministic and globally unique onchain event
+     * identifier.
+     *
+     * Guarantees:
+     * - Each eventId is of events that occurred within the block
+     *   referenced by `block.number`.
+     * - At least 1 eventId.
+     * - Ordered chronologically (ascending) by logIndex within `block.number`.
+     * - The first element in the array is equal to the `id` of
+     *   the overall "logical registrar action" record.
+     *
+     * The following ideas are not generalized for ENS overall but happen to
+     * be a characteristic of the scope of our current indexing logic:
+     * 1. These id's always reference events emitted by
+     *    a related "BaseRegistrar" contract.
+     * 2. These id's optionally reference events emitted by
+     *    a related "Registrar Controller" contract. This is because our
+     *    current indexing logic doesn't guarantee to index
+     *    all "Registrar Controller" contracts.
+     */
+    eventIds: [RegistrarActionEventId, ...RegistrarActionEventId[]];
+}
+/**
+ * Serialized representation of {@link RegistrarActionPricingUnknown}.
+ */
+type SerializedRegistrarActionPricingUnknown = RegistrarActionPricingUnknown;
+/**
+ * Serialized representation of {@link RegistrarActionPricingAvailable}.
+ */
+interface SerializedRegistrarActionPricingAvailable {
+    baseCost: SerializedPriceEth;
+    premium: SerializedPriceEth;
+    total: SerializedPriceEth;
+}
+/**
+ * Serialized representation of {@link RegistrarActionPricing}.
+ */
+type SerializedRegistrarActionPricing = SerializedRegistrarActionPricingAvailable | SerializedRegistrarActionPricingUnknown;
+/**
+ * Serialized representation of {@link RegistrarAction}.
+ */
+interface SerializedRegistrarAction extends Omit<RegistrarAction, "pricing"> {
+    pricing: SerializedRegistrarActionPricing;
+}
+declare function serializeRegistrarActionPricing(pricing: RegistrarActionPricing): SerializedRegistrarActionPricing;
+declare function serializeRegistrarAction(registrarAction: RegistrarAction): SerializedRegistrarAction;
+
+declare const RECORDS_PER_PAGE_DEFAULT = 10;
+declare const RECORDS_PER_PAGE_MAX = 100;
+/**
+ * Request page params.
+ */
+interface RequestPageParams {
+    /**
+     * Requested page number (1-indexed)
+     * @invariant Must be a positive integer (>= 1)
+     * @default 1
+     */
+    page?: number;
+    /**
+     * Maximum number of records to return per page
+     * @invariant Must be a positive integer (>= 1) and less than or equal to {@link RECORDS_PER_PAGE_MAX}
+     * @default {@link RECORDS_PER_PAGE_DEFAULT}
+     */
+    recordsPerPage?: number;
+}
+
+interface ResponsePageContextWithNoRecords extends Required<RequestPageParams> {
+    /**
+     * Total number of records across all pages
+     */
+    totalRecords: 0;
+    /**
+     * Total number of pages
+     */
+    totalPages: 1;
+    /**
+     * Indicates if there is a next page available
+     */
+    hasNext: false;
+    /**
+     * Indicates if there is a previous page available
+     */
+    hasPrev: false;
+    /**
+     * The start index of the records on the page (0-indexed)
+     */
+    startIndex: undefined;
+    /**
+     * The end index of the records on the page (0-indexed)
+     */
+    endIndex: undefined;
+}
+interface ResponsePageContextWithRecords extends Required<RequestPageParams> {
+    /**
+     * Total number of records across all pages
+     * @invariant Guaranteed to be a positive integer (>= 1)
+     */
+    totalRecords: number;
+    /**
+     * Total number of pages
+     * @invariant Guaranteed to be a positive integer (>= 1)
+     */
+    totalPages: number;
+    /**
+     * Indicates if there is a next page available
+     * @invariant true if and only if (`page` * `recordsPerPage` < `totalRecords`)
+     */
+    hasNext: boolean;
+    /**
+     * Indicates if there is a previous page available
+     * @invariant true if and only if (`page` > 1)
+     */
+    hasPrev: boolean;
+    /**
+     * The start index of the records on the page (0-indexed)
+     *
+     * @invariant Guaranteed to be a non-negative integer (>= 0)
+     */
+    startIndex: number;
+    /**
+     * The end index of the records on the page (0-indexed)
+     *
+     * @invariant Guaranteed to be a non-negative integer (>= 0)
+     * @invariant Guaranteed to be greater than or equal to `startIndex`.
+     * @invariant Guaranteed to be less than `totalRecords`.
+     */
+    endIndex: number;
+}
+type ResponsePageContext = ResponsePageContextWithNoRecords | ResponsePageContextWithRecords;
+
+/**
+ * Build page context from request params and total records count.
+ */
+declare function buildPageContext(page: number, recordsPerPage: number, totalRecords: number): ResponsePageContext;
+
+/**
+ * A status code for Registrar Actions API responses.
+ */
+declare const RegistrarActionsResponseCodes: {
+    /**
+     * Represents that Registrar Actions are available.
+     */
+    readonly Ok: "ok";
+    /**
+     * Represents that Registrar Actions are unavailable.
+     */
+    readonly Error: "error";
+};
+/**
+ * The derived string union of possible {@link RegistrarActionsResponseCodes}.
+ */
+type RegistrarActionsResponseCode = (typeof RegistrarActionsResponseCodes)[keyof typeof RegistrarActionsResponseCodes];
+/**
+ * "Logical registrar action" with its associated name.
+ */
+interface NamedRegistrarAction {
+    action: RegistrarAction;
+    /**
+     * Name
+     *
+     * FQDN of the name associated with `action`.
+     *
+     * Guarantees:
+     * - `namehash(name)` is always `action.registrationLifecycle.node`.
+     */
+    name: InterpretedName;
+}
+/**
+ * A response when Registrar Actions are available.
+ */
+type RegistrarActionsResponseOk = {
+    responseCode: typeof RegistrarActionsResponseCodes.Ok;
+    registrarActions: NamedRegistrarAction[];
+    pageContext: ResponsePageContext;
+};
+/**
+ * A response when Registrar Actions are unavailable.
+ */
+interface RegistrarActionsResponseError {
+    responseCode: typeof IndexingStatusResponseCodes.Error;
+    error: ErrorResponse;
+}
+/**
+ * Registrar Actions response.
+ *
+ * Use the `responseCode` field to determine the specific type interpretation
+ * at runtime.
+ */
+type RegistrarActionsResponse = RegistrarActionsResponseOk | RegistrarActionsResponseError;
 
 /**
- * Arguments required to perform Forward Resolution
+ * Serialized representation of {@link RegistrarActionsResponseError}.
+ */
+type SerializedRegistrarActionsResponseError = RegistrarActionsResponseError;
+/**
+ * Serialized representation of {@link NamedRegistrarAction}.
+ */
+interface SerializedNamedRegistrarAction extends Omit<NamedRegistrarAction, "action"> {
+    action: SerializedRegistrarAction;
+}
+/**
+ * Serialized representation of {@link RegistrarActionsResponseOk}.
  */
-interface ForwardResolutionArgs<SELECTION extends ResolverRecordsSelection> {
-    name: Name;
-    selection: SELECTION;
+interface SerializedRegistrarActionsResponseOk extends Omit<RegistrarActionsResponseOk, "registrarActions"> {
+    registrarActions: SerializedNamedRegistrarAction[];
 }
 /**
- * The result of performing ForwardResolution
+ * Serialized representation of {@link SerializedRegistrarActionsResponse}.
  */
-type ForwardResolutionResult<SELECTION extends ResolverRecordsSelection> = ResolverRecordsResponse<SELECTION>;
+type SerializedRegistrarActionsResponse = SerializedRegistrarActionsResponseOk | SerializedRegistrarActionsResponseError;
+
 /**
- * Arguments required to perform Reverse Resolution
+ * Deserialize a {@link RegistrarActionsResponse} object.
  */
-interface ReverseResolutionArgs {
-    address: Address;
-    chainId: ChainId;
-}
+declare function deserializeRegistrarActionsResponse(maybeResponse: SerializedRegistrarActionsResponse): RegistrarActionsResponse;
+
 /**
- * The result of performing ReverseResolution
+ * Records Filters: Filter Types
  */
-type ReverseResolutionResult = Name | null;
+declare const RegistrarActionsFilterTypes: {
+    readonly BySubregistryNode: "bySubregistryNode";
+    readonly WithEncodedReferral: "withEncodedReferral";
+    readonly ByDecodedReferrer: "byDecodedReferrer";
+};
+type RegistrarActionsFilterType = (typeof RegistrarActionsFilterTypes)[keyof typeof RegistrarActionsFilterTypes];
+type RegistrarActionsFilterBySubregistryNode = {
+    filterType: typeof RegistrarActionsFilterTypes.BySubregistryNode;
+    value: Node;
+};
+type RegistrarActionsFilterWithEncodedReferral = {
+    filterType: typeof RegistrarActionsFilterTypes.WithEncodedReferral;
+};
+type RegistrarActionsFilterByDecodedReferrer = {
+    filterType: typeof RegistrarActionsFilterTypes.ByDecodedReferrer;
+    value: Address;
+};
+type RegistrarActionsFilter = RegistrarActionsFilterBySubregistryNode | RegistrarActionsFilterWithEncodedReferral | RegistrarActionsFilterByDecodedReferrer;
 /**
- * Arguments required to perform Multichain Primary Name Resolution
+ * Records Orders
  */
-interface MultichainPrimaryNameResolutionArgs {
-    address: Address;
-    chainIds?: ChainId[];
-}
+declare const RegistrarActionsOrders: {
+    readonly LatestRegistrarActions: "orderBy[timestamp]=desc";
+};
+type RegistrarActionsOrder = (typeof RegistrarActionsOrders)[keyof typeof RegistrarActionsOrders];
 /**
- * The result of performing MultichainPrimaryNameResolution
+ * Represents a request to Registrar Actions API.
  */
-type MultichainPrimaryNameResolutionResult = Record<ChainId, Name | null>;
+interface RegistrarActionsRequest extends RequestPageParams {
+    /**
+     * Filters to be applied while generating results.
+     */
+    filters?: RegistrarActionsFilter[];
+    /**
+     * Order applied while generating results.
+     */
+    order?: RegistrarActionsOrder;
+}
 
 /**
- * Identifiers for each traceable ENS protocol.
+ * Build a "parent node" filter object for Registrar Actions query.
  */
-declare enum TraceableENSProtocol {
-    ForwardResolution = "forward-resolution",
-    ReverseResolution = "reverse-resolution"
-}
+declare function byParentNode(parentNode: Node): RegistrarActionsFilter;
+declare function byParentNode(parentNode: undefined): undefined;
 /**
- * Encodes the set of well-known steps in the ENS Forward Resolution protocol.
+ * Build a "with referral" filter object for Registrar Actions query.
  */
-declare enum ForwardResolutionProtocolStep {
-    Operation = "forward-resolution",
-    FindResolver = "find-resolver",
-    ActiveResolverExists = "active-resolver-exists",
-    AccelerateENSIP19ReverseResolver = "accelerate-ensip-19-reverse-resolver",
-    AccelerateKnownOffchainLookupResolver = "accelerate-known-offchain-lookup-resolver",
-    AccelerateKnownOnchainStaticResolver = "accelerate-known-onchain-static-resolver",
-    RequireResolver = "require-resolver",
-    ExecuteResolveCalls = "execute-resolve-calls"
-}
+declare function withReferral(withReferral: true): RegistrarActionsFilter;
+declare function withReferral(withReferral: false | undefined): undefined;
 /**
- * Encodes the set of well-known steps in the ENS Reverse Resolution protocol.
+ * Build a "decoded referrer" filter object for Registrar Actions query.
  */
-declare enum ReverseResolutionProtocolStep {
-    Operation = "reverse-resolution",
-    ResolveReverseName = "resolve-reverse-name",
-    NameRecordExists = "name-record-exists-check",
-    ForwardResolveAddressRecord = "forward-resolve-address-record",
-    VerifyResolvedAddressMatchesAddress = "verify-resolved-address-matches-address"
-}
-declare const PROTOCOL_ATTRIBUTE_PREFIX = "ens";
-declare const ATTR_PROTOCOL_NAME = "ens.protocol";
-declare const ATTR_PROTOCOL_STEP = "ens.protocol.step";
-declare const ATTR_PROTOCOL_STEP_RESULT = "ens.protocol.step.result";
-interface SpanAttributes {
-    [key: string]: unknown;
-}
-interface SpanEvent {
-    name: string;
-    attributes: SpanAttributes;
-    time: number;
-}
-interface ProtocolSpan {
-    scope: string;
-    id: string;
-    traceId: string;
-    parentSpanContext: {
-        traceId: string;
-        spanId: string;
-    } | undefined;
-    name: string;
-    timestamp: number;
-    duration: number;
-    attributes: SpanAttributes;
-    status: {
-        code: number;
-        message?: string;
-    };
-    events: SpanEvent[];
-}
-type ProtocolSpanTreeNode = ProtocolSpan & {
-    children: ProtocolSpanTreeNode[];
+declare function byDecodedReferrer(decodedReferrer: Address): RegistrarActionsFilter;
+declare function byDecodedReferrer(decodedReferrer: undefined): undefined;
+declare const registrarActionsFilter: {
+    byParentNode: typeof byParentNode;
+    withReferral: typeof withReferral;
+    byDecodedReferrer: typeof byDecodedReferrer;
 };
-type ProtocolTrace = ProtocolSpanTreeNode[];
 
-declare const ErrorResponseSchema: z$1.ZodObject<{
-    message: z$1.ZodString;
-    details: z$1.ZodOptional<z$1.ZodUnknown>;
-}, z$1.core.$strip>;
+declare const registrarActionsPrerequisites: Readonly<{
+    /**
+     * Required plugins to enable Registrar Actions API routes.
+     *
+     * 1. `registrars` plugin is required so that data in the `registrarActions`
+     *    table is populated.
+     * 2. `subgraph`, `basenames`, and `lineanames` are required to get the data
+     *    for the name associated with each registrar action.
+     * 3. In theory not all of `subgraph`, `basenames`, and `lineanames` plugins
+     *    might be required. Ex: At least one, but the current logic in
+     *    the `registrars` plugin always indexes registrar actions across
+     *    Ethnames (subgraph), Basenames, and Lineanames and therefore we need to
+     *    ensure each value in the registrar actions table has
+     *    an associated record in the domains table.
+     */
+    requiredPlugins: readonly [PluginName.Subgraph, PluginName.Basenames, PluginName.Lineanames, PluginName.Registrars];
+    /**
+     * Check if provided ENSApiPublicConfig supports the Registrar Actions API.
+     */
+    hasEnsIndexerConfigSupport(config: ENSIndexerPublicConfig): boolean;
+    /**
+     * Required Indexing Status IDs
+     *
+     * Database indexes are created by the time the omnichain indexing status
+     * is either `completed` or `following`.
+     */
+    supportedIndexingStatusIds: ("omnichain-following" | "omnichain-completed")[];
+    /**
+     * Check if provided indexing status supports the Registrar Actions API.
+     */
+    hasIndexingStatusSupport(omnichainIndexingStatusId: OmnichainIndexingStatusId): boolean;
+}>;
+
+declare function serializeNamedRegistrarAction({ action, name, }: NamedRegistrarAction): SerializedNamedRegistrarAction;
+declare function serializeRegistrarActionsResponse(response: RegistrarActionsResponse): SerializedRegistrarActionsResponse;
 
 /**
- * API Error Response Type
- */
-type ErrorResponse = z$1.infer<typeof ErrorResponseSchema>;
-interface TraceableRequest {
-    trace?: boolean;
-}
-interface TraceableResponse {
-    trace?: ProtocolTrace;
-}
-interface AcceleratableRequest {
-    accelerate?: boolean;
-}
-interface AcceleratableResponse {
-    accelerationRequested: boolean;
-    accelerationAttempted: boolean;
-}
-/**
- * Resolve Records Request Type
+ * The resolution status for an `Identity`.
  */
-interface ResolveRecordsRequest<SELECTION extends ResolverRecordsSelection> extends ForwardResolutionArgs<SELECTION>, AcceleratableRequest, TraceableRequest {
-}
+declare const ResolutionStatusIds: {
+    /**
+     * Represents that the `Identity` is not resolved yet.
+     */
+    readonly Unresolved: "unresolved";
+    /**
+     * Represents that resolution of the `Identity` resulted in a named identity.
+     */
+    readonly Named: "named";
+    /**
+     * Represents that resolution of the `Identity` resulted in an unnamed identity.
+     */
+    readonly Unnamed: "unnamed";
+    /**
+     * Represents that attempted resolution of the `Identity` resulted in an error
+     * and therefore it is unknown if the `Identity` resolves to a named or unnamed identity.
+     */
+    readonly Unknown: "unknown";
+};
 /**
- * Resolve Records Response Type
+ * The derived string union of possible {@link ResolutionStatusIds}.
  */
-interface ResolveRecordsResponse<SELECTION extends ResolverRecordsSelection> extends AcceleratableResponse, TraceableResponse {
-    records: ResolverRecordsResponse<SELECTION>;
-}
+type ResolutionStatusId = (typeof ResolutionStatusIds)[keyof typeof ResolutionStatusIds];
 /**
- * Resolve Primary Name Request Type
+ * Represents an {@link Identity} that has not become a {@link ResolvedIdentity} yet.
+ *
+ * Invariants:
+ * - `resolutionStatus` is always {@link ResolutionStatusIds.Unresolved}.
  */
-interface ResolvePrimaryNameRequest extends ReverseResolutionArgs, AcceleratableRequest, TraceableRequest {
+interface UnresolvedIdentity {
+    resolutionStatus: typeof ResolutionStatusIds.Unresolved;
+    /**
+     * The {@link DefaultableChainId} for an ENSIP-19 primary name lookup of the
+     * identity associated with `address`.
+     */
+    chainId: DefaultableChainId;
+    /**
+     * The {@link Address} of the identity.
+     */
+    address: Address;
 }
 /**
- * Resolve Primary Name Response Type
+ * Represents an `Identity` that resolved to a primary name.
+ *
+ * Invariants:
+ * - `resolutionStatus` is always {@link ResolutionStatusIds.Named}.
  */
-interface ResolvePrimaryNameResponse extends AcceleratableResponse, TraceableResponse {
-    name: ReverseResolutionResult;
-}
-interface ResolvePrimaryNamesRequest extends MultichainPrimaryNameResolutionArgs, AcceleratableRequest, TraceableRequest {
-}
-interface ResolvePrimaryNamesResponse extends AcceleratableResponse, TraceableResponse {
-    names: MultichainPrimaryNameResolutionResult;
+interface NamedIdentity {
+    resolutionStatus: typeof ResolutionStatusIds.Named;
+    /**
+     * The {@link DefaultableChainId} for an ENSIP-19 primary name lookup of the
+     * identity associated with `address`.
+     */
+    chainId: DefaultableChainId;
+    /**
+     * The address of the identity.
+     */
+    address: Address;
+    /**
+     * The ENSIP-19 primary name lookup result of `address` on `chainId`.
+     */
+    name: Name;
 }
 /**
- * ENSIndexer Public Config Response
- */
-type ConfigResponse = ENSApiPublicConfig;
-/**
- * Represents a request to Indexing Status API.
- */
-type IndexingStatusRequest = {};
-/**
- * A status code for indexing status responses.
+ * Represents an `Identity` that did not resolve to a primary name.
+ *
+ * Invariants:
+ * - `resolutionStatus` is always {@link ResolutionStatusIds.Unnamed}.
+ * - `name` is always `null`.
  */
-declare const IndexingStatusResponseCodes: {
+interface UnnamedIdentity {
+    resolutionStatus: typeof ResolutionStatusIds.Unnamed;
     /**
-     * Represents that the indexing status is available.
+     * The {@link DefaultableChainId} for an ENSIP-19 primary name lookup of the
+     * identity associated with `address`.
      */
-    readonly Ok: "ok";
+    chainId: DefaultableChainId;
     /**
-     * Represents that the indexing status is unavailable.
+     * The address of the identity.
      */
-    readonly Error: "error";
-};
+    address: Address;
+    /**
+     * The ENSIP-19 primary name lookup result of `address` on `chainId`.
+     */
+    name: null;
+}
 /**
- * The derived string union of possible {@link IndexingStatusResponseCodes}.
+ * Represents an `Identity` that was attempted to be resolved but the resolution attempt
+ * resulted in an error and therefore it is unknown if the `Identity` resolves to a named
+ * or unnamed identity.
+ *
+ * Invariants:
+ * - `resolutionStatus` is always {@link ResolutionStatusIds.Unknown}.
  */
-type IndexingStatusResponseCode = (typeof IndexingStatusResponseCodes)[keyof typeof IndexingStatusResponseCodes];
+interface UnknownIdentity {
+    resolutionStatus: typeof ResolutionStatusIds.Unknown;
+    /**
+     * The {@link DefaultableChainId} for an ENSIP-19 primary name lookup of the
+     * identity associated with `address`.
+     */
+    chainId: DefaultableChainId;
+    /**
+     * The address of the identity.
+     */
+    address: Address;
+}
 /**
- * An indexing status response when the indexing status is available.
+ * Represents an ENSIP-19 identity resolution result.
+ *
+ * Use the `resolutionStatus` field to determine the specific type interpretation
+ * at runtime.
  */
-type IndexingStatusResponseOk = {
-    responseCode: typeof IndexingStatusResponseCodes.Ok;
-    realtimeProjection: RealtimeIndexingStatusProjection;
-};
+type ResolvedIdentity = NamedIdentity | UnnamedIdentity | UnknownIdentity;
 /**
- * An indexing status response when the indexing status is unavailable.
+ * Represents an ENSIP-19 identity resolution (which may or not have been
+ * resolved to a result yet).
+ *
+ * Use the `resolutionStatus` field to determine the specific type interpretation
+ * at runtime.
  */
-type IndexingStatusResponseError = {
-    responseCode: typeof IndexingStatusResponseCodes.Error;
-};
+type Identity = UnresolvedIdentity | ResolvedIdentity;
+
 /**
- * Indexing status response.
+ * Builds an {@link UnresolvedIdentity} for the provided {@link Address},
+ * {@link DefaultableChainId} and {@link ENSNamespaceId}.
  *
- * Use the `responseCode` field to determine the specific type interpretation
- * at runtime.
+ * If no `chainId` is provided, uses the ENS Root Chain Id for the provided
+ * `namespaceId`.
  */
-type IndexingStatusResponse = IndexingStatusResponseOk | IndexingStatusResponseError;
+declare function buildUnresolvedIdentity(address: Address, namespaceId: ENSNamespaceId, chainId?: DefaultableChainId): UnresolvedIdentity;
 /**
- * Registrar Actions response
+ * Returns whether the provided {@link Identity} is a {@link ResolvedIdentity}.
+ *
+ * @param identity - The {@link Identity} to check.
+ * @returns Whether the provided {@link Identity} is a {@link ResolvedIdentity}.
  */
+declare function isResolvedIdentity(identity: Identity): identity is ResolvedIdentity;
+
 /**
- * Records Filters: Filter Types
+ * Gets the "chainId param" that should be used for a primary name resolution
+ * request.
+ *
+ * ENSIP-19 defines special rules for the "chainId param" used
+ * in primary name resolutions for the case that the `chainId` is the
+ * ENS Root Chain Id for the provided `namespaceId`.
+ *
+ * Whenever this case happens, ENSIP-19 requires that the
+ * "chainId param" is always set to chainId: 1 (mainnet), even if the
+ * `chainId` where the primary name lookup is actually happening
+ * on a non-mainnet ENS Root Chain, such as on a testnet or
+ * the ens-test-env.
+ *
+ * @param namespaceId The namespace id for the primary name lookup.
+ * @param chainId The chain id where the primary name lookup will actually happen.
+ * @returns The "chainId param" that should be used for the primary name lookup.
  */
-declare const RegistrarActionsFilterTypes: {
-    readonly BySubregistryNode: "bySubregistryNode";
-    readonly WithEncodedReferral: "withEncodedReferral";
-};
-type RegistrarActionsFilterType = (typeof RegistrarActionsFilterTypes)[keyof typeof RegistrarActionsFilterTypes];
-type RegistrarActionsFilterBySubregistryNode = {
-    filterType: typeof RegistrarActionsFilterTypes.BySubregistryNode;
-    value: Node;
-};
-type RegistrarActionsFilterWithEncodedReferral = {
-    filterType: typeof RegistrarActionsFilterTypes.WithEncodedReferral;
-};
-type RegistrarActionsFilter = RegistrarActionsFilterBySubregistryNode | RegistrarActionsFilterWithEncodedReferral;
+declare const getResolvePrimaryNameChainIdParam: (chainId: DefaultableChainId, namespaceId: ENSNamespaceId) => DefaultableChainId;
 /**
- * Records Orders
+ * Translates a `DefaultableChainId` a `ChainId`
+ * such that if the provided `chainId` is `DEFAULT_EVM_CHAIN_ID`,
+ * the `ChainId` of the ENS Root Chain for the provided `namespaceId` is returned.
+ *
+ * @param chainId The `DefaultableChainId` to translate.
+ * @param namespaceId The namespace id for the translation.
+ * @returns the translated `ChainId`.
  */
-declare const RegistrarActionsOrders: {
-    readonly LatestRegistrarActions: "orderBy[timestamp]=desc";
-};
-type RegistrarActionsOrder = (typeof RegistrarActionsOrders)[keyof typeof RegistrarActionsOrders];
+declare const translateDefaultableChainIdToChainId: (chainId: DefaultableChainId, namespaceId: ENSNamespaceId) => ChainId;
+
 /**
- * Represents a request to Registrar Actions API.
+ * Encodes a selection of Resolver records in the context of a specific Name.
  */
-type RegistrarActionsRequest = {
+interface ResolverRecordsSelection {
     /**
-     * Filters to be applied while generating results.
+     * Whether to fetch the name's `name` record. This value is primarily used in the context of
+     * Reverse Resolution.
+     *
+     * @see https://docs.ens.domains/ensip/19/#reverse-resolution
      */
-    filters?: RegistrarActionsFilter[];
+    name?: boolean;
     /**
-     * Order applied while generating results.
+     * Which coinTypes to fetch address records for.
      */
-    order?: RegistrarActionsOrder;
+    addresses?: CoinType[];
     /**
-     * Limit the count of items per page to selected count of records.
-     *
-     * Guaranteed to be a positive integer (if defined).
+     * Which keys to fetch text records for.
      */
-    itemsPerPage?: number;
-};
+    texts?: string[];
+}
+declare const isSelectionEmpty: (selection: ResolverRecordsSelection) => boolean;
+
 /**
- * A status code for Registrar Actions API responses.
+ * An internal type representing a non-inferred ResolverRecordsResponse, used in situations where
+ * access to the more specific inferred type (ResolverRecordsResponse<SELECTION>) is difficult or
+ * unnecessary.
  */
-declare const RegistrarActionsResponseCodes: {
+type ResolverRecordsResponseBase = {
     /**
-     * Represents that Registrar Actions are available.
+     * The name record, relevant in the context of Reverse Resolution.
+     * Null if no name record is set.
      */
-    readonly Ok: "ok";
+    name: Name | null;
     /**
-     * Represents that Registrar Actions are unavailable.
+     * Address records, keyed by CoinType.
+     * Value is null if no record for the specified CoinType is set.
+     *
+     * NOTE: ENS resolver address records can store arbitrary string values,
+     * including non-EVM addresses — always validate the record value against
+     * the format your application expects.
      */
-    readonly Error: "error";
+    addresses: Record<CoinType, string | null>;
+    /**
+     * Text records, keyed by key.
+     * Value is null if no record for the specified key is set.
+     */
+    texts: Record<string, string | null>;
 };
 /**
- * The derived string union of possible {@link RegistrarActionsResponseCodes}.
+ * Represents the strongly-typed set of records based on the provided SELECTION
+ *
+ * @example
+ * ```typescript
+ * const selection = {
+ *   name: true,
+ *   addresses: [60],
+ *   texts: ["com.twitter", "avatar"],
+ * } as const satisfies ResolverRecordsSelection;
+ *
+ * type Response = ResolverRecordsResponse<typeof selection>;
+ *
+ * // results in the following type
+ * type Response = {
+ *   readonly name: Name | null;
+ *   readonly addresses: Record<"60", string | null>;
+ *   readonly texts: Record<"avatar" | "com.twitter", string | null>;
+ * }
+ * ```
  */
-type RegistrarActionsResponseCode = (typeof RegistrarActionsResponseCodes)[keyof typeof RegistrarActionsResponseCodes];
+type ResolverRecordsResponse<T extends ResolverRecordsSelection = ResolverRecordsSelection> = {
+    [K in keyof T as T[K] extends true | any[] ? K : never]: K extends "addresses" ? Record<`${T["addresses"] extends readonly CoinType[] ? T["addresses"][number] : never}`, string | null> : K extends "texts" ? Record<T["texts"] extends readonly string[] ? T["texts"][number] : never, string | null> : ResolverRecordsResponseBase[K & keyof ResolverRecordsResponseBase];
+};
+
 /**
- * "Logical registrar action" with its associated name.
+ * Arguments required to perform Forward Resolution
  */
-interface NamedRegistrarAction {
-    action: RegistrarAction;
-    /**
-     * Name
-     *
-     * FQDN of the name associated with `action`.
-     *
-     * Guarantees:
-     * - `namehash(name)` is always `action.registrationLifecycle.node`.
-     */
-    name: InterpretedName;
+interface ForwardResolutionArgs<SELECTION extends ResolverRecordsSelection> {
+    name: Name;
+    selection: SELECTION;
 }
 /**
- * A response when Registrar Actions are available.
+ * The result of performing ForwardResolution
  */
-type RegistrarActionsResponseOk = {
-    responseCode: typeof RegistrarActionsResponseCodes.Ok;
-    registrarActions: NamedRegistrarAction[];
-};
+type ForwardResolutionResult<SELECTION extends ResolverRecordsSelection> = ResolverRecordsResponse<SELECTION>;
 /**
- * A response when Registrar Actions are unavailable.
+ * Arguments required to perform Reverse Resolution
  */
-interface RegistrarActionsResponseError {
-    responseCode: typeof IndexingStatusResponseCodes.Error;
-    error: ErrorResponse;
+interface ReverseResolutionArgs {
+    address: Address;
+    chainId: ChainId;
 }
 /**
- * Registrar Actions response.
- *
- * Use the `responseCode` field to determine the specific type interpretation
- * at runtime.
+ * The result of performing ReverseResolution
  */
-type RegistrarActionsResponse = RegistrarActionsResponseOk | RegistrarActionsResponseError;
-
+type ReverseResolutionResult = Name | null;
 /**
- * Serialized representation of {@link IndexingStatusResponseError}.
+ * Arguments required to perform Multichain Primary Name Resolution
  */
-type SerializedIndexingStatusResponseError = IndexingStatusResponseError;
+interface MultichainPrimaryNameResolutionArgs {
+    address: Address;
+    chainIds?: ChainId[];
+}
 /**
- * Serialized representation of {@link IndexingStatusResponseOk}.
+ * The result of performing MultichainPrimaryNameResolution
  */
-interface SerializedIndexingStatusResponseOk extends Omit<IndexingStatusResponseOk, "realtimeProjection"> {
-    realtimeProjection: SerializedRealtimeIndexingStatusProjection;
-}
+type MultichainPrimaryNameResolutionResult = Record<ChainId, Name | null>;
+
 /**
- * Serialized representation of {@link IndexingStatusResponse}.
+ * Identifiers for each traceable ENS protocol.
  */
-type SerializedIndexingStatusResponse = SerializedIndexingStatusResponseOk | SerializedIndexingStatusResponseError;
+declare enum TraceableENSProtocol {
+    ForwardResolution = "forward-resolution",
+    ReverseResolution = "reverse-resolution"
+}
 /**
- * Serialized representation of {@link RegistrarActionsResponseError}.
+ * Encodes the set of well-known steps in the ENS Forward Resolution protocol.
  */
-type SerializedRegistrarActionsResponseError = RegistrarActionsResponseError;
+declare enum ForwardResolutionProtocolStep {
+    Operation = "forward-resolution",
+    FindResolver = "find-resolver",
+    ActiveResolverExists = "active-resolver-exists",
+    AccelerateENSIP19ReverseResolver = "accelerate-ensip-19-reverse-resolver",
+    AccelerateKnownOffchainLookupResolver = "accelerate-known-offchain-lookup-resolver",
+    AccelerateKnownOnchainStaticResolver = "accelerate-known-onchain-static-resolver",
+    RequireResolver = "require-resolver",
+    ExecuteResolveCalls = "execute-resolve-calls"
+}
 /**
- * Serialized representation of {@link NamedRegistrarAction}.
+ * Encodes the set of well-known steps in the ENS Reverse Resolution protocol.
  */
-interface SerializedNamedRegistrarAction extends Omit<NamedRegistrarAction, "action"> {
-    action: SerializedRegistrarAction;
+declare enum ReverseResolutionProtocolStep {
+    Operation = "reverse-resolution",
+    ResolveReverseName = "resolve-reverse-name",
+    NameRecordExists = "name-record-exists-check",
+    ForwardResolveAddressRecord = "forward-resolve-address-record",
+    VerifyResolvedAddressMatchesAddress = "verify-resolved-address-matches-address"
+}
+declare const PROTOCOL_ATTRIBUTE_PREFIX = "ens";
+declare const ATTR_PROTOCOL_NAME = "ens.protocol";
+declare const ATTR_PROTOCOL_STEP = "ens.protocol.step";
+declare const ATTR_PROTOCOL_STEP_RESULT = "ens.protocol.step.result";
+interface SpanAttributes {
+    [key: string]: unknown;
+}
+interface SpanEvent {
+    name: string;
+    attributes: SpanAttributes;
+    time: number;
+}
+interface ProtocolSpan {
+    scope: string;
+    id: string;
+    traceId: string;
+    parentSpanContext: {
+        traceId: string;
+        spanId: string;
+    } | undefined;
+    name: string;
+    timestamp: number;
+    duration: number;
+    attributes: SpanAttributes;
+    status: {
+        code: number;
+        message?: string;
+    };
+    events: SpanEvent[];
+}
+type ProtocolSpanTreeNode = ProtocolSpan & {
+    children: ProtocolSpanTreeNode[];
+};
+type ProtocolTrace = ProtocolSpanTreeNode[];
+
+interface TraceableRequest {
+    trace?: boolean;
+}
+interface TraceableResponse {
+    trace?: ProtocolTrace;
+}
+interface AcceleratableRequest {
+    accelerate?: boolean;
+}
+interface AcceleratableResponse {
+    accelerationRequested: boolean;
+    accelerationAttempted: boolean;
 }
 /**
- * Serialized representation of {@link RegistrarActionsResponseOk}.
+ * Resolve Records Request Type
  */
-interface SerializedRegistrarActionsResponseOk extends Omit<RegistrarActionsResponseOk, "registrarActions"> {
-    registrarActions: SerializedNamedRegistrarAction[];
+interface ResolveRecordsRequest<SELECTION extends ResolverRecordsSelection> extends ForwardResolutionArgs<SELECTION>, AcceleratableRequest, TraceableRequest {
 }
 /**
- * Serialized representation of {@link SerializedRegistrarActionsResponse}.
+ * Resolve Records Response Type
  */
-type SerializedRegistrarActionsResponse = SerializedRegistrarActionsResponseOk | SerializedRegistrarActionsResponseError;
-
-declare function deserializeErrorResponse(maybeErrorResponse: unknown): ErrorResponse;
-declare function deserializeIndexingStatusResponse(maybeResponse: SerializedIndexingStatusResponse): IndexingStatusResponse;
-declare function deserializeRegistrarActionsResponse(maybeResponse: SerializedRegistrarActionsResponse): RegistrarActionsResponse;
-
+interface ResolveRecordsResponse<SELECTION extends ResolverRecordsSelection> extends AcceleratableResponse, TraceableResponse {
+    records: ResolverRecordsResponse<SELECTION>;
+}
 /**
- * Build a "parent node" filter object for Registrar Actions query.
+ * Resolve Primary Name Request Type
  */
-declare function byParentNode(parentNode: Node): RegistrarActionsFilter;
-declare function byParentNode(parentNode: undefined): undefined;
+interface ResolvePrimaryNameRequest extends ReverseResolutionArgs, AcceleratableRequest, TraceableRequest {
+}
 /**
- * Build a "with referral" filter object for Registrar Actions query.
+ * Resolve Primary Name Response Type
  */
-declare function withReferral(withReferral: true): RegistrarActionsFilter;
-declare function withReferral(withReferral: false | undefined): undefined;
-declare const registrarActionsFilter: {
-    byParentNode: typeof byParentNode;
-    withReferral: typeof withReferral;
-};
-
-declare const registrarActionsPrerequisites: Readonly<{
-    /**
-     * Required plugins to enable Registrar Actions API routes.
-     *
-     * 1. `registrars` plugin is required so that data in the `registrarActions`
-     *    table is populated.
-     * 2. `subgraph`, `basenames`, and `lineanames` are required to get the data
-     *    for the name associated with each registrar action.
-     * 3. In theory not all of `subgraph`, `basenames`, and `lineanames` plugins
-     *    might be required. Ex: At least one, but the current logic in
-     *    the `registrars` plugin always indexes registrar actions across
-     *    Ethnames (subgraph), Basenames, and Lineanames and therefore we need to
-     *    ensure each value in the registrar actions table has
-     *    an associated record in the domains table.
-     */
-    requiredPlugins: readonly [PluginName.Subgraph, PluginName.Basenames, PluginName.Lineanames, PluginName.Registrars];
-    /**
-     * Check if provided ENSApiPublicConfig supports the Registrar Actions API.
-     */
-    hasEnsIndexerConfigSupport(config: ENSIndexerPublicConfig): boolean;
-    /**
-     * Required Indexing Status IDs
-     *
-     * Database indexes are created by the time the omnichain indexing status
-     * is either `completed` or `following`.
-     */
-    supportedIndexingStatusIds: ("omnichain-following" | "omnichain-completed")[];
-    /**
-     * Check if provided indexing status supports the Registrar Actions API.
-     */
-    hasIndexingStatusSupport(omnichainIndexingStatusId: OmnichainIndexingStatusId): boolean;
-}>;
-
-declare function serializeIndexingStatusResponse(response: IndexingStatusResponse): SerializedIndexingStatusResponse;
-declare function serializeNamedRegistrarAction({ action, name, }: NamedRegistrarAction): SerializedNamedRegistrarAction;
-declare function serializeRegistrarActionsResponse(response: RegistrarActionsResponse): SerializedRegistrarActionsResponse;
+interface ResolvePrimaryNameResponse extends AcceleratableResponse, TraceableResponse {
+    name: ReverseResolutionResult;
+}
+interface ResolvePrimaryNamesRequest extends MultichainPrimaryNameResolutionArgs, AcceleratableRequest, TraceableRequest {
+}
+interface ResolvePrimaryNamesResponse extends AcceleratableResponse, TraceableResponse {
+    names: MultichainPrimaryNameResolutionResult;
+}
 
 /**
  * Request parameters for a referrer leaderboard page query.
  */
-interface ReferrerLeaderboardPaginationRequest extends ReferrerLeaderboardPaginationParams {
+interface ReferrerLeaderboardPageRequest extends ReferrerLeaderboardPageParams {
 }
 /**
  * A status code for a referrer leaderboard page API response.
@@ -3236,6 +4028,52 @@ type ReferrerLeaderboardPageResponseError = {
  * at runtime.
  */
 type ReferrerLeaderboardPageResponse = ReferrerLeaderboardPageResponseOk | ReferrerLeaderboardPageResponseError;
+/**
+ * Request parameters for referrer detail query.
+ */
+interface ReferrerDetailRequest {
+    /** The Ethereum address of the referrer to query */
+    referrer: Address;
+}
+/**
+ * A status code for referrer detail API responses.
+ */
+declare const ReferrerDetailResponseCodes: {
+    /**
+     * Represents that the referrer detail data is available.
+     */
+    readonly Ok: "ok";
+    /**
+     * Represents that an error occurred while fetching the data.
+     */
+    readonly Error: "error";
+};
+/**
+ * The derived string union of possible {@link ReferrerDetailResponseCodes}.
+ */
+type ReferrerDetailResponseCode = (typeof ReferrerDetailResponseCodes)[keyof typeof ReferrerDetailResponseCodes];
+/**
+ * A referrer detail response when the data is available for a referrer on the leaderboard.
+ */
+type ReferrerDetailResponseOk = {
+    responseCode: typeof ReferrerDetailResponseCodes.Ok;
+    data: ReferrerDetail;
+};
+/**
+ * A referrer detail response when an error occurs.
+ */
+type ReferrerDetailResponseError = {
+    responseCode: typeof ReferrerDetailResponseCodes.Error;
+    error: string;
+    errorMessage: string;
+};
+/**
+ * A referrer detail API response.
+ *
+ * Use the `responseCode` field to determine the specific type interpretation
+ * at runtime.
+ */
+type ReferrerDetailResponse = ReferrerDetailResponseOk | ReferrerDetailResponseError;
 
 /**
  * Serialized representation of {@link ReferrerLeaderboardPageResponseError}.
@@ -3253,6 +4091,24 @@ type SerializedReferrerLeaderboardPageResponseOk = ReferrerLeaderboardPageRespon
  * Serialized representation of {@link ReferrerLeaderboardPageResponse}.
  */
 type SerializedReferrerLeaderboardPageResponse = SerializedReferrerLeaderboardPageResponseOk | SerializedReferrerLeaderboardPageResponseError;
+/**
+ * Serialized representation of {@link ReferrerDetailResponseOk}.
+ *
+ * Note: All fields in ReferrerDetailRanked and ReferrerDetailUnranked
+ * (rules, referrer metrics, aggregatedMetrics, and timestamp) are already serializable primitives.
+ * The rank field can be either a number or null, both of which are valid JSON primitives.
+ */
+type SerializedReferrerDetailResponseOk = ReferrerDetailResponseOk;
+/**
+ * Serialized representation of {@link ReferrerDetailResponseError}.
+ *
+ * Note: All fields are already serializable, so this type is identical to the source type.
+ */
+type SerializedReferrerDetailResponseError = ReferrerDetailResponseError;
+/**
+ * Serialized representation of {@link ReferrerDetailResponse}.
+ */
+type SerializedReferrerDetailResponse = SerializedReferrerDetailResponseOk | SerializedReferrerDetailResponseError;
 
 /**
  * Deserialize a {@link ReferrerLeaderboardPageResponse} object.
@@ -3263,6 +4119,15 @@ type SerializedReferrerLeaderboardPageResponse = SerializedReferrerLeaderboardPa
  * responses from the API.
  */
 declare function deserializeReferrerLeaderboardPageResponse(maybeResponse: SerializedReferrerLeaderboardPageResponse, valueLabel?: string): ReferrerLeaderboardPageResponse;
+/**
+ * Deserialize a {@link ReferrerDetailResponse} object.
+ *
+ * Note: While the serialized and deserialized types are identical (all fields
+ * are primitives), this function performs critical validation using Zod schemas
+ * to enforce invariants on the data. This ensures data integrity when receiving
+ * responses from the API.
+ */
+declare function deserializeReferrerDetailResponse(maybeResponse: SerializedReferrerDetailResponse, valueLabel?: string): ReferrerDetailResponse;
 
 /**
  * Serialize a {@link ReferrerLeaderboardPageResponse} object.
@@ -3273,6 +4138,16 @@ declare function deserializeReferrerLeaderboardPageResponse(maybeResponse: Seria
  * throughout the codebase.
  */
 declare function serializeReferrerLeaderboardPageResponse(response: ReferrerLeaderboardPageResponse): SerializedReferrerLeaderboardPageResponse;
+/**
+ * Serialize a {@link ReferrerDetailResponse} object.
+ *
+ * Note: Since all fields in ReferrerDetailRanked and ReferrerDetailUnranked
+ * (rules, referrer metrics, aggregatedMetrics, and timestamp) are already
+ * serializable primitives, this function performs an identity transformation.
+ * The rank field can be either a number or null, both of which are valid JSON primitives.
+ * It exists to maintain consistency with the serialization pattern used throughout the codebase.
+ */
+declare function serializeReferrerDetailResponse(response: ReferrerDetailResponse): SerializedReferrerDetailResponse;
 
 /**
  * Configuration options for ENSNode API client
@@ -3461,7 +4336,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
@@ -3470,34 +4345,34 @@ declare class ENSNodeClient {
      *
      * @example
      * ```typescript
-     * // Get first page with default page size (25 items)
-     * const response = await client.getReferrerLeaderboard();
+     * // 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.getReferrerLeaderboard({ page: 2, itemsPerPage: 50 });
+     * // Get second page with 50 records per page
+     * const response = await client.getReferrerLeaderboardPage({ page: 2, recordsPerPage: 50 });
      * ```
      *
      * @example
      * ```typescript
      * // Handle error response, ie. when Referrer Leaderboard is not currently available.
-     * const response = await client.getReferrerLeaderboard();
+     * const response = await client.getReferrerLeaderboardPage();
      *
      * if (response.responseCode === ReferrerLeaderboardPageResponseCodes.Error) {
      *   console.error(response.error);
@@ -3505,15 +4380,94 @@ declare class ENSNodeClient {
      * }
      * ```
      */
-    getReferrerLeaderboard(request?: ReferrerLeaderboardPaginationRequest): Promise<ReferrerLeaderboardPageResponse>;
+    getReferrerLeaderboardPage(request?: ReferrerLeaderboardPageRequest): Promise<ReferrerLeaderboardPageResponse>;
+    /**
+     * Fetch Referrer Detail
+     *
+     * Retrieves detailed information about a specific referrer, whether they are on the
+     * leaderboard or not.
+     *
+     * The response data is a discriminated union type with a `type` field:
+     *
+     * **For referrers on the leaderboard** (`ReferrerDetailRanked`):
+     * - `type`: {@link ReferrerDetailTypeIds.Ranked}
+     * - `referrer`: The `AwardedReferrerMetrics` from @namehash/ens-referrals
+     * - `rules`: The referral program rules
+     * - `aggregatedMetrics`: Aggregated metrics for all referrers on the leaderboard
+     * - `accurateAsOf`: Unix timestamp indicating when the data was last updated
+     *
+     * **For referrers NOT on the leaderboard** (`ReferrerDetailUnranked`):
+     * - `type`: {@link ReferrerDetailTypeIds.Unranked}
+     * - `referrer`: The `UnrankedReferrerMetrics` from @namehash/ens-referrals
+     * - `rules`: The referral program rules
+     * - `aggregatedMetrics`: Aggregated metrics for all referrers on the leaderboard
+     * - `accurateAsOf`: Unix timestamp indicating when the data was last updated
+     *
+     * @see {@link https://www.npmjs.com/package/@namehash/ens-referrals|@namehash/ens-referrals} for calculation details
+     *
+     * @param request The referrer address to query
+     * @returns {ReferrerDetailResponse} Returns the referrer detail response
+     *
+     * @throws if the ENSNode request fails
+     * @throws if the response data is malformed
+     *
+     * @example
+     * ```typescript
+     * // Get referrer detail for a specific address
+     * const response = await client.getReferrerDetail({
+     *   referrer: "0x1234567890123456789012345678901234567890"
+     * });
+     * if (response.responseCode === ReferrerDetailResponseCodes.Ok) {
+     *   const { type, referrer, rules, aggregatedMetrics, accurateAsOf } = response.data;
+     *   console.log(type); // ReferrerDetailTypeIds.Ranked or ReferrerDetailTypeIds.Unranked
+     *   console.log(referrer);
+     *   console.log(accurateAsOf);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Use discriminated union to check if referrer is ranked
+     * const response = await client.getReferrerDetail({
+     *   referrer: "0x1234567890123456789012345678901234567890"
+     * });
+     * if (response.responseCode === ReferrerDetailResponseCodes.Ok) {
+     *   if (response.data.type === ReferrerDetailTypeIds.Ranked) {
+     *     // TypeScript knows this is ReferrerDetailRanked
+     *     console.log(`Rank: ${response.data.referrer.rank}`);
+     *     console.log(`Qualified: ${response.data.referrer.isQualified}`);
+     *     console.log(`Award Pool Share: ${response.data.referrer.awardPoolShare * 100}%`);
+     *   } else {
+     *     // TypeScript knows this is ReferrerDetailUnranked
+     *     console.log("Referrer is not on the leaderboard (no referrals yet)");
+     *   }
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Handle error response, ie. when Referrer Detail is not currently available.
+     * const response = await client.getReferrerDetail({
+     *   referrer: "0x1234567890123456789012345678901234567890"
+     * });
+     *
+     * if (response.responseCode === ReferrerDetailResponseCodes.Error) {
+     *   console.error(response.error);
+     *   console.error(response.errorMessage);
+     * }
+     * ```
+     */
+    getReferrerDetail(request: ReferrerDetailRequest): Promise<ReferrerDetailResponse>;
     /**
      * Fetch ENSNode Registrar Actions
      *
-     * @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
@@ -3523,23 +4477,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
@@ -3553,15 +4509,50 @@ 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>;
+    /**
+     * Fetch Name Tokens for requested name.
+     *
+     * @param request.name - Name for which Name Tokens will be fetched.
+     * @returns {NameTokensResponse}
+     *
+     * @throws if the ENSNode request fails
+     * @throws if the ENSNode API returns an error response
+     * @throws if the ENSNode response breaks required invariants
+     *
+     * @example
+     * ```ts
+     * import {
+     *   ENSNodeClient,
+     * } from "@ensnode/ensnode-sdk";
+     * import { namehash } from "viem/ens";
+     *
+     * const client: ENSNodeClient;
+     *
+     * // get latest name token records from the indexed subregistry based on the requested name
+     * const response = await client.nameTokens({
+     *   name: "vitalik.eth"
+     * });
+     *
+     * const response = await client.nameTokens({
+     *   domainId: "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835" // namehash('vitalik.eth')
+     * })
+     * ```
+     */
+    nameTokens(request: NameTokensRequest): Promise<NameTokensResponse>;
 }
 
 declare class ClientError extends Error {
@@ -3570,4 +4561,4 @@ declare class ClientError extends Error {
     static fromErrorResponse({ message, details }: ErrorResponse): ClientError;
 }
 
-export { ADDR_REVERSE_NODE, ATTR_PROTOCOL_NAME, ATTR_PROTOCOL_STEP, ATTR_PROTOCOL_STEP_RESULT, type AcceleratableRequest, type AcceleratableResponse, type AccountId, BASENAMES_NODE, type BlockNumber, type BlockRef, type Blockrange, type Cache, type 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 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 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, ROOT_NODE, type RealtimeIndexingStatusProjection, type ReferrerLeaderboardPageResponse, type ReferrerLeaderboardPageResponseCode, ReferrerLeaderboardPageResponseCodes, type ReferrerLeaderboardPageResponseError, type ReferrerLeaderboardPageResponseOk, type ReferrerLeaderboardPaginationRequest, type RegistrarAction, type RegistrarActionEventId, type RegistrarActionPricing, type RegistrarActionPricingAvailable, type RegistrarActionPricingUnknown, type RegistrarActionReferral, type RegistrarActionReferralAvailable, type RegistrarActionReferralNotApplicable, type RegistrarActionType, RegistrarActionTypes, type RegistrarActionsFilter, type RegistrarActionsFilterBySubregistryNode, type RegistrarActionsFilterType, RegistrarActionsFilterTypes, type RegistrarActionsFilterWithEncodedReferral, type RegistrarActionsOrder, RegistrarActionsOrders, type RegistrarActionsRequest, type RegistrarActionsResponse, type RegistrarActionsResponseCode, RegistrarActionsResponseCodes, type RegistrarActionsResponseError, type RegistrarActionsResponseOk, type RegistrationLifecycle, type RegistrationLifecycleStage, type ResolutionStatusId, ResolutionStatusIds, type ResolvePrimaryNameRequest, type ResolvePrimaryNameResponse, type ResolvePrimaryNamesRequest, type ResolvePrimaryNamesResponse, type ResolveRecordsRequest, type ResolveRecordsResponse, type ResolvedIdentity, type ResolverRecordsResponse, type ResolverRecordsResponseBase, type ResolverRecordsSelection, type ReverseResolutionArgs, ReverseResolutionProtocolStep, type ReverseResolutionResult, type RpcUrl, SWRCache, type SWRCacheOptions, type SerializedAccountId, type SerializedChainIndexingStatusSnapshot, type SerializedChainIndexingStatusSnapshotBackfill, type SerializedChainIndexingStatusSnapshotCompleted, type SerializedChainIndexingStatusSnapshotFollowing, type SerializedChainIndexingStatusSnapshotQueued, type SerializedCrossChainIndexingStatusSnapshot, type SerializedCrossChainIndexingStatusSnapshotOmnichain, type SerializedCurrencyAmount, type SerializedCurrentIndexingProjectionOmnichain, type SerializedENSApiPublicConfig, type SerializedENSIndexerPublicConfig, type SerializedENSIndexerVersionInfo, type SerializedIndexedChainIds, type SerializedIndexingStatusResponse, type SerializedIndexingStatusResponseError, type SerializedIndexingStatusResponseOk, type SerializedNamedRegistrarAction, type SerializedOmnichainIndexingStatusSnapshot, type SerializedOmnichainIndexingStatusSnapshotBackfill, type SerializedOmnichainIndexingStatusSnapshotCompleted, type SerializedOmnichainIndexingStatusSnapshotFollowing, type SerializedOmnichainIndexingStatusSnapshotUnstarted, type SerializedPrice, type SerializedPriceDai, type SerializedPriceEth, type SerializedPriceUsdc, type SerializedRealtimeIndexingStatusProjection, 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, TraceableENSProtocol, type TraceableRequest, type TraceableResponse, TtlCache, type UnixTimestamp, type UnknownIdentity, type UnnamedIdentity, type UnresolvedIdentity, type UrlString, accountIdEqual, addDuration, addPrices, addrReverseLabel, asLowerCaseAddress, beautifyName, bigIntToNumber, bigintToCoinType, buildEnsRainbowClientLabelSet, buildLabelSetId, buildLabelSetVersion, buildUnresolvedIdentity, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted, coinTypeReverseLabel, coinTypeToEvmChainId, createIndexingConfig, createRealtimeIndexingStatusProjection, decodeDNSEncodedLiteralName, decodeDNSEncodedName, deserializeAccountId, deserializeBlockNumber, deserializeBlockRef, deserializeBlockrange, deserializeChainId, deserializeChainIndexingStatusSnapshot, deserializeCrossChainIndexingStatusSnapshot, deserializeDatetime, deserializeDuration, deserializeENSApiPublicConfig, deserializeENSIndexerPublicConfig, deserializeErrorResponse, deserializeIndexingStatusResponse, deserializeOmnichainIndexingStatusSnapshot, deserializeRealtimeIndexingStatusProjection, deserializeReferrerLeaderboardPageResponse, deserializeRegistrarActionsResponse, deserializeUnixTimestamp, deserializeUrl, durationBetween, encodeLabelHash, evmChainIdToCoinType, getCurrencyInfo, getEthnamesSubregistryId, getLatestIndexedBlockRef, getNameHierarchy, getOmnichainIndexingCursor, getOmnichainIndexingStatus, getResolvePrimaryNameChainIdParam, getTimestampForHighestOmnichainKnownBlock, getTimestampForLowestOmnichainStartBlock, hasNullByte, interpretedLabelsToInterpretedName, isEncodedLabelHash, isHttpProtocol, isLabelHash, isNormalizedLabel, isNormalizedName, isPriceCurrencyEqual, isPriceEqual, isRegistrarActionPricingAvailable, isRegistrarActionReferralAvailable, isResolvedIdentity, isSelectionEmpty, isSubgraphCompatible, isWebSocketProtocol, labelHashToBytes, labelhashLiteralLabel, literalLabelToInterpretedLabel, literalLabelsToInterpretedName, literalLabelsToLiteralName, makeENSApiPublicConfigSchema, makeSubdomainNode, parseNonNegativeInteger, parseReverseName, priceDai, priceEth, priceUsdc, registrarActionsFilter, registrarActionsPrerequisites, reverseName, serializeAccountId, serializeChainId, serializeChainIndexingSnapshots, serializeCrossChainIndexingStatusSnapshotOmnichain, serializeDatetime, serializeENSApiPublicConfig, serializeENSIndexerPublicConfig, serializeIndexedChainIds, serializeIndexingStatusResponse, serializeNamedRegistrarAction, serializeOmnichainIndexingStatusSnapshot, serializePrice, serializePriceEth, serializeRealtimeIndexingStatusProjection, 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 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, 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, 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 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, 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 };