@ensnode/ensnode-sdk 0.0.0-next-20260130145445 → 0.0.0-next-20260202030222

package/dist/index.d.cts

@@ -781,312 +781,282 @@ type RequiredAndNotNull<T, K extends keyof T> = T & {
 };
 
 /**
- * Determines where the provided AccountId values represent the same address on the same chain.
+ * A label set ID identifies a label set (see https://ensnode.io/ensrainbow/concepts/glossary#label-set for definition).
+ * It is guaranteed to be 1 to 50 characters long and contain only lowercase letters (a-z)
+ * and hyphens (-).
  */
-declare const accountIdEqual: (a: AccountId, b: AccountId) => boolean;
-
+type LabelSetId = string;
 /**
- * Converts an EVM address to its lowercase representation.
+ * A label set version identifies a specific version of a label set. It allows clients to
+ * request data from a specific snapshot in time, ensuring deterministic results.
  *
- * @param address - EVM address to convert.
- * @returns The lowercase representation of the EVM address.
+ * It is guaranteed to be a non-negative integer.
  */
-declare function asLowerCaseAddress(address: Address): Address;
-
+type LabelSetVersion = number;
 /**
- * Cache that maps from string -> ValueType.
+ * The label set preferences of an ENSRainbow client.
  */
-interface Cache<KeyType extends string, ValueType> {
-    /**
-     * Store a value in the cache with the given key.
-     *
-     * @param key Cache key
-     * @param value Value to store
-     */
-    set(key: KeyType, value: ValueType): void;
+interface EnsRainbowClientLabelSet {
     /**
-     * Retrieve a value from the cache with the given key.
-     *
-     * @param key Cache key
-     * @returns The cached value if it exists, otherwise undefined
+     * Optional label set ID that the ENSRainbow server is expected to use. If provided, heal
+     * operations will validate the ENSRainbow server is using this labelSetId.
+     * Required if `labelSetVersion` is defined.
      */
-    get(key: KeyType): ValueType | undefined;
+    labelSetId?: LabelSetId;
     /**
-     * Clear the cache.
+     * Optional highest label set version of label set id to query. Enables deterministic heal
+     * results across time even if the ENSRainbow server ingests label sets with greater versions
+     * than this value. If provided, only labels from label sets with versions less than or equal to this
+     * value will be returned. If not provided, the server will use the latest available version.
+     * When `labelSetVersion` is defined, `labelSetId` must also be defined.
      */
-    clear(): void;
+    labelSetVersion?: LabelSetVersion;
+}
+/**
+ * The state of label sets managed by an ENSRainbow server.
+ */
+interface EnsRainbowServerLabelSet {
     /**
-     * The current number of items in the cache. Always a non-negative integer.
+     * The LabelSetId managed by the ENSRainbow server.
      */
-    get size(): number;
+    labelSetId: LabelSetId;
     /**
-     * The maximum number of items in the cache. Always a non-negative integer that is >= size().
+     * The highest label set version available on the ENSRainbow server for the current
+     * label set ID. This represents the most recent version of the label set that the
+     * server has ingested and can provide label healing results for.
      */
-    get capacity(): number;
+    highestLabelSetVersion: LabelSetVersion;
 }
 
 /**
- * Cache that maps from string -> ValueType with a LRU (least recently used) eviction policy.
- *
- * `get` and `set` are O(1) operations.
- *
- * @link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
+ * A PluginName is a unique id for a 'plugin': we use the notion of
+ * 'plugins' to describe bundles of indexing logic.
  */
-declare class LruCache<KeyType extends string, ValueType> implements Cache<KeyType, ValueType> {
-    private readonly _cache;
-    private readonly _capacity;
+declare enum PluginName {
+    Subgraph = "subgraph",
+    Basenames = "basenames",
+    Lineanames = "lineanames",
+    ThreeDNS = "threedns",
+    ProtocolAcceleration = "protocol-acceleration",
+    Registrars = "registrars",
+    TokenScope = "tokenscope",
+    ENSv2 = "ensv2"
+}
+/**
+ * Version info about ENSIndexer and its dependencies.
+ */
+interface ENSIndexerVersionInfo {
     /**
-     * Create a new LRU cache with the given capacity.
+     * Node.js runtime version
      *
-     * @param capacity The maximum number of items in the cache. If set to 0, the cache is effectively disabled.
-     * @throws Error if capacity is not a non-negative integer.
-     */
-    constructor(capacity: number);
-    set(key: string, value: ValueType): void;
-    get(key: string): ValueType | undefined;
-    clear(): void;
-    get size(): number;
-    get capacity(): number;
-}
-
-interface SWRCacheOptions<ValueType> {
+     * @see https://nodejs.org/en/about/previous-releases
+     **/
+    nodejs: string;
     /**
-     * The async function generating a value of `ValueType` to wrap with SWR caching. It may throw an
-     * Error type.
-     */
-    fn: () => Promise<ValueType>;
+     * Ponder framework version
+     *
+     * @see https://www.npmjs.com/package/ponder
+     **/
+    ponder: string;
     /**
-     * Time-to-live duration of a cached result in seconds. After this duration:
-     * - the currently cached result is considered "stale" but is still retained in the cache
-     *   until successfully replaced.
-     * - Each time the cache is read, if the cached result is "stale" and no background
-     *   revalidation attempt is already in progress, a new background revalidation
-     *   attempt will be made.
-     */
-    ttl: Duration;
+     * ENSDb service version
+     *
+     * Guaranteed to be the same as {@link ENSIndexerVersionInfo.ensIndexer}.
+     * */
+    ensDb: string;
     /**
-     * Optional time-to-proactively-revalidate duration in seconds. After a cached result is
-     * initialized, and this duration has passed, attempts to asynchronously revalidate
-     * the cached result will be proactively made in the background on this interval.
-     */
-    proactiveRevalidationInterval?: Duration;
+     * ENSIndexer service version
+     *
+     * @see https://ghcr.io/namehash/ensnode/ensindexer
+     **/
+    ensIndexer: string;
     /**
-     * Optional proactive initialization. Defaults to `false`.
+     * ENSRainbow service version
      *
-     * If `true`: The SWR cache will proactively initialize itself.
-     * If `false`: The SWR cache will lazily wait to initialize itself until the first read.
-     */
-    proactivelyInitialize?: boolean;
+     * @see https://ghcr.io/namehash/ensnode/ensindexer
+     **/
+    ensRainbow: string;
+    /**
+     * ENSRainbow schema version
+     **/
+    ensRainbowSchema: number;
+    /**
+     * ENS Normalize package version
+     *
+     * Available on NPM as: `@adraffy/ens-normalize`
+     *
+     * @see https://www.npmjs.com/package/@adraffy/ens-normalize
+     **/
+    ensNormalize: string;
 }
 /**
- * Stale-While-Revalidate (SWR) cache for async functions.
- *
- * This caching strategy serves cached data immediately (even if stale) while
- * asynchronously revalidating the cache in the background. This provides:
- * - Sub-millisecond response times (after first fetch)
- * - Always available data (serves stale data during revalidation)
- * - Automatic background updates via configurable intervals
- *
- * @example
- * ```typescript
- * const cache = new SWRCache({
- *   fn: async () => fetch('/api/data').then(r => r.json()),
- *   ttl: 60, // 1 minute TTL
- *   proactiveRevalidationInterval: 300 // proactively revalidate every 5 minutes
- * });
- *
- * // Returns cached data or waits for initial fetch
- * const data = await cache.read();
- *
- * if (data instanceof Error) { ... }
- * ```
+ * Complete public configuration object for ENSIndexer.
  *
- * @link https://web.dev/stale-while-revalidate/
- * @link https://datatracker.ietf.org/doc/html/rfc5861
+ * We use parameter types to maintain fields layout and documentation across
+ * the domain model and its serialized counterpart.
  */
-declare class SWRCache<ValueType> {
-    private readonly options;
-    private cache;
-    private inProgressRevalidate;
-    private backgroundInterval;
-    constructor(options: SWRCacheOptions<ValueType>);
-    private revalidate;
+interface ENSIndexerPublicConfig {
     /**
-     * Read the most recently cached result from the `SWRCache`.
+     * The ENS namespace that ENSNode operates in the context of.
      *
-     * @returns a `ValueType` that was most recently successfully returned by `fn` or `Error` if `fn`
-     * has never successfully returned.
+     * See {@link ENSNamespaceIds} for available namespace identifiers.
      */
-    read(): Promise<ValueType | Error>;
+    namespace: ENSNamespaceId;
     /**
-     * Destroys the background revalidation interval, if exists.
+     * The "fully pinned" label set reference that ENSIndexer will request ENSRainbow use for deterministic label healing across time. This label set reference is "fully pinned" as it requires both the labelSetId and labelSetVersion fields to be defined.
      */
-    destroy(): void;
-}
-
-/**
- * Cache that maps from string -> ValueType with TTL (time-to-live) expiration.
- *
- * Items are automatically removed when they expire.
- */
-declare class TtlCache<KeyType extends string, ValueType> implements Cache<KeyType, ValueType> {
-    private readonly _cache;
-    private readonly _ttl;
+    labelSet: Required<EnsRainbowClientLabelSet>;
     /**
-     * Create a new TTL cache with the given TTL.
+     * A Postgres database schema name. This instance of ENSIndexer will write
+     * indexed data to the tables in this schema.
      *
-     * @param ttl Time-to-live duration in seconds. Items expire after this duration.
+     * Invariants:
+     * - Must be a non-empty string that is a valid Postgres database schema
+     *   identifier.
      */
-    constructor(ttl: Duration);
-    private _cleanup;
-    set(key: string, value: ValueType): void;
-    get(key: string): ValueType | undefined;
-    clear(): void;
-    get size(): number;
-    get capacity(): number;
-    has(key: string): boolean;
-    delete(key: string): boolean;
-}
-
-/**
- * Filter out duplicates.
- */
-declare const uniq: <T>(arr: T[]) => T[];
-
-/**
- * Identifiers for supported currencies.
- *
- * TODO: Add support for WETH
- */
-declare const CurrencyIds: {
-    readonly ETH: "ETH";
-    readonly USDC: "USDC";
-    readonly DAI: "DAI";
-};
-type CurrencyId = (typeof CurrencyIds)[keyof typeof CurrencyIds];
-/**
- * The amount of the currency in the smallest unit of the currency
- * (see {@link CurrencyInfo.decimals} for the currency).
- *
- * Guaranteed to be non-negative.
- */
-type CurrencyAmount = bigint;
-/**
- * Serialized representation of {@link CurrencyAmount}.
- */
-type SerializedCurrencyAmount = string;
-interface PriceEth {
-    currency: typeof CurrencyIds.ETH;
-    amount: CurrencyAmount;
-}
-interface PriceDai {
-    currency: typeof CurrencyIds.DAI;
-    amount: CurrencyAmount;
-}
-interface PriceUsdc {
-    currency: typeof CurrencyIds.USDC;
-    amount: CurrencyAmount;
-}
-type Price = PriceEth | PriceDai | PriceUsdc;
-/**
- * Serialized representation of {@link PriceEth}.
- */
-interface SerializedPriceEth extends Omit<PriceEth, "amount"> {
-    amount: SerializedCurrencyAmount;
-}
-/**
- * Serialized representation of {@link PriceDai}.
- */
-interface SerializedPriceDai extends Omit<PriceDai, "amount"> {
-    amount: SerializedCurrencyAmount;
+    databaseSchemaName: string;
+    /**
+     * A set of strings referring to the names of plugins that are active.
+     *
+     * For future-proofing, this is a list of strings that may or may
+     * not be currently valid {@link PluginName} values.
+     *
+     * Invariants:
+     * - A set of strings with at least one value.
+     */
+    plugins: string[];
+    /**
+     * Indexed Chain IDs
+     *
+     * Includes the {@link ChainId} for each chain being indexed.
+     */
+    indexedChainIds: Set<ChainId>;
+    /**
+     * A feature flag to enable/disable ENSIndexer's Subgraph Compatible Indexing Behavior.
+     *
+     * If {@link isSubgraphCompatible} is true, indexing behavior will match that of the legacy ENS
+     * Subgraph.
+     *
+     * ENSIndexer will store and return Literal Labels and Literal Names without further interpretation.
+     * @see https://ensnode.io/docs/reference/terminology#literal-label
+     * @see https://ensnode.io/docs/reference/terminology#literal-name
+     *
+     * If {@link isSubgraphCompatible} is true, the following invariants are true for the ENSIndexerConfig:
+     * 1. only the 'subgraph' plugin is enabled, and
+     * 2. the labelSet must be { labelSetId: 'subgraph', labelSetVersion: 0 }
+     *
+     * If {@link isSubgraphCompatible} is false, ENSIndexer will additionally:
+     *
+     * 1. ENSIndexer will heal all subnames of addr.reverse on the ENS Root Chain.
+     *
+     * 2. ENSIndexer will track both the keys and the values of Resolver records.
+     *
+     * WARNING: Special care must be taken when interacting with indexed resolver record values. It
+     * is unsafe to naively assume that indexed resolver record values are equivalent to the
+     * resolver record values that would be returned through dynamic lookups via the ENS protocol.
+     * For example, if a resolver implements CCIP-Read, the resolver records may not be
+     * discoverable through onchain indexing.
+     *
+     * 3. Literal Labels and Literal Names encountered by ENSIndexer will be Interpreted.
+     * @see https://ensnode.io/docs/reference/terminology#interpreted-label
+     * @see https://ensnode.io/docs/reference/terminology#interpreted-name
+     *
+     * That is,
+     * a) all Labels stored and returned by ENSIndexer will be Interpreted Labels, which are either:
+     *    i. normalized, or
+     *    ii. represented as an Encoded LabelHash of the Literal Label value found onchain, and
+     * b) all Names stored and returned by ENSIndexer will be Interpreted Names, which are exclusively
+     *   composed of Interpreted Labels.
+     */
+    isSubgraphCompatible: boolean;
+    /**
+     * Version info about ENSIndexer.
+     */
+    versionInfo: ENSIndexerVersionInfo;
 }
+
+type SerializedIndexedChainIds = Array<ChainId>;
 /**
- * Serialized representation of {@link PriceUsdc}.
+ * Serialized representation of {@link ENSIndexerPublicConfig}
  */
-interface SerializedPriceUsdc extends Omit<PriceUsdc, "amount"> {
-    amount: SerializedCurrencyAmount;
+interface SerializedENSIndexerPublicConfig extends Omit<ENSIndexerPublicConfig, "indexedChainIds"> {
+    /**
+     * Array representation of {@link ENSIndexerPublicConfig.indexedChainIds}.
+     */
+    indexedChainIds: ChainId[];
 }
 /**
- * Serialized representation of {@link Price}.
+ * Serialized representation of {@link ENSIndexerVersionInfo}
  */
-type SerializedPrice = SerializedPriceEth | SerializedPriceDai | SerializedPriceUsdc;
-interface CurrencyInfo {
-    id: CurrencyId;
-    name: string;
-    decimals: number;
-}
+type SerializedENSIndexerVersionInfo = ENSIndexerVersionInfo;
+
 /**
- * Get currency info for a provided currency.
+ * Serialize a {@link ENSIndexerPublicConfig} object.
  */
-declare function getCurrencyInfo(currencyId: CurrencyId): CurrencyInfo;
+declare function deserializeENSIndexerPublicConfig(maybeConfig: SerializedENSIndexerPublicConfig, valueLabel?: string): ENSIndexerPublicConfig;
+
 /**
- * Create price in ETH for given amount.
+ * Determines if the provided `config` results in indexing behavior compatible with the legacy ENS
+ * Subgraph.
+ *
+ * @see https://ensnode.io/docs/concepts/what-is-the-ens-subgraph/
  */
-declare function priceEth(amount: Price["amount"]): PriceEth;
+declare function isSubgraphCompatible(config: Pick<ENSIndexerPublicConfig, "namespace" | "plugins" | "labelSet">): boolean;
+
 /**
- * Create price in USDC for given amount.
+ * Converts a Labelhash to bytes, with validation
+ * @param labelHash The Labelhash to convert
+ * @returns A ByteArray containing the bytes
+ * @throws Error if `labelHash` is not a valid 32-byte hex string
  */
-declare function priceUsdc(amount: Price["amount"]): PriceUsdc;
+declare function labelHashToBytes(labelHash: LabelHash): ByteArray;
+
 /**
- * Create price in DAI for given amount.
+ * Builds a valid LabelSetId from a string.
+ * @param maybeLabelSetId - The string to validate and convert to a LabelSetId.
+ * @returns A valid LabelSetId.
+ * @throws If the input string is not a valid LabelSetId.
  */
-declare function priceDai(amount: Price["amount"]): PriceDai;
+declare function buildLabelSetId(maybeLabelSetId: string): LabelSetId;
 /**
- * Check if two prices have the same currency.
+ * Builds a valid LabelSetVersion from a number or string.
+ * @param maybeLabelSetVersion - The number or string to validate and convert to a LabelSetVersion.
+ * @returns A valid LabelSetVersion.
+ * @throws If the input is not a valid LabelSetVersion.
  */
-declare function isPriceCurrencyEqual(priceA: Price, priceB: Price): boolean;
+declare function buildLabelSetVersion(maybeLabelSetVersion: number | string): LabelSetVersion;
 /**
- * Check if two {@link Price} values have the same currency and amount.
+ * Builds an EnsRainbowClientLabelSet.
+ * @param labelSetId - The label set ID.
+ * @param labelSetVersion - The label set version.
+ * @returns A valid EnsRainbowClientLabelSet object.
+ * @throws If `labelSetVersion` is defined without `labelSetId`.
  */
-declare function isPriceEqual(priceA: Price, priceB: Price): boolean;
+declare function buildEnsRainbowClientLabelSet(labelSetId?: LabelSetId, labelSetVersion?: LabelSetVersion): EnsRainbowClientLabelSet;
 /**
- * Add prices
- *
- * @param prices at least two {@link Price} values to be added together.
- * @returns total of all prices.
- * @throws if not all prices have the same currency.
+ * Validates that the server's label set is compatible with the client's requested label set.
+ * @param serverSet - The label set provided by the server.
+ * @param clientSet - The label set requested by the client.
+ * @throws If the server set is not compatible with the client set.
  */
-declare function addPrices<const PriceType extends Price = Price>(...prices: [PriceType, PriceType, ...PriceType[]]): PriceType;
+declare function validateSupportedLabelSetAndVersion(serverSet: EnsRainbowServerLabelSet, clientSet: EnsRainbowClientLabelSet): void;
 
 /**
- * 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', '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: <N extends ENSNamespaceId, D extends DatasourceName, C extends string>(namespaceId: N, datasourceName: D, contractName: C) => 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', '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;
-/**
- * Makes a comparator fn for `b` against the contract described by `namespace`, `datasourceName`, and `contractName`.
+ * Parses a string into a non-negative integer.
+ * @param input The string to parse
+ * @returns The parsed non-negative integer
+ * @throws Error if the input is not a valid non-negative integer
  */
-declare const makeContractMatcher: (namespace: ENSNamespaceId, b: AccountId) => (datasourceName: DatasourceName, contractName: string) => boolean | undefined;
+declare function parseNonNegativeInteger(maybeNumber: string): number;
 
 /**
- * Duration between two moments in time.
+ * Serializes a {@link ChainConfig} object.
  */
-declare function durationBetween(start: UnixTimestamp, end: UnixTimestamp): Duration;
+declare function serializeIndexedChainIds(indexedChainIds: Set<ChainId>): SerializedIndexedChainIds;
 /**
- * Add a duration to a timestamp.
+ * Serialize a {@link ENSIndexerPublicConfig} object.
  */
-declare function addDuration(timestamp: UnixTimestamp, duration: Duration): UnixTimestamp;
+declare function serializeENSIndexerPublicConfig(config: ENSIndexerPublicConfig): SerializedENSIndexerPublicConfig;
 
 /**
  * Serialized representation of {@link ChainId}.
@@ -1121,1679 +1091,1154 @@ type AccountIdString = string;
  */
 type AssetIdString = string;
 
-declare function deserializeChainId(maybeChainId: ChainIdString, valueLabel?: string): ChainId;
-declare function deserializeDatetime(maybeDatetime: string, valueLabel?: string): Datetime;
-declare function deserializeUnixTimestamp(maybeTimestamp: number, valueLabel?: string): number;
-declare function deserializeUrl(maybeUrl: UrlString, valueLabel?: string): URL;
-declare function deserializeBlockNumber(maybeBlockNumber: number, valueLabel?: string): BlockNumber;
-declare function deserializeBlockrange(maybeBlockrange: Partial<Blockrange>, valueLabel?: string): {
-    startBlock?: number | undefined;
-    endBlock?: number | undefined;
+/**
+ * The type of indexing configuration for a chain.
+ */
+declare const ChainIndexingConfigTypeIds: {
+    /**
+     * Represents that indexing of the chain should be performed for an indefinite range.
+     */
+    readonly Indefinite: "indefinite";
+    /**
+     * Represents that indexing of the chain should be performed for a definite range.
+     */
+    readonly Definite: "definite";
 };
-declare function deserializeBlockRef(maybeBlockRef: Partial<BlockRef>, valueLabel?: string): BlockRef;
-declare function deserializeDuration(maybeDuration: unknown, valueLabel?: string): Duration;
-declare function parseAccountId(maybeAccountId: unknown, valueLabel?: string): AccountId;
-
 /**
- * Interprets a viem#Address. zeroAddress is interpreted as null, otherwise Address.
+ * The derived string union of possible {@link ChainIndexingConfigTypeIds}.
  */
-declare const interpretAddress: (owner: Address) => `0x${string}` | null;
-
+type ChainIndexingConfigTypeId = (typeof ChainIndexingConfigTypeIds)[keyof typeof ChainIndexingConfigTypeIds];
 /**
- * Interprets a name record value string and returns null if the value is interpreted as a deletion.
- *
- * The interpreted record value is either:
- * a) null, representing a non-existant or deletion of the record, or
- * b) a normalized, non-empty-string Name.
+ * Chain indexing config for a chain whose indexing config `configType` is
+ * {@link ChainIndexingConfigTypeIds.Indefinite}.
  *
- * @param value - The name record value string to interpret.
- * @returns The interpreted name string, or null if deleted.
+ * Invariants:
+ * - `configType` is always `ChainIndexingConfigTypeIds.Indefinite`.
  */
-declare function interpretNameRecordValue(value: string): NormalizedName | null;
+interface ChainIndexingConfigIndefinite {
+    /**
+     * The type of chain indexing config.
+     */
+    configType: typeof ChainIndexingConfigTypeIds.Indefinite;
+    /**
+     * A {@link BlockRef} to the block where indexing of the chain should start.
+     */
+    startBlock: BlockRef;
+}
 /**
- * Interprets an address record value string and returns null if the value is interpreted as a deletion.
+ * Chain indexing config for a chain whose indexing config `configType` is
+ * {@link ChainIndexingConfigTypeIds.Definite}.
  *
- * The interpreted record value is either:
- * a) null, representing a non-existant or deletion of the record, or
- *   i. contains null bytes
- *   ii. empty string
- *   iii. empty hex (0x)
- *   iv. zeroAddress
- * b) an address record value that
- *   i. does not contain null bytes
- *   ii. (if is an EVM address) is lowercase
- *
- * @param value - The address record value to interpret.
- * @returns The interpreted address string or null if deleted.
+ * Invariants:
+ * - `configType` is always `ChainIndexingConfigTypeIds.Definite`.
+ * - `startBlock` is always before or the same as `endBlock`.
  */
-declare function interpretAddressRecordValue(value: string): string | null;
+interface ChainIndexingConfigDefinite {
+    /**
+     * The type of chain indexing config.
+     */
+    configType: typeof ChainIndexingConfigTypeIds.Definite;
+    /**
+     * A {@link BlockRef} to the block where indexing of the chain should start.
+     */
+    startBlock: BlockRef;
+    /**
+     * A {@link BlockRef} to the block where indexing of the chain should end.
+     */
+    endBlock: BlockRef;
+}
 /**
- * Interprets a text record key string and returns null if the key should be ignored.
- *
- * The interpreted text record key is either:
- * a) null, representing a text record key that should be ignored, or
- *   i. contains null bytes
- *   ii. empty string
- * b) a text record key that
- *   i. does not contain null bytes
+ * Indexing configuration for a chain.
  *
- * @param value - The text record key to interpret.
- * @returns The interpreted text string or null if ignored.
+ * Use the `configType` field to determine the specific type interpretation
+ * at runtime.
  */
-declare function interpretTextRecordKey(key: string): string | null;
+type ChainIndexingConfig = ChainIndexingConfigIndefinite | ChainIndexingConfigDefinite;
 /**
- * Interprets a text record value string and returns null if the value is interpreted as a deletion.
- *
- * The interpreted record value is either:
- * a) null, representing a non-existant or deletion of the record, or
- *   i. contains null bytes
- *   ii. empty string
- * b) a text record value that
- *   i. does not contain null bytes
- *
- * @param value - The text record value to interpret.
- * @returns The interpreted text string or null if deleted.
+ * The status of indexing a chain at the time an indexing status snapshot
+ * is captured.
  */
-declare function interpretTextRecordValue(value: string): string | null;
-
+declare const ChainIndexingStatusIds: {
+    /**
+     * Represents that indexing of the chain is not ready to begin yet because:
+     * - ENSIndexer is in its initialization phase and the data to build a
+     *   "true" {@link ChainIndexingSnapshot} for the chain is still being loaded; or
+     * - ENSIndexer is using an omnichain indexing strategy and the
+     *   `omnichainIndexingCursor` is <= `config.startBlock.timestamp` for the chain's
+     *   {@link ChainIndexingSnapshot}.
+     */
+    readonly Queued: "chain-queued";
+    /**
+     * Represents that indexing of the chain is in progress and under a special
+     * "backfill" phase that optimizes for accelerated indexing until reaching the
+     * "fixed target" `backfillEndBlock`.
+     */
+    readonly Backfill: "chain-backfill";
+    /**
+     * Represents that the "backfill" phase of indexing the chain is completed
+     * and that the chain is configured to be indexed for an indefinite range.
+     * Therefore, indexing of the chain remains indefinitely in progress where
+     * ENSIndexer will continuously work to discover and index new blocks as they
+     * are added to the chain across time.
+     */
+    readonly Following: "chain-following";
+    /**
+     * Represents that indexing of the chain is completed as the chain is configured
+     * to be indexed for a definite range and the indexing of all blocks through
+     * that definite range is completed.
+     */
+    readonly Completed: "chain-completed";
+};
 /**
- * Decodes a uint256-encoded-LabelHash (eg. from a tokenId) into a {@link LabelHash}.
- *
- * Remember that contracts that operate in the context of a Managed Name frequently store and operate
- * over _LabelHashes_ that represent a direct subname of a Managed Name. These contracts also frequently
- * implement ERC721 or ERC1155 to represent ownership of these Names. As such, to construct the
- * ERC721/ERC1155 tokenId, they may encode the direct subnames's LabelHash as a uint256.
- *
- * This is true for the ENSv1 BaseRegistrar, RegistrarControllers, as well as any
- * contracts forked from it (which includes Basenames' and Lineanames' implementations).
- *
- * So, in order to turn the tokenId into a LabelHash, we perform the opposite operation, decoding
- * from a uint256 into a Hex (of size 32) and cast it as our semantic {@link LabelHash} type.
- *
- * @see https://github.com/ensdomains/ens-contracts/blob/db613bc/contracts/ethregistrar/ETHRegistrarController.sol#L215
- * @see https://github.com/base/basenames/blob/1b5c1ad/src/L2/RegistrarController.sol#L488
- * @see https://github.com/Consensys/linea-ens/blob/3a4f02f/packages/linea-ens-contracts/contracts/ethregistrar/ETHRegistrarController.sol#L447
+ * The derived string union of possible {@link ChainIndexingStatusIds}.
  */
-declare const interpretTokenIdAsLabelHash: (tokenId: bigint) => LabelHash;
+type ChainIndexingStatusId = (typeof ChainIndexingStatusIds)[keyof typeof ChainIndexingStatusIds];
 /**
- * Decodes a uint256-encoded-Node (eg. from a tokenId) into a {@link Node}.
- *
- * Contracts in the ENSv1 ecosystem frequently implement ERC721 or ERC1155 to represent
- * ownership of a Domain. As such, to construct the ERC721/ERC1155 tokenId, they may encode the
- * domain's {@link Node} as a uint256.
- *
- * This is true for the ENSv1 NameWrapper, as well as any contracts forked from it (which includes
- * Lineanames' implementation).
- *
- * So, in order to turn the tokenId into a Node, we perform the opposite operation, decoding
- * from a uint256 into a Hex (of size 32) and cast it as our semantic {@link Node} type.
+ * Chain indexing status snapshot for a chain whose `chainStatus` is
+ * {@link ChainIndexingStatusIds.Queued}.
  *
- * @see https://github.com/ensdomains/ens-contracts/blob/db613bc/contracts/wrapper/ERC1155Fuse.sol#L262
+ * Invariants:
+ * - `chainStatus` is always {@link ChainIndexingStatusIds.Queued}.
  */
-declare const interpretTokenIdAsNode: (tokenId: bigint) => Node;
-
+interface ChainIndexingStatusSnapshotQueued {
+    /**
+     * The status of indexing the chain at the time the indexing status snapshot
+     * was captured.
+     */
+    chainStatus: typeof ChainIndexingStatusIds.Queued;
+    /**
+     * The indexing configuration of the chain.
+     */
+    config: ChainIndexingConfig;
+}
 /**
- * Interprets a Literal Label, producing an Interpreted Label.
- *
- * @see https://ensnode.io/docs/reference/terminology#literal-label
- * @see https://ensnode.io/docs/reference/terminology#interpreted-label
+ * Chain indexing status snapshot for a chain whose `chainStatus` is
+ * {@link ChainIndexingStatusIds.Backfill}.
  *
- * @param label - The Literal Label string to interpret
- * @returns The provided label if it is a normalized label, else the EncodedLabelHash of the label
- */
-declare function literalLabelToInterpretedLabel(label: LiteralLabel): InterpretedLabel;
-/**
- * Interprets an ordered list of Literal Labels, producing an Interpreted Name.
+ * During a backfill, special performance optimizations are applied to
+ * index all blocks between `config.startBlock` and `backfillEndBlock`
+ * as fast as possible.
  *
- * Note that it's important that the Literal Labels are provided as an array, otherwise it's
- * impossible to differentiate between 'a.label.eth' being ['a.label', 'eth'] or ['a', 'label', 'eth'].
+ * Note how `backfillEndBlock` is a "fixed target" that does not change during
+ * the lifetime of an ENSIndexer process instance:
+ * - If the `config` is {@link ChainIndexingConfigDefinite}:
+ *   `backfillEndBlock` is always the same as `config.endBlock`.
+ * - If the `config` is {@link ChainIndexingConfigIndefinite}:
+ *   `backfillEndBlock` is a {@link BlockRef} to what was the latest block on the
+ *    chain when the ENSIndexer process was performing its initialization. Note how
+ *    this means that if the backfill process takes X hours to complete, because the
+ *    `backfillEndBlock` is a "fixed target", when `chainStatus` transitions to
+ *    {@link ChainIndexingStatusIds.Following} the chain will be X hours behind
+ *    "realtime" indexing.
  *
- * Note that the input is an ordered list of _Literal_ Labels: in this context, any literal label
- * that is formatted as an Encoded LabelHash will NOT be interpreted as such. Instead it will be
- * interpreted into an Encoded LabelHash that encodes the literal labelhash of the Literal Label.
+ * When `latestIndexedBlock` reaches `backfillEndBlock` the backfill is complete.
+ * The moment backfill is complete the `chainStatus` may not immediately transition.
+ * Instead, internal processing is completed for a period of time while
+ * `chainStatus` remains {@link ChainIndexingStatusIds.Backfill}. After this internal
+ * processing is completed `chainStatus` will transition:
+ * - to {@link ChainIndexingStatusIds.Following} if the `config` is
+ *   {@link ChainIndexingConfigIndefinite}.
+ * - to {@link ChainIndexingStatusIds.Completed} if the `config` is
+ *   {@link ChainIndexingConfigDefinite}.
  *
- * @param labels An ordered list of 0 or more Literal Labels
- * @returns An InterpretedName
+ * Invariants:
+ * - `chainStatus` is always {@link ChainIndexingStatusIds.Backfill}.
+ * - `config.startBlock` is always before or the same as `latestIndexedBlock`
+ * - `config.endBlock` is always the same as `backfillEndBlock` if and only if
+ *   the config is {@link ChainIndexingConfigDefinite}.
+ * - `latestIndexedBlock` is always before or the same as `backfillEndBlock`
  */
-declare function literalLabelsToInterpretedName(labels: LiteralLabel[]): InterpretedName;
+interface ChainIndexingStatusSnapshotBackfill {
+    /**
+     * The status of indexing the chain at the time the indexing status snapshot
+     * was captured.
+     */
+    chainStatus: typeof ChainIndexingStatusIds.Backfill;
+    /**
+     * The indexing configuration of the chain.
+     */
+    config: ChainIndexingConfig;
+    /**
+     * A {@link BlockRef} to the block that was most recently indexed as of the time the
+     * indexing status snapshot was captured.
+     */
+    latestIndexedBlock: BlockRef;
+    /**
+     * A {@link BlockRef} to the block where the backfill will end.
+     */
+    backfillEndBlock: BlockRef;
+}
 /**
- * Joins the list of Interpreted Labels with '.' to form an Interpreted Name.
+ * Chain indexing status snapshot for a chain whose `chainStatus` is
+ * {@link ChainIndexingStatusIds.Following}.
  *
- * @param labels An ordered list of 0 or more Interpreted Labels
- * @returns An InterpretedName
+ * Invariants:
+ * - `chainStatus` is always {@link ChainIndexingStatusIds.Following}.
+ * - `config` is always {@link ChainIndexingConfigIndefinite}
+ * - `config.startBlock` is always before or the same as `latestIndexedBlock`
+ * - `latestIndexedBlock` is always before or the same as `latestKnownBlock`
  */
-declare function interpretedLabelsToInterpretedName(labels: InterpretedLabel[]): InterpretedName;
+interface ChainIndexingStatusSnapshotFollowing {
+    /**
+     * The status of indexing the chain at the time the indexing status snapshot
+     * was captured.
+     */
+    chainStatus: typeof ChainIndexingStatusIds.Following;
+    /**
+     * The indexing configuration of the chain.
+     */
+    config: ChainIndexingConfigIndefinite;
+    /**
+     * A {@link BlockRef} to the block that was most recently indexed as of the time the
+     * indexing status snapshot was captured.
+     */
+    latestIndexedBlock: BlockRef;
+    /**
+     * A {@link BlockRef} to the "highest" block that has been discovered by RPCs
+     * and stored in the RPC cache as of the time the indexing status snapshot was
+     * captured.
+     */
+    latestKnownBlock: BlockRef;
+}
 /**
- * Joins the list of Literal Labels with '.' to form a Literal Name.
+ * Chain indexing status snapshot for a chain whose `chainStatus` is
+ * {@link ChainIndexingStatusIds.Completed}.
  *
- * Note: LiteralLabel values may contain '.' characters, which will be preserved
- * in the resulting LiteralName. Therefore, the number of labels in the returned
- * LiteralName may be greater than the number of LiteralLabels in the input array.
+ * After the backfill of a chain is completed, if the chain was configured
+ * to be indexed for a definite range, the chain indexing status will transition to
+ * {@link ChainIndexingStatusIds.Completed}.
  *
- * @param labels An ordered list of 0 or more Literal Labels
- * @returns An LiteralName
- */
-declare function literalLabelsToLiteralName(labels: LiteralLabel[]): LiteralName;
-/**
- * Converts an Interpreted Name into a list of Interpreted Labels.
+ * Invariants:
+ * - `chainStatus` is always {@link ChainIndexingStatusIds.Completed}.
+ * - `config` is always {@link ChainIndexingConfigDefinite}
+ * - `config.startBlock` is always before or the same as `latestIndexedBlock`
+ * - `latestIndexedBlock` is always the same as `config.endBlock`.
  */
-declare function interpretedNameToInterpretedLabels(name: InterpretedName): InterpretedLabel[];
-declare function encodedLabelToLabelhash(label: string): LabelHash | null;
-declare function isInterpetedLabel(label: Label): label is InterpretedLabel;
-declare function isInterpretedName(name: Name): name is InterpretedName;
-/**
- * Converts an InterpretedName into a LabelHashPath.
- */
-declare function interpretedNameToLabelHashPath(name: InterpretedName): LabelHashPath;
-
-/**
- * Implements the ENS `labelhash` function for Literal Labels.
- * @see https://docs.ens.domains/ensip/1
- *
- * @param label the Literal Label to hash
- * @returns the hash of the provided label
- * @dev This function is viem/ens#labelhash but without the special-case handling of Encoded LabelHashes.
- */
-declare const labelhashLiteralLabel: (label: LiteralLabel) => LabelHash;
-
-declare const hasNullByte: (value: string) => boolean;
-declare const stripNullBytes: (value: string) => string;
-
+interface ChainIndexingStatusSnapshotCompleted {
+    /**
+     * The status of indexing the chain at the time the indexing status snapshot
+     * was captured.
+     */
+    chainStatus: typeof ChainIndexingStatusIds.Completed;
+    /**
+     * The indexing configuration of the chain.
+     */
+    config: ChainIndexingConfigDefinite;
+    /**
+     * A {@link BlockRef} to the block that was most recently indexed as of the time the
+     * indexing status snapshot was captured.
+     */
+    latestIndexedBlock: BlockRef;
+}
 /**
- * Converts a bigint value into a number value.
+ * Indexing status snapshot for a single chain.
  *
- * @throws when value is outside the range of `Number.MIN_SAFE_INTEGER` and
- * `Number.MAX_SAFE_INTEGER`.
- */
-declare function bigIntToNumber(n: bigint): number;
-
-/**
- * Gets the AccountId representing the ENSv1 Registry in the selected `namespace`.
- */
-declare const getENSv1Registry: (namespace: ENSNamespaceId) => AccountId;
-/**
- * Determines whether `contract` is the ENSv1 Registry in `namespace`.
- */
-declare const isENSv1Registry: (namespace: ENSNamespaceId, contract: AccountId) => boolean;
-/**
- * Gets the AccountId representing the ENSv2 Root Registry in the selected `namespace`.
- */
-declare const getENSv2RootRegistry: (namespace: ENSNamespaceId) => AccountId;
-/**
- * Gets the RegistryId representing the ENSv2 Root Registry in the selected `namespace`.
- */
-declare const getENSv2RootRegistryId: (namespace: ENSNamespaceId) => RegistryId;
-/**
- * Determines whether `contract` is the ENSv2 Root Registry in `namespace`.
- */
-declare const isENSv2RootRegistry: (namespace: ENSNamespaceId, contract: AccountId) => boolean;
-
-/**
- * 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.
+ * Use the `chainStatus` field to determine the specific type interpretation
+ * at runtime.
  */
-declare function serializeUrl(url: URL): UrlString;
+type ChainIndexingStatusSnapshot = ChainIndexingStatusSnapshotQueued | ChainIndexingStatusSnapshotBackfill | ChainIndexingStatusSnapshotFollowing | ChainIndexingStatusSnapshotCompleted;
 /**
- * Serializes a {@link Price} object.
+ * The status of omnichain indexing at the time an omnichain indexing status
+ * snapshot is captured.
  */
-declare function serializePrice(price: Price): SerializedPrice;
+declare const OmnichainIndexingStatusIds: {
+    /**
+     * Represents that omnichain indexing is not ready to begin yet because
+     * ENSIndexer is in its initialization phase and the data to build a "true"
+     * {@link OmnichainIndexingStatusSnapshot} is still being loaded.
+     */
+    readonly Unstarted: "omnichain-unstarted";
+    /**
+     * Represents that omnichain indexing is in an overall "backfill" status because
+     * - At least one indexed chain has a `chainStatus` of
+     *   {@link ChainIndexingStatusIds.Backfill}; and
+     * - No indexed chain has a `chainStatus` of {@link ChainIndexingStatusIds.Following}.
+     */
+    readonly Backfill: "omnichain-backfill";
+    /**
+     * Represents that omnichain indexing is in an overall "following" status because
+     * at least one indexed chain has a `chainStatus` of
+     * {@link ChainIndexingStatusIds.Following}.
+     */
+    readonly Following: "omnichain-following";
+    /**
+     * Represents that omnichain indexing has completed because all indexed chains have
+     * a `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
+     */
+    readonly Completed: "omnichain-completed";
+};
 /**
- * Serializes a {@link PriceEth} object.
+ * The derived string union of possible {@link OmnichainIndexingStatusIds}.
  */
-declare function serializePriceEth(price: PriceEth): SerializedPriceEth;
+type OmnichainIndexingStatusId = (typeof OmnichainIndexingStatusIds)[keyof typeof OmnichainIndexingStatusIds];
 /**
- * Format {@link AccountId} object as a string.
- *
- * Formatted as a fully lowercase CAIP-10 AccountId.
+ * Omnichain indexing status snapshot when the overall `omnichainStatus` is
+ * {@link OmnichainIndexingStatusIds.Unstarted}.
  *
- * @see https://chainagnostic.org/CAIPs/caip-10
+ * Invariants:
+ * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Unstarted}.
+ * - `chains` is always a map to {@link ChainIndexingStatusSnapshotQueued} values exclusively.
+ * - `omnichainIndexingCursor` is always < the `config.startBlock.timestamp` for all
+ *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Queued}.
  */
-declare function formatAccountId(accountId: AccountId): AccountIdString;
+interface OmnichainIndexingStatusSnapshotUnstarted {
+    /**
+     * The status of omnichain indexing.
+     */
+    omnichainStatus: typeof OmnichainIndexingStatusIds.Unstarted;
+    /**
+     * The indexing status snapshot for each indexed chain.
+     */
+    chains: Map<ChainId, ChainIndexingStatusSnapshotQueued>;
+    /**
+     * The timestamp of omnichain indexing progress across all indexed chains.
+     */
+    omnichainIndexingCursor: UnixTimestamp;
+}
 /**
- * Format {@link AssetId} object as a string.
- *
- * Formatted as a fully lowercase CAIP-19 AssetId.
+ * The range of {@link ChainIndexingSnapshot} types allowed when the
+ * overall omnichain indexing status is {@link OmnichainIndexingStatusIds.Backfill}.
  *
- * @see https://chainagnostic.org/CAIPs/caip-19
- */
-declare function formatAssetId({ assetNamespace, contract: { chainId, address }, tokenId, }: AssetId): AssetIdString;
-
-declare function isHttpProtocol(url: URL): boolean;
-declare function isWebSocketProtocol(url: URL): boolean;
-
-/**
- * A label set ID identifies a label set (see https://ensnode.io/ensrainbow/concepts/glossary#label-set for definition).
- * It is guaranteed to be 1 to 50 characters long and contain only lowercase letters (a-z)
- * and hyphens (-).
+ * Note that this is all of the {@link ChainIndexingSnapshot} types with the exception
+ * of {@link ChainIndexingStatusSnapshotFollowing}.
  */
-type LabelSetId = string;
+type ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill = ChainIndexingStatusSnapshotQueued | ChainIndexingStatusSnapshotBackfill | ChainIndexingStatusSnapshotCompleted;
 /**
- * A label set version identifies a specific version of a label set. It allows clients to
- * request data from a specific snapshot in time, ensuring deterministic results.
+ * Omnichain indexing status snapshot when the `omnichainStatus` is
+ * {@link OmnichainIndexingStatusIds.Backfill}.
  *
- * It is guaranteed to be a non-negative integer.
- */
-type LabelSetVersion = number;
-/**
- * The label set preferences of an ENSRainbow client.
+ * Invariants:
+ * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Backfill}.
+ * - `chains` is guaranteed to contain at least one chain with a `chainStatus` of
+ *   {@link ChainIndexingStatusIds.Backfill}.
+ * - `chains` is guaranteed to not to contain any chain with a `chainStatus` of
+ *   {@link ChainIndexingStatusIds.Following}
+ * - `omnichainIndexingCursor` is always < the `config.startBlock.timestamp` for all
+ *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Queued}.
+ * - `omnichainIndexingCursor` is always <= the `backfillEndBlock.timestamp` for all
+ *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Backfill}.
+ * - `omnichainIndexingCursor` is always >= the `latestIndexedBlock.timestamp` for all
+ *    chains with `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
+ * - `omnichainIndexingCursor` is always equal to the timestamp of the highest
+ *   `latestIndexedBlock` across all chains that have started indexing
+ *   (`chainStatus` is not {@link ChainIndexingStatusIds.Queued}).
  */
-interface EnsRainbowClientLabelSet {
+interface OmnichainIndexingStatusSnapshotBackfill {
     /**
-     * Optional label set ID that the ENSRainbow server is expected to use. If provided, heal
-     * operations will validate the ENSRainbow server is using this labelSetId.
-     * Required if `labelSetVersion` is defined.
+     * The status of omnichain indexing.
      */
-    labelSetId?: LabelSetId;
+    omnichainStatus: typeof OmnichainIndexingStatusIds.Backfill;
     /**
-     * Optional highest label set version of label set id to query. Enables deterministic heal
-     * results across time even if the ENSRainbow server ingests label sets with greater versions
-     * than this value. If provided, only labels from label sets with versions less than or equal to this
-     * value will be returned. If not provided, the server will use the latest available version.
-     * When `labelSetVersion` is defined, `labelSetId` must also be defined.
+     * The indexing status snapshot for each indexed chain.
      */
-    labelSetVersion?: LabelSetVersion;
+    chains: Map<ChainId, ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill>;
+    /**
+     * The timestamp of omnichain indexing progress across all indexed chains.
+     */
+    omnichainIndexingCursor: UnixTimestamp;
 }
 /**
- * The state of label sets managed by an ENSRainbow server.
+ * Omnichain indexing status snapshot when the overall `omnichainStatus` is
+ * {@link OmnichainIndexingStatusIds.Following}.
+ *
+ * Invariants:
+ * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Following}.
+ * - `chains` is guaranteed to contain at least one chain with a `status` of
+ *   {@link ChainIndexingStatusIds.Following}.
+ * - `omnichainIndexingCursor` is always < the `config.startBlock.timestamp` for all
+ *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Queued}.
+ * - `omnichainIndexingCursor` is always <= the `backfillEndBlock.timestamp` for all
+ *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Backfill}.
+ * - `omnichainIndexingCursor` is always >= the `latestIndexedBlock.timestamp` for all
+ *    chains with `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
+ * - `omnichainIndexingCursor` is always equal to the timestamp of the highest
+ *   `latestIndexedBlock` across all chains that have started indexing
+ *   (`chainStatus` is not {@link ChainIndexingStatusIds.Queued}).
  */
-interface EnsRainbowServerLabelSet {
+interface OmnichainIndexingStatusSnapshotFollowing {
     /**
-     * The LabelSetId managed by the ENSRainbow server.
+     * The status of omnichain indexing.
      */
-    labelSetId: LabelSetId;
+    omnichainStatus: typeof OmnichainIndexingStatusIds.Following;
     /**
-     * The highest label set version available on the ENSRainbow server for the current
-     * label set ID. This represents the most recent version of the label set that the
-     * server has ingested and can provide label healing results for.
+     * The indexing status snapshot for each indexed chain.
      */
-    highestLabelSetVersion: LabelSetVersion;
+    chains: Map<ChainId, ChainIndexingStatusSnapshot>;
+    /**
+     * The timestamp of omnichain indexing progress across all indexed chains.
+     */
+    omnichainIndexingCursor: UnixTimestamp;
 }
-
 /**
- * A PluginName is a unique id for a 'plugin': we use the notion of
- * 'plugins' to describe bundles of indexing logic.
+ * Omnichain indexing status snapshot when the overall `omnichainStatus` is
+ * {@link OmnichainIndexingStatusIds.Completed}.
+ *
+ * Invariants:
+ * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Completed}.
+ * - `chains` is always a map to {@link ChainIndexingStatusSnapshotCompleted} values exclusively.
+ * - `omnichainIndexingCursor` is always equal to the highest
+ *   `latestIndexedBlock.timestamp` for all chains.
  */
-declare enum PluginName {
-    Subgraph = "subgraph",
-    Basenames = "basenames",
-    Lineanames = "lineanames",
-    ThreeDNS = "threedns",
-    ProtocolAcceleration = "protocol-acceleration",
-    Registrars = "registrars",
-    TokenScope = "tokenscope",
-    ENSv2 = "ensv2"
-}
-/**
- * Version info about ENSIndexer and its dependencies.
- */
-interface ENSIndexerVersionInfo {
-    /**
-     * Node.js runtime version
-     *
-     * @see https://nodejs.org/en/about/previous-releases
-     **/
-    nodejs: string;
-    /**
-     * Ponder framework version
-     *
-     * @see https://www.npmjs.com/package/ponder
-     **/
-    ponder: string;
-    /**
-     * ENSDb service version
-     *
-     * Guaranteed to be the same as {@link ENSIndexerVersionInfo.ensIndexer}.
-     * */
-    ensDb: string;
-    /**
-     * ENSIndexer service version
-     *
-     * @see https://ghcr.io/namehash/ensnode/ensindexer
-     **/
-    ensIndexer: string;
+interface OmnichainIndexingStatusSnapshotCompleted {
     /**
-     * ENSRainbow service version
-     *
-     * @see https://ghcr.io/namehash/ensnode/ensindexer
-     **/
-    ensRainbow: string;
+     * The status of omnichain indexing.
+     */
+    omnichainStatus: typeof OmnichainIndexingStatusIds.Completed;
     /**
-     * ENSRainbow schema version
-     **/
-    ensRainbowSchema: number;
+     * The indexing status snapshot for each indexed chain.
+     */
+    chains: Map<ChainId, ChainIndexingStatusSnapshotCompleted>;
     /**
-     * ENS Normalize package version
-     *
-     * Available on NPM as: `@adraffy/ens-normalize`
-     *
-     * @see https://www.npmjs.com/package/@adraffy/ens-normalize
-     **/
-    ensNormalize: string;
+     * The timestamp of omnichain indexing progress across all indexed chains.
+     */
+    omnichainIndexingCursor: UnixTimestamp;
 }
 /**
- * Complete public configuration object for ENSIndexer.
+ * Omnichain indexing status snapshot for one or more chains.
  *
- * We use parameter types to maintain fields layout and documentation across
- * the domain model and its serialized counterpart.
+ * Use the `omnichainStatus` field to determine the specific type interpretation
+ * at runtime.
  */
-interface ENSIndexerPublicConfig {
+type OmnichainIndexingStatusSnapshot = OmnichainIndexingStatusSnapshotUnstarted | OmnichainIndexingStatusSnapshotBackfill | OmnichainIndexingStatusSnapshotCompleted | OmnichainIndexingStatusSnapshotFollowing;
+/**
+ * The strategy used for indexing one or more chains.
+ *
+ * @see https://ponder.sh/docs/api-reference/ponder/config#parameters
+ */
+declare const CrossChainIndexingStrategyIds: {
     /**
-     * The ENS namespace that ENSNode operates in the context of.
+     * Represents that the indexing of events across all indexed chains will
+     * proceed in a deterministic "omnichain" ordering by block timestamp, chain ID,
+     * and block number.
      *
-     * See {@link ENSNamespaceIds} for available namespace identifiers.
+     * This strategy is "deterministic" in that the order of processing cross-chain indexed
+     * events and each resulting indexed data state transition recorded in ENSDb is always
+     * the same for each ENSIndexer instance operating with an equivalent
+     * `ENSIndexerConfig` and ENSIndexer version. However it also has the drawbacks of:
+     * - increased indexing latency that must wait for the slowest indexed chain to
+     *   add new blocks or to discover new blocks through the configured RPCs.
+     * - if any indexed chain gets "stuck" due to chain or RPC failures, all indexed chains
+     *   will be affected.
      */
-    namespace: ENSNamespaceId;
+    readonly Omnichain: "omnichain";
+};
+/**
+ * The derived string union of possible {@link CrossChainIndexingStrategyIds}.
+ */
+type CrossChainIndexingStrategyId = (typeof CrossChainIndexingStrategyIds)[keyof typeof CrossChainIndexingStrategyIds];
+/**
+ * Cross-chain indexing status snapshot when the `strategy` is
+ * {@link CrossChainIndexingStrategyId.Omnichain}.
+ *
+ * Invariants:
+ * - `strategy` is always {@link CrossChainIndexingStrategyId.Omnichain}.
+ * - `slowestChainIndexingCursor` is always equal to
+ *   `omnichainSnapshot.omnichainIndexingCursor`.
+ * - `snapshotTime` is always >= the "highest known block timestamp", defined as the max of:
+ *     - the `slowestChainIndexingCursor`.
+ *     - the `config.startBlock.timestamp` for all indexed chains.
+ *     - the `config.endBlock.timestamp` for all indexed chains with a `config.configType` of
+ *       {@link ChainIndexingConfigTypeIds.Definite}.
+ *     - the `backfillEndBlock.timestamp` for all chains with `chainStatus` of
+ *       {@link ChainIndexingStatusIds.Backfill}.
+ *     - the `latestKnownBlock.timestamp` for all chains with `chainStatus` of
+ *       {@link ChainIndexingStatusIds.Following}.
+ */
+interface CrossChainIndexingStatusSnapshotOmnichain {
     /**
-     * The "fully pinned" label set reference that ENSIndexer will request ENSRainbow use for deterministic label healing across time. This label set reference is "fully pinned" as it requires both the labelSetId and labelSetVersion fields to be defined.
+     * The strategy used for indexing one or more chains.
      */
-    labelSet: Required<EnsRainbowClientLabelSet>;
+    strategy: typeof CrossChainIndexingStrategyIds.Omnichain;
     /**
-     * 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.
+     * The timestamp of the "slowest" latest indexed block timestamp
+     * across all indexed chains.
      */
-    databaseSchemaName: string;
+    slowestChainIndexingCursor: UnixTimestamp;
     /**
-     * A set of strings referring to the names of plugins that are active.
-     *
-     * For future-proofing, this is a list of strings that may or may
-     * not be currently valid {@link PluginName} values.
+     * The timestamp when the cross-chain indexing status snapshot was generated.
      *
-     * Invariants:
-     * - A set of strings with at least one value.
+     * Due to possible clock skew between different systems this value must be set
+     * to the max of each of the following values to ensure all invariants are followed:
+     * - the current system time of the system generating this cross-chain indexing
+     *   status snapshot.
+     * - the "highest known block timestamp" (see invariants above for full definition).
      */
-    plugins: string[];
+    snapshotTime: UnixTimestamp;
     /**
-     * Indexed Chain IDs
-     *
-     * Includes the {@link ChainId} for each chain being indexed.
+     * The omnichain indexing status snapshot for one or more chains.
      */
-    indexedChainIds: Set<ChainId>;
+    omnichainSnapshot: OmnichainIndexingStatusSnapshot;
+}
+/**
+ * Cross-chain indexing status snapshot for one or more chains.
+ *
+ * Use the `strategy` field to determine the specific type interpretation
+ * at runtime.
+ *
+ * Currently, only omnichain indexing is supported. This type could theoretically
+ * be extended to support other cross-chain indexing strategies in the future,
+ * such as Ponder's "multichain" indexing strategy that indexes each chain
+ * independently without deterministic ordering.
+ */
+type CrossChainIndexingStatusSnapshot = CrossChainIndexingStatusSnapshotOmnichain;
+/**
+ * A "realtime" indexing status projection based on worst-case assumptions
+ * from the `snapshot`.
+ *
+ * Invariants:
+ * - `projectedAt` is always >= `snapshot.snapshotTime`.
+ * - `worstCaseDistance` is always equal to
+ *   `projectedAt - snapshot.slowestChainIndexingCursor`.
+ */
+type RealtimeIndexingStatusProjection = {
     /**
-     * A feature flag to enable/disable ENSIndexer's Subgraph Compatible Indexing Behavior.
-     *
-     * If {@link isSubgraphCompatible} is true, indexing behavior will match that of the legacy ENS
-     * Subgraph.
-     *
-     * ENSIndexer will store and return Literal Labels and Literal Names without further interpretation.
-     * @see https://ensnode.io/docs/reference/terminology#literal-label
-     * @see https://ensnode.io/docs/reference/terminology#literal-name
-     *
-     * If {@link isSubgraphCompatible} is true, the following invariants are true for the ENSIndexerConfig:
-     * 1. only the 'subgraph' plugin is enabled, and
-     * 2. the labelSet must be { labelSetId: 'subgraph', labelSetVersion: 0 }
-     *
-     * If {@link isSubgraphCompatible} is false, ENSIndexer will additionally:
-     *
-     * 1. ENSIndexer will heal all subnames of addr.reverse on the ENS Root Chain.
-     *
-     * 2. ENSIndexer will track both the keys and the values of Resolver records.
-     *
-     * WARNING: Special care must be taken when interacting with indexed resolver record values. It
-     * is unsafe to naively assume that indexed resolver record values are equivalent to the
-     * resolver record values that would be returned through dynamic lookups via the ENS protocol.
-     * For example, if a resolver implements CCIP-Read, the resolver records may not be
-     * discoverable through onchain indexing.
-     *
-     * 3. Literal Labels and Literal Names encountered by ENSIndexer will be Interpreted.
-     * @see https://ensnode.io/docs/reference/terminology#interpreted-label
-     * @see https://ensnode.io/docs/reference/terminology#interpreted-name
+     * The timestamp representing "now" as of the time this projection was generated.
+     */
+    projectedAt: UnixTimestamp;
+    /**
+     * The distance between `projectedAt` and `snapshot.slowestChainIndexingCursor`.
      *
-     * That is,
-     * a) all Labels stored and returned by ENSIndexer will be Interpreted Labels, which are either:
-     *    i. normalized, or
-     *    ii. represented as an Encoded LabelHash of the Literal Label value found onchain, and
-     * b) all Names stored and returned by ENSIndexer will be Interpreted Names, which are exclusively
-     *   composed of Interpreted Labels.
+     * This is "worst-case" because it assumes all of the following:
+     * - the `snapshot` (which may have `snapshot.snapshotTime < projectedAt`) is still the
+     *   latest snapshot and no indexing progress has been made since `snapshotTime`.
+     * - each indexed chain has added a new block as of `projectedAt`.
      */
-    isSubgraphCompatible: boolean;
+    worstCaseDistance: Duration;
     /**
-     * Version info about ENSIndexer.
+     * The {@link CrossChainIndexingStatusSnapshot} that this projection is based on.
      */
-    versionInfo: ENSIndexerVersionInfo;
-}
+    snapshot: CrossChainIndexingStatusSnapshot;
+};
 
-type SerializedIndexedChainIds = Array<ChainId>;
 /**
- * Serialized representation of {@link ENSIndexerPublicConfig}
+ * Serialized representation of {@link ChainIndexingStatusSnapshot}
  */
-interface SerializedENSIndexerPublicConfig extends Omit<ENSIndexerPublicConfig, "indexedChainIds"> {
-    /**
-     * Array representation of {@link ENSIndexerPublicConfig.indexedChainIds}.
-     */
-    indexedChainIds: ChainId[];
-}
+type SerializedChainIndexingStatusSnapshot = ChainIndexingStatusSnapshot;
 /**
- * Serialized representation of {@link ENSIndexerVersionInfo}
+ * Serialized representation of {@link ChainIndexingStatusSnapshotQueued}
  */
-type SerializedENSIndexerVersionInfo = ENSIndexerVersionInfo;
-
+type SerializedChainIndexingStatusSnapshotQueued = ChainIndexingStatusSnapshotQueued;
 /**
- * Serialize a {@link ENSIndexerPublicConfig} object.
+ * Serialized representation of {@link ChainIndexingStatusSnapshotBackfill}
  */
-declare function deserializeENSIndexerPublicConfig(maybeConfig: SerializedENSIndexerPublicConfig, valueLabel?: string): ENSIndexerPublicConfig;
-
+type SerializedChainIndexingStatusSnapshotBackfill = ChainIndexingStatusSnapshotBackfill;
 /**
- * Determines if the provided `config` results in indexing behavior compatible with the legacy ENS
- * Subgraph.
- *
- * @see https://ensnode.io/docs/concepts/what-is-the-ens-subgraph/
+ * Serialized representation of {@link ChainIndexingStatusSnapshotCompleted}
  */
-declare function isSubgraphCompatible(config: Pick<ENSIndexerPublicConfig, "namespace" | "plugins" | "labelSet">): boolean;
-
+type SerializedChainIndexingStatusSnapshotCompleted = ChainIndexingStatusSnapshotCompleted;
 /**
- * Converts a Labelhash to bytes, with validation
- * @param labelHash The Labelhash to convert
- * @returns A ByteArray containing the bytes
- * @throws Error if `labelHash` is not a valid 32-byte hex string
+ * Serialized representation of {@link ChainIndexingStatusSnapshotFollowing}
  */
-declare function labelHashToBytes(labelHash: LabelHash): ByteArray;
-
+type SerializedChainIndexingStatusSnapshotFollowing = ChainIndexingStatusSnapshotFollowing;
 /**
- * Builds a valid LabelSetId from a string.
- * @param maybeLabelSetId - The string to validate and convert to a LabelSetId.
- * @returns A valid LabelSetId.
- * @throws If the input string is not a valid LabelSetId.
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshotUnstarted}
  */
-declare function buildLabelSetId(maybeLabelSetId: string): LabelSetId;
+interface SerializedOmnichainIndexingStatusSnapshotUnstarted extends Omit<OmnichainIndexingStatusSnapshotUnstarted, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatusSnapshotQueued>;
+}
 /**
- * Builds a valid LabelSetVersion from a number or string.
- * @param maybeLabelSetVersion - The number or string to validate and convert to a LabelSetVersion.
- * @returns A valid LabelSetVersion.
- * @throws If the input is not a valid LabelSetVersion.
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshotBackfill}
  */
-declare function buildLabelSetVersion(maybeLabelSetVersion: number | string): LabelSetVersion;
+interface SerializedOmnichainIndexingStatusSnapshotBackfill extends Omit<OmnichainIndexingStatusSnapshotBackfill, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill>;
+}
 /**
- * Builds an EnsRainbowClientLabelSet.
- * @param labelSetId - The label set ID.
- * @param labelSetVersion - The label set version.
- * @returns A valid EnsRainbowClientLabelSet object.
- * @throws If `labelSetVersion` is defined without `labelSetId`.
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshotCompleted}
  */
-declare function buildEnsRainbowClientLabelSet(labelSetId?: LabelSetId, labelSetVersion?: LabelSetVersion): EnsRainbowClientLabelSet;
+interface SerializedOmnichainIndexingStatusSnapshotCompleted extends Omit<OmnichainIndexingStatusSnapshotCompleted, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatusSnapshotCompleted>;
+}
 /**
- * Validates that the server's label set is compatible with the client's requested label set.
- * @param serverSet - The label set provided by the server.
- * @param clientSet - The label set requested by the client.
- * @throws If the server set is not compatible with the client set.
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshotFollowing}
  */
-declare function validateSupportedLabelSetAndVersion(serverSet: EnsRainbowServerLabelSet, clientSet: EnsRainbowClientLabelSet): void;
-
+interface SerializedOmnichainIndexingStatusSnapshotFollowing extends Omit<OmnichainIndexingStatusSnapshotFollowing, "chains"> {
+    chains: Record<ChainIdString, ChainIndexingStatusSnapshot>;
+}
 /**
- * Parses a string into a non-negative integer.
- * @param input The string to parse
- * @returns The parsed non-negative integer
- * @throws Error if the input is not a valid non-negative integer
+ * Serialized representation of {@link OmnichainIndexingStatusSnapshot}
  */
-declare function parseNonNegativeInteger(maybeNumber: string): number;
-
+type SerializedOmnichainIndexingStatusSnapshot = SerializedOmnichainIndexingStatusSnapshotUnstarted | SerializedOmnichainIndexingStatusSnapshotBackfill | SerializedOmnichainIndexingStatusSnapshotCompleted | SerializedOmnichainIndexingStatusSnapshotFollowing;
 /**
- * Serializes a {@link ChainConfig} object.
+ * Serialized representation of {@link CrossChainIndexingStatusSnapshotOmnichain}
  */
-declare function serializeIndexedChainIds(indexedChainIds: Set<ChainId>): SerializedIndexedChainIds;
+interface SerializedCrossChainIndexingStatusSnapshotOmnichain extends Omit<CrossChainIndexingStatusSnapshotOmnichain, "omnichainSnapshot"> {
+    omnichainSnapshot: SerializedOmnichainIndexingStatusSnapshot;
+}
 /**
- * Serialize a {@link ENSIndexerPublicConfig} object.
+ * Serialized representation of {@link CrossChainIndexingStatusSnapshot}
  */
-declare function serializeENSIndexerPublicConfig(config: ENSIndexerPublicConfig): SerializedENSIndexerPublicConfig;
-
+type SerializedCrossChainIndexingStatusSnapshot = SerializedCrossChainIndexingStatusSnapshotOmnichain;
 /**
- * The type of indexing configuration for a chain.
+ * Serialized representation of {@link RealtimeIndexingStatusProjection}
  */
-declare const ChainIndexingConfigTypeIds: {
-    /**
-     * Represents that indexing of the chain should be performed for an indefinite range.
-     */
-    readonly Indefinite: "indefinite";
-    /**
-     * Represents that indexing of the chain should be performed for a definite range.
-     */
-    readonly Definite: "definite";
-};
+interface SerializedCurrentIndexingProjectionOmnichain extends Omit<RealtimeIndexingStatusProjection, "snapshot"> {
+    snapshot: SerializedOmnichainIndexingStatusSnapshot;
+}
 /**
- * The derived string union of possible {@link ChainIndexingConfigTypeIds}.
+ * Serialized representation of {@link RealtimeIndexingStatusProjection}
  */
-type ChainIndexingConfigTypeId = (typeof ChainIndexingConfigTypeIds)[keyof typeof ChainIndexingConfigTypeIds];
+interface SerializedRealtimeIndexingStatusProjection extends Omit<RealtimeIndexingStatusProjection, "snapshot"> {
+    snapshot: SerializedCrossChainIndexingStatusSnapshot;
+}
+
 /**
- * Chain indexing config for a chain whose indexing config `configType` is
- * {@link ChainIndexingConfigTypeIds.Indefinite}.
- *
- * Invariants:
- * - `configType` is always `ChainIndexingConfigTypeIds.Indefinite`.
+ * Deserialize into a {@link ChainIndexingSnapshot} object.
  */
-interface ChainIndexingConfigIndefinite {
-    /**
-     * The type of chain indexing config.
-     */
-    configType: typeof ChainIndexingConfigTypeIds.Indefinite;
-    /**
-     * A {@link BlockRef} to the block where indexing of the chain should start.
-     */
-    startBlock: BlockRef;
-}
+declare function deserializeChainIndexingStatusSnapshot(maybeSnapshot: SerializedChainIndexingStatusSnapshot, valueLabel?: string): ChainIndexingStatusSnapshot;
 /**
- * Chain indexing config for a chain whose indexing config `configType` is
- * {@link ChainIndexingConfigTypeIds.Definite}.
- *
- * Invariants:
- * - `configType` is always `ChainIndexingConfigTypeIds.Definite`.
- * - `startBlock` is always before or the same as `endBlock`.
+ * Deserialize an {@link OmnichainIndexingStatusSnapshot} object.
  */
-interface ChainIndexingConfigDefinite {
-    /**
-     * The type of chain indexing config.
-     */
-    configType: typeof ChainIndexingConfigTypeIds.Definite;
-    /**
-     * A {@link BlockRef} to the block where indexing of the chain should start.
-     */
-    startBlock: BlockRef;
-    /**
-     * A {@link BlockRef} to the block where indexing of the chain should end.
-     */
-    endBlock: BlockRef;
-}
+declare function deserializeOmnichainIndexingStatusSnapshot(maybeSnapshot: SerializedOmnichainIndexingStatusSnapshot, valueLabel?: string): OmnichainIndexingStatusSnapshot;
 /**
- * Indexing configuration for a chain.
- *
- * Use the `configType` field to determine the specific type interpretation
- * at runtime.
+ * Deserialize an {@link CrossChainIndexingStatusSnapshot} object.
  */
-type ChainIndexingConfig = ChainIndexingConfigIndefinite | ChainIndexingConfigDefinite;
+declare function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot: SerializedCrossChainIndexingStatusSnapshot, valueLabel?: string): CrossChainIndexingStatusSnapshot;
 /**
- * The status of indexing a chain at the time an indexing status snapshot
- * is captured.
+ * Deserialize into a {@link RealtimeIndexingStatusProjection} object.
  */
-declare const ChainIndexingStatusIds: {
-    /**
-     * Represents that indexing of the chain is not ready to begin yet because:
-     * - ENSIndexer is in its initialization phase and the data to build a
-     *   "true" {@link ChainIndexingSnapshot} for the chain is still being loaded; or
-     * - ENSIndexer is using an omnichain indexing strategy and the
-     *   `omnichainIndexingCursor` is <= `config.startBlock.timestamp` for the chain's
-     *   {@link ChainIndexingSnapshot}.
-     */
-    readonly Queued: "chain-queued";
-    /**
-     * Represents that indexing of the chain is in progress and under a special
-     * "backfill" phase that optimizes for accelerated indexing until reaching the
-     * "fixed target" `backfillEndBlock`.
-     */
-    readonly Backfill: "chain-backfill";
-    /**
-     * Represents that the "backfill" phase of indexing the chain is completed
-     * and that the chain is configured to be indexed for an indefinite range.
-     * Therefore, indexing of the chain remains indefinitely in progress where
-     * ENSIndexer will continuously work to discover and index new blocks as they
-     * are added to the chain across time.
-     */
-    readonly Following: "chain-following";
-    /**
-     * Represents that indexing of the chain is completed as the chain is configured
-     * to be indexed for a definite range and the indexing of all blocks through
-     * that definite range is completed.
-     */
-    readonly Completed: "chain-completed";
-};
+declare function deserializeRealtimeIndexingStatusProjection(maybeProjection: SerializedRealtimeIndexingStatusProjection, valueLabel?: string): RealtimeIndexingStatusProjection;
+
 /**
- * The derived string union of possible {@link ChainIndexingStatusIds}.
+ * Get {@link OmnichainIndexingStatusId} based on indexed chains' statuses.
+ *
+ * This function decides what is the `OmnichainIndexingStatusId` is,
+ * based on provided chain indexing statuses.
+ *
+ * @throws an error if unable to determine overall indexing status
  */
-type ChainIndexingStatusId = (typeof ChainIndexingStatusIds)[keyof typeof ChainIndexingStatusIds];
+declare function getOmnichainIndexingStatus(chains: ChainIndexingStatusSnapshot[]): OmnichainIndexingStatusId;
 /**
- * Chain indexing status snapshot for a chain whose `chainStatus` is
- * {@link ChainIndexingStatusIds.Queued}.
+ * Get the timestamp of the lowest `config.startBlock` across all chains
+ * in the provided array of {@link ChainIndexingStatusSnapshot}.
  *
- * Invariants:
- * - `chainStatus` is always {@link ChainIndexingStatusIds.Queued}.
+ * Such timestamp is useful when presenting the "lowest" block
+ * to be indexed across all chains.
  */
-interface ChainIndexingStatusSnapshotQueued {
-    /**
-     * The status of indexing the chain at the time the indexing status snapshot
-     * was captured.
-     */
-    chainStatus: typeof ChainIndexingStatusIds.Queued;
-    /**
-     * The indexing configuration of the chain.
-     */
-    config: ChainIndexingConfig;
-}
+declare function getTimestampForLowestOmnichainStartBlock(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
 /**
- * Chain indexing status snapshot for a chain whose `chainStatus` is
- * {@link ChainIndexingStatusIds.Backfill}.
+ * Get the timestamp of the "highest known block" across all chains
+ * in the provided array of {@link ChainIndexingStatusSnapshot}.
  *
- * During a backfill, special performance optimizations are applied to
- * index all blocks between `config.startBlock` and `backfillEndBlock`
- * as fast as possible.
+ * Such timestamp is useful when presenting the "highest known block"
+ * to be indexed across all chains.
  *
- * Note how `backfillEndBlock` is a "fixed target" that does not change during
- * the lifetime of an ENSIndexer process instance:
- * - If the `config` is {@link ChainIndexingConfigDefinite}:
- *   `backfillEndBlock` is always the same as `config.endBlock`.
- * - If the `config` is {@link ChainIndexingConfigIndefinite}:
- *   `backfillEndBlock` is a {@link BlockRef} to what was the latest block on the
- *    chain when the ENSIndexer process was performing its initialization. Note how
- *    this means that if the backfill process takes X hours to complete, because the
- *    `backfillEndBlock` is a "fixed target", when `chainStatus` transitions to
- *    {@link ChainIndexingStatusIds.Following} the chain will be X hours behind
- *    "realtime" indexing.
+ * The "highest known block" for a chain depends on its status:
+ * - `config.endBlock` for a "queued" chain,
+ * - `backfillEndBlock` for a "backfill" chain,
+ * - `latestIndexedBlock` for a "completed" chain,
+ * - `latestKnownBlock` for a "following" chain.
+ */
+declare function getTimestampForHighestOmnichainKnownBlock(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
+/**
+ * Get Omnichain Indexing Cursor
  *
- * When `latestIndexedBlock` reaches `backfillEndBlock` the backfill is complete.
- * The moment backfill is complete the `chainStatus` may not immediately transition.
- * Instead, internal processing is completed for a period of time while
- * `chainStatus` remains {@link ChainIndexingStatusIds.Backfill}. After this internal
- * processing is completed `chainStatus` will transition:
- * - to {@link ChainIndexingStatusIds.Following} if the `config` is
- *   {@link ChainIndexingConfigIndefinite}.
- * - to {@link ChainIndexingStatusIds.Completed} if the `config` is
- *   {@link ChainIndexingConfigDefinite}.
+ * The cursor tracks the "highest" latest indexed block timestamp across
+ * all indexed chains. If all chains are queued, the cursor tracks the moment
+ * just before the earliest start block timestamp across those chains.
  *
- * Invariants:
- * - `chainStatus` is always {@link ChainIndexingStatusIds.Backfill}.
- * - `config.startBlock` is always before or the same as `latestIndexedBlock`
- * - `config.endBlock` is always the same as `backfillEndBlock` if and only if
- *   the config is {@link ChainIndexingConfigDefinite}.
- * - `latestIndexedBlock` is always before or the same as `backfillEndBlock`
+ * @throws an error if no chains are provided
  */
-interface ChainIndexingStatusSnapshotBackfill {
-    /**
-     * The status of indexing the chain at the time the indexing status snapshot
-     * was captured.
-     */
-    chainStatus: typeof ChainIndexingStatusIds.Backfill;
-    /**
-     * The indexing configuration of the chain.
-     */
-    config: ChainIndexingConfig;
-    /**
-     * A {@link BlockRef} to the block that was most recently indexed as of the time the
-     * indexing status snapshot was captured.
-     */
-    latestIndexedBlock: BlockRef;
-    /**
-     * A {@link BlockRef} to the block where the backfill will end.
-     */
-    backfillEndBlock: BlockRef;
-}
+declare function getOmnichainIndexingCursor(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
 /**
- * Chain indexing status snapshot for a chain whose `chainStatus` is
- * {@link ChainIndexingStatusIds.Following}.
+ * Create {@link ChainIndexingConfig} for given block refs.
  *
- * Invariants:
- * - `chainStatus` is always {@link ChainIndexingStatusIds.Following}.
- * - `config` is always {@link ChainIndexingConfigIndefinite}
- * - `config.startBlock` is always before or the same as `latestIndexedBlock`
- * - `latestIndexedBlock` is always before or the same as `latestKnownBlock`
+ * @param startBlock required block ref
+ * @param endBlock optional block ref
  */
-interface ChainIndexingStatusSnapshotFollowing {
-    /**
-     * The status of indexing the chain at the time the indexing status snapshot
-     * was captured.
-     */
-    chainStatus: typeof ChainIndexingStatusIds.Following;
-    /**
-     * The indexing configuration of the chain.
-     */
-    config: ChainIndexingConfigIndefinite;
-    /**
-     * A {@link BlockRef} to the block that was most recently indexed as of the time the
-     * indexing status snapshot was captured.
-     */
-    latestIndexedBlock: BlockRef;
-    /**
-     * A {@link BlockRef} to the "highest" block that has been discovered by RPCs
-     * and stored in the RPC cache as of the time the indexing status snapshot was
-     * captured.
-     */
-    latestKnownBlock: BlockRef;
-}
+declare function createIndexingConfig(startBlock: BlockRef, endBlock: BlockRef | null): ChainIndexingConfig;
 /**
- * Chain indexing status snapshot for a chain whose `chainStatus` is
- * {@link ChainIndexingStatusIds.Completed}.
+ * Check if Chain Indexing Status Snapshots fit the 'unstarted' overall status
+ * snapshot requirements:
+ * - All chains are guaranteed to have a status of "queued".
  *
- * After the backfill of a chain is completed, if the chain was configured
- * to be indexed for a definite range, the chain indexing status will transition to
- * {@link ChainIndexingStatusIds.Completed}.
+ * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
+ * {@link ChainIndexingStatusSnapshotQueued}.
+ */
+declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotQueued[];
+/**
+ * Check if Chain Indexing Status Snapshots fit the 'backfill' overall status
+ * snapshot requirements:
+ * - At least one chain is guaranteed to be in the "backfill" status.
+ * - Each chain is guaranteed to have a status of either "queued",
+ *   "backfill" or "completed".
  *
- * Invariants:
- * - `chainStatus` is always {@link ChainIndexingStatusIds.Completed}.
- * - `config` is always {@link ChainIndexingConfigDefinite}
- * - `config.startBlock` is always before or the same as `latestIndexedBlock`
- * - `latestIndexedBlock` is always the same as `config.endBlock`.
+ * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
+ * {@link ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill}.
  */
-interface ChainIndexingStatusSnapshotCompleted {
-    /**
-     * The status of indexing the chain at the time the indexing status snapshot
-     * was captured.
-     */
-    chainStatus: typeof ChainIndexingStatusIds.Completed;
-    /**
-     * The indexing configuration of the chain.
-     */
-    config: ChainIndexingConfigDefinite;
-    /**
-     * A {@link BlockRef} to the block that was most recently indexed as of the time the
-     * indexing status snapshot was captured.
-     */
-    latestIndexedBlock: BlockRef;
-}
+declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill[];
 /**
- * Indexing status snapshot for a single chain.
+ * Checks if Chain Indexing Status Snapshots fit the 'completed' overall status
+ * snapshot requirements:
+ * - All chains are guaranteed to have a status of "completed".
  *
- * Use the `chainStatus` field to determine the specific type interpretation
- * at runtime.
+ * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
+ * {@link ChainIndexingStatusSnapshotCompleted}.
  */
-type ChainIndexingStatusSnapshot = ChainIndexingStatusSnapshotQueued | ChainIndexingStatusSnapshotBackfill | ChainIndexingStatusSnapshotFollowing | ChainIndexingStatusSnapshotCompleted;
+declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotCompleted[];
 /**
- * The status of omnichain indexing at the time an omnichain indexing status
- * snapshot is captured.
+ * Checks Chain Indexing Status Snapshots fit the 'following' overall status
+ * snapshot requirements:
+ * - At least one chain is guaranteed to be in the "following" status.
+ * - Any other chain can have any status.
  */
-declare const OmnichainIndexingStatusIds: {
-    /**
-     * Represents that omnichain indexing is not ready to begin yet because
-     * ENSIndexer is in its initialization phase and the data to build a "true"
-     * {@link OmnichainIndexingStatusSnapshot} is still being loaded.
-     */
-    readonly Unstarted: "omnichain-unstarted";
-    /**
-     * Represents that omnichain indexing is in an overall "backfill" status because
-     * - At least one indexed chain has a `chainStatus` of
-     *   {@link ChainIndexingStatusIds.Backfill}; and
-     * - No indexed chain has a `chainStatus` of {@link ChainIndexingStatusIds.Following}.
-     */
-    readonly Backfill: "omnichain-backfill";
-    /**
-     * Represents that omnichain indexing is in an overall "following" status because
-     * at least one indexed chain has a `chainStatus` of
-     * {@link ChainIndexingStatusIds.Following}.
-     */
-    readonly Following: "omnichain-following";
-    /**
-     * Represents that omnichain indexing has completed because all indexed chains have
-     * a `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
-     */
-    readonly Completed: "omnichain-completed";
-};
+declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshot[];
 /**
- * The derived string union of possible {@link OmnichainIndexingStatusIds}.
+ * Sort a list of [{@link ChainId}, {@link ChainIndexingStatusSnapshot}] tuples
+ * by the omnichain start block timestamp in ascending order.
  */
-type OmnichainIndexingStatusId = (typeof OmnichainIndexingStatusIds)[keyof typeof OmnichainIndexingStatusIds];
+declare function sortChainStatusesByStartBlockAsc<ChainStatusType extends ChainIndexingStatusSnapshot>(chains: [ChainId, ChainStatusType][]): [ChainId, ChainStatusType][];
 /**
- * Omnichain indexing status snapshot when the overall `omnichainStatus` is
- * {@link OmnichainIndexingStatusIds.Unstarted}.
+ * Gets the latest indexed {@link BlockRef} for the given {@link ChainId}.
  *
- * Invariants:
- * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Unstarted}.
- * - `chains` is always a map to {@link ChainIndexingStatusSnapshotQueued} values exclusively.
- * - `omnichainIndexingCursor` is always < the `config.startBlock.timestamp` for all
- *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Queued}.
+ * @returns the latest indexed {@link BlockRef} for the given {@link ChainId}, or null if the chain
+ *          isn't being indexed at all or is queued and therefore hasn't started indexing yet.
  */
-interface OmnichainIndexingStatusSnapshotUnstarted {
-    /**
-     * The status of omnichain indexing.
-     */
-    omnichainStatus: typeof OmnichainIndexingStatusIds.Unstarted;
-    /**
-     * The indexing status snapshot for each indexed chain.
-     */
-    chains: Map<ChainId, ChainIndexingStatusSnapshotQueued>;
-    /**
-     * The timestamp of omnichain indexing progress across all indexed chains.
-     */
-    omnichainIndexingCursor: UnixTimestamp;
-}
+declare function getLatestIndexedBlockRef(indexingStatus: CrossChainIndexingStatusSnapshot, chainId: ChainId): BlockRef | null;
+
 /**
- * The range of {@link ChainIndexingSnapshot} types allowed when the
- * overall omnichain indexing status is {@link OmnichainIndexingStatusIds.Backfill}.
- *
- * Note that this is all of the {@link ChainIndexingSnapshot} types with the exception
- * of {@link ChainIndexingStatusSnapshotFollowing}.
+ * Create realtime indexing status projection from
+ * a {@link CrossChainIndexingStatusSnapshot}.
  */
-type ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill = ChainIndexingStatusSnapshotQueued | ChainIndexingStatusSnapshotBackfill | ChainIndexingStatusSnapshotCompleted;
+declare function createRealtimeIndexingStatusProjection(snapshot: CrossChainIndexingStatusSnapshot, now: UnixTimestamp): RealtimeIndexingStatusProjection;
+
+declare function serializeCrossChainIndexingStatusSnapshotOmnichain({ strategy, slowestChainIndexingCursor, snapshotTime, omnichainSnapshot, }: CrossChainIndexingStatusSnapshot): SerializedCrossChainIndexingStatusSnapshot;
+declare function serializeRealtimeIndexingStatusProjection(indexingProjection: RealtimeIndexingStatusProjection): SerializedRealtimeIndexingStatusProjection;
 /**
- * Omnichain indexing status snapshot when the `omnichainStatus` is
- * {@link OmnichainIndexingStatusIds.Backfill}.
+ * Serialize chain indexing snapshots.
+ */
+declare function serializeChainIndexingSnapshots<ChainIndexingStatusSnapshotType extends ChainIndexingStatusSnapshot>(chains: Map<ChainId, ChainIndexingStatusSnapshotType>): Record<ChainIdString, ChainIndexingStatusSnapshotType>;
+/**
+ * Serialize a {@link OmnichainIndexingStatusSnapshot} object.
+ */
+declare function serializeOmnichainIndexingStatusSnapshot(indexingStatus: OmnichainIndexingStatusSnapshot): SerializedOmnichainIndexingStatusSnapshot;
+
+/**
+ * Reasons why TheGraph fallback cannot be used.
+ */
+declare const TheGraphCannotFallbackReasonSchema: z.ZodEnum<{
+    readonly NotSubgraphCompatible: "not-subgraph-compatible";
+    readonly NoApiKey: "no-api-key";
+    readonly NoSubgraphUrl: "no-subgraph-url";
+}>;
+type TheGraphCannotFallbackReason = z.infer<typeof TheGraphCannotFallbackReasonSchema>;
+/**
+ * Configuration for TheGraph fallback behavior.
+ * Indicates whether fallback to TheGraph is possible and the reason if not.
+ */
+declare const TheGraphFallbackSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    canFallback: z.ZodLiteral<true>;
+    url: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    canFallback: z.ZodLiteral<false>;
+    reason: z.ZodEnum<{
+        readonly NotSubgraphCompatible: "not-subgraph-compatible";
+        readonly NoApiKey: "no-api-key";
+        readonly NoSubgraphUrl: "no-subgraph-url";
+    }>;
+}, z.core.$strict>], "canFallback">;
+type TheGraphFallback = z.infer<typeof TheGraphFallbackSchema>;
+
+/**
+ * Complete public configuration object for ENSApi.
  *
- * Invariants:
- * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Backfill}.
- * - `chains` is guaranteed to contain at least one chain with a `chainStatus` of
- *   {@link ChainIndexingStatusIds.Backfill}.
- * - `chains` is guaranteed to not to contain any chain with a `chainStatus` of
- *   {@link ChainIndexingStatusIds.Following}
- * - `omnichainIndexingCursor` is always < the `config.startBlock.timestamp` for all
- *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Queued}.
- * - `omnichainIndexingCursor` is always <= the `backfillEndBlock.timestamp` for all
- *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Backfill}.
- * - `omnichainIndexingCursor` is always >= the `latestIndexedBlock.timestamp` for all
- *    chains with `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
- * - `omnichainIndexingCursor` is always equal to the timestamp of the highest
- *   `latestIndexedBlock` across all chains that have started indexing
- *   (`chainStatus` is not {@link ChainIndexingStatusIds.Queued}).
+ * Contains ENSApi-specific configuration at the top level and
+ * embeds the complete ENSIndexer public configuration.
  */
-interface OmnichainIndexingStatusSnapshotBackfill {
+interface ENSApiPublicConfig {
     /**
-     * The status of omnichain indexing.
+     * ENSApi service version
+     *
+     * @see https://ghcr.io/namehash/ensnode/ensapi
      */
-    omnichainStatus: typeof OmnichainIndexingStatusIds.Backfill;
+    version: string;
     /**
-     * The indexing status snapshot for each indexed chain.
+     * The Graph Fallback-related info.
      */
-    chains: Map<ChainId, ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill>;
+    theGraphFallback: TheGraphFallback;
     /**
-     * The timestamp of omnichain indexing progress across all indexed chains.
+     * Complete ENSIndexer public configuration
+     *
+     * Contains all ENSIndexer public configuration including
+     * namespace, plugins, version info, etc.
      */
-    omnichainIndexingCursor: UnixTimestamp;
+    ensIndexerPublicConfig: ENSIndexerPublicConfig;
 }
+
 /**
- * Omnichain indexing status snapshot when the overall `omnichainStatus` is
- * {@link OmnichainIndexingStatusIds.Following}.
- *
- * Invariants:
- * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Following}.
- * - `chains` is guaranteed to contain at least one chain with a `status` of
- *   {@link ChainIndexingStatusIds.Following}.
- * - `omnichainIndexingCursor` is always < the `config.startBlock.timestamp` for all
- *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Queued}.
- * - `omnichainIndexingCursor` is always <= the `backfillEndBlock.timestamp` for all
- *   chains with `chainStatus` of {@link ChainIndexingStatusIds.Backfill}.
- * - `omnichainIndexingCursor` is always >= the `latestIndexedBlock.timestamp` for all
- *    chains with `chainStatus` of {@link ChainIndexingStatusIds.Completed}.
- * - `omnichainIndexingCursor` is always equal to the timestamp of the highest
- *   `latestIndexedBlock` across all chains that have started indexing
- *   (`chainStatus` is not {@link ChainIndexingStatusIds.Queued}).
+ * Serialized representation of {@link ENSApiPublicConfig}
  */
-interface OmnichainIndexingStatusSnapshotFollowing {
+interface SerializedENSApiPublicConfig extends Omit<ENSApiPublicConfig, "ensIndexerPublicConfig"> {
     /**
-     * The status of omnichain indexing.
+     * Serialized representation of {@link ENSApiPublicConfig.ensIndexerPublicConfig}.
      */
-    omnichainStatus: typeof OmnichainIndexingStatusIds.Following;
-    /**
-     * The indexing status snapshot for each indexed chain.
-     */
-    chains: Map<ChainId, ChainIndexingStatusSnapshot>;
-    /**
-     * The timestamp of omnichain indexing progress across all indexed chains.
-     */
-    omnichainIndexingCursor: UnixTimestamp;
+    ensIndexerPublicConfig: SerializedENSIndexerPublicConfig;
 }
+
 /**
- * Omnichain indexing status snapshot when the overall `omnichainStatus` is
- * {@link OmnichainIndexingStatusIds.Completed}.
- *
- * Invariants:
- * - `omnichainStatus` is always {@link OmnichainIndexingStatusIds.Completed}.
- * - `chains` is always a map to {@link ChainIndexingStatusSnapshotCompleted} values exclusively.
- * - `omnichainIndexingCursor` is always equal to the highest
- *   `latestIndexedBlock.timestamp` for all chains.
+ * Deserialize a {@link ENSApiPublicConfig} object.
  */
-interface OmnichainIndexingStatusSnapshotCompleted {
-    /**
-     * The status of omnichain indexing.
-     */
-    omnichainStatus: typeof OmnichainIndexingStatusIds.Completed;
-    /**
-     * The indexing status snapshot for each indexed chain.
-     */
-    chains: Map<ChainId, ChainIndexingStatusSnapshotCompleted>;
-    /**
-     * The timestamp of omnichain indexing progress across all indexed chains.
-     */
-    omnichainIndexingCursor: UnixTimestamp;
-}
+declare function deserializeENSApiPublicConfig(maybeConfig: SerializedENSApiPublicConfig, valueLabel?: string): ENSApiPublicConfig;
+
 /**
- * Omnichain indexing status snapshot for one or more chains.
- *
- * Use the `omnichainStatus` field to determine the specific type interpretation
- * at runtime.
+ * Serialize a {@link ENSApiPublicConfig} object.
  */
-type OmnichainIndexingStatusSnapshot = OmnichainIndexingStatusSnapshotUnstarted | OmnichainIndexingStatusSnapshotBackfill | OmnichainIndexingStatusSnapshotCompleted | OmnichainIndexingStatusSnapshotFollowing;
+declare function serializeENSApiPublicConfig(config: ENSApiPublicConfig): SerializedENSApiPublicConfig;
+
 /**
- * The strategy used for indexing one or more chains.
+ * Create a Zod schema for validating a serialized ENSApiPublicConfig.
  *
- * @see https://ponder.sh/docs/api-reference/ponder/config#parameters
- */
-declare const CrossChainIndexingStrategyIds: {
-    /**
-     * Represents that the indexing of events across all indexed chains will
-     * proceed in a deterministic "omnichain" ordering by block timestamp, chain ID,
-     * and block number.
-     *
-     * This strategy is "deterministic" in that the order of processing cross-chain indexed
-     * events and each resulting indexed data state transition recorded in ENSDb is always
-     * the same for each ENSIndexer instance operating with an equivalent
-     * `ENSIndexerConfig` and ENSIndexer version. However it also has the drawbacks of:
-     * - increased indexing latency that must wait for the slowest indexed chain to
-     *   add new blocks or to discover new blocks through the configured RPCs.
-     * - if any indexed chain gets "stuck" due to chain or RPC failures, all indexed chains
-     *   will be affected.
-     */
-    readonly Omnichain: "omnichain";
-};
-/**
- * The derived string union of possible {@link CrossChainIndexingStrategyIds}.
+ * @param valueLabel - Optional label for the value being validated (used in error messages)
  */
-type CrossChainIndexingStrategyId = (typeof CrossChainIndexingStrategyIds)[keyof typeof CrossChainIndexingStrategyIds];
+declare function makeENSApiPublicConfigSchema(valueLabel?: string): z.ZodObject<{
+    version: z.ZodString;
+    theGraphFallback: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        canFallback: z.ZodLiteral<true>;
+        url: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        canFallback: z.ZodLiteral<false>;
+        reason: z.ZodEnum<{
+            readonly NotSubgraphCompatible: "not-subgraph-compatible";
+            readonly NoApiKey: "no-api-key";
+            readonly NoSubgraphUrl: "no-subgraph-url";
+        }>;
+    }, z.core.$strict>], "canFallback">;
+    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 SepoliaV2: "sepolia-v2";
+            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>;
+
 /**
- * Cross-chain indexing status snapshot when the `strategy` is
- * {@link CrossChainIndexingStrategyId.Omnichain}.
- *
- * Invariants:
- * - `strategy` is always {@link CrossChainIndexingStrategyId.Omnichain}.
- * - `slowestChainIndexingCursor` is always equal to
- *   `omnichainSnapshot.omnichainIndexingCursor`.
- * - `snapshotTime` is always >= the "highest known block timestamp", defined as the max of:
- *     - the `slowestChainIndexingCursor`.
- *     - the `config.startBlock.timestamp` for all indexed chains.
- *     - the `config.endBlock.timestamp` for all indexed chains with a `config.configType` of
- *       {@link ChainIndexingConfigTypeIds.Definite}.
- *     - the `backfillEndBlock.timestamp` for all chains with `chainStatus` of
- *       {@link ChainIndexingStatusIds.Backfill}.
- *     - the `latestKnownBlock.timestamp` for all chains with `chainStatus` of
- *       {@link ChainIndexingStatusIds.Following}.
+ * ENSApi Public Config Response
  */
-interface CrossChainIndexingStatusSnapshotOmnichain {
-    /**
-     * The strategy used for indexing one or more chains.
-     */
-    strategy: typeof CrossChainIndexingStrategyIds.Omnichain;
-    /**
-     * The timestamp of the "slowest" latest indexed block timestamp
-     * across all indexed chains.
-     */
-    slowestChainIndexingCursor: UnixTimestamp;
-    /**
-     * The timestamp when the cross-chain indexing status snapshot was generated.
-     *
-     * Due to possible clock skew between different systems this value must be set
-     * to the max of each of the following values to ensure all invariants are followed:
-     * - the current system time of the system generating this cross-chain indexing
-     *   status snapshot.
-     * - the "highest known block timestamp" (see invariants above for full definition).
-     */
-    snapshotTime: UnixTimestamp;
-    /**
-     * The omnichain indexing status snapshot for one or more chains.
-     */
-    omnichainSnapshot: OmnichainIndexingStatusSnapshot;
-}
+type ConfigResponse = ENSApiPublicConfig;
+
+type SerializedConfigResponse = SerializedENSApiPublicConfig;
+
 /**
- * Cross-chain indexing status snapshot for one or more chains.
- *
- * Use the `strategy` field to determine the specific type interpretation
- * at runtime.
- *
- * Currently, only omnichain indexing is supported. This type could theoretically
- * be extended to support other cross-chain indexing strategies in the future,
- * such as Ponder's "multichain" indexing strategy that indexes each chain
- * independently without deterministic ordering.
+ * Deserialize a {@link ConfigResponse} object.
  */
-type CrossChainIndexingStatusSnapshot = CrossChainIndexingStatusSnapshotOmnichain;
+declare function deserializeConfigResponse(serializedResponse: SerializedConfigResponse): ConfigResponse;
+
+declare function serializeConfigResponse(response: ConfigResponse): SerializedConfigResponse;
+
 /**
- * A "realtime" indexing status projection based on worst-case assumptions
- * from the `snapshot`.
- *
- * Invariants:
- * - `projectedAt` is always >= `snapshot.snapshotTime`.
- * - `worstCaseDistance` is always equal to
- *   `projectedAt - snapshot.slowestChainIndexingCursor`.
+ * A status code for indexing status responses.
  */
-type RealtimeIndexingStatusProjection = {
-    /**
-     * The timestamp representing "now" as of the time this projection was generated.
-     */
-    projectedAt: UnixTimestamp;
+declare const IndexingStatusResponseCodes: {
     /**
-     * The distance between `projectedAt` and `snapshot.slowestChainIndexingCursor`.
-     *
-     * This is "worst-case" because it assumes all of the following:
-     * - the `snapshot` (which may have `snapshot.snapshotTime < projectedAt`) is still the
-     *   latest snapshot and no indexing progress has been made since `snapshotTime`.
-     * - each indexed chain has added a new block as of `projectedAt`.
+     * Represents that the indexing status is available.
      */
-    worstCaseDistance: Duration;
+    readonly Ok: "ok";
     /**
-     * The {@link CrossChainIndexingStatusSnapshot} that this projection is based on.
+     * Represents that the indexing status is unavailable.
      */
-    snapshot: CrossChainIndexingStatusSnapshot;
+    readonly Error: "error";
 };
-
 /**
- * Serialized representation of {@link ChainIndexingStatusSnapshot}
+ * The derived string union of possible {@link IndexingStatusResponseCodes}.
  */
-type SerializedChainIndexingStatusSnapshot = ChainIndexingStatusSnapshot;
+type IndexingStatusResponseCode = (typeof IndexingStatusResponseCodes)[keyof typeof IndexingStatusResponseCodes];
 /**
- * Serialized representation of {@link ChainIndexingStatusSnapshotQueued}
+ * An indexing status response when the indexing status is available.
  */
-type SerializedChainIndexingStatusSnapshotQueued = ChainIndexingStatusSnapshotQueued;
+type IndexingStatusResponseOk = {
+    responseCode: typeof IndexingStatusResponseCodes.Ok;
+    realtimeProjection: RealtimeIndexingStatusProjection;
+};
 /**
- * Serialized representation of {@link ChainIndexingStatusSnapshotBackfill}
+ * An indexing status response when the indexing status is unavailable.
  */
-type SerializedChainIndexingStatusSnapshotBackfill = ChainIndexingStatusSnapshotBackfill;
+type IndexingStatusResponseError = {
+    responseCode: typeof IndexingStatusResponseCodes.Error;
+};
 /**
- * Serialized representation of {@link ChainIndexingStatusSnapshotCompleted}
+ * Indexing status response.
+ *
+ * Use the `responseCode` field to determine the specific type interpretation
+ * at runtime.
  */
-type SerializedChainIndexingStatusSnapshotCompleted = ChainIndexingStatusSnapshotCompleted;
+type IndexingStatusResponse = IndexingStatusResponseOk | IndexingStatusResponseError;
+
 /**
- * Serialized representation of {@link ChainIndexingStatusSnapshotFollowing}
+ * Serialized representation of {@link IndexingStatusResponseError}.
  */
-type SerializedChainIndexingStatusSnapshotFollowing = ChainIndexingStatusSnapshotFollowing;
+type SerializedIndexingStatusResponseError = IndexingStatusResponseError;
 /**
- * Serialized representation of {@link OmnichainIndexingStatusSnapshotUnstarted}
+ * Serialized representation of {@link IndexingStatusResponseOk}.
  */
-interface SerializedOmnichainIndexingStatusSnapshotUnstarted extends Omit<OmnichainIndexingStatusSnapshotUnstarted, "chains"> {
-    chains: Record<ChainIdString, ChainIndexingStatusSnapshotQueued>;
+interface SerializedIndexingStatusResponseOk extends Omit<IndexingStatusResponseOk, "realtimeProjection"> {
+    realtimeProjection: SerializedRealtimeIndexingStatusProjection;
 }
 /**
- * Serialized representation of {@link OmnichainIndexingStatusSnapshotBackfill}
+ * Serialized representation of {@link IndexingStatusResponse}.
  */
-interface SerializedOmnichainIndexingStatusSnapshotBackfill extends Omit<OmnichainIndexingStatusSnapshotBackfill, "chains"> {
-    chains: Record<ChainIdString, ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill>;
-}
+type SerializedIndexingStatusResponse = SerializedIndexingStatusResponseOk | SerializedIndexingStatusResponseError;
+
 /**
- * Serialized representation of {@link OmnichainIndexingStatusSnapshotCompleted}
+ * Deserialize a {@link IndexingStatusResponse} object.
  */
-interface SerializedOmnichainIndexingStatusSnapshotCompleted extends Omit<OmnichainIndexingStatusSnapshotCompleted, "chains"> {
-    chains: Record<ChainIdString, ChainIndexingStatusSnapshotCompleted>;
-}
+declare function deserializeIndexingStatusResponse(maybeResponse: SerializedIndexingStatusResponse): IndexingStatusResponse;
+
 /**
- * Serialized representation of {@link OmnichainIndexingStatusSnapshotFollowing}
+ * Represents a request to Indexing Status API.
  */
-interface SerializedOmnichainIndexingStatusSnapshotFollowing extends Omit<OmnichainIndexingStatusSnapshotFollowing, "chains"> {
-    chains: Record<ChainIdString, ChainIndexingStatusSnapshot>;
-}
+type IndexingStatusRequest = {};
+
+declare function serializeIndexingStatusResponse(response: IndexingStatusResponse): SerializedIndexingStatusResponse;
+
 /**
- * Serialized representation of {@link OmnichainIndexingStatusSnapshot}
- */
-type SerializedOmnichainIndexingStatusSnapshot = SerializedOmnichainIndexingStatusSnapshotUnstarted | SerializedOmnichainIndexingStatusSnapshotBackfill | SerializedOmnichainIndexingStatusSnapshotCompleted | SerializedOmnichainIndexingStatusSnapshotFollowing;
-/**
- * Serialized representation of {@link CrossChainIndexingStatusSnapshotOmnichain}
- */
-interface SerializedCrossChainIndexingStatusSnapshotOmnichain extends Omit<CrossChainIndexingStatusSnapshotOmnichain, "omnichainSnapshot"> {
-    omnichainSnapshot: SerializedOmnichainIndexingStatusSnapshot;
-}
-/**
- * Serialized representation of {@link CrossChainIndexingStatusSnapshot}
- */
-type SerializedCrossChainIndexingStatusSnapshot = SerializedCrossChainIndexingStatusSnapshotOmnichain;
-/**
- * Serialized representation of {@link RealtimeIndexingStatusProjection}
- */
-interface SerializedCurrentIndexingProjectionOmnichain extends Omit<RealtimeIndexingStatusProjection, "snapshot"> {
-    snapshot: SerializedOmnichainIndexingStatusSnapshot;
-}
-/**
- * Serialized representation of {@link RealtimeIndexingStatusProjection}
+ * Deserialize a {@link NameTokensResponse} object.
  */
-interface SerializedRealtimeIndexingStatusProjection extends Omit<RealtimeIndexingStatusProjection, "snapshot"> {
-    snapshot: SerializedCrossChainIndexingStatusSnapshot;
-}
+declare function deserializedNameTokensResponse(maybeResponse: SerializedNameTokensResponse): NameTokensResponse;
 
-/**
- * Deserialize into a {@link ChainIndexingSnapshot} object.
- */
-declare function deserializeChainIndexingStatusSnapshot(maybeSnapshot: SerializedChainIndexingStatusSnapshot, valueLabel?: string): ChainIndexingStatusSnapshot;
-/**
- * Deserialize an {@link OmnichainIndexingStatusSnapshot} object.
- */
-declare function deserializeOmnichainIndexingStatusSnapshot(maybeSnapshot: SerializedOmnichainIndexingStatusSnapshot, valueLabel?: string): OmnichainIndexingStatusSnapshot;
-/**
- * Deserialize an {@link CrossChainIndexingStatusSnapshot} object.
- */
-declare function deserializeCrossChainIndexingStatusSnapshot(maybeSnapshot: SerializedCrossChainIndexingStatusSnapshot, valueLabel?: string): CrossChainIndexingStatusSnapshot;
-/**
- * Deserialize into a {@link RealtimeIndexingStatusProjection} object.
- */
-declare function deserializeRealtimeIndexingStatusProjection(maybeProjection: SerializedRealtimeIndexingStatusProjection, valueLabel?: string): RealtimeIndexingStatusProjection;
+declare const nameTokensPrerequisites: Readonly<{
+    /**
+     * Required plugins to enable Name Tokens API routes.
+     *
+     * 1. `registrars` plugin is required so that data in the `registrationLifecycles`
+     *    table is populated.
+     * 2. `tokenscope` plugin is required so that data in the `nameTokens`
+     *    table is populated.
+     */
+    requiredPlugins: readonly [PluginName.Registrars, PluginName.TokenScope];
+    /**
+     * Check if provided ENSApiPublicConfig supports the Name Tokens API.
+     */
+    hasEnsIndexerConfigSupport(config: ENSIndexerPublicConfig): boolean;
+    /**
+     * Required Indexing Status IDs
+     *
+     * Database indexes are created by the time the omnichain indexing status
+     * is either `completed` or `following`.
+     */
+    supportedIndexingStatusIds: ("omnichain-following" | "omnichain-completed")[];
+    /**
+     * Check if provided indexing status supports the Name Tokens API.
+     */
+    hasIndexingStatusSupport(omnichainIndexingStatusId: OmnichainIndexingStatusId): boolean;
+}>;
 
 /**
- * Get {@link OmnichainIndexingStatusId} based on indexed chains' statuses.
- *
- * This function decides what is the `OmnichainIndexingStatusId` is,
- * based on provided chain indexing statuses.
- *
- * @throws an error if unable to determine overall indexing status
- */
-declare function getOmnichainIndexingStatus(chains: ChainIndexingStatusSnapshot[]): OmnichainIndexingStatusId;
-/**
- * Get the timestamp of the lowest `config.startBlock` across all chains
- * in the provided array of {@link ChainIndexingStatusSnapshot}.
+ * Represents request to Name Tokens API.
  *
- * Such timestamp is useful when presenting the "lowest" block
- * to be indexed across all chains.
+ * Either `domainId` or `name` must be provided, but not both.
  */
-declare function getTimestampForLowestOmnichainStartBlock(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
+interface NameTokensRequest {
+    /**
+     * Domain ID (namehash) for which name tokens were requested.
+     */
+    domainId?: Node;
+    /**
+     * Name for which name tokens were requested.
+     */
+    name?: Name;
+}
+
 /**
- * Get the timestamp of the "highest known block" across all chains
- * in the provided array of {@link ChainIndexingStatusSnapshot}.
- *
- * Such timestamp is useful when presenting the "highest known block"
- * to be indexed across all chains.
- *
- * The "highest known block" for a chain depends on its status:
- * - `config.endBlock` for a "queued" chain,
- * - `backfillEndBlock` for a "backfill" chain,
- * - `latestIndexedBlock` for a "completed" chain,
- * - `latestKnownBlock` for a "following" chain.
+ * Serialized representation of {@link TokenId}.
  */
-declare function getTimestampForHighestOmnichainKnownBlock(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
+type SerializedTokenId = string;
 /**
- * Get Omnichain Indexing Cursor
- *
- * The cursor tracks the "highest" latest indexed block timestamp across
- * all indexed chains. If all chains are queued, the cursor tracks the moment
- * just before the earliest start block timestamp across those chains.
- *
- * @throws an error if no chains are provided
+ * Serialized representation of {@link AssetId}.
  */
-declare function getOmnichainIndexingCursor(chains: ChainIndexingStatusSnapshot[]): UnixTimestamp;
+interface SerializedAssetId extends Omit<AssetId, "tokenId"> {
+    tokenId: SerializedTokenId;
+}
 /**
- * Create {@link ChainIndexingConfig} for given block refs.
- *
- * @param startBlock required block ref
- * @param endBlock optional block ref
+ * Serializes {@link AssetId} object to a structured form.
  */
-declare function createIndexingConfig(startBlock: BlockRef, endBlock: BlockRef | null): ChainIndexingConfig;
+declare function serializeAssetId(assetId: AssetId): SerializedAssetId;
 /**
- * Check if Chain Indexing Status Snapshots fit the 'unstarted' overall status
- * snapshot requirements:
- * - All chains are guaranteed to have a status of "queued".
- *
- * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
- * {@link ChainIndexingStatusSnapshotQueued}.
+ * Deserialize a {@link AssetId} object.
  */
-declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotQueued[];
+declare function deserializeAssetId(maybeAssetId: unknown, valueLabel?: string): AssetId;
 /**
- * Check if Chain Indexing Status Snapshots fit the 'backfill' overall status
- * snapshot requirements:
- * - At least one chain is guaranteed to be in the "backfill" status.
- * - Each chain is guaranteed to have a status of either "queued",
- *   "backfill" or "completed".
- *
- * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
- * {@link ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill}.
+ * Parse a stringified representation of {@link AssetId} object.
  */
-declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotForOmnichainIndexingStatusSnapshotBackfill[];
+declare function parseAssetId(maybeAssetId: AssetIdString, valueLabel?: string): AssetId;
 /**
- * Checks if Chain Indexing Status Snapshots fit the 'completed' overall status
- * snapshot requirements:
- * - All chains are guaranteed to have a status of "completed".
+ * Builds an AssetId for the NFT represented by the given contract,
+ * tokenId, and assetNamespace.
  *
- * Note: This function narrows the {@link ChainIndexingStatusSnapshot} type to
- * {@link ChainIndexingStatusSnapshotCompleted}.
+ * @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 function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshotCompleted[];
+declare const buildAssetId: (contract: AccountId, tokenId: TokenId, assetNamespace: AssetNamespace) => AssetId;
 /**
- * Checks Chain Indexing Status Snapshots fit the 'following' overall status
- * snapshot requirements:
- * - At least one chain is guaranteed to be in the "following" status.
- * - Any other chain can have any status.
+ * A globally unique reference to an NFT tokenizing the ownership of a domain.
  */
-declare function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains: ChainIndexingStatusSnapshot[]): chains is ChainIndexingStatusSnapshot[];
+interface DomainAssetId extends AssetId {
+    /**
+     * The namehash (node) of the domain who's ownership is tokenized by
+     * this `AssetId`.
+     */
+    domainId: Node;
+}
 /**
- * Sort a list of [{@link ChainId}, {@link ChainIndexingStatusSnapshot}] tuples
- * by the omnichain start block timestamp in ascending order.
+ * Serialized representation of {@link DomainAssetId}.
  */
-declare function sortChainStatusesByStartBlockAsc<ChainStatusType extends ChainIndexingStatusSnapshot>(chains: [ChainId, ChainStatusType][]): [ChainId, ChainStatusType][];
+interface SerializedDomainAssetId extends SerializedAssetId {
+    domainId: Node;
+}
+declare function serializeDomainAssetId(domainAsset: DomainAssetId): SerializedDomainAssetId;
 /**
- * Gets the latest indexed {@link BlockRef} for the given {@link ChainId}.
+ * An enum representing the mint status of a DomainAssetId.
  *
- * @returns the latest indexed {@link BlockRef} for the given {@link ChainId}, or null if the chain
- *          isn't being indexed at all or is queued and therefore hasn't started indexing yet.
- */
-declare function getLatestIndexedBlockRef(indexingStatus: CrossChainIndexingStatusSnapshot, chainId: ChainId): BlockRef | null;
-
-/**
- * Create realtime indexing status projection from
- * a {@link CrossChainIndexingStatusSnapshot}.
- */
-declare function createRealtimeIndexingStatusProjection(snapshot: CrossChainIndexingStatusSnapshot, now: UnixTimestamp): RealtimeIndexingStatusProjection;
-
-declare function serializeCrossChainIndexingStatusSnapshotOmnichain({ strategy, slowestChainIndexingCursor, snapshotTime, omnichainSnapshot, }: CrossChainIndexingStatusSnapshot): SerializedCrossChainIndexingStatusSnapshot;
-declare function serializeRealtimeIndexingStatusProjection(indexingProjection: RealtimeIndexingStatusProjection): SerializedRealtimeIndexingStatusProjection;
-/**
- * Serialize chain indexing snapshots.
- */
-declare function serializeChainIndexingSnapshots<ChainIndexingStatusSnapshotType extends ChainIndexingStatusSnapshot>(chains: Map<ChainId, ChainIndexingStatusSnapshotType>): Record<ChainIdString, ChainIndexingStatusSnapshotType>;
-/**
- * Serialize a {@link OmnichainIndexingStatusSnapshot} object.
- */
-declare function serializeOmnichainIndexingStatusSnapshot(indexingStatus: OmnichainIndexingStatusSnapshot): SerializedOmnichainIndexingStatusSnapshot;
-
-/**
- * Reasons why TheGraph fallback cannot be used.
+ * 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 TheGraphCannotFallbackReasonSchema: z.ZodEnum<{
-    readonly NotSubgraphCompatible: "not-subgraph-compatible";
-    readonly NoApiKey: "no-api-key";
-    readonly NoSubgraphUrl: "no-subgraph-url";
-}>;
-type TheGraphCannotFallbackReason = z.infer<typeof TheGraphCannotFallbackReasonSchema>;
+declare const NFTMintStatuses: {
+    readonly Minted: "minted";
+    readonly Burned: "burned";
+};
+type NFTMintStatus = (typeof NFTMintStatuses)[keyof typeof NFTMintStatuses];
 /**
- * Configuration for TheGraph fallback behavior.
- * Indicates whether fallback to TheGraph is possible and the reason if not.
+ * Metadata about a NFT transfer event.
+ *
+ * This metadata can be used for building more helpful messages when processing
+ * NFT transfer events.
  */
-declare const TheGraphFallbackSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    canFallback: z.ZodLiteral<true>;
-    url: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    canFallback: z.ZodLiteral<false>;
-    reason: z.ZodEnum<{
-        readonly NotSubgraphCompatible: "not-subgraph-compatible";
-        readonly NoApiKey: "no-api-key";
-        readonly NoSubgraphUrl: "no-subgraph-url";
-    }>;
-}, z.core.$strict>], "canFallback">;
-type TheGraphFallback = z.infer<typeof TheGraphFallbackSchema>;
-
+interface NFTTransferEventMetadata {
+    chainId: ChainId;
+    blockNumber: bigint;
+    transactionHash: Hex;
+    eventHandlerName: string;
+    nft: DomainAssetId;
+}
+declare const formatNFTTransferEventMetadata: (metadata: NFTTransferEventMetadata) => string;
 /**
- * Complete public configuration object for ENSApi.
- *
- * Contains ENSApi-specific configuration at the top level and
- * embeds the complete ENSIndexer public configuration.
+ * An enum representing the type of transfer that has occurred to a DomainAssetId.
  */
-interface ENSApiPublicConfig {
+declare const NFTTransferTypes: {
     /**
-     * ENSApi service version
+     * Initial transfer from zeroAddress to a non-zeroAddress
+     * Can happen at most once to a NFT AssetId
      *
-     * @see https://ghcr.io/namehash/ensnode/ensapi
-     */
-    version: string;
-    /**
-     * The Graph Fallback-related info.
+     * 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
      */
-    theGraphFallback: TheGraphFallback;
+    readonly Mint: "mint";
     /**
-     * Complete ENSIndexer public configuration
+     * 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 -> ...
      *
-     * Contains all ENSIndexer public configuration including
-     * namespace, plugins, version info, etc.
+     * 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
      */
-    ensIndexerPublicConfig: ENSIndexerPublicConfig;
-}
-
-/**
- * Serialized representation of {@link ENSApiPublicConfig}
- */
-interface SerializedENSApiPublicConfig extends Omit<ENSApiPublicConfig, "ensIndexerPublicConfig"> {
+    readonly Remint: "remint";
     /**
-     * Serialized representation of {@link ENSApiPublicConfig.ensIndexerPublicConfig}.
+     * Special transfer type for improperly implemented NFT contracts that allow a NFT
+     * that is currently minted to be reminted before an intermediate burn.
+     *
+     * Transfer from zeroAddress to non-zeroAddress for an indexed NFT where the
+     * previously indexed nft had status `minted` with a non-zeroAddress owner.
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous NFT mint status was `minted`
+     * - previous NFT owner was a non-zeroAddress
+     * - new NFT mint status is `minted`
+     * - new NFT owner is a non-zeroAddress
      */
-    ensIndexerPublicConfig: SerializedENSIndexerPublicConfig;
-}
-
-/**
- * Deserialize a {@link ENSApiPublicConfig} object.
- */
-declare function deserializeENSApiPublicConfig(maybeConfig: SerializedENSApiPublicConfig, valueLabel?: string): ENSApiPublicConfig;
-
-/**
- * Serialize a {@link ENSApiPublicConfig} object.
- */
-declare function serializeENSApiPublicConfig(config: ENSApiPublicConfig): SerializedENSApiPublicConfig;
-
-/**
- * Create a Zod schema for validating a serialized ENSApiPublicConfig.
- *
- * @param valueLabel - Optional label for the value being validated (used in error messages)
- */
-declare function makeENSApiPublicConfigSchema(valueLabel?: string): z.ZodObject<{
-    version: z.ZodString;
-    theGraphFallback: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        canFallback: z.ZodLiteral<true>;
-        url: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        canFallback: z.ZodLiteral<false>;
-        reason: z.ZodEnum<{
-            readonly NotSubgraphCompatible: "not-subgraph-compatible";
-            readonly NoApiKey: "no-api-key";
-            readonly NoSubgraphUrl: "no-subgraph-url";
-        }>;
-    }, z.core.$strict>], "canFallback">;
-    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 SepoliaV2: "sepolia-v2";
-            readonly EnsTestEnv: "ens-test-env";
-        }>;
-        plugins: z.ZodArray<z.ZodString>;
-        databaseSchemaName: z.ZodString;
-        versionInfo: z.ZodObject<{
-            nodejs: z.ZodString;
-            ponder: z.ZodString;
-            ensDb: z.ZodString;
-            ensIndexer: z.ZodString;
-            ensNormalize: z.ZodString;
-            ensRainbow: z.ZodString;
-            ensRainbowSchema: z.ZodInt;
-        }, z.core.$strict>;
-    }, z.core.$strip>;
-}, z.core.$strict>;
-
-/**
- * ENSApi Public Config Response
- */
-type ConfigResponse = ENSApiPublicConfig;
-
-type SerializedConfigResponse = SerializedENSApiPublicConfig;
-
-/**
- * Deserialize a {@link ConfigResponse} object.
- */
-declare function deserializeConfigResponse(serializedResponse: SerializedConfigResponse): ConfigResponse;
-
-declare function serializeConfigResponse(response: ConfigResponse): SerializedConfigResponse;
-
-/**
- * A status code for indexing status responses.
- */
-declare const IndexingStatusResponseCodes: {
+    readonly MintedRemint: "minted-remint";
     /**
-     * Represents that the indexing status is available.
+     * Transfer from a non-zeroAddress to zeroAddress
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous NFT mint status was `minted`
+     * - previous NFT owner is a non-zeroAddress
+     * - new NFT mint status is `burned`
+     * - new NFT owner is the zeroAddress
      */
-    readonly Ok: "ok";
+    readonly Burn: "burn";
     /**
-     * Represents that the indexing status is unavailable.
+     * Transfer from a non-zeroAddress to a distinct non-zeroAddress
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous and new NFT mint status is `minted`
+     * - previous and new NFT owner are distinct non-zeroAddress
      */
-    readonly Error: "error";
-};
-/**
- * The derived string union of possible {@link IndexingStatusResponseCodes}.
- */
-type IndexingStatusResponseCode = (typeof IndexingStatusResponseCodes)[keyof typeof IndexingStatusResponseCodes];
-/**
- * An indexing status response when the indexing status is available.
- */
-type IndexingStatusResponseOk = {
-    responseCode: typeof IndexingStatusResponseCodes.Ok;
-    realtimeProjection: RealtimeIndexingStatusProjection;
-};
-/**
- * An indexing status response when the indexing status is unavailable.
- */
-type IndexingStatusResponseError = {
-    responseCode: typeof IndexingStatusResponseCodes.Error;
-};
-/**
- * Indexing status response.
- *
- * Use the `responseCode` field to determine the specific type interpretation
- * at runtime.
- */
-type IndexingStatusResponse = IndexingStatusResponseOk | IndexingStatusResponseError;
-
-/**
- * Serialized representation of {@link IndexingStatusResponseError}.
- */
-type SerializedIndexingStatusResponseError = IndexingStatusResponseError;
-/**
- * Serialized representation of {@link IndexingStatusResponseOk}.
- */
-interface SerializedIndexingStatusResponseOk extends Omit<IndexingStatusResponseOk, "realtimeProjection"> {
-    realtimeProjection: SerializedRealtimeIndexingStatusProjection;
-}
-/**
- * Serialized representation of {@link IndexingStatusResponse}.
- */
-type SerializedIndexingStatusResponse = SerializedIndexingStatusResponseOk | SerializedIndexingStatusResponseError;
-
-/**
- * Deserialize a {@link IndexingStatusResponse} object.
- */
-declare function deserializeIndexingStatusResponse(maybeResponse: SerializedIndexingStatusResponse): IndexingStatusResponse;
-
-/**
- * Represents a request to Indexing Status API.
- */
-type IndexingStatusRequest = {};
-
-declare function serializeIndexingStatusResponse(response: IndexingStatusResponse): SerializedIndexingStatusResponse;
-
-/**
- * Deserialize a {@link NameTokensResponse} object.
- */
-declare function deserializedNameTokensResponse(maybeResponse: SerializedNameTokensResponse): NameTokensResponse;
-
-declare const nameTokensPrerequisites: Readonly<{
+    readonly Transfer: "transfer";
     /**
-     * Required plugins to enable Name Tokens API routes.
+     * Transfer from a non-zeroAddress to the same non-zeroAddress
      *
-     * 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.
+     * Invariants:
+     * - NFT is indexed
+     * - previous and new NFT mint status is `minted`
+     * - previous and new NFT owner are equivalent non-zeroAddress
      */
-    requiredPlugins: readonly [PluginName.Registrars, PluginName.TokenScope];
+    readonly SelfTransfer: "self-transfer";
     /**
-     * Check if provided ENSApiPublicConfig supports the Name Tokens API.
+     * Transfer from zeroAddress to zeroAddress for an indexed NFT
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous and new NFT mint status is `burned`
+     * - previous and new NFT owner are zeroAddress
      */
-    hasEnsIndexerConfigSupport(config: ENSIndexerPublicConfig): boolean;
+    readonly RemintBurn: "remint-burn";
     /**
-     * Required Indexing Status IDs
+     * Special transfer type for improperly implemented NFT contracts that allow a NFT
+     * that is currently minted to be reminted again before an intermediate burn.
      *
-     * Database indexes are created by the time the omnichain indexing status
-     * is either `completed` or `following`.
+     * Transfer from zeroAddress to zeroAddress for an indexed NFT where the
+     * previously indexed nft had status `minted` with a non-zeroAddress owner.
+     *
+     * Invariants:
+     * - NFT is indexed
+     * - previous NFT mint status was `minted`
+     * - previous NFT owner was a non-zeroAddress
+     * - new NFT mint status is `burned`
+     * - new NFT owner is the zeroAddress
      */
-    supportedIndexingStatusIds: ("omnichain-following" | "omnichain-completed")[];
+    readonly MintedRemintBurn: "minted-remint-burn";
     /**
-     * Check if provided indexing status supports the Name Tokens API.
+     * Transfer from zeroAddress to zeroAddress for an unindexed NFT
+     *
+     * Invariants:
+     * - NFT is not indexed and therefore has no previous mint status or owner
+     * - NFT should remain unindexed and without any mint status or owner
      */
-    hasIndexingStatusSupport(omnichainIndexingStatusId: OmnichainIndexingStatusId): boolean;
-}>;
-
-/**
- * Represents request to Name Tokens API.
- *
- * Either `domainId` or `name` must be provided, but not both.
- */
-interface NameTokensRequest {
-    /**
-     * Domain ID (namehash) for which name tokens were requested.
-     */
-    domainId?: Node;
-    /**
-     * Name for which name tokens were requested.
-     */
-    name?: Name;
-}
-
-/**
- * Serialized representation of {@link TokenId}.
- */
-type SerializedTokenId = string;
-/**
- * Serialized representation of {@link AssetId}.
- */
-interface SerializedAssetId extends Omit<AssetId, "tokenId"> {
-    tokenId: SerializedTokenId;
-}
-/**
- * Serializes {@link AssetId} object to a structured form.
- */
-declare function serializeAssetId(assetId: AssetId): SerializedAssetId;
-/**
- * Deserialize a {@link AssetId} object.
- */
-declare function deserializeAssetId(maybeAssetId: unknown, valueLabel?: string): AssetId;
-/**
- * Parse a stringified representation of {@link AssetId} object.
- */
-declare function parseAssetId(maybeAssetId: AssetIdString, valueLabel?: string): AssetId;
-/**
- * Builds an AssetId for the NFT represented by the given contract,
- * tokenId, and assetNamespace.
- *
- * @param contract - The contract that manages the NFT
- * @param tokenId - The tokenId of the NFT
- * @param assetNamespace - The assetNamespace of the NFT
- * @returns The AssetId for the NFT represented by the given contract,
- *          tokenId, and assetNamespace
- */
-declare const buildAssetId: (contract: AccountId, tokenId: TokenId, assetNamespace: AssetNamespace) => AssetId;
-/**
- * A globally unique reference to an NFT tokenizing the ownership of a domain.
- */
-interface DomainAssetId extends AssetId {
-    /**
-     * The namehash (node) of the domain who's ownership is tokenized by
-     * this `AssetId`.
-     */
-    domainId: Node;
-}
-/**
- * Serialized representation of {@link DomainAssetId}.
- */
-interface SerializedDomainAssetId extends SerializedAssetId {
-    domainId: Node;
-}
-declare function serializeDomainAssetId(domainAsset: DomainAssetId): SerializedDomainAssetId;
-/**
- * An enum representing the mint status of a DomainAssetId.
- *
- * After we index a NFT we never delete it from our index. Instead, when an
- * indexed NFT is burned onchain we retain its record and update its mint
- * status as `burned`. If a NFT is minted again after it is burned its mint
- * status is updated to `minted`.
- */
-declare const NFTMintStatuses: {
-    readonly Minted: "minted";
-    readonly Burned: "burned";
-};
-type NFTMintStatus = (typeof NFTMintStatuses)[keyof typeof NFTMintStatuses];
-/**
- * Metadata about a NFT transfer event.
- *
- * This metadata can be used for building more helpful messages when processing
- * NFT transfer events.
- */
-interface NFTTransferEventMetadata {
-    chainId: ChainId;
-    blockNumber: bigint;
-    transactionHash: Hex;
-    eventHandlerName: string;
-    nft: DomainAssetId;
-}
-declare const formatNFTTransferEventMetadata: (metadata: NFTTransferEventMetadata) => string;
-/**
- * An enum representing the type of transfer that has occurred to a DomainAssetId.
- */
-declare const NFTTransferTypes: {
-    /**
-     * Initial transfer from zeroAddress to a non-zeroAddress
-     * Can happen at most once to a NFT AssetId
-     *
-     * Invariants:
-     * - NFT is not indexed and therefore has no previous mint status or owner
-     * - new NFT mint status is `minted`
-     * - new NFT owner is a non-zeroAddress
-     */
-    readonly Mint: "mint";
-    /**
-     * Subsequent transfer from zeroAddress to a non-zeroAddress
-     * Can happen any number of times to a NFT AssetId as it passes in a cycle from
-     * mint -> burn -> remint -> burn -> remint -> ...
-     *
-     * Invariants:
-     * - NFT is indexed
-     * - previous NFT mint status was `burned`
-     * - previous NFT owner is the zeroAddress
-     * - new NFT mint status is `minted`
-     * - new NFT owner is a non-zeroAddress
-     */
-    readonly Remint: "remint";
-    /**
-     * Special transfer type for improperly implemented NFT contracts that allow a NFT
-     * that is currently minted to be reminted before an intermediate burn.
-     *
-     * Transfer from zeroAddress to non-zeroAddress for an indexed NFT where the
-     * previously indexed nft had status `minted` with a non-zeroAddress owner.
-     *
-     * Invariants:
-     * - NFT is indexed
-     * - previous NFT mint status was `minted`
-     * - previous NFT owner was a non-zeroAddress
-     * - new NFT mint status is `minted`
-     * - new NFT owner is a non-zeroAddress
-     */
-    readonly MintedRemint: "minted-remint";
-    /**
-     * Transfer from a non-zeroAddress to zeroAddress
-     *
-     * Invariants:
-     * - NFT is indexed
-     * - previous NFT mint status was `minted`
-     * - previous NFT owner is a non-zeroAddress
-     * - new NFT mint status is `burned`
-     * - new NFT owner is the zeroAddress
-     */
-    readonly Burn: "burn";
-    /**
-     * Transfer from a non-zeroAddress to a distinct non-zeroAddress
-     *
-     * Invariants:
-     * - NFT is indexed
-     * - previous and new NFT mint status is `minted`
-     * - previous and new NFT owner are distinct non-zeroAddress
-     */
-    readonly Transfer: "transfer";
-    /**
-     * Transfer from a non-zeroAddress to the same non-zeroAddress
-     *
-     * Invariants:
-     * - NFT is indexed
-     * - previous and new NFT mint status is `minted`
-     * - previous and new NFT owner are equivalent non-zeroAddress
-     */
-    readonly SelfTransfer: "self-transfer";
-    /**
-     * Transfer from zeroAddress to zeroAddress for an indexed NFT
-     *
-     * Invariants:
-     * - NFT is indexed
-     * - previous and new NFT mint status is `burned`
-     * - previous and new NFT owner are zeroAddress
-     */
-    readonly RemintBurn: "remint-burn";
-    /**
-     * Special transfer type for improperly implemented NFT contracts that allow a NFT
-     * that is currently minted to be reminted again before an intermediate burn.
-     *
-     * Transfer from zeroAddress to zeroAddress for an indexed NFT where the
-     * previously indexed nft had status `minted` with a non-zeroAddress owner.
-     *
-     * Invariants:
-     * - NFT is indexed
-     * - previous NFT mint status was `minted`
-     * - previous NFT owner was a non-zeroAddress
-     * - new NFT mint status is `burned`
-     * - new NFT owner is the zeroAddress
-     */
-    readonly MintedRemintBurn: "minted-remint-burn";
-    /**
-     * Transfer from zeroAddress to zeroAddress for an unindexed NFT
-     *
-     * Invariants:
-     * - NFT is not indexed and therefore has no previous mint status or owner
-     * - NFT should remain unindexed and without any mint status or owner
-     */
-    readonly MintBurn: "mint-burn";
-};
-type NFTTransferType = (typeof NFTTransferTypes)[keyof typeof NFTTransferTypes];
-declare const getNFTTransferType: (from: Address, to: Address, allowMintedRemint: boolean, metadata: NFTTransferEventMetadata, currentlyIndexedOwner?: Address) => NFTTransferType;
+    readonly MintBurn: "mint-burn";
+};
+type NFTTransferType = (typeof NFTTransferTypes)[keyof typeof NFTTransferTypes];
+declare const getNFTTransferType: (from: Address, to: Address, allowMintedRemint: boolean, metadata: NFTTransferEventMetadata, currentlyIndexedOwner?: Address) => NFTTransferType;
 
 /**
  * An enum representing the possible Name Token Ownership types.
@@ -3252,57 +2697,241 @@ declare function getLineanamesSubregistryId(namespace: ENSNamespaceId): AccountI
 declare function getLineanamesSubregistryManagedName(namespaceId: ENSNamespaceId): Name;
 
 /**
- * Subregistry
+ * Identifiers for supported currencies.
+ *
+ * TODO: Add support for WETH
  */
-interface Subregistry {
-    /**
-     * Subregistry ID
-     *
-     * The ID of the subregistry the "logical registrar action" was taken on.
-     *
-     * Identifies the chainId and address of the associated subregistry smart
-     * contract.
-     */
-    subregistryId: AccountId;
-    /**
-     * The node (namehash) of the name the subregistry manages subnames of.
-     * Example subregistry managed names:
-     * - `eth`
-     * - `base.eth`
-     * - `linea.eth`
-     */
-    node: Node;
-}
-
+declare const CurrencyIds: {
+    readonly ETH: "ETH";
+    readonly USDC: "USDC";
+    readonly DAI: "DAI";
+};
+type CurrencyId = (typeof CurrencyIds)[keyof typeof CurrencyIds];
 /**
- * Registration Lifecycle Stages
+ * The amount of the currency in the smallest unit of the currency
+ * (see {@link CurrencyInfo.decimals} for the currency).
  *
- * Important: this definition should not be used anywhere.
- * It's only here to capture some ideas that were shared in the team.
+ * Guaranteed to be non-negative.
  */
-declare const RegistrationLifecycleStages: {
-    /**
-     * Active
-     *
-     * Happens when
-     * the current timestamp <= expiry.
-     */
-    readonly Active: "registrationLifecycle_active";
-    /**
-     * Grace Period
-     *
-     * Happens when
-     * `expiry < the current timestamp <= expiry + 90 days`.
-     */
-    readonly GracePeriod: "registrationLifecycle_gracePeriod";
-    /**
-     * Released with Temporary Premium Price
-     *
-     * Happens when
-     * `expiry + 90 days < the current timestamp <= expiry + 120 days`.
-     */
-    readonly ReleasedWithTempPrice: "registrationLifecycle_releasedWithTempPrice";
-    /**
+type CurrencyAmount = bigint;
+/**
+ * Serialized representation of {@link CurrencyAmount}.
+ */
+type SerializedCurrencyAmount = string;
+interface PriceEth {
+    currency: typeof CurrencyIds.ETH;
+    amount: CurrencyAmount;
+}
+interface PriceDai {
+    currency: typeof CurrencyIds.DAI;
+    amount: CurrencyAmount;
+}
+interface PriceUsdc {
+    currency: typeof CurrencyIds.USDC;
+    amount: CurrencyAmount;
+}
+type Price = PriceEth | PriceDai | PriceUsdc;
+/**
+ * Serialized representation of {@link PriceEth}.
+ */
+interface SerializedPriceEth extends Omit<PriceEth, "amount"> {
+    amount: SerializedCurrencyAmount;
+}
+/**
+ * Serialized representation of {@link PriceDai}.
+ */
+interface SerializedPriceDai extends Omit<PriceDai, "amount"> {
+    amount: SerializedCurrencyAmount;
+}
+/**
+ * Serialized representation of {@link PriceUsdc}.
+ */
+interface SerializedPriceUsdc extends Omit<PriceUsdc, "amount"> {
+    amount: SerializedCurrencyAmount;
+}
+/**
+ * Serialized representation of {@link Price}.
+ */
+type SerializedPrice = SerializedPriceEth | SerializedPriceDai | SerializedPriceUsdc;
+interface CurrencyInfo {
+    id: CurrencyId;
+    name: string;
+    decimals: number;
+}
+/**
+ * Get currency info for a provided currency.
+ */
+declare function getCurrencyInfo(currencyId: CurrencyId): CurrencyInfo;
+/**
+ * Create price in ETH for given amount.
+ */
+declare function priceEth(amount: Price["amount"]): PriceEth;
+/**
+ * Create price in USDC for given amount.
+ */
+declare function priceUsdc(amount: Price["amount"]): PriceUsdc;
+/**
+ * Create price in DAI for given amount.
+ */
+declare function priceDai(amount: Price["amount"]): PriceDai;
+/**
+ * Check if two prices have the same currency.
+ */
+declare function isPriceCurrencyEqual(priceA: Price, priceB: Price): boolean;
+/**
+ * Check if two {@link Price} values have the same currency and amount.
+ */
+declare function isPriceEqual(priceA: Price, priceB: Price): boolean;
+/**
+ * Add prices
+ *
+ * @param prices at least two {@link Price} values to be added together.
+ * @returns total of all prices.
+ * @throws if not all prices have the same currency.
+ */
+declare function addPrices<const PriceType extends Price = Price>(...prices: [PriceType, PriceType, ...PriceType[]]): PriceType;
+/**
+ * Scales a Price object by a floating-point number while maintaining precision.
+ *
+ * **Important:** The precision of this method is bound to the precision of float
+ * in JavaScript. For more information, see {@link scaleBigintByNumber}.
+ *
+ * @param price - The Price object to scale
+ * @param scaleFactor - The number to multiply by (can be a decimal like 0.5)
+ * @returns A new Price object with the scaled amount and same currency
+ *
+ * @throws {Error} If scaleFactor is negative, NaN, or infinite
+ * @throws {Error} If price amount is negative
+ *
+ * @example
+ * // Scale USDC price by 0.5
+ * const price = priceUsdc(1000000n); // 1 USDC
+ * const scaled = scalePrice(price, 0.5); // 0.5 USDC
+ * // scaled = { currency: "USDC", amount: 500000n }
+ *
+ * @example
+ * // Calculate 33.3% of ETH price
+ * const ethPrice = priceEth(1000000000000000000n); // 1 ETH
+ * const share = scalePrice(ethPrice, 0.333);
+ * // share = { currency: "ETH", amount: 333000000000000000n }
+ */
+declare function scalePrice<T extends Price>(price: T, scaleFactor: number): T;
+/**
+ * Parses a string representation of ETH into a {@link PriceEth} object.
+ *
+ * Uses {@link getCurrencyInfo} to get the correct number of decimals (18) for ETH
+ * and {@link parseUnits} from viem to convert the decimal string to a bigint.
+ *
+ * **Note:** Values with more than 18 decimal places will be truncated/rounded by viem's `parseUnits`.
+ *
+ * @param value - The decimal string to parse (e.g., "0.015" for 0.015 ETH)
+ * @returns A PriceEth object with the amount in wei (smallest unit)
+ *
+ * @throws {Error} If value is empty, whitespace-only or untrimmed
+ * @throws {Error} If value represents a negative number
+ * @throws {Error} If value is not a valid decimal string (e.g., "abc", "1.2.3")
+ *
+ * @example
+ * parseEth("0.015") // returns { currency: "ETH", amount: 15000000000000000n }
+ * parseEth("1") // returns { currency: "ETH", amount: 1000000000000000000n }
+ * parseEth("123.456789012345678") // returns { currency: "ETH", amount: 123456789012345678000n }
+ */
+declare function parseEth(value: string): PriceEth;
+/**
+ * Parses a string representation of USDC into a {@link PriceUsdc} object.
+ *
+ * Uses {@link getCurrencyInfo} to get the correct number of decimals (6) for USDC
+ * and {@link parseUnits} from viem to convert the decimal string to a bigint.
+ *
+ * **Note:** Values with more than 6 decimal places will be truncated/rounded by viem's `parseUnits`.
+ *
+ * @param value - The decimal string to parse (e.g., "123.45678" for $123.45678)
+ * @returns A PriceUsdc object with the amount in the smallest unit (6 decimals)
+ *
+ * @throws {Error} If value is empty, whitespace-only or untrimmed
+ * @throws {Error} If value represents a negative number
+ * @throws {Error} If value is not a valid decimal string (e.g., "abc", "1.2.3")
+ *
+ * @example
+ * parseUsdc("123.45678") // returns { currency: "USDC", amount: 123456780n }
+ * parseUsdc("1") // returns { currency: "USDC", amount: 1000000n }
+ * parseUsdc("0.001") // returns { currency: "USDC", amount: 1000n }
+ */
+declare function parseUsdc(value: string): PriceUsdc;
+/**
+ * Parses a string representation of DAI into a {@link PriceDai} object.
+ *
+ * Uses {@link getCurrencyInfo} to get the correct number of decimals (18) for DAI
+ * and {@link parseUnits} from viem to convert the decimal string to a bigint.
+ *
+ * **Note:** Values with more than 18 decimal places will be truncated/rounded by viem's `parseUnits`.
+ *
+ * @param value - The decimal string to parse (e.g., "123.456789012345678" for 123.456789012345678 DAI)
+ * @returns A PriceDai object with the amount in the smallest unit (18 decimals)
+ *
+ * @throws {Error} If value is empty, whitespace-only or untrimmed
+ * @throws {Error} If value represents a negative number
+ * @throws {Error} If value is not a valid decimal string (e.g., "abc", "1.2.3")
+ *
+ * @example
+ * parseDai("123.456789012345678") // returns { currency: "DAI", amount: 123456789012345678000n }
+ * parseDai("1") // returns { currency: "DAI", amount: 1000000000000000000n }
+ * parseDai("0.001") // returns { currency: "DAI", amount: 1000000000000000n }
+ */
+declare function parseDai(value: string): PriceDai;
+
+/**
+ * Subregistry
+ */
+interface Subregistry {
+    /**
+     * Subregistry ID
+     *
+     * The ID of the subregistry the "logical registrar action" was taken on.
+     *
+     * Identifies the chainId and address of the associated subregistry smart
+     * contract.
+     */
+    subregistryId: AccountId;
+    /**
+     * The node (namehash) of the name the subregistry manages subnames of.
+     * Example subregistry managed names:
+     * - `eth`
+     * - `base.eth`
+     * - `linea.eth`
+     */
+    node: Node;
+}
+
+/**
+ * Registration Lifecycle Stages
+ *
+ * Important: this definition should not be used anywhere.
+ * It's only here to capture some ideas that were shared in the team.
+ */
+declare const RegistrationLifecycleStages: {
+    /**
+     * Active
+     *
+     * Happens when
+     * the current timestamp <= expiry.
+     */
+    readonly Active: "registrationLifecycle_active";
+    /**
+     * Grace Period
+     *
+     * Happens when
+     * `expiry < the current timestamp <= expiry + 90 days`.
+     */
+    readonly GracePeriod: "registrationLifecycle_gracePeriod";
+    /**
+     * Released with Temporary Premium Price
+     *
+     * Happens when
+     * `expiry + 90 days < the current timestamp <= expiry + 120 days`.
+     */
+    readonly ReleasedWithTempPrice: "registrationLifecycle_releasedWithTempPrice";
+    /**
      * Fully Released (Regular Price)
      *
      * Happens when
@@ -4689,4 +4318,507 @@ declare const DEFAULT_ENSNODE_API_URL_SEPOLIA: "https://api.alpha-sepolia.ensnod
  */
 declare const getDefaultEnsNodeUrl: (namespace?: ENSNamespaceId) => URL;
 
-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 CanonicalId, type CanonicalPath, 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_ENSNODE_API_URL_MAINNET, DEFAULT_ENSNODE_API_URL_SEPOLIA, 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 DomainId, type Duration, ENCODED_REFERRER_BYTE_LENGTH, ENCODED_REFERRER_BYTE_OFFSET, type ENSApiPublicConfig, type ENSIndexerPublicConfig, type ENSIndexerVersionInfo, ENSNodeClient, ENS_ROOT, type ENSv1DomainId, type ENSv2DomainId, ETH_COIN_TYPE, ETH_NODE, EXPECTED_ENCODED_REFERRER_PADDING, type EncodedLabelHash, type EncodedReferrer, 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 LabelHashPath, type LabelSetId, type LabelSetVersion, type LiteralLabel, type LiteralName, LruCache, type MultichainPrimaryNameResolutionArgs, type MultichainPrimaryNameResolutionResult, type NFTMintStatus, NFTMintStatuses, type NFTTransferEventMetadata, type NFTTransferType, NFTTransferTypes, NODE_ANY, type Name, type NameToken, type NameTokenOwnership, type NameTokenOwnershipBurned, type NameTokenOwnershipFullyOnchain, type NameTokenOwnershipNameWrapper, type NameTokenOwnershipType, NameTokenOwnershipTypes, type NameTokenOwnershipUnknown, type NameTokensRequest, type NameTokensResponse, type NameTokensResponseCode, NameTokensResponseCodes, type NameTokensResponseError, type NameTokensResponseErrorCode, NameTokensResponseErrorCodes, type NameTokensResponseErrorEnsIndexerConfigUnsupported, type NameTokensResponseErrorIndexingStatusUnsupported, type NameTokensResponseErrorNameTokensNotIndexed, type NameTokensResponseOk, type NamedIdentity, type NamedRegistrarAction, type Node, type NormalizedName, type OmnichainIndexingStatusId, OmnichainIndexingStatusIds, type OmnichainIndexingStatusSnapshot, type OmnichainIndexingStatusSnapshotBackfill, type OmnichainIndexingStatusSnapshotCompleted, type OmnichainIndexingStatusSnapshotFollowing, type OmnichainIndexingStatusSnapshotUnstarted, PROTOCOL_ATTRIBUTE_PREFIX, type PermissionsId, type PermissionsResourceId, type PermissionsUserId, PluginName, type Price, type PriceDai, type PriceEth, type PriceUsdc, RECORDS_PER_PAGE_DEFAULT, RECORDS_PER_PAGE_MAX, ROOT_NODE, ROOT_RESOURCE, type RealtimeIndexingStatusProjection, type RegisteredNameTokens, type RegistrarAction, type RegistrarActionEventId, type RegistrarActionPricing, type RegistrarActionPricingAvailable, type RegistrarActionPricingUnknown, type RegistrarActionReferral, type RegistrarActionReferralAvailable, type RegistrarActionReferralNotApplicable, type RegistrarActionType, RegistrarActionTypes, type RegistrarActionsFilter, type RegistrarActionsFilterBeginTimestamp, type RegistrarActionsFilterByDecodedReferrer, type RegistrarActionsFilterBySubregistryNode, type RegistrarActionsFilterEndTimestamp, type RegistrarActionsFilterType, RegistrarActionsFilterTypes, type RegistrarActionsFilterWithEncodedReferral, type RegistrarActionsOrder, RegistrarActionsOrders, type RegistrarActionsRequest, type RegistrarActionsResponse, type RegistrarActionsResponseCode, RegistrarActionsResponseCodes, type RegistrarActionsResponseError, type RegistrarActionsResponseOk, type RegistrationExpiryInfo, type RegistrationId, type RegistrationLifecycle, type RegistrationLifecycleStage, type RegistryId, type RenewalId, type RequestPageParams, type RequiredAndNotNull, type ResolutionStatusId, ResolutionStatusIds, type ResolvePrimaryNameRequest, type ResolvePrimaryNameResponse, type ResolvePrimaryNamesRequest, type ResolvePrimaryNamesResponse, type ResolveRecordsRequest, type ResolveRecordsResponse, type ResolvedIdentity, type ResolverId, type ResolverRecordsId, 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 SerializedRegisteredNameTokens, type SerializedRegistrarAction, type SerializedRegistrarActionPricing, type SerializedRegistrarActionPricingAvailable, type SerializedRegistrarActionPricingUnknown, type SerializedRegistrarActionsResponse, type SerializedRegistrarActionsResponseError, type SerializedRegistrarActionsResponseOk, type SerializedTokenId, type SubgraphInterpretedLabel, type SubgraphInterpretedName, type Subregistry, type TheGraphCannotFallbackReason, TheGraphCannotFallbackReasonSchema, type TheGraphFallback, TheGraphFallbackSchema, type TokenId, TraceableENSProtocol, type TraceableRequest, type TraceableResponse, type TracingNode, type TracingSpan, type TracingTrace, TtlCache, type UnixTimestamp, type UnknownIdentity, type UnnamedIdentity, type UnresolvedIdentity, type UrlString, ZERO_ENCODED_REFERRER, accountIdEqual, addDuration, addPrices, addrReverseLabel, asLowerCaseAddress, beautifyName, bigIntToNumber, bigintToCoinType, buildAssetId, buildEncodedReferrer, buildEnsRainbowClientLabelSet, buildLabelSetId, buildLabelSetVersion, buildPageContext, buildUnresolvedIdentity, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted, coinTypeReverseLabel, coinTypeToEvmChainId, createIndexingConfig, createRealtimeIndexingStatusProjection, decodeDNSEncodedLiteralName, decodeDNSEncodedName, decodeEncodedReferrer, deserializeAssetId, deserializeBlockNumber, deserializeBlockRef, deserializeBlockrange, deserializeChainId, deserializeChainIndexingStatusSnapshot, deserializeConfigResponse, deserializeCrossChainIndexingStatusSnapshot, deserializeDatetime, deserializeDuration, deserializeENSApiPublicConfig, deserializeENSIndexerPublicConfig, deserializeErrorResponse, deserializeIndexingStatusResponse, deserializeOmnichainIndexingStatusSnapshot, deserializeRealtimeIndexingStatusProjection, deserializeRegistrarActionsResponse, deserializeUnixTimestamp, deserializeUrl, deserializedNameTokensResponse, durationBetween, encodeLabelHash, encodedLabelToLabelhash, evmChainIdToCoinType, formatAccountId, formatAssetId, formatNFTTransferEventMetadata, getBasenamesSubregistryId, getBasenamesSubregistryManagedName, getCanonicalId, getCurrencyInfo, getDatasourceContract, getDefaultEnsNodeUrl, getENSv1Registry, getENSv2RootRegistry, getENSv2RootRegistryId, getEthnamesSubregistryId, getEthnamesSubregistryManagedName, getLatestIndexedBlockRef, getLineanamesSubregistryId, getLineanamesSubregistryManagedName, getNFTTransferType, getNameHierarchy, getNameTokenOwnership, getNameWrapperAccounts, getOmnichainIndexingCursor, getOmnichainIndexingStatus, getParentNameFQDN, getResolvePrimaryNameChainIdParam, getTimestampForHighestOmnichainKnownBlock, getTimestampForLowestOmnichainStartBlock, hasNullByte, interpretAddress, interpretAddressRecordValue, interpretNameRecordValue, interpretTextRecordKey, interpretTextRecordValue, interpretTokenIdAsLabelHash, interpretTokenIdAsNode, interpretedLabelsToInterpretedName, interpretedNameToInterpretedLabels, interpretedNameToLabelHashPath, isENSv1Registry, isENSv2RootRegistry, isEncodedLabelHash, isHttpProtocol, isInterpetedLabel, isInterpretedName, isLabelHash, isNormalizedLabel, isNormalizedName, isPccFuseSet, isPriceCurrencyEqual, isPriceEqual, isRegistrarActionPricingAvailable, isRegistrarActionReferralAvailable, isRegistrationExpired, isRegistrationFullyExpired, isRegistrationInGracePeriod, isResolvedIdentity, isSelectionEmpty, isSubgraphCompatible, isWebSocketProtocol, labelHashToBytes, labelhashLiteralLabel, literalLabelToInterpretedLabel, literalLabelsToInterpretedName, literalLabelsToLiteralName, makeContractMatcher, makeENSApiPublicConfigSchema, makeENSv1DomainId, makeENSv2DomainId, makeLatestRegistrationId, makeLatestRenewalId, makePermissionsId, makePermissionsResourceId, makePermissionsUserId, makeRegistrationId, makeRegistryId, makeRenewalId, makeResolverId, makeResolverRecordsId, 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, serializeRegisteredNameTokens, serializeRegistrarAction, serializeRegistrarActionPricing, serializeRegistrarActionsResponse, serializeUrl, sortChainStatusesByStartBlockAsc, stripNullBytes, translateDefaultableChainIdToChainId, uint256ToHex32, uniq, validateSupportedLabelSetAndVersion };
+/**
+ * Determines where the provided AccountId values represent the same address on the same chain.
+ */
+declare const accountIdEqual: (a: AccountId, b: AccountId) => boolean;
+
+/**
+ * Converts an EVM address to its lowercase representation.
+ *
+ * @param address - EVM address to convert.
+ * @returns The lowercase representation of the EVM address.
+ */
+declare function asLowerCaseAddress(address: Address): Address;
+
+/**
+ * Cache that maps from string -> ValueType.
+ */
+interface Cache<KeyType extends string, ValueType> {
+    /**
+     * Store a value in the cache with the given key.
+     *
+     * @param key Cache key
+     * @param value Value to store
+     */
+    set(key: KeyType, value: ValueType): void;
+    /**
+     * Retrieve a value from the cache with the given key.
+     *
+     * @param key Cache key
+     * @returns The cached value if it exists, otherwise undefined
+     */
+    get(key: KeyType): ValueType | undefined;
+    /**
+     * Clear the cache.
+     */
+    clear(): void;
+    /**
+     * The current number of items in the cache. Always a non-negative integer.
+     */
+    get size(): number;
+    /**
+     * The maximum number of items in the cache. Always a non-negative integer that is >= size().
+     */
+    get capacity(): number;
+}
+
+/**
+ * Cache that maps from string -> ValueType with a LRU (least recently used) eviction policy.
+ *
+ * `get` and `set` are O(1) operations.
+ *
+ * @link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
+ */
+declare class LruCache<KeyType extends string, ValueType> implements Cache<KeyType, ValueType> {
+    private readonly _cache;
+    private readonly _capacity;
+    /**
+     * Create a new LRU cache with the given capacity.
+     *
+     * @param capacity The maximum number of items in the cache. If set to 0, the cache is effectively disabled.
+     * @throws Error if capacity is not a non-negative integer.
+     */
+    constructor(capacity: number);
+    set(key: string, value: ValueType): void;
+    get(key: string): ValueType | undefined;
+    clear(): void;
+    get size(): number;
+    get capacity(): number;
+}
+
+interface SWRCacheOptions<ValueType> {
+    /**
+     * The async function generating a value of `ValueType` to wrap with SWR caching. It may throw an
+     * Error type.
+     */
+    fn: () => Promise<ValueType>;
+    /**
+     * Time-to-live duration of a cached result in seconds. After this duration:
+     * - the currently cached result is considered "stale" but is still retained in the cache
+     *   until successfully replaced.
+     * - Each time the cache is read, if the cached result is "stale" and no background
+     *   revalidation attempt is already in progress, a new background revalidation
+     *   attempt will be made.
+     */
+    ttl: Duration;
+    /**
+     * Optional time-to-proactively-revalidate duration in seconds. After a cached result is
+     * initialized, and this duration has passed, attempts to asynchronously revalidate
+     * the cached result will be proactively made in the background on this interval.
+     */
+    proactiveRevalidationInterval?: Duration;
+    /**
+     * Optional proactive initialization. Defaults to `false`.
+     *
+     * If `true`: The SWR cache will proactively initialize itself.
+     * If `false`: The SWR cache will lazily wait to initialize itself until the first read.
+     */
+    proactivelyInitialize?: boolean;
+}
+/**
+ * Stale-While-Revalidate (SWR) cache for async functions.
+ *
+ * This caching strategy serves cached data immediately (even if stale) while
+ * asynchronously revalidating the cache in the background. This provides:
+ * - Sub-millisecond response times (after first fetch)
+ * - Always available data (serves stale data during revalidation)
+ * - Automatic background updates via configurable intervals
+ *
+ * @example
+ * ```typescript
+ * const cache = new SWRCache({
+ *   fn: async () => fetch('/api/data').then(r => r.json()),
+ *   ttl: 60, // 1 minute TTL
+ *   proactiveRevalidationInterval: 300 // proactively revalidate every 5 minutes
+ * });
+ *
+ * // Returns cached data or waits for initial fetch
+ * const data = await cache.read();
+ *
+ * if (data instanceof Error) { ... }
+ * ```
+ *
+ * @link https://web.dev/stale-while-revalidate/
+ * @link https://datatracker.ietf.org/doc/html/rfc5861
+ */
+declare class SWRCache<ValueType> {
+    private readonly options;
+    private cache;
+    private inProgressRevalidate;
+    private backgroundInterval;
+    constructor(options: SWRCacheOptions<ValueType>);
+    private revalidate;
+    /**
+     * Read the most recently cached result from the `SWRCache`.
+     *
+     * @returns a `ValueType` that was most recently successfully returned by `fn` or `Error` if `fn`
+     * has never successfully returned.
+     */
+    read(): Promise<ValueType | Error>;
+    /**
+     * Destroys the background revalidation interval, if exists.
+     */
+    destroy(): void;
+}
+
+/**
+ * Cache that maps from string -> ValueType with TTL (time-to-live) expiration.
+ *
+ * Items are automatically removed when they expire.
+ */
+declare class TtlCache<KeyType extends string, ValueType> implements Cache<KeyType, ValueType> {
+    private readonly _cache;
+    private readonly _ttl;
+    /**
+     * Create a new TTL cache with the given TTL.
+     *
+     * @param ttl Time-to-live duration in seconds. Items expire after this duration.
+     */
+    constructor(ttl: Duration);
+    private _cleanup;
+    set(key: string, value: ValueType): void;
+    get(key: string): ValueType | undefined;
+    clear(): void;
+    get size(): number;
+    get capacity(): number;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+}
+
+/**
+ * Filter out duplicates.
+ */
+declare const uniq: <T>(arr: T[]) => T[];
+
+/**
+ * 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', '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: <N extends ENSNamespaceId, D extends DatasourceName, C extends string>(namespaceId: N, datasourceName: D, contractName: C) => 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', '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;
+/**
+ * Makes a comparator fn for `b` against the contract described by `namespace`, `datasourceName`, and `contractName`.
+ */
+declare const makeContractMatcher: (namespace: ENSNamespaceId, b: AccountId) => (datasourceName: DatasourceName, contractName: string) => boolean | undefined;
+
+/**
+ * Duration between two moments in time.
+ */
+declare function durationBetween(start: UnixTimestamp, end: UnixTimestamp): Duration;
+/**
+ * Add a duration to a timestamp.
+ */
+declare function addDuration(timestamp: UnixTimestamp, duration: Duration): UnixTimestamp;
+
+declare function deserializeChainId(maybeChainId: ChainIdString, valueLabel?: string): ChainId;
+declare function deserializeDatetime(maybeDatetime: string, valueLabel?: string): Datetime;
+declare function deserializeUnixTimestamp(maybeTimestamp: number, valueLabel?: string): number;
+declare function deserializeUrl(maybeUrl: UrlString, valueLabel?: string): URL;
+declare function deserializeBlockNumber(maybeBlockNumber: number, valueLabel?: string): BlockNumber;
+declare function deserializeBlockrange(maybeBlockrange: Partial<Blockrange>, valueLabel?: string): {
+    startBlock?: number | undefined;
+    endBlock?: number | undefined;
+};
+declare function deserializeBlockRef(maybeBlockRef: Partial<BlockRef>, valueLabel?: string): BlockRef;
+declare function deserializeDuration(maybeDuration: unknown, valueLabel?: string): Duration;
+declare function parseAccountId(maybeAccountId: unknown, valueLabel?: string): AccountId;
+declare function deserializePriceEth(maybePrice: unknown, valueLabel?: string): PriceEth;
+declare function deserializePriceUsdc(maybePrice: unknown, valueLabel?: string): PriceUsdc;
+declare function deserializePriceDai(maybePrice: unknown, valueLabel?: string): PriceDai;
+
+/**
+ * Interprets a viem#Address. zeroAddress is interpreted as null, otherwise Address.
+ */
+declare const interpretAddress: (owner: Address) => `0x${string}` | null;
+
+/**
+ * Interprets a name record value string and returns null if the value is interpreted as a deletion.
+ *
+ * The interpreted record value is either:
+ * a) null, representing a non-existant or deletion of the record, or
+ * b) a normalized, non-empty-string Name.
+ *
+ * @param value - The name record value string to interpret.
+ * @returns The interpreted name string, or null if deleted.
+ */
+declare function interpretNameRecordValue(value: string): NormalizedName | null;
+/**
+ * Interprets an address record value string and returns null if the value is interpreted as a deletion.
+ *
+ * The interpreted record value is either:
+ * a) null, representing a non-existant or deletion of the record, or
+ *   i. contains null bytes
+ *   ii. empty string
+ *   iii. empty hex (0x)
+ *   iv. zeroAddress
+ * b) an address record value that
+ *   i. does not contain null bytes
+ *   ii. (if is an EVM address) is lowercase
+ *
+ * @param value - The address record value to interpret.
+ * @returns The interpreted address string or null if deleted.
+ */
+declare function interpretAddressRecordValue(value: string): string | null;
+/**
+ * Interprets a text record key string and returns null if the key should be ignored.
+ *
+ * The interpreted text record key is either:
+ * a) null, representing a text record key that should be ignored, or
+ *   i. contains null bytes
+ *   ii. empty string
+ * b) a text record key that
+ *   i. does not contain null bytes
+ *
+ * @param value - The text record key to interpret.
+ * @returns The interpreted text string or null if ignored.
+ */
+declare function interpretTextRecordKey(key: string): string | null;
+/**
+ * Interprets a text record value string and returns null if the value is interpreted as a deletion.
+ *
+ * The interpreted record value is either:
+ * a) null, representing a non-existant or deletion of the record, or
+ *   i. contains null bytes
+ *   ii. empty string
+ * b) a text record value that
+ *   i. does not contain null bytes
+ *
+ * @param value - The text record value to interpret.
+ * @returns The interpreted text string or null if deleted.
+ */
+declare function interpretTextRecordValue(value: string): string | null;
+
+/**
+ * Decodes a uint256-encoded-LabelHash (eg. from a tokenId) into a {@link LabelHash}.
+ *
+ * Remember that contracts that operate in the context of a Managed Name frequently store and operate
+ * over _LabelHashes_ that represent a direct subname of a Managed Name. These contracts also frequently
+ * implement ERC721 or ERC1155 to represent ownership of these Names. As such, to construct the
+ * ERC721/ERC1155 tokenId, they may encode the direct subnames's LabelHash as a uint256.
+ *
+ * This is true for the ENSv1 BaseRegistrar, RegistrarControllers, as well as any
+ * contracts forked from it (which includes Basenames' and Lineanames' implementations).
+ *
+ * So, in order to turn the tokenId into a LabelHash, we perform the opposite operation, decoding
+ * from a uint256 into a Hex (of size 32) and cast it as our semantic {@link LabelHash} type.
+ *
+ * @see https://github.com/ensdomains/ens-contracts/blob/db613bc/contracts/ethregistrar/ETHRegistrarController.sol#L215
+ * @see https://github.com/base/basenames/blob/1b5c1ad/src/L2/RegistrarController.sol#L488
+ * @see https://github.com/Consensys/linea-ens/blob/3a4f02f/packages/linea-ens-contracts/contracts/ethregistrar/ETHRegistrarController.sol#L447
+ */
+declare const interpretTokenIdAsLabelHash: (tokenId: bigint) => LabelHash;
+/**
+ * Decodes a uint256-encoded-Node (eg. from a tokenId) into a {@link Node}.
+ *
+ * Contracts in the ENSv1 ecosystem frequently implement ERC721 or ERC1155 to represent
+ * ownership of a Domain. As such, to construct the ERC721/ERC1155 tokenId, they may encode the
+ * domain's {@link Node} as a uint256.
+ *
+ * This is true for the ENSv1 NameWrapper, as well as any contracts forked from it (which includes
+ * Lineanames' implementation).
+ *
+ * So, in order to turn the tokenId into a Node, we perform the opposite operation, decoding
+ * from a uint256 into a Hex (of size 32) and cast it as our semantic {@link Node} type.
+ *
+ * @see https://github.com/ensdomains/ens-contracts/blob/db613bc/contracts/wrapper/ERC1155Fuse.sol#L262
+ */
+declare const interpretTokenIdAsNode: (tokenId: bigint) => Node;
+
+/**
+ * Interprets a Literal Label, producing an Interpreted Label.
+ *
+ * @see https://ensnode.io/docs/reference/terminology#literal-label
+ * @see https://ensnode.io/docs/reference/terminology#interpreted-label
+ *
+ * @param label - The Literal Label string to interpret
+ * @returns The provided label if it is a normalized label, else the EncodedLabelHash of the label
+ */
+declare function literalLabelToInterpretedLabel(label: LiteralLabel): InterpretedLabel;
+/**
+ * Interprets an ordered list of Literal Labels, producing an Interpreted Name.
+ *
+ * Note that it's important that the Literal Labels are provided as an array, otherwise it's
+ * impossible to differentiate between 'a.label.eth' being ['a.label', 'eth'] or ['a', 'label', 'eth'].
+ *
+ * Note that the input is an ordered list of _Literal_ Labels: in this context, any literal label
+ * that is formatted as an Encoded LabelHash will NOT be interpreted as such. Instead it will be
+ * interpreted into an Encoded LabelHash that encodes the literal labelhash of the Literal Label.
+ *
+ * @param labels An ordered list of 0 or more Literal Labels
+ * @returns An InterpretedName
+ */
+declare function literalLabelsToInterpretedName(labels: LiteralLabel[]): InterpretedName;
+/**
+ * Joins the list of Interpreted Labels with '.' to form an Interpreted Name.
+ *
+ * @param labels An ordered list of 0 or more Interpreted Labels
+ * @returns An InterpretedName
+ */
+declare function interpretedLabelsToInterpretedName(labels: InterpretedLabel[]): InterpretedName;
+/**
+ * Joins the list of Literal Labels with '.' to form a Literal Name.
+ *
+ * Note: LiteralLabel values may contain '.' characters, which will be preserved
+ * in the resulting LiteralName. Therefore, the number of labels in the returned
+ * LiteralName may be greater than the number of LiteralLabels in the input array.
+ *
+ * @param labels An ordered list of 0 or more Literal Labels
+ * @returns An LiteralName
+ */
+declare function literalLabelsToLiteralName(labels: LiteralLabel[]): LiteralName;
+/**
+ * Converts an Interpreted Name into a list of Interpreted Labels.
+ */
+declare function interpretedNameToInterpretedLabels(name: InterpretedName): InterpretedLabel[];
+declare function encodedLabelToLabelhash(label: string): LabelHash | null;
+declare function isInterpetedLabel(label: Label): label is InterpretedLabel;
+declare function isInterpretedName(name: Name): name is InterpretedName;
+/**
+ * Converts an InterpretedName into a LabelHashPath.
+ */
+declare function interpretedNameToLabelHashPath(name: InterpretedName): LabelHashPath;
+
+/**
+ * Implements the ENS `labelhash` function for Literal Labels.
+ * @see https://docs.ens.domains/ensip/1
+ *
+ * @param label the Literal Label to hash
+ * @returns the hash of the provided label
+ * @dev This function is viem/ens#labelhash but without the special-case handling of Encoded LabelHashes.
+ */
+declare const labelhashLiteralLabel: (label: LiteralLabel) => LabelHash;
+
+declare const hasNullByte: (value: string) => boolean;
+declare const stripNullBytes: (value: string) => string;
+
+/**
+ * Converts a bigint value into a number value.
+ *
+ * @throws when value is outside the range of `Number.MIN_SAFE_INTEGER` and
+ * `Number.MAX_SAFE_INTEGER`.
+ */
+declare function bigIntToNumber(n: bigint): number;
+/**
+ * Scales a bigint value by a floating-point number while maintaining precision.
+ *
+ * **How it works:**
+ * Converts the float to a fixed-point decimal string, extracts the decimal digits,
+ * and performs multiplication using bigint arithmetic: `(value * numerator) / denominator`.
+ *
+ * **Important:** JavaScript floats (IEEE 754 double-precision) have ~15-17 significant
+ * decimal digits. Any imprecision in the input `scaleFactor` will be reflected in the result.
+ * For example, `1/3` in JavaScript is `0.3333333333333333...` (not infinite threes), and
+ * this function accurately preserves that limitation.
+ *
+ * @param value - The bigint value to scale (must be non-negative)
+ * @param scaleFactor - The non-negative number to multiply by (can be a decimal like 0.5 or 0.333)
+ * @returns The scaled bigint value, rounded down via integer division
+ *
+ * @throws {Error} If value is negative
+ * @throws {Error} If scaleFactor is negative, NaN, infinite, or >= 1e21
+ *
+ * @example
+ * // Scale by 0.5
+ * scaleBigintByNumber(1000n, 0.5) // returns 500n
+ *
+ * @example
+ * // Scale by 1/3 (uses JavaScript's float representation)
+ * scaleBigintByNumber(1000n, 1/3) // returns 333n
+ *
+ * @example
+ * // Scale USDC amount (6 decimals) by percentage
+ * scaleBigintByNumber(5000000000n, 0.4) // 5000 USDC * 0.4 = 2000000000n (2000 USDC)
+ */
+declare function scaleBigintByNumber(value: bigint, scaleFactor: number): bigint;
+
+/**
+ * Gets the AccountId representing the ENSv1 Registry in the selected `namespace`.
+ */
+declare const getENSv1Registry: (namespace: ENSNamespaceId) => AccountId;
+/**
+ * Determines whether `contract` is the ENSv1 Registry in `namespace`.
+ */
+declare const isENSv1Registry: (namespace: ENSNamespaceId, contract: AccountId) => boolean;
+/**
+ * Gets the AccountId representing the ENSv2 Root Registry in the selected `namespace`.
+ */
+declare const getENSv2RootRegistry: (namespace: ENSNamespaceId) => AccountId;
+/**
+ * Gets the RegistryId representing the ENSv2 Root Registry in the selected `namespace`.
+ */
+declare const getENSv2RootRegistryId: (namespace: ENSNamespaceId) => RegistryId;
+/**
+ * Determines whether `contract` is the ENSv2 Root Registry in `namespace`.
+ */
+declare const isENSv2RootRegistry: (namespace: ENSNamespaceId, contract: AccountId) => boolean;
+
+/**
+ * Serializes a {@link ChainId} value into its string representation.
+ */
+declare function serializeChainId(chainId: ChainId): ChainIdString;
+/**
+ * Serializes a {@link Datetime} value into its string representation.
+ */
+declare function serializeDatetime(datetime: Datetime): DatetimeISO8601;
+/**
+ * Serializes a {@link URL} value into its string representation.
+ */
+declare function serializeUrl(url: URL): UrlString;
+/**
+ * Serializes a {@link Price} object.
+ */
+declare function serializePrice(price: Price): SerializedPrice;
+/**
+ * Serializes a {@link PriceEth} object.
+ */
+declare function serializePriceEth(price: PriceEth): SerializedPriceEth;
+/**
+ * Serializes a {@link PriceUsdc} object.
+ */
+declare function serializePriceUsdc(price: PriceUsdc): SerializedPriceUsdc;
+/**
+ * Serializes a {@link PriceDai} object.
+ */
+declare function serializePriceDai(price: PriceDai): SerializedPriceDai;
+/**
+ * Format {@link AccountId} object as a string.
+ *
+ * Formatted as a fully lowercase CAIP-10 AccountId.
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-10
+ */
+declare function formatAccountId(accountId: AccountId): AccountIdString;
+/**
+ * Format {@link AssetId} object as a string.
+ *
+ * Formatted as a fully lowercase CAIP-19 AssetId.
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-19
+ */
+declare function formatAssetId({ assetNamespace, contract: { chainId, address }, tokenId, }: AssetId): AssetIdString;
+
+declare function isHttpProtocol(url: URL): boolean;
+declare function isWebSocketProtocol(url: URL): boolean;
+
+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 CanonicalId, type CanonicalPath, 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_ENSNODE_API_URL_MAINNET, DEFAULT_ENSNODE_API_URL_SEPOLIA, 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 DomainId, type Duration, ENCODED_REFERRER_BYTE_LENGTH, ENCODED_REFERRER_BYTE_OFFSET, type ENSApiPublicConfig, type ENSIndexerPublicConfig, type ENSIndexerVersionInfo, ENSNodeClient, ENS_ROOT, type ENSv1DomainId, type ENSv2DomainId, ETH_COIN_TYPE, ETH_NODE, EXPECTED_ENCODED_REFERRER_PADDING, type EncodedLabelHash, type EncodedReferrer, 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 LabelHashPath, type LabelSetId, type LabelSetVersion, type LiteralLabel, type LiteralName, LruCache, type MultichainPrimaryNameResolutionArgs, type MultichainPrimaryNameResolutionResult, type NFTMintStatus, NFTMintStatuses, type NFTTransferEventMetadata, type NFTTransferType, NFTTransferTypes, NODE_ANY, type Name, type NameToken, type NameTokenOwnership, type NameTokenOwnershipBurned, type NameTokenOwnershipFullyOnchain, type NameTokenOwnershipNameWrapper, type NameTokenOwnershipType, NameTokenOwnershipTypes, type NameTokenOwnershipUnknown, type NameTokensRequest, type NameTokensResponse, type NameTokensResponseCode, NameTokensResponseCodes, type NameTokensResponseError, type NameTokensResponseErrorCode, NameTokensResponseErrorCodes, type NameTokensResponseErrorEnsIndexerConfigUnsupported, type NameTokensResponseErrorIndexingStatusUnsupported, type NameTokensResponseErrorNameTokensNotIndexed, type NameTokensResponseOk, type NamedIdentity, type NamedRegistrarAction, type Node, type NormalizedName, type OmnichainIndexingStatusId, OmnichainIndexingStatusIds, type OmnichainIndexingStatusSnapshot, type OmnichainIndexingStatusSnapshotBackfill, type OmnichainIndexingStatusSnapshotCompleted, type OmnichainIndexingStatusSnapshotFollowing, type OmnichainIndexingStatusSnapshotUnstarted, PROTOCOL_ATTRIBUTE_PREFIX, type PermissionsId, type PermissionsResourceId, type PermissionsUserId, PluginName, type Price, type PriceDai, type PriceEth, type PriceUsdc, RECORDS_PER_PAGE_DEFAULT, RECORDS_PER_PAGE_MAX, ROOT_NODE, ROOT_RESOURCE, type RealtimeIndexingStatusProjection, type RegisteredNameTokens, type RegistrarAction, type RegistrarActionEventId, type RegistrarActionPricing, type RegistrarActionPricingAvailable, type RegistrarActionPricingUnknown, type RegistrarActionReferral, type RegistrarActionReferralAvailable, type RegistrarActionReferralNotApplicable, type RegistrarActionType, RegistrarActionTypes, type RegistrarActionsFilter, type RegistrarActionsFilterBeginTimestamp, type RegistrarActionsFilterByDecodedReferrer, type RegistrarActionsFilterBySubregistryNode, type RegistrarActionsFilterEndTimestamp, type RegistrarActionsFilterType, RegistrarActionsFilterTypes, type RegistrarActionsFilterWithEncodedReferral, type RegistrarActionsOrder, RegistrarActionsOrders, type RegistrarActionsRequest, type RegistrarActionsResponse, type RegistrarActionsResponseCode, RegistrarActionsResponseCodes, type RegistrarActionsResponseError, type RegistrarActionsResponseOk, type RegistrationExpiryInfo, type RegistrationId, type RegistrationLifecycle, type RegistrationLifecycleStage, type RegistryId, type RenewalId, type RequestPageParams, type RequiredAndNotNull, type ResolutionStatusId, ResolutionStatusIds, type ResolvePrimaryNameRequest, type ResolvePrimaryNameResponse, type ResolvePrimaryNamesRequest, type ResolvePrimaryNamesResponse, type ResolveRecordsRequest, type ResolveRecordsResponse, type ResolvedIdentity, type ResolverId, type ResolverRecordsId, 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 SerializedRegisteredNameTokens, type SerializedRegistrarAction, type SerializedRegistrarActionPricing, type SerializedRegistrarActionPricingAvailable, type SerializedRegistrarActionPricingUnknown, type SerializedRegistrarActionsResponse, type SerializedRegistrarActionsResponseError, type SerializedRegistrarActionsResponseOk, type SerializedTokenId, type SubgraphInterpretedLabel, type SubgraphInterpretedName, type Subregistry, type TheGraphCannotFallbackReason, TheGraphCannotFallbackReasonSchema, type TheGraphFallback, TheGraphFallbackSchema, type TokenId, TraceableENSProtocol, type TraceableRequest, type TraceableResponse, type TracingNode, type TracingSpan, type TracingTrace, TtlCache, type UnixTimestamp, type UnknownIdentity, type UnnamedIdentity, type UnresolvedIdentity, type UrlString, ZERO_ENCODED_REFERRER, accountIdEqual, addDuration, addPrices, addrReverseLabel, asLowerCaseAddress, beautifyName, bigIntToNumber, bigintToCoinType, buildAssetId, buildEncodedReferrer, buildEnsRainbowClientLabelSet, buildLabelSetId, buildLabelSetVersion, buildPageContext, buildUnresolvedIdentity, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing, checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted, coinTypeReverseLabel, coinTypeToEvmChainId, createIndexingConfig, createRealtimeIndexingStatusProjection, decodeDNSEncodedLiteralName, decodeDNSEncodedName, decodeEncodedReferrer, deserializeAssetId, deserializeBlockNumber, deserializeBlockRef, deserializeBlockrange, deserializeChainId, deserializeChainIndexingStatusSnapshot, deserializeConfigResponse, deserializeCrossChainIndexingStatusSnapshot, deserializeDatetime, deserializeDuration, deserializeENSApiPublicConfig, deserializeENSIndexerPublicConfig, deserializeErrorResponse, deserializeIndexingStatusResponse, deserializeOmnichainIndexingStatusSnapshot, deserializePriceDai, deserializePriceEth, deserializePriceUsdc, deserializeRealtimeIndexingStatusProjection, deserializeRegistrarActionsResponse, deserializeUnixTimestamp, deserializeUrl, deserializedNameTokensResponse, durationBetween, encodeLabelHash, encodedLabelToLabelhash, evmChainIdToCoinType, formatAccountId, formatAssetId, formatNFTTransferEventMetadata, getBasenamesSubregistryId, getBasenamesSubregistryManagedName, getCanonicalId, getCurrencyInfo, getDatasourceContract, getDefaultEnsNodeUrl, getENSv1Registry, getENSv2RootRegistry, getENSv2RootRegistryId, getEthnamesSubregistryId, getEthnamesSubregistryManagedName, getLatestIndexedBlockRef, getLineanamesSubregistryId, getLineanamesSubregistryManagedName, getNFTTransferType, getNameHierarchy, getNameTokenOwnership, getNameWrapperAccounts, getOmnichainIndexingCursor, getOmnichainIndexingStatus, getParentNameFQDN, getResolvePrimaryNameChainIdParam, getTimestampForHighestOmnichainKnownBlock, getTimestampForLowestOmnichainStartBlock, hasNullByte, interpretAddress, interpretAddressRecordValue, interpretNameRecordValue, interpretTextRecordKey, interpretTextRecordValue, interpretTokenIdAsLabelHash, interpretTokenIdAsNode, interpretedLabelsToInterpretedName, interpretedNameToInterpretedLabels, interpretedNameToLabelHashPath, isENSv1Registry, isENSv2RootRegistry, isEncodedLabelHash, isHttpProtocol, isInterpetedLabel, isInterpretedName, isLabelHash, isNormalizedLabel, isNormalizedName, isPccFuseSet, isPriceCurrencyEqual, isPriceEqual, isRegistrarActionPricingAvailable, isRegistrarActionReferralAvailable, isRegistrationExpired, isRegistrationFullyExpired, isRegistrationInGracePeriod, isResolvedIdentity, isSelectionEmpty, isSubgraphCompatible, isWebSocketProtocol, labelHashToBytes, labelhashLiteralLabel, literalLabelToInterpretedLabel, literalLabelsToInterpretedName, literalLabelsToLiteralName, makeContractMatcher, makeENSApiPublicConfigSchema, makeENSv1DomainId, makeENSv2DomainId, makeLatestRegistrationId, makeLatestRenewalId, makePermissionsId, makePermissionsResourceId, makePermissionsUserId, makeRegistrationId, makeRegistryId, makeRenewalId, makeResolverId, makeResolverRecordsId, makeSubdomainNode, maybeGetDatasourceContract, nameTokensPrerequisites, parseAccountId, parseAssetId, parseDai, parseEth, parseNonNegativeInteger, parseReverseName, parseUsdc, priceDai, priceEth, priceUsdc, registrarActionsFilter, registrarActionsPrerequisites, reverseName, scaleBigintByNumber, scalePrice, serializeAssetId, serializeChainId, serializeChainIndexingSnapshots, serializeConfigResponse, serializeCrossChainIndexingStatusSnapshotOmnichain, serializeDatetime, serializeDomainAssetId, serializeENSApiPublicConfig, serializeENSIndexerPublicConfig, serializeIndexedChainIds, serializeIndexingStatusResponse, serializeNameToken, serializeNameTokensResponse, serializeNamedRegistrarAction, serializeOmnichainIndexingStatusSnapshot, serializePrice, serializePriceDai, serializePriceEth, serializePriceUsdc, serializeRealtimeIndexingStatusProjection, serializeRegisteredNameTokens, serializeRegistrarAction, serializeRegistrarActionPricing, serializeRegistrarActionsResponse, serializeUrl, sortChainStatusesByStartBlockAsc, stripNullBytes, translateDefaultableChainIdToChainId, uint256ToHex32, uniq, validateSupportedLabelSetAndVersion };