@ensnode/ensnode-sdk 0.31.0 → 0.33.0

package/dist/index.d.ts

@@ -1,15 +1,9 @@
 import { Hex, Address } from 'viem';
+import { CoinType, EvmCoinType } from '@ensdomains/address-encoder';
+export { CoinType, EvmCoinType } from '@ensdomains/address-encoder';
+import { ENSNamespaceId } from '@ensnode/datasources';
+export { ENSNamespaceId, ENSNamespaceIds } from '@ensnode/datasources';
 
-/**
- * A PluginName is a unique id for a 'plugin': we use the notion of 'plugins' to describe bundles
- * of indexing logic.
- */
-declare enum PluginName {
-    Subgraph = "subgraph",
-    Basenames = "basenames",
-    Lineanames = "lineanames",
-    ThreeDNS = "threedns"
-}
 /**
  * A hash value that uniquely identifies a single ENS name.
  * Result of `namehash` function as specified in ENSIP-1.
@@ -21,6 +15,12 @@ declare enum PluginName {
  * @link https://docs.ens.domains/ensip/1#namehash-algorithm
  */
 type Node = Hex;
+/**
+ * A Name represents a human-readable ENS name.
+ *
+ * ex: vitalik.eth
+ */
+type Name = string;
 /**
  * A LabelHash is the result of the labelhash function (which is just keccak256) on a Label.
  *
@@ -41,12 +41,6 @@ type Label = string;
  * @example [abcd].example.eth
  */
 type EncodedLabelHash = `[${string}]`;
-/**
- * A Name represents a human-readable ENS name.
- *
- * ex: vitalik.eth
- */
-type Name = string;
 
 declare const ROOT_NODE: Node;
 /**
@@ -56,12 +50,46 @@ declare const ROOT_NODE: Node;
  * See apps/ensindexer/src/handlers/Registry.ts for context.
  */
 declare const REVERSE_ROOT_NODES: Set<Node>;
+
 /**
- * The ETH coinType.
+ * Implements one step of the namehash algorithm, combining `labelHash` with `node` to produce
+ * the `node` of a given subdomain. Note that the order of the arguments is 'reversed' (as compared to
+ * the actual concatenation) in order to improve readability (i.e. read as [labelHash].[node]).
+ */
+declare const makeSubdomainNode: (labelHash: LabelHash, node: Node) => Node;
+/**
+ * Attempt to heal the labelHash of an addr.reverse subname using an address that might be related to the subname.
  *
- * @see https://docs.ens.domains/ensip/9
+ * @throws if maybeReverseAddress is not a valid Address
+ * @throws if labelHash is not a valid Labelhash
+ *
+ * @returns the original label if healed, otherwise null
+ */
+declare const maybeHealLabelByReverseAddress: ({ maybeReverseAddress, labelHash, }: {
+    /** The address that is possibly associated with the addr.reverse subname */
+    maybeReverseAddress: Address;
+    /** The labelhash of the addr.reverse subname */
+    labelHash: LabelHash;
+}) => string | null;
+/**
+ * Encodes a uint256 bigint as hex string sized to 32 bytes.
+ * Uses include, in the context of ENS, decoding the uint256-encoded tokenId of NFT-issuing contracts
+ * into Node or LabelHash, which is a common behavior in the ENS ecosystem.
+ * (see NameWrapper, ETHRegistrarController)
+ */
+declare const uint256ToHex32: (num: bigint) => `0x${string}`;
+/**
+ * Check if any characters in `label` are "unindexable".
+ *
+ * Related logic in ENS Subgraph:
+ * https://github.com/ensdomains/ens-subgraph/blob/c844791/src/utils.ts#L68
+ *
+ * @param label - The label to check. Note:
+ * A `null` value for `label` represents an unhealable labelhash.
+ *
+ * @returns `true` if the label is indexable, `false` otherwise.
  */
-declare const ETH_COIN_TYPE = 60n;
+declare const isLabelIndexable: (label: Label | null) => label is Label;
 
 /**
  * Cache that maps from string -> ValueType.
@@ -119,43 +147,1226 @@ declare class LruCache<KeyType extends string, ValueType> implements Cache<KeyTy
 }
 
 /**
- * Implements one step of the namehash algorithm, combining `labelHash` with `node` to produce
- * the `node` of a given subdomain. Note that the order of the arguments is 'reversed' (as compared to
- * the actual concatenation) in order to improve readability (i.e. read as [labelHash].[node]).
+ * Filter out duplicates.
  */
-declare const makeSubdomainNode: (labelHash: LabelHash, node: Node) => Node;
+declare const uniq: <T>(arr: T[]) => T[];
+
 /**
- * Attempt to heal the labelHash of an addr.reverse subname using an address that might be related to the subname.
+ * Chain ID
  *
- * @throws if maybeReverseAddress is not a valid Address
- * @throws if labelHash is not a valid Labelhash
+ * Represents a unique identifier for a chain.
+ * Guaranteed to be a positive integer.
+ **/
+type ChainId = number;
+/**
+ * Block Number
  *
- * @returns the original label if healed, otherwise null
+ * Guaranteed to be a non-negative integer.
  */
-declare const maybeHealLabelByReverseAddress: ({ maybeReverseAddress, labelHash, }: {
-    /** The address that is possibly associated with the addr.reverse subname */
-    maybeReverseAddress: Address;
-    /** The labelhash of the addr.reverse subname */
-    labelHash: LabelHash;
-}) => string | null;
+type BlockNumber = number;
 /**
- * Encodes a uint256 bigint as hex string sized to 32 bytes.
- * Uses include, in the context of ENS, decoding the uint256-encoded tokenId of NFT-issuing contracts
- * into Node or LabelHash, which is a common behavior in the ENS ecosystem.
- * (see NameWrapper, ETHRegistrarController)
+ * Datetime value
  */
-declare const uint256ToHex32: (num: bigint) => `0x${string}`;
+type Datetime = Date;
 /**
- * Check if any characters in `label` are "unindexable".
+ * Unix timestamp value
  *
- * Related logic in ENS Subgraph:
- * https://github.com/ensdomains/ens-subgraph/blob/c844791/src/utils.ts#L68
+ * Guaranteed to be an integer.
+ */
+type UnixTimestamp = number;
+/**
+ * Represents a URL that is used for RPC endpoints.
+ */
+type RpcUrl = URL;
+/**
+ * BlockRef
  *
- * @param label - The label to check. Note:
- * A `null` value for `label` represents an unhealable labelhash.
+ * Describes a block.
  *
- * @returns `true` if the label is indexable, `false` otherwise.
+ * We use parameter types to maintain fields layout and documentation across
+ * the domain model and its serialized counterpart.
  */
-declare const isLabelIndexable: (label: Label | null) => label is Label;
+interface BlockRef {
+    /** Block number (height) */
+    number: BlockNumber;
+    /** Block timestamp */
+    timestamp: UnixTimestamp;
+}
+/**
+ * Block range
+ *
+ * Represents a range of blocks
+ */
+interface Blockrange<BlockType = BlockNumber> {
+    /** Start block number */
+    startBlock?: BlockType;
+    /** End block number */
+    endBlock?: BlockType;
+}
+/**
+ * Duration
+ *
+ * Representing a duration in seconds.
+ *
+ * Guaranteed to be a non-negative integer.
+ */
+type Duration = number;
+/**
+ * A utility type that makes all properties of a type optional recursively,
+ * including nested objects and arrays.
+ *
+ * @example
+ * ```typescript
+ * type Config = {
+ *   a: string;
+ *   b: {
+ *     x: number;
+ *     y: { z: boolean };
+ *   };
+ *   c: { id: string }[];
+ * }
+ *
+ * type PartialConfig = DeepPartial<Config>;
+ * // Results in:
+ * // {
+ * //   a?: string;
+ * //   b?: {
+ * //     x?: number;
+ * //     y?: { z?: boolean };
+ * //   };
+ * //   c?: { id?: string }[];
+ * // }
+ *
+ * // Usage:
+ * const update: PartialConfig = { b: { y: { z: true } } };
+ * ```
+ */
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? DeepPartial<U>[] : T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+
+/**
+ * A string representation of {@link ChainId}.
+ **/
+type ChainIdString = string;
+/**
+ * Datetime value following the ISO 8601 standard.
+ *
+ * @see https://www.iso.org/iso-8601-date-and-time-format.html
+ */
+type DatetimeISO8601 = string;
+/**
+ * A string representation of a {@link URL}.
+ */
+type UrlString = string;
+
+/**
+ * Serializes a {@link ChainId} value into its string representation.
+ */
+declare function serializeChainId(chainId: ChainId): ChainIdString;
+/**
+ * Serializes a {@link Datetime} value into its string representation.
+ */
+declare function serializeDatetime(datetime: Datetime): DatetimeISO8601;
+/**
+ * Serializes a {@link URL} value into its string representation.
+ */
+declare function serializeUrl(url: URL): UrlString;
+
+declare function deserializeChainId(maybeChainId: ChainIdString, valueLabel?: string): ChainId;
+declare function deserializeDatetime(maybeDatetime: string, valueLabel?: string): Datetime;
+declare function deserializeUrl(maybeUrl: UrlString, valueLabel?: string): URL;
+declare function deserializeBlockNumber(maybeBlockNumber: number, valueLabel?: string): BlockNumber;
+declare function deserializeBlockrange(maybeBlockrange: Partial<Blockrange>, valueLabel?: string): {
+    startBlock?: number | undefined;
+    endBlock?: number | undefined;
+};
+declare function deserializeBlockRef(maybeBlockRef: Partial<BlockRef>, valueLabel?: string): BlockRef;
+declare function deserializeDuration(maybeDuration: string, valueLabel?: string): Duration;
+
+declare function isNormalized(name: Name): 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: ChainId;
+/**
+ * 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;
+
+/**
+ * Constructs a name hierarchy from a given Name.
+ * i.e. sub.example.eth -> [sub.example.eth, example.eth, eth]
+ */
+declare const getNameHierarchy: (name: Name) => Name[];
+
+/**
+ * Gets the Label used for the reverse names of subnames as per ENSIP-11 & ENSIP-19.
+ *
+ * @see https://docs.ens.domains/ensip/19/#reverse-resolution
+ */
+declare const addrReverseLabel: (address: Address) => Label;
+/**
+ * Converts `coinType` to prefix-free hex string.
+ *
+ * @see https://docs.ens.domains/ensip/19
+ */
+declare const coinTypeReverseLabel: (coinType: CoinType) => Label;
+/**
+ * Gets the reverse name for an address according to ENSIP-11 & ENSIP-19.
+ *
+ * @see https://docs.ens.domains/ensip/11#specification
+ * @see https://docs.ens.domains/ensip/19#specification
+ *
+ * @param address - The address to get the reverse name for
+ * @param coinType - The coin type to use for the reverse name
+ * @returns The reverse name for the address
+ *
+ * @example
+ * ```ts
+ * reverseName("0x1234", BigInt(ETH_COIN_TYPE)) // "1234.addr.reverse"
+ * reverseName("0x1234", BigInt(0x80000000)) // "1234.default.reverse"
+ * reverseName("0x1234", BigInt(0x5678)) // "1234.5678.reverse"
+ * ```
+ */
+declare function reverseName(address: Address, coinType: CoinType): Name;
+
+/**
+ * Parse the address and coinType out of an ENSIP-19 reverse name.
+ */
+declare function parseReverseName(name: Name): {
+    address: Address;
+    coinType: CoinType;
+} | null;
+
+/**
+ * A PluginName is a unique id for a 'plugin': we use the notion of
+ * 'plugins' to describe bundles of indexing logic.
+ */
+declare enum PluginName {
+    Subgraph = "subgraph",
+    Basenames = "basenames",
+    Lineanames = "lineanames",
+    ThreeDNS = "threedns",
+    ReverseResolvers = "reverse-resolvers",
+    Referrals = "referrals"
+}
+/**
+ * Information about ENSIndexer's dependencies.
+ */
+interface DependencyInfo {
+    /** Node.js runtime version */
+    nodejs: string;
+    /** Ponder framework version */
+    ponder: string;
+    /** ENSRainbow service version */
+    ensRainbow: string;
+    /** ENSRainbow schema version */
+    ensRainbowSchema: number;
+}
+/**
+ * Complete public configuration object for ENSIndexer.
+ *
+ * We use parameter types to maintain fields layout and documentation across
+ * the domain model and its serialized counterpart.
+ */
+interface ENSIndexerPublicConfig {
+    /**
+     * The ENS namespace that ENSNode operates in the context of.
+     *
+     * See {@link ENSNamespaceIds} for available namespace identifiers.
+     */
+    namespace: ENSNamespaceId;
+    /**
+     * An ENSAdmin URL
+     *
+     * The ENSNode root api route `/` redirects to {@link ensAdminUrl},
+     * configuring ENSAdmin with an entry for this instance of ENSNode,
+     * identified by {@link ensNodePublicUrl}.
+     *
+     * @see https://ensnode.io/ensadmin/overview/what-is-ensadmin
+     */
+    ensAdminUrl: URL;
+    /**
+     * The publicly accessible endpoint of the ENSNode API
+     * (ex: http://localhost:42069).
+     *
+     * ENSAdmin will use this url to connect to the ENSNode api for querying
+     * state about the ENSNode instance.
+     */
+    ensNodePublicUrl: URL;
+    /**
+     * A Postgres database schema name. This instance of ENSIndexer will write
+     * indexed data to the tables in this schema.
+     *
+     * Invariants:
+     * - Must be a non-empty string that is a valid Postgres database schema
+     *   identifier.
+     */
+    databaseSchemaName: string;
+    /**
+     * A set of {@link PluginName}s indicating which plugins to activate.
+     *
+     * Invariants:
+     * - A set of valid {@link PluginName}s with at least one value
+     */
+    plugins: PluginName[];
+    /**
+     * Enable or disable healing of addr.reverse subnames.
+     * If this is set to true, ENSIndexer will attempt to heal subnames of
+     * addr.reverse.
+     */
+    healReverseAddresses: boolean;
+    /**
+     * Enable or disable the indexing of Resolver record values.
+     * If this is set to false, ENSIndexer will apply subgraph-backwards
+     * compatible logic that only tracks the keys of Resolver records.
+     * If this is set to true, ENSIndexer will track both the keys and the values
+     * of Resolver records.
+     *
+     * WARNING: Special care must be taken when interacting with indexed resolver
+     * record values. It is unsafe to naively assume that indexed resolver record
+     * values are equivalent to the resolver record values that would be returned
+     * through dynamic lookups via the ENS protocol. For example, if a resolver
+     * implements CCIP-Read, the resolver records may not be discoverable through
+     * onchain indexing. This feature is under R&D. At this time we do not
+     * recommend anyone directly use indexed resolver record values in their
+     * applications. Features are planned in the ENSNode roadmap that will
+     * provide safe use of indexed resolver record values (in appropriate
+     * contexts).
+     *
+     * Note that enabling {@link indexAdditionalResolverRecords} results in
+     * indexed data becoming a _superset_ of the Subgraph. For exact data-level
+     * backwards compatibility with the ENS Subgraph,
+     * {@link indexAdditionalResolverRecords} should be `false`.
+     */
+    indexAdditionalResolverRecords: boolean;
+    /**
+     * Indexed Chain IDs
+     *
+     * Includes the {@link ChainId} for each chain being indexed.
+     */
+    indexedChainIds: Set<ChainId>;
+    /**
+     * A flag derived from the built config indicating whether ENSIndexer is operating in a
+     * subgraph-compatible way. This flag is true if:
+     * a) only the subgraph plugin is activated,
+     * b) healReverseAddresess is false, and
+     * c) indexRecordValues is false
+     *
+     * If {@link isSubgraphCompatible} is true, ENSIndexer will:
+     * 1) use subgraph-compatible IDs for entities and events
+     * 2) limit indexing behavior to subgraph indexing semantics
+     */
+    isSubgraphCompatible: boolean;
+    /**
+     * Information about the ENSIndexer instance dependencies.
+     */
+    dependencyInfo: DependencyInfo;
+}
+
+type SerializedIndexedChainIds = Array<ChainId>;
+/**
+ * Serialized representation of {@link ENSIndexerPublicConfig}
+ */
+interface SerializedENSIndexerPublicConfig extends Omit<ENSIndexerPublicConfig, "ensAdminUrl" | "ensNodePublicUrl" | "indexedChainIds"> {
+    /**
+     * String representation of {@link ENSIndexerPublicConfig.ensAdminUrl}.
+     */
+    ensAdminUrl: UrlString;
+    /**
+     * String representation of {@link ENSIndexerPublicConfig.ensNodePublicUrl}.
+     */
+    ensNodePublicUrl: UrlString;
+    /**
+     * Array representation of {@link ENSIndexerPublicConfig.indexedChainIds}.
+     */
+    indexedChainIds: ChainId[];
+}
+
+/**
+ * Serialize a {@link ENSIndexerPublicConfig} object.
+ */
+declare function deserializeENSIndexerPublicConfig(maybeConfig: SerializedENSIndexerPublicConfig, valueLabel?: string): ENSIndexerPublicConfig;
+
+/**
+ * Subgraph compatibility
+ *
+ * Tells if indexer config guarantees data to be indexed while
+ * maintaining full subgraph-compatibility.
+ */
+declare function isSubgraphCompatible(config: Pick<ENSIndexerPublicConfig, "plugins" | "healReverseAddresses" | "indexAdditionalResolverRecords">): boolean;
+
+/**
+ * Serializes a {@link ChainConfig} object.
+ */
+declare function serializeIndexedChainIds(indexedChainIds: Set<ChainId>): SerializedIndexedChainIds;
+/**
+ * Serialize a {@link ENSIndexerPublicConfig} object.
+ */
+declare function serializeENSIndexerPublicConfig(config: ENSIndexerPublicConfig): SerializedENSIndexerPublicConfig;
+
+declare const ChainIndexingStatusIds: {
+    readonly Unstarted: "unstarted";
+    readonly Backfill: "backfill";
+    readonly Following: "following";
+    readonly Completed: "completed";
+};
+/**
+ * ChainIndexingStatusId is the derived string union of possible Chain Indexing Status identifiers.
+ */
+type ChainIndexingStatusId = (typeof ChainIndexingStatusIds)[keyof typeof ChainIndexingStatusIds];
+declare const OverallIndexingStatusIds: {
+    readonly Unstarted: "unstarted";
+    readonly Backfill: "backfill";
+    readonly Following: "following";
+    readonly Completed: "completed";
+    readonly IndexerError: "indexer-error";
+};
+/**
+ * OverallIndexingStatusId is the derived string union of possible Overall Indexing Status identifiers.
+ */
+type OverallIndexingStatusId = (typeof OverallIndexingStatusIds)[keyof typeof OverallIndexingStatusIds];
+declare const ChainIndexingStrategyIds: {
+    readonly Indefinite: "indefinite";
+    readonly Definite: "definite";
+};
+/**
+ * ChainIndexingStrategyIds is the derived string union of possible Chain Indexing Strategy identifiers.
+ */
+type ChainIndexingStrategyId = (typeof ChainIndexingStrategyIds)[keyof typeof ChainIndexingStrategyIds];
+/**
+ * Chain Indexing Indefinite Config
+ *
+ * Configures a chain to be indexed for an indefinite range.
+ */
+interface ChainIndexingIndefiniteConfig {
+    /**
+     * Chain indexing strategy.
+     */
+    strategy: typeof ChainIndexingStrategyIds.Indefinite;
+    /**
+     * The block where indexing of the chain starts.
+     *
+     * An indexed chain always has its `startBlock` defined.
+     */
+    startBlock: BlockRef;
+    /**
+     * Indefinite chain indexing configs always have a null `endBlock`.
+     */
+    endBlock?: null;
+}
+/**
+ * Chain Indexing Definite Config
+ *
+ * Configures a chain to be indexed for a definite range.
+ *
+ * Invariants:
+ * - `startBlock` is always before or the same as `endBlock`
+ */
+interface ChainIndexingDefiniteConfig {
+    /**
+     * Chain indexing strategy.
+     */
+    strategy: typeof ChainIndexingStrategyIds.Definite;
+    /**
+     * The block where indexing of the chain starts.
+     *
+     * `startBlock` must always be defined.
+     */
+    startBlock: BlockRef;
+    /**
+     * The block where indexing of the chain ends.
+     *
+     * Definite chain indexing configs always have a defined `endBlock`.
+     */
+    endBlock: BlockRef;
+}
+/**
+ * Chain Indexing Config
+ *
+ * Configuration of an indexed chain.
+ */
+type ChainIndexingConfig = ChainIndexingIndefiniteConfig | ChainIndexingDefiniteConfig;
+/**
+ * Chain Indexing Status: Unstarted
+ *
+ * Notes:
+ * - The "unstarted" status applies when using omnichain ordering and
+ *   the omnichainIndexingCursor from the overall indexing status <= config.startBlock.timestamp.
+ */
+interface ChainIndexingUnstartedStatus {
+    status: typeof ChainIndexingStatusIds.Unstarted;
+    config: ChainIndexingConfig;
+}
+/**
+ * Chain Indexing Status: Backfill
+ *
+ * During a backfill, special performance optimizations are applied to
+ * index all blocks between config.startBlock and backfillEndBlock
+ * as fast as possible.
+ *
+ * Notes:
+ * - The backfillEndBlock is either config.endBlock (if present) or
+ *   the latest block on the chain when the ENSIndexer process started up.
+ *   Note how this means the backfillEndBlock is always a "fixed target".
+ * - When latestIndexedBlock reaches backfillEndBlock, the backfill is complete.
+ *   The moment backfill is complete the status does not immediately transition.
+ *   Instead, internal processing is completed for a period of time while
+ *   the status remains "backfill". After this internal processing is completed
+ *   the status will change to "following" or "completed" depending on
+ *   the configured indexing strategy. If the strategy is indefinite,
+ *   changes to "following", else if the strategy is definite, changes to
+ *   "completed".
+ *
+ * Invariants:
+ * - `config.startBlock` is always before or the same as `latestIndexedBlock`
+ * - `latestIndexedBlock` is always before or the same as `backfillEndBlock`
+ * - `backfillEndBlock` is the same as `config.endBlock` if and only if
+ *   the config is definite.
+ */
+interface ChainIndexingBackfillStatus {
+    status: typeof ChainIndexingStatusIds.Backfill;
+    config: ChainIndexingConfig;
+    /**
+     * The block that was most recently indexed.
+     */
+    latestIndexedBlock: BlockRef;
+    /**
+     * The block that is the target for finishing the backfill.
+     */
+    backfillEndBlock: BlockRef;
+}
+/**
+ * Chain Indexing Status: Following
+ *
+ * Following occurs after the backfill of a chain is completed and represents
+ * the process of indefinitely following (and indexing!) new blocks as they are
+ * added to the indexed chain across time.
+ *
+ * Invariants:
+ * - `config.startBlock` is always before or the same as `latestIndexedBlock`
+ * - `latestIndexedBlock` is always before or the same as `latestKnownBlock`
+ */
+interface ChainIndexingFollowingStatus {
+    status: typeof ChainIndexingStatusIds.Following;
+    config: ChainIndexingIndefiniteConfig;
+    /**
+     * The block that was most recently indexed.
+     */
+    latestIndexedBlock: BlockRef;
+    /**
+     * The "highest" block that has been fetched by RPC calls and stored in
+     * the RPC cache as part of the indexing process.
+     */
+    latestKnownBlock: BlockRef;
+    /**
+     * The number of seconds between `latestIndexedBlock.timestamp` and
+     * the current time in ENSIndexer. This represents the upper-bound worst case
+     * distance approximation between the latest block on the chain (independent
+     * of it becoming known to us) and the latest block that has completed
+     * indexing. The true distance to the latest block on the chain will be less
+     * if the latest block on the chain was not issued at the current second.
+     */
+    approxRealtimeDistance: Duration;
+}
+/**
+ * Chain Indexing Status: Completed
+ *
+ * Indexing of a chain is completed after the backfill when the chain is
+ * not configured to be indefinitely indexed.
+ *
+ * Invariants:
+ * - `config.startBlock` is always before or the same as `latestIndexedBlock`
+ * - `latestIndexedBlock` is always the same as `config.endBlock`.
+ */
+interface ChainIndexingCompletedStatus {
+    status: typeof ChainIndexingStatusIds.Completed;
+    config: ChainIndexingDefiniteConfig;
+    /**
+     * The block that was most recently indexed.
+     */
+    latestIndexedBlock: BlockRef;
+}
+/**
+ * Chain Indexing Status
+ *
+ * Use the `status` field to determine the correct type interpretation at runtime.
+ */
+type ChainIndexingStatus = ChainIndexingUnstartedStatus | ChainIndexingBackfillStatus | ChainIndexingFollowingStatus | ChainIndexingCompletedStatus;
+/**
+ * Chain Indexing Status: Active
+ *
+ * Represents a chain where indexing is currently active.
+ * The `latestIndexedBlock` field will be available.
+ */
+type ChainIndexingActiveStatus = ChainIndexingBackfillStatus | ChainIndexingFollowingStatus;
+/**
+ * Chain Indexing Status: Standby
+ *
+ * Represents a chain where indexing is currently on standby (not happening).
+ * The `latestIndexedBlock` field will not be available.
+ */
+type ChainIndexingStandbyStatus = ChainIndexingUnstartedStatus | ChainIndexingCompletedStatus;
+/**
+ * ENSIndexer Overall Indexing Status: Unstarted
+ *
+ * Describes the current state of indexing operations across all indexed chains
+ * when the overall indexing status is {@link OverallIndexingStatusIds.Unstarted}.
+ */
+interface ENSIndexerOverallIndexingUnstartedStatus {
+    /**
+     * Overall Indexing Status
+     */
+    overallStatus: typeof OverallIndexingStatusIds.Unstarted;
+    /**
+     * Indexing Status for each chain.
+     *
+     * Each chain is guaranteed to have the "unstarted" status.
+     * It's impossible for any chain to have status other than "unstarted".
+     */
+    chains: Map<ChainId, ChainIndexingUnstartedStatus>;
+}
+/**
+ * Chain Indexing Status allowed when overall status is 'backfill'.
+ */
+type ChainIndexingStatusForBackfillOverallStatus = ChainIndexingUnstartedStatus | ChainIndexingBackfillStatus | ChainIndexingCompletedStatus;
+/**
+ * ENSIndexer Overall Indexing Status: Backfill
+ *
+ * Describes the current state of indexing operations across all indexed chains
+ * when the overall indexing status is {@link OverallIndexingStatusIds.Backfill}.
+ */
+interface ENSIndexerOverallIndexingBackfillStatus {
+    /**
+     * Overall Indexing Status
+     */
+    overallStatus: typeof OverallIndexingStatusIds.Backfill;
+    /**
+     * Omnichain Indexing Cursor
+     *
+     * Identifies the timestamp of the progress of omnichain indexing across
+     * all chains in {@link ChainIndexingBackfillStatus} status.
+     *
+     * Invariants:
+     * - the cursor value is guaranteed to be lower than or equal to
+     *   the timestamp of the earliest `config.startBlock` across all chains
+     *   in {@link ChainIndexingStandbyStatus} status.
+     */
+    omnichainIndexingCursor: UnixTimestamp;
+    /**
+     * Indexing Status for each chain.
+     *
+     * At least one chain is guaranteed to be in the "backfill" status.
+     * Each chain is guaranteed to have a status of either "unstarted",
+     * "backfill" or "completed". It's impossible for any chain to be
+     * in the "following" status.
+     */
+    chains: Map<ChainId, ChainIndexingStatusForBackfillOverallStatus>;
+}
+/**
+ * ENSIndexer Overall Indexing Status: Completed
+ *
+ * Describes the final state of indexing operations across all indexed chains
+ * when all indexed chains are configured for a definite indexing strategy and
+ * all indexing of that definite range is completed.
+ */
+interface ENSIndexerOverallIndexingCompletedStatus {
+    /**
+     * Overall Indexing Status
+     */
+    overallStatus: typeof OverallIndexingStatusIds.Completed;
+    /**
+     * Indexing Status for each chain.
+     *
+     * Each chain is guaranteed to have the "completed" status.
+     * It's impossible for any chain to have status other than "completed".
+     */
+    chains: Map<ChainId, ChainIndexingCompletedStatus>;
+}
+/**
+ * ENSIndexer Overall Indexing Status: Following
+ *
+ * Describes the state when the overall indexing status is
+ * {@link OverallIndexingStatusIds.Following}.
+ */
+interface ENSIndexerOverallIndexingFollowingStatus {
+    /**
+     * Overall Indexing Status
+     */
+    overallStatus: typeof OverallIndexingStatusIds.Following;
+    /**
+     * Omnichain Indexing Cursor
+     *
+     * Identifies the timestamp of the progress of omnichain indexing across
+     * all chains in {@link ChainIndexingActiveStatus} status.
+     *
+     * Invariants:
+     * - the cursor value is guaranteed to be lower than or equal to
+     *   the timestamp of the earliest `config.startBlock` across all chains
+     *   in {@link ChainIndexingStandbyStatus} status.
+     */
+    omnichainIndexingCursor: UnixTimestamp;
+    /**
+     * Indexing Status for each chain.
+     *
+     * At least one chain is guaranteed to be in the "following" status.
+     * Each chain is guaranteed to have a status of either "unstarted",
+     * "backfill", "following" or "completed".
+     */
+    chains: Map<ChainId, ChainIndexingStatus>;
+    /**
+     * The maximum
+     * {@link ChainIndexingFollowingStatus.approxRealtimeDistance} value
+     * across all chains with status: 'following'.
+     */
+    overallApproxRealtimeDistance: Duration;
+}
+/**
+ * ENSIndexer Overall Indexing Status: Error
+ *
+ * Describes the state when ENSIndexer failed to return the indexing status for
+ * all indexed chains.
+ *
+ * This state suggests an error with the "primary" ENSIndexer.
+ */
+interface ENSIndexerOverallIndexingErrorStatus {
+    /**
+     * Overall Indexing Status
+     */
+    overallStatus: typeof OverallIndexingStatusIds.IndexerError;
+}
+/**
+ * ENSIndexer Overall Indexing Status
+ *
+ * Describes the overall state of indexing operations.
+ */
+type ENSIndexerOverallIndexingStatus = ENSIndexerOverallIndexingUnstartedStatus | ENSIndexerOverallIndexingBackfillStatus | ENSIndexerOverallIndexingCompletedStatus | ENSIndexerOverallIndexingFollowingStatus | ENSIndexerOverallIndexingErrorStatus;
+
+/**
+ * Serialized representation of {@link ENSIndexerOverallIndexingUnstartedStatus}
+ */
+interface SerializedENSIndexerOverallIndexingUnstartedStatus extends Omit<ENSIndexerOverallIndexingUnstartedStatus, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingUnstartedStatus>;
+}
+/**
+ * Serialized representation of {@link ENSIndexerOverallIndexingBackfillStatus}
+ */
+interface SerializedENSIndexerOverallIndexingBackfillStatus extends Omit<ENSIndexerOverallIndexingBackfillStatus, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatusForBackfillOverallStatus>;
+}
+/**
+ * Serialized representation of {@link ENSIndexerOverallIndexingCompletedStatus}
+ */
+interface SerializedENSIndexerOverallIndexingCompletedStatus extends Omit<ENSIndexerOverallIndexingCompletedStatus, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingCompletedStatus>;
+}
+/**
+ * Serialized representation of {@link ENSIndexerOverallIndexingFollowingStatus}
+ */
+interface SerializedENSIndexerOverallIndexingFollowingStatus extends Omit<ENSIndexerOverallIndexingFollowingStatus, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatus>;
+}
+/**
+ * Serialized representation of {@link ENSIndexerOverallIndexingErrorStatus}
+ */
+interface SerializedENSIndexerOverallIndexingErrorStatus extends ENSIndexerOverallIndexingErrorStatus {
+}
+/**
+ * Serialized representation of {@link ENSIndexerOverallIndexingStatus}
+ */
+type SerializedENSIndexerOverallIndexingStatus = SerializedENSIndexerOverallIndexingUnstartedStatus | SerializedENSIndexerOverallIndexingBackfillStatus | SerializedENSIndexerOverallIndexingCompletedStatus | SerializedENSIndexerOverallIndexingFollowingStatus | SerializedENSIndexerOverallIndexingErrorStatus;
+
+/**
+ * Serialize a {@link ENSIndexerOverallIndexingStatus} object.
+ */
+declare function deserializeENSIndexerIndexingStatus(maybeStatus: SerializedENSIndexerOverallIndexingStatus, valueLabel?: string): ENSIndexerOverallIndexingStatus;
+
+/**
+ * Get {@link OverallIndexingStatusId} based on indexed chains' statuses.
+ *
+ * This function decides what is the current overall indexing status,
+ * based on provided chain indexing statuses. The fact that chain indexing
+ * statuses were provided to this function guarantees there was no indexer
+ * error, and that the overall indexing status is never
+ * an {@link OverallIndexingStatusIds.IndexerError}
+ */
+declare function getOverallIndexingStatus(chains: ChainIndexingStatus[]): Exclude<OverallIndexingStatusId, typeof OverallIndexingStatusIds.IndexerError>;
+/**
+ * Get overall approximate realtime distance across all indexed chains.
+ *
+ * @throws an error if none of the indexed chains was in the 'following' status.
+ */
+declare function getOverallApproxRealtimeDistance(chains: ChainIndexingStatus[]): Duration;
+/**
+ * Get Omnichain Indexing Cursor across all chains which status is
+ * {@link ChainIndexingActiveStatus}.
+ */
+declare function getOmnichainIndexingCursor(chains: ChainIndexingActiveStatus[]): UnixTimestamp;
+/**
+ * Get all chains which status is {@link ChainIndexingActiveStatus}.
+ */
+declare function getActiveChains(chains: ChainIndexingStatus[]): ChainIndexingActiveStatus[];
+/**
+ * Get all chains which status is {@link ChainIndexingStandbyStatus}.
+ */
+declare function getStandbyChains(chains: ChainIndexingStatus[]): ChainIndexingStandbyStatus[];
+/**
+ * Create {@link ChainIndexingConfig} for given block refs.
+ *
+ * @param startBlock required block ref
+ * @param endBlock optional block ref
+ */
+declare function createIndexingConfig(startBlock: BlockRef, endBlock: BlockRef | null): ChainIndexingConfig;
+/**
+ * Check if Chain Indexing Statuses fit the 'unstarted' overall status
+ * requirements:
+ * - All chains are guaranteed to have a status of "unstarted".
+ *
+ * Note: This function narrows the {@link ChainIndexingStatus} type to
+ * {@link ChainIndexingUnstartedStatus}.
+ */
+declare function checkChainIndexingStatusesForUnstartedOverallStatus(chains: ChainIndexingStatus[]): chains is ChainIndexingUnstartedStatus[];
+/**
+ * Check if Chain Indexing Statuses fit the 'backfill' overall status
+ * requirements:
+ * - At least one chain is guaranteed to be in the "backfill" status.
+ * - Each chain is guaranteed to have a status of either "unstarted",
+ *   "backfill" or "completed".
+ *
+ * Note: This function narrows the {@linkChainIndexingStatus} type to
+ * {@link ChainIndexingStatusForBackfillOverallStatus}.
+ */
+declare function checkChainIndexingStatusesForBackfillOverallStatus(chains: ChainIndexingStatus[]): chains is ChainIndexingStatusForBackfillOverallStatus[];
+/**
+ * Checks if Chain Indexing Statuses fit the 'completed' overall status
+ * requirements:
+ * - All chains are guaranteed to have a status of "completed".
+ *
+ * Note: This function narrows the {@linkChainIndexingStatus} type to
+ * {@link ChainIndexingCompletedStatus}.
+ */
+declare function checkChainIndexingStatusesForCompletedOverallStatus(chains: ChainIndexingStatus[]): chains is ChainIndexingCompletedStatus[];
+/**
+ * Checks Chain Indexing Statuses fit the 'following' overall status
+ * requirements:
+ * - At least one chain is guaranteed to be in the "following" status.
+ * - Any other chain can have any status.
+ */
+declare function checkChainIndexingStatusesForFollowingOverallStatus(chains: ChainIndexingStatus[]): chains is ChainIndexingStatus[];
+
+/**
+ * Serialize chain indexing statuses.
+ */
+declare function serializeChainIndexingStatuses<ChainIndexingStatusType extends ChainIndexingStatus>(chainIndexingStatuses: Map<ChainId, ChainIndexingStatusType>): Record<ChainIdString, ChainIndexingStatusType>;
+/**
+ * Serialize a {@link ENSIndexerIndexingStatus} object.
+ */
+declare function serializeENSIndexerIndexingStatus(indexingStatus: ENSIndexerOverallIndexingStatus): SerializedENSIndexerOverallIndexingStatus;
+
+/**
+ * Identifiers for each traceable ENS protocol.
+ */
+declare enum TraceableENSProtocol {
+    ForwardResolution = "forward-resolution",
+    ReverseResolution = "reverse-resolution"
+}
+/**
+ * Encodes the set of well-known steps in the ENS Forward Resolution protocol.
+ */
+declare enum ForwardResolutionProtocolStep {
+    Operation = "operation",
+    FindResolver = "find-resolver",
+    ActiveResolverExists = "active-resolver-exists",
+    AccelerateENSIP19ReverseResolver = "accelerate-ensip-19-reverse-resolver",
+    AccelerateKnownOffchainLookupResolver = "accelerate-known-offchain-lookup-resolver",
+    AccelerateKnownOnchainStaticResolver = "accelerate-known-onchain-static-resolver",
+    RequireResolver = "require-resolver",
+    ExecuteResolveCalls = "execute-resolve-calls"
+}
+/**
+ * Encodes the set of well-known steps in the ENS Reverse Resolution protocol.
+ */
+declare enum ReverseResolutionProtocolStep {
+    Operation = "operation",
+    ResolveReverseName = "resolve-reverse-name",
+    NameRecordExists = "name-record-exists-check",
+    ForwardResolveAddressRecord = "forward-resolve-address-record",
+    VerifyResolvedAddressMatchesAddress = "verify-resolved-address-matches-address"
+}
+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";
+/**
+ * Re-implements hrTimeToMicroseconds to avoid a dependency on @opentelemetry/core.
+ *
+ * @see https://github.com/open-telemetry/opentelemetry-js/blob/41ba7f57cbf5ae22290168188b467e0c60cd4765/packages/opentelemetry-core/src/common/time.ts#L135
+ */
+declare function hrTimeToMicroseconds(time: [number, number]): number;
+/**
+ * Encodes a ReadableSpan as a consumer-friendly and externally-visible JSON-representable object.
+ *
+ * NOTE: to avoid a dependency on @opentelemetry/sdk-trace-base and an obscure typing issue related
+ * to the patched version necessary for it to run in ENSIndexer, we type the span as `any`, but note
+ * that it is ReadableSpan.
+ */
+declare const readableSpanToProtocolSpan: (span: any) => {
+    id: any;
+    traceId: any;
+    parentSpanContext: any;
+    name: any;
+    timestamp: number;
+    duration: number;
+    attributes: {
+        [k: string]: unknown;
+    };
+    status: any;
+    events: any;
+};
+type ProtocolSpan = ReturnType<typeof readableSpanToProtocolSpan>;
+type ProtocolTrace = ProtocolSpan[];
+
+/**
+ * Encodes a selection of Resolver records in the context of a specific Name.
+ */
+interface ResolverRecordsSelection {
+    /**
+     * Whether to fetch the name's `name` record. This value is primarily used in the context of
+     * Reverse Resolution.
+     *
+     * @see https://docs.ens.domains/ensip/19/#reverse-resolution
+     */
+    name?: boolean;
+    /**
+     * Which coinTypes to fetch address records for.
+     */
+    addresses?: CoinType[];
+    /**
+     * Which keys to fetch text records for.
+     */
+    texts?: string[];
+}
+declare const DEFAULT_RECORDS_SELECTION: {
+    readonly addresses: [CoinType];
+    readonly texts: ["url", "avatar", "header", "description", "email", "com.twitter", "com.farcaster", "com.github"];
+};
+declare const isSelectionEmpty: (selection: ResolverRecordsSelection) => boolean;
+
+/**
+ * An internal type representing a non-inferred ResolverRecordsResponse, used in situations where
+ * access to the more specific inferred type (ResolverRecordsResponse<SELECTION>) is difficult or
+ * unnecessary.
+ */
+type ResolverRecordsResponseBase = {
+    /**
+     * The name record, relevant in the context of Reverse Resolution.
+     * Null if no name record is set.
+     */
+    name: Name | null;
+    /**
+     * Address records, keyed by CoinType.
+     * Value is null if no record for the specified CoinType is set.
+     *
+     * NOTE: ENS resolver address records can store arbitrary string values,
+     * including non-EVM addresses — always validate the record value against
+     * the format your application expects.
+     */
+    addresses: Record<CoinType, string | null>;
+    /**
+     * Text records, keyed by key.
+     * Value is null if no record for the specified key is set.
+     */
+    texts: Record<string, string | null>;
+};
+/**
+ * Represents the strongly-typed set of records based on the provided SELECTION
+ *
+ * @example
+ * ```typescript
+ * const selection = {
+ *   name: true,
+ *   addresses: [60],
+ *   texts: ["com.twitter", "avatar"],
+ * } as const satisfies ResolverRecordsSelection;
+ *
+ * type Response = ResolverRecordsResponse<typeof selection>;
+ *
+ * // results in the following type
+ * type Response = {
+ *   readonly name: Name | null;
+ *   readonly addresses: Record<"60", string | null>;
+ *   readonly texts: Record<"avatar" | "com.twitter", string | null>;
+ * }
+ * ```
+ */
+type ResolverRecordsResponse<T extends ResolverRecordsSelection = ResolverRecordsSelection> = {
+    [K in keyof T as T[K] extends true | any[] ? K : never]: K extends "addresses" ? Record<`${T["addresses"] extends readonly CoinType[] ? T["addresses"][number] : never}`, string | null> : K extends "texts" ? Record<T["texts"] extends readonly string[] ? T["texts"][number] : never, string | null> : ResolverRecordsResponseBase[K & keyof ResolverRecordsResponseBase];
+};
+
+/**
+ * Arguments required to perform Forward Resolution
+ */
+interface ForwardResolutionArgs<SELECTION extends ResolverRecordsSelection> {
+    name: Name;
+    selection: SELECTION;
+}
+/**
+ * The result of performing ForwardResolution
+ */
+type ForwardResolutionResult<SELECTION extends ResolverRecordsSelection> = ResolverRecordsResponse<SELECTION>;
+/**
+ * Arguments required to perform Reverse Resolution
+ */
+interface ReverseResolutionArgs {
+    address: Address;
+    chainId: ChainId;
+}
+/**
+ * The result of performing ReverseResolution
+ */
+type ReverseResolutionResult = Name | null;
+/**
+ * Arguments required to perform Multichain Primary Name Resolution
+ */
+interface MultichainPrimaryNameResolutionArgs {
+    address: Address;
+    chainIds?: ChainId[];
+}
+/**
+ * The result of performing MultichainPrimaryNameResolution
+ */
+type MultichainPrimaryNameResolutionResult = Record<ChainId, Name | null>;
+
+/**
+ * API Error Response Type
+ */
+interface ErrorResponse {
+    message: string;
+    details?: unknown;
+}
+interface TraceableRequest {
+    trace?: boolean;
+}
+interface TraceableResponse {
+    trace?: ProtocolTrace;
+}
+interface AcceleratableRequest {
+    accelerate?: boolean;
+}
+/**
+ * Resolve Records Request Type
+ */
+interface ResolveRecordsRequest<SELECTION extends ResolverRecordsSelection> extends ForwardResolutionArgs<SELECTION>, AcceleratableRequest, TraceableRequest {
+}
+/**
+ * Resolve Records Response Type
+ */
+interface ResolveRecordsResponse<SELECTION extends ResolverRecordsSelection> extends TraceableResponse {
+    records: ResolverRecordsResponse<SELECTION>;
+}
+/**
+ * Resolve Primary Name Request Type
+ */
+interface ResolvePrimaryNameRequest extends ReverseResolutionArgs, AcceleratableRequest, TraceableRequest {
+}
+/**
+ * Resolve Primary Name Response Type
+ */
+interface ResolvePrimaryNameResponse extends TraceableResponse {
+    name: ReverseResolutionResult;
+}
+interface ResolvePrimaryNamesRequest extends MultichainPrimaryNameResolutionArgs, AcceleratableRequest, TraceableRequest {
+}
+interface ResolvePrimaryNamesResponse extends TraceableResponse {
+    names: MultichainPrimaryNameResolutionResult;
+}
+
+/**
+ * Default ENSNode API endpoint URL
+ */
+declare const DEFAULT_ENSNODE_API_URL: "https://api.alpha.ensnode.io";
+/**
+ * Configuration options for ENSNode API client
+ */
+interface ClientOptions {
+    /** The ENSNode API URL */
+    url: URL;
+}
+/**
+ * ENSNode API Client
+ *
+ * Provides access to the following ENSNode APIs:
+ * - Resolution API
+ * - 🚧 Configuration API
+ * - 🚧 Indexing Status API
+ *
+ * @example
+ * ```typescript
+ * // Create client with default options
+ * const client = new ENSNodeClient();
+ *
+ * // Use resolution methods
+ * const { records } = await client.resolveRecords("jesse.base.eth", {
+ *   addresses: [60],
+ *   texts: ["avatar"]
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Custom configuration
+ * const client = new ENSNodeClient({
+ *   url: new URL("https://my-ensnode-instance.com"),
+ * });
+ * ```
+ */
+declare class ENSNodeClient {
+    private readonly options;
+    static defaultOptions(): ClientOptions;
+    constructor(options?: Partial<ClientOptions>);
+    getOptions(): Readonly<ClientOptions>;
+    /**
+     * Resolves records for an ENS name (Forward Resolution).
+     *
+     * @param name The ENS Name whose records to resolve
+     * @param selection selection of Resolver records
+     * @param options additional options
+     * @param options.accelerate whether to attempt Protocol Acceleration (default false)
+     * @param options.trace whether to include a trace in the response (default false)
+     * @returns ResolveRecordsResponse<SELECTION>
+     * @throws If the request fails or the ENSNode API returns an error response
+     *
+     * @example
+     * ```typescript
+     * const { records } = await client.resolveRecords("jesse.base.eth", {
+     *   addresses: [60],
+     *   texts: ["avatar", "com.twitter"]
+     * });
+     *
+     * console.log(records);
+     * // {
+     * //   addresses: {
+     * //     60: "0xabcd..."
+     * //   },
+     * //   texts: {
+     * //     avatar: "https://example.com/image.jpg",
+     * //     "com.twitter": null, // if not set, for example
+     * //   }
+     * // }
+     * ```
+     */
+    resolveRecords<SELECTION extends ResolverRecordsSelection>(name: ResolveRecordsRequest<SELECTION>["name"], selection: ResolveRecordsRequest<SELECTION>["selection"], options?: Omit<ResolveRecordsRequest<SELECTION>, "name" | "selection">): Promise<ResolveRecordsResponse<SELECTION>>;
+    /**
+     * Resolves the primary name of a specified address (Reverse Resolution) on a specific chain.
+     *
+     * If the `address` specifies a valid [ENSIP-19 Default Name](https://docs.ens.domains/ensip/19/#default-primary-name),
+     * the Default Name will be returned. You _may_ query the Default EVM Chain Id (`0`) in order to
+     * determine the `address`'s Default Name directly.
+     *
+     * @param address The Address whose Primary Name to resolve
+     * @param chainId The chain id within which to query the address' ENSIP-19 Multichain Primary Name
+     * @param options additional options
+     * @param options.accelerate whether to attempt Protocol Acceleration (default false)
+     * @param options.trace whether to include a trace in the response (default false)
+     * @returns ResolvePrimaryNameResponse
+     * @throws If the request fails or the ENSNode API returns an error response
+     *
+     * @example
+     * ```typescript
+     * // Resolve the address' Primary Name on Ethereum Mainnet
+     * const { name } = await client.resolvePrimaryName("0x179A862703a4adfb29896552DF9e307980D19285", 1);
+     * // name === 'gregskril.eth'
+     *
+     * // Resolve the address' Primary Name on Base
+     * const { name } = await client.resolvePrimaryName("0x179A862703a4adfb29896552DF9e307980D19285", 8453);
+     * // name === 'greg.base.eth'
+     *
+     * // Resolve the address' Default Primary Name
+     * const { name } = await client.resolvePrimaryName("0x179A862703a4adfb29896552DF9e307980D19285", 0);
+     * // name === 'gregskril.eth'
+     * ```
+     */
+    resolvePrimaryName(address: ResolvePrimaryNameRequest["address"], chainId: ResolvePrimaryNameRequest["chainId"], options?: Omit<ResolvePrimaryNameRequest, "address" | "chainId">): Promise<ResolvePrimaryNameResponse>;
+    /**
+     * Resolves the primary names of a specified address across multiple chains.
+     *
+     * If the `address` specifies a valid [ENSIP-19 Default Name](https://docs.ens.domains/ensip/19/#default-primary-name),
+     * the Default Name will be returned for all chainIds for which there is not a chain-specific
+     * Primary Name. To avoid misuse, you _may not_ query the Default EVM Chain Id (`0`) directly, and
+     * should rely on the aforementioned per-chain defaulting behavior.
+     *
+     * @param address The Address whose Primary Names to resolve
+     * @param options additional options
+     * @param options.chainIds The set of chain ids within which to query the address' ENSIP-19
+     *  Multichain Primary Name (default: all ENSIP-19 supported chains)
+     * @param options.accelerate whether to attempt Protocol Acceleration (default: true)
+     * @param options.trace whether to include a trace in the response (default: false)
+     * @returns ResolvePrimaryNamesResponse
+     * @throws If the request fails or the ENSNode API returns an error response
+     *
+     * @example
+     * ```typescript
+     * // Resolve the address' Primary Names on all ENSIP-19 supported chain ids
+     * const { names } = await client.resolvePrimaryNames("0x179A862703a4adfb29896552DF9e307980D19285");
+     *
+     * console.log(names);
+     * // {
+     * //   "1": "gregskril.eth",
+     * //   "10": "gregskril.eth",
+     * //   "8453": "greg.base.eth", // base-specific Primary Name!
+     * //   "42161": "gregskril.eth",
+     * //   "59144": "gregskril.eth",
+     * //   "534352": "gregskril.eth"
+     * // }
+     *
+     * // Resolve the address' Primary Names on specific chain Ids
+     * const { names } = await client.resolvePrimaryNames("0xabcd...", [1, 8453]);
+     *
+     * console.log(names);
+     * // {
+     * //   "1": "gregskril.eth",
+     * //   "8453": "greg.base.eth", // base-specific Primary Name!
+     * // }
+     * ```
+     */
+    resolvePrimaryNames(address: ResolvePrimaryNamesRequest["address"], options?: Omit<ResolvePrimaryNamesRequest, "address">): Promise<ResolvePrimaryNamesResponse>;
+}
 
-export { type Cache, ETH_COIN_TYPE, type EncodedLabelHash, type Label, type LabelHash, LruCache, type Name, type Node, PluginName, REVERSE_ROOT_NODES, ROOT_NODE, isLabelIndexable, makeSubdomainNode, maybeHealLabelByReverseAddress, uint256ToHex32 };
+export { ATTR_PROTOCOL_NAME, ATTR_PROTOCOL_STEP, ATTR_PROTOCOL_STEP_RESULT, type AcceleratableRequest, type BlockNumber, type BlockRef, type Blockrange, type Cache, type ChainId, type ChainIdString, type ChainIndexingActiveStatus, type ChainIndexingBackfillStatus, type ChainIndexingCompletedStatus, type ChainIndexingConfig, type ChainIndexingDefiniteConfig, type ChainIndexingFollowingStatus, type ChainIndexingIndefiniteConfig, type ChainIndexingStandbyStatus, type ChainIndexingStatus, type ChainIndexingStatusForBackfillOverallStatus, type ChainIndexingStatusId, ChainIndexingStatusIds, type ChainIndexingStrategyId, ChainIndexingStrategyIds, type ChainIndexingUnstartedStatus, type ClientOptions, DEFAULT_ENSNODE_API_URL, DEFAULT_EVM_CHAIN_ID, DEFAULT_EVM_COIN_TYPE, DEFAULT_RECORDS_SELECTION, type Datetime, type DatetimeISO8601, type DeepPartial, type DependencyInfo, type Duration, type ENSIndexerOverallIndexingBackfillStatus, type ENSIndexerOverallIndexingCompletedStatus, type ENSIndexerOverallIndexingErrorStatus, type ENSIndexerOverallIndexingFollowingStatus, type ENSIndexerOverallIndexingStatus, type ENSIndexerOverallIndexingUnstartedStatus, type ENSIndexerPublicConfig, ENSNodeClient, ETH_COIN_TYPE, type EncodedLabelHash, type ErrorResponse, type ForwardResolutionArgs, ForwardResolutionProtocolStep, type ForwardResolutionResult, type Label, type LabelHash, LruCache, type MultichainPrimaryNameResolutionArgs, type MultichainPrimaryNameResolutionResult, type Name, type Node, type OverallIndexingStatusId, OverallIndexingStatusIds, PluginName, type ProtocolSpan, type ProtocolTrace, REVERSE_ROOT_NODES, ROOT_NODE, type ResolvePrimaryNameRequest, type ResolvePrimaryNameResponse, type ResolvePrimaryNamesRequest, type ResolvePrimaryNamesResponse, type ResolveRecordsRequest, type ResolveRecordsResponse, type ResolverRecordsResponse, type ResolverRecordsResponseBase, type ResolverRecordsSelection, type ReverseResolutionArgs, ReverseResolutionProtocolStep, type ReverseResolutionResult, type RpcUrl, type SerializedENSIndexerOverallIndexingBackfillStatus, type SerializedENSIndexerOverallIndexingCompletedStatus, type SerializedENSIndexerOverallIndexingErrorStatus, type SerializedENSIndexerOverallIndexingFollowingStatus, type SerializedENSIndexerOverallIndexingStatus, type SerializedENSIndexerOverallIndexingUnstartedStatus, type SerializedENSIndexerPublicConfig, type SerializedIndexedChainIds, TraceableENSProtocol, type UnixTimestamp, type UrlString, addrReverseLabel, bigintToCoinType, checkChainIndexingStatusesForBackfillOverallStatus, checkChainIndexingStatusesForCompletedOverallStatus, checkChainIndexingStatusesForFollowingOverallStatus, checkChainIndexingStatusesForUnstartedOverallStatus, coinTypeReverseLabel, coinTypeToEvmChainId, createIndexingConfig, deserializeBlockNumber, deserializeBlockRef, deserializeBlockrange, deserializeChainId, deserializeDatetime, deserializeDuration, deserializeENSIndexerIndexingStatus, deserializeENSIndexerPublicConfig, deserializeUrl, evmChainIdToCoinType, getActiveChains, getNameHierarchy, getOmnichainIndexingCursor, getOverallApproxRealtimeDistance, getOverallIndexingStatus, getStandbyChains, hrTimeToMicroseconds, isLabelIndexable, isNormalized, isSelectionEmpty, isSubgraphCompatible, makeSubdomainNode, maybeHealLabelByReverseAddress, parseReverseName, readableSpanToProtocolSpan, reverseName, serializeChainId, serializeChainIndexingStatuses, serializeDatetime, serializeENSIndexerIndexingStatus, serializeENSIndexerPublicConfig, serializeIndexedChainIds, serializeUrl, uint256ToHex32, uniq };