@ensnode/ensnode-sdk 1.13.1 → 1.14.0

package/dist/namespace-specific-value-CPvcFpGI.d.cts

@@ -0,0 +1,1260 @@
+import { UnixTimestamp, ChainId, Hex, NormalizedAddress, AccountId, Node, Duration, Address, LiteralName, InterpretedName } from 'enssdk';
+import { ENSNamespaceId } from '@ensnode/datasources';
+import { z } from 'zod/v4';
+import { Hash } from 'viem';
+
+/**
+ * Block Number
+ *
+ * Guaranteed to be a non-negative integer.
+ */
+type BlockNumber = number;
+/**
+ * Datetime value
+ */
+type Datetime = Date;
+/**
+ * Represents a URL that is used for RPC endpoints.
+ */
+type RpcUrl = URL;
+/**
+ * BlockRef
+ *
+ * Describes a block.
+ *
+ * We use parameter types to maintain fields layout and documentation across
+ * the domain model and its serialized counterpart.
+ */
+interface BlockRef {
+    /** Block number (height) */
+    number: BlockNumber;
+    /** Block timestamp */
+    timestamp: UnixTimestamp;
+}
+/**
+ * A utility type that makes all properties of a type optional recursively,
+ * including nested objects and arrays.
+ *
+ * @example
+ * ```typescript
+ * type Config = {
+ *   a: string;
+ *   b: {
+ *     x: number;
+ *     y: { z: boolean };
+ *   };
+ *   c: { id: string }[];
+ * }
+ *
+ * type PartialConfig = DeepPartial<Config>;
+ * // Results in:
+ * // {
+ * //   a?: string;
+ * //   b?: {
+ * //     x?: number;
+ * //     y?: { z?: boolean };
+ * //   };
+ * //   c?: { id?: string }[];
+ * // }
+ *
+ * // Usage:
+ * const update: PartialConfig = { b: { y: { z: true } } };
+ * ```
+ */
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? DeepPartial<U>[] : T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+/**
+ * Helper type to represent an unvalidated version of a business layer type `T`,
+ * where all properties are optional.
+ *
+ * This is useful for building a validated object `T` from partial input,
+ * where the input may be missing required fields or have fields that
+ * are not yet validated.
+ *
+ * For example, transforming serialized representation of type `T` into
+ * an unvalidated version of `T` that can be later validated against
+ * defined business rules and constraints.
+ *
+ * ```ts
+ * function buildUnvalidatedValue(serialized: SerializedChainId): Unvalidated<ChainId> {
+ *  // transform serialized chainId into unvalidated number (e.g. parseInt)
+ *  return parseInt(serialized, 10);
+ * }
+ *
+ * // Later, we can validate the unvalidated value against our business rules
+ * function validateChainId(unvalidatedChainId: Unvalidated<ChainId>): ChainId {
+ *   if (typeof unvalidatedChainId !== "number" || unvalidatedChainId <= 0) {
+ *     throw new Error("Invalid ChainId");
+ *   }
+ *
+ *   return unvalidatedChainId as ChainId;
+ * }
+ *
+ * ```
+ */
+type Unvalidated<T> = DeepPartial<T>;
+/**
+ * Marks keys in K as required (not undefined) and not null.
+ */
+type RequiredAndNotNull<T, K extends keyof T> = T & {
+    [P in K]-?: NonNullable<T[P]>;
+};
+/**
+ * Marks keys in K as required (not undefined) and null.
+ */
+type RequiredAndNull<T, K extends keyof T> = T & {
+    [P in K]-?: null;
+};
+
+/**
+ * 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 (-).
+ */
+type LabelSetId = string;
+/**
+ * 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.
+ *
+ * It is guaranteed to be a non-negative integer.
+ */
+type LabelSetVersion = number;
+/**
+ * The label set preferences of an ENSRainbow client.
+ */
+interface EnsRainbowClientLabelSet {
+    /**
+     * 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.
+     */
+    labelSetId?: LabelSetId;
+    /**
+     * 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.
+     */
+    labelSetVersion?: LabelSetVersion;
+}
+/**
+ * The state of label sets managed by an ENSRainbow server.
+ */
+interface EnsRainbowServerLabelSet {
+    /**
+     * The LabelSetId managed by the ENSRainbow server.
+     */
+    labelSetId: LabelSetId;
+    /**
+     * 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.
+     */
+    highestLabelSetVersion: LabelSetVersion;
+}
+
+/**
+ * Version info about ENSRainbow and its dependencies.
+ */
+interface EnsRainbowVersionInfo {
+    /**
+     * ENSRainbow service version
+     *
+     * @see https://ghcr.io/namehash/ensnode/ensrainbow
+     **/
+    ensRainbow: string;
+}
+/**
+ * Complete public configuration object for ENSRainbow.
+ *
+ * Contains all public configuration information about the ENSRainbow service instance.
+ */
+interface EnsRainbowPublicConfig {
+    /**
+     * The label set reference managed by the ENSRainbow server.
+     */
+    serverLabelSet: EnsRainbowServerLabelSet;
+    /**
+     * ENSRainbow version info
+     */
+    versionInfo: EnsRainbowVersionInfo;
+}
+
+/**
+ * A PluginName is a unique id for a 'plugin': we use the notion of
+ * 'plugins' to describe bundles of indexing logic.
+ */
+declare enum PluginName {
+    Subgraph = "subgraph",
+    Basenames = "basenames",
+    Lineanames = "lineanames",
+    ThreeDNS = "threedns",
+    ProtocolAcceleration = "protocol-acceleration",
+    Registrars = "registrars",
+    TokenScope = "tokenscope",
+    /** @deprecated use {@link PluginName.Unigraph} instead */
+    ENSv2 = "ensv2",
+    Unigraph = "unigraph"
+}
+/**
+ * Version info about ENSIndexer and its dependencies.
+ */
+interface EnsIndexerVersionInfo {
+    /**
+     * 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;
+    /**
+     * ENS Normalize package version
+     *
+     * Available on NPM as: `@adraffy/ens-normalize`
+     *
+     * @see https://www.npmjs.com/package/@adraffy/ens-normalize
+     **/
+    ensNormalize: string;
+}
+/**
+ * Version info about ENSIndexer and its dependencies.
+ *
+ * @deprecated Use {@link EnsIndexerVersionInfo} instead.
+ */
+type ENSIndexerVersionInfo = EnsIndexerVersionInfo;
+/**
+ * Complete public configuration object for ENSIndexer.
+ *
+ * We use parameter types to maintain fields layout and documentation across
+ * the domain model and its serialized counterpart.
+ */
+interface EnsIndexerPublicConfig {
+    /**
+     * The ENS namespace that ENSNode operates in the context of.
+     *
+     * See {@link ENSNamespaceIds} for available namespace identifiers.
+     */
+    namespace: ENSNamespaceId;
+    /**
+     * 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.
+     */
+    clientLabelSet: Required<EnsRainbowClientLabelSet>;
+    /**
+     * The name of the ENSIndexer Schema in the ENSDb instance,
+     * where the ENSIndexer instance writes indexed data.
+     *
+     * Invariants:
+     * - Must be a non-empty string that is a valid Postgres database schema
+     *   identifier.
+     */
+    ensIndexerSchemaName: string;
+    /**
+     * ENSRainbow public config
+     *
+     * Represents the public config of the connected ENSRainbow instance.
+     */
+    ensRainbowPublicConfig: EnsRainbowPublicConfig;
+    /**
+     * 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 {@link clientLabelSet} 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;
+}
+/**
+ * Complete public configuration object for ENSIndexer.
+ *
+ * @deprecated Use {@link EnsIndexerPublicConfig} instead.
+ */
+type ENSIndexerPublicConfig = EnsIndexerPublicConfig;
+
+/**
+ * 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>;
+
+/**
+ * Create a Zod schema for validating ENSApiPublicConfig.
+ *
+ * @param valueLabel - Optional label for the value being validated (used in error messages)
+ */
+declare function makeEnsApiPublicConfigSchema(valueLabel?: string): z.ZodObject<{
+    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<{
+        ensIndexerSchemaName: z.ZodString;
+        ensRainbowPublicConfig: z.ZodObject<{
+            serverLabelSet: z.ZodObject<{
+                labelSetId: z.ZodString;
+                highestLabelSetVersion: z.ZodInt;
+            }, z.core.$strip>;
+            versionInfo: z.ZodObject<{
+                ensRainbow: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        indexedChainIds: z.ZodSet<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
+        isSubgraphCompatible: z.ZodBoolean;
+        clientLabelSet: z.ZodObject<{
+            labelSetId: z.ZodString;
+            labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
+        }, z.core.$strip>;
+        namespace: z.ZodEnum<{
+            readonly Mainnet: "mainnet";
+            readonly Sepolia: "sepolia";
+            readonly SepoliaV2: "sepolia-v2";
+            readonly EnsTestEnv: "ens-test-env";
+        }>;
+        plugins: z.ZodArray<z.ZodString>;
+        versionInfo: z.ZodObject<{
+            ponder: z.ZodString;
+            ensDb: z.ZodString;
+            ensIndexer: z.ZodString;
+            ensNormalize: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    versionInfo: z.ZodObject<{
+        ensApi: z.ZodString;
+        ensNormalize: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Create a Zod schema for validating a serialized ENSApiPublicConfig.
+ *
+ * @deprecated Use {@link makeEnsApiPublicConfigSchema} instead.
+ */
+declare const makeENSApiPublicConfigSchema: typeof makeEnsApiPublicConfigSchema;
+declare function makeSerializedEnsApiPublicConfigSchema(valueLabel?: string): z.ZodObject<{
+    ensIndexerPublicConfig: z.ZodObject<{
+        ensIndexerSchemaName: z.ZodString;
+        ensRainbowPublicConfig: z.ZodObject<{
+            serverLabelSet: z.ZodObject<{
+                labelSetId: z.ZodString;
+                highestLabelSetVersion: z.ZodInt;
+            }, z.core.$strip>;
+            versionInfo: z.ZodObject<{
+                ensRainbow: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        indexedChainIds: z.ZodArray<z.ZodPipe<z.ZodInt, z.ZodTransform<number, number>>>;
+        isSubgraphCompatible: z.ZodBoolean;
+        clientLabelSet: z.ZodObject<{
+            labelSetId: z.ZodString;
+            labelSetVersion: z.ZodPipe<z.ZodCoercedNumber<number>, z.ZodInt>;
+        }, z.core.$strip>;
+        namespace: z.ZodEnum<{
+            readonly Mainnet: "mainnet";
+            readonly Sepolia: "sepolia";
+            readonly SepoliaV2: "sepolia-v2";
+            readonly EnsTestEnv: "ens-test-env";
+        }>;
+        plugins: z.ZodArray<z.ZodString>;
+        versionInfo: z.ZodObject<{
+            ponder: z.ZodString;
+            ensDb: z.ZodString;
+            ensIndexer: z.ZodString;
+            ensNormalize: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    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">;
+    versionInfo: z.ZodObject<{
+        ensApi: z.ZodString;
+        ensNormalize: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+
+/**
+ * Schema for {@link ErrorResponse}.
+ */
+declare const makeErrorResponseSchema: () => z.ZodObject<{
+    message: z.ZodString;
+    details: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+
+/**
+ * Encoded Referrer
+ *
+ * Represents a "raw" ENS referrer value.
+ *
+ * Registrar controllers emit referrer data as bytes32 values. This type represents
+ * that raw 32-byte hex string.
+ *
+ * @invariant Guaranteed to be a hex string representation of a 32-byte value.
+ */
+type EncodedReferrer = Hex;
+/**
+ * Encoded Referrer byte offset
+ *
+ * The count of left-padded bytes in an {@link EncodedReferrer} value.
+ */
+declare const ENCODED_REFERRER_BYTE_OFFSET = 12;
+/**
+ * Encoded Referrer byte length
+ *
+ * The count of bytes the {@link EncodedReferrer} value consists of.
+ */
+declare const ENCODED_REFERRER_BYTE_LENGTH = 32;
+/**
+ * Expected padding for a valid encoded referrer
+ *
+ * Properly encoded referrers must have exactly 12 zero bytes of left padding
+ * before the 20-byte Ethereum address.
+ */
+declare const EXPECTED_ENCODED_REFERRER_PADDING: Hex;
+/**
+ * Zero Encoded Referrer
+ *
+ * Guaranteed to be a hex string representation of a 32-byte zero value.
+ */
+declare const ZERO_ENCODED_REFERRER: EncodedReferrer;
+/**
+ * Build an {@link EncodedReferrer} value for the given {@link NormalizedAddress}
+ * according to the referrer encoding with left-zero-padding.
+ */
+declare function buildEncodedReferrer(address: NormalizedAddress): EncodedReferrer;
+/**
+ * Decode an {@link EncodedReferrer} value into a {@link NormalizedAddress}
+ * according to the referrer encoding with left-zero-padding.
+ *
+ * @param encodedReferrer - The "raw" {@link EncodedReferrer} value to decode.
+ * @returns The decoded referrer address.
+ * @throws when encodedReferrer value is not represented by
+ *         {@link ENCODED_REFERRER_BYTE_LENGTH} bytes.
+ * @throws when decodedReferrer is not a valid EVM address.
+ */
+declare function decodeEncodedReferrer(encodedReferrer: EncodedReferrer): NormalizedAddress;
+
+/**
+ * Identifiers for supported currencies.
+ *
+ * TODO: Add support for WETH
+ */
+declare const CurrencyIds: {
+    readonly ETH: "ETH";
+    readonly USDC: "USDC";
+    readonly DAI: "DAI";
+    readonly ENSTokens: "ENSTokens";
+};
+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;
+}
+interface PriceEnsTokens {
+    currency: typeof CurrencyIds.ENSTokens;
+    amount: CurrencyAmount;
+}
+type Price = PriceEth | PriceDai | PriceUsdc | PriceEnsTokens;
+/**
+ * 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 PriceEnsTokens}.
+ */
+interface SerializedPriceEnsTokens extends Omit<PriceEnsTokens, "amount"> {
+    amount: SerializedCurrencyAmount;
+}
+/**
+ * Serialized representation of {@link Price}.
+ */
+type SerializedPrice = SerializedPriceEth | SerializedPriceDai | SerializedPriceUsdc | SerializedPriceEnsTokens;
+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;
+/**
+ * Create price in ENS Tokens for given amount.
+ */
+declare function priceEnsTokens(amount: Price["amount"]): PriceEnsTokens;
+/**
+ * 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;
+/**
+ * Subtract price B from price A.
+ *
+ * @param a the minuend {@link Price} value.
+ * @param b the subtrahend {@link Price} value.
+ * @returns the resulting {@link Price} (`a - b`) with the same currency as the inputs.
+ * @throws if the prices have different currencies.
+ * @throws if the result would be negative ({@link CurrencyAmount} must be non-negative).
+ */
+declare function subtractPrice<const PriceType extends Price = Price>(a: PriceType, b: PriceType): PriceType;
+/**
+ * Return the smallest of the given {@link Price} values.
+ *
+ * @param prices at least two {@link Price} values to compare.
+ * @returns the {@link Price} with the smallest amount. Ties return the first
+ *          such value in argument order.
+ * @throws if not all prices have the same currency.
+ */
+declare function minPrice<const PriceType extends Price = Price>(...prices: [PriceType, PriceType, ...PriceType[]]): PriceType;
+/**
+ * Return the largest of the given {@link Price} values.
+ *
+ * @param prices at least two {@link Price} values to compare.
+ * @returns the {@link Price} with the largest amount. Ties return the first
+ *          such value in argument order.
+ * @throws if not all prices have the same currency.
+ */
+declare function maxPrice<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;
+/**
+ * Parses a string representation of ENS Tokens into a {@link PriceEnsTokens} object.
+ *
+ * Uses {@link getCurrencyInfo} to get the correct number of decimals (18) for ENS Tokens
+ * 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 ENS Tokens)
+ * @returns A PriceEnsTokens 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
+ * parseEnsTokens("123.456789012345678") // returns { currency: "ENSTokens", amount: 123456789012345678000n }
+ * parseEnsTokens("1") // returns { currency: "ENSTokens", amount: 1000000000000000000n }
+ * parseEnsTokens("0.001") // returns { currency: "ENSTokens", amount: 1000000000000000n }
+ */
+declare function parseEnsTokens(value: string): PriceEnsTokens;
+
+/**
+ * Subregistry
+ */
+interface Subregistry {
+    /**
+     * Subregistry ID
+     *
+     * The ID of the subregistry the "logical registrar action" was taken on.
+     *
+     * Identifies the chainId and address of the associated subregistry smart
+     * contract.
+     */
+    subregistryId: AccountId;
+    /**
+     * The node (namehash) of the name the subregistry manages subnames of.
+     * Example subregistry managed names:
+     * - `eth`
+     * - `base.eth`
+     * - `linea.eth`
+     */
+    node: Node;
+}
+
+/**
+ * Registration Lifecycle Stages
+ *
+ * Important: this definition should not be used anywhere.
+ * It's only here to capture some ideas that were shared in the team.
+ */
+declare const RegistrationLifecycleStages: {
+    /**
+     * Active
+     *
+     * Happens when
+     * the current timestamp <= expiry.
+     */
+    readonly Active: "registrationLifecycle_active";
+    /**
+     * Grace Period
+     *
+     * Happens when
+     * `expiry < the current timestamp <= expiry + 90 days`.
+     */
+    readonly GracePeriod: "registrationLifecycle_gracePeriod";
+    /**
+     * Released with Temporary Premium Price
+     *
+     * Happens when
+     * `expiry + 90 days < the current timestamp <= expiry + 120 days`.
+     */
+    readonly ReleasedWithTempPrice: "registrationLifecycle_releasedWithTempPrice";
+    /**
+     * Fully Released (Regular Price)
+     *
+     * Happens when
+     * ` expiry + 120 days < the current timestamp`.
+     */
+    readonly FullyReleased: "registrationLifecycle_fullyReleased";
+};
+type RegistrationLifecycleStage = (typeof RegistrationLifecycleStages)[keyof typeof RegistrationLifecycleStages];
+/**
+ * Registration Lifecycle
+ */
+interface RegistrationLifecycle {
+    /**
+     * Subregistry that manages this Registration Lifecycle.
+     */
+    subregistry: Subregistry;
+    /**
+     * The node (namehash) of the FQDN of the domain the registration lifecycle
+     * is associated with.
+     *
+     * Guaranteed to be a subname of the node (namehash) of the subregistry
+     * identified by `subregistryId.subregistryId`.
+     */
+    node: Node;
+    /**
+     * Expires at
+     *
+     * Identifies when the Registration Lifecycle is scheduled to expire.
+     */
+    expiresAt: UnixTimestamp;
+}
+
+/**
+ * Globally unique, deterministic ID of an indexed onchain event
+ * associated with the "logical registrar action".
+ */
+type RegistrarActionEventId = string;
+/**
+ * Types of "logical registrar action".
+ */
+declare const RegistrarActionTypes: {
+    readonly Registration: "registration";
+    readonly Renewal: "renewal";
+};
+type RegistrarActionType = (typeof RegistrarActionTypes)[keyof typeof RegistrarActionTypes];
+/**
+ * Pricing information for a "logical registrar action".
+ */
+interface RegistrarActionPricingAvailable {
+    /**
+     * Base cost
+     *
+     * Base cost (before any `premium`) of Ether measured in units of Wei
+     * paid to execute the "logical registrar action".
+     *
+     * May be 0.
+     */
+    baseCost: PriceEth;
+    /**
+     * Premium
+     *
+     * "premium" cost (in excesses of the `baseCost`) of Ether measured in
+     * units of Wei paid to execute the "logical registrar action".
+     *
+     * May be 0.
+     */
+    premium: PriceEth;
+    /**
+     * Total
+     *
+     * Total cost of Ether measured in units of Wei paid to execute
+     * the "logical registrar action".
+     *
+     * May be 0.
+     */
+    total: PriceEth;
+}
+/**
+ * Pricing information for a "logical registrar action" when
+ * there is no known pricing data.
+ */
+interface RegistrarActionPricingUnknown {
+    /**
+     * Base cost
+     *
+     * Base cost (before any `premium`) of Ether measured in units of Wei
+     * paid to execute the "logical registrar action".
+     */
+    baseCost: null;
+    /**
+     * Premium
+     *
+     * "premium" cost (in excesses of the `baseCost`) of Ether measured in
+     * units of Wei paid to execute the "logical registrar action".
+     */
+    premium: null;
+    /**
+     * Total
+     *
+     * Total cost of Ether measured in units of Wei paid to execute
+     * the "logical registrar action".
+     */
+    total: null;
+}
+type RegistrarActionPricing = RegistrarActionPricingAvailable | RegistrarActionPricingUnknown;
+declare function isRegistrarActionPricingAvailable(registrarActionPricing: RegistrarActionPricing): registrarActionPricing is RegistrarActionPricingAvailable;
+/**
+ * * Referral information for performing a "logical registrar action".
+ */
+interface RegistrarActionReferralAvailable {
+    /**
+     * Encoded Referrer
+     *
+     * Represents the "raw" 32-byte "referrer" value emitted onchain in
+     * association with the registrar action.
+     */
+    encodedReferrer: EncodedReferrer;
+    /**
+     * Decoded Referrer
+     *
+     * The referrer address decoded from {@link encodedReferrer} using strict
+     * left-zero-padding validation.
+     *
+     * Identifies the interpreted address of the referrer.
+     * The "chainId" of this address is the same as is referenced in
+     * `subregistryId`.
+     *
+     * May be the "zero address" to represent that an `encodedReferrer` is
+     * defined but that it is interpreted as no referrer.
+     */
+    decodedReferrer: Address;
+}
+/**
+ * Referral information for performing a "logical registrar action" when
+ * registrar controller does not implement referrals.
+ */
+interface RegistrarActionReferralNotApplicable {
+    /**
+     * Encoded Referrer
+     *
+     * Represents the "raw" 32-byte "referrer" value emitted onchain in
+     * association with the registrar action.
+     */
+    encodedReferrer: null;
+    /**
+     * Decoded Referrer
+     *
+     * The referrer address decoded from {@link encodedReferrer} using strict
+     * left-zero-padding validation. Null when the registrar controller does not implement referrals.
+     */
+    decodedReferrer: null;
+}
+type RegistrarActionReferral = RegistrarActionReferralAvailable | RegistrarActionReferralNotApplicable;
+declare function isRegistrarActionReferralAvailable(registrarActionReferral: RegistrarActionReferral): registrarActionReferral is RegistrarActionReferralAvailable;
+/**
+ * "Logical registrar action"
+ *
+ * Represents a state of "logical registrar action". May be built using data
+ * from multiple events within the same "logical" registration / renewal action.
+ */
+interface RegistrarAction {
+    /**
+     * "Logical registrar action" ID
+     *
+     * The `id` value is a deterministic and globally unique identifier for
+     * the "logical registrar action".
+     *
+     * The `id` value represents the *initial* onchain event associated with
+     * the "logical registrar action", but the full state of
+     * the "logical registrar action" is an aggregate across each of
+     * the onchain events referenced in the `eventIds` field.
+     *
+     * Guaranteed to be the very first element in `eventIds` array.
+     */
+    id: RegistrarActionEventId;
+    /**
+     * The type of the "logical registrar action".
+     */
+    type: RegistrarActionType;
+    /**
+     *
+     * Incremental Duration
+     *
+     * If `type` is "registration":
+     *   - Represents the duration between `block.timestamp` and
+     *     the initial `registrationLifecycle.expiresAt` value that the associated
+     *     "registration lifecycle" will be initialized with.
+     * If `type` is "renewal":
+     *   - Represents the incremental increase in duration made to
+     *     the `registrationLifecycle.expiresAt` value in the associated
+     *     "registration lifecycle".
+     *
+     * A "registration lifecycle" may be extended via renewal even after it
+     * expires if it is still within its grace period.
+     *
+     * Consider the following scenario:
+     *
+     * The "registration lifecycle" of a direct subname of .eth is scheduled to
+     * expire on Jan 1, midnight UTC. It is currently 30 days after this
+     * expiration time. Therefore, there are currently another 60 days of grace
+     * period remaining for this name. Anyone can still make a renewal to
+     * extend the "registration lifecycle" of this name.
+     *
+     * Given this scenario, consider the following examples:
+     *
+     * 1. If a renewal is made with 10 days incremental duration,
+     *    the "registration lifecycle" for this name will remain in
+     *    an "expired" state, but it will now have another 70 days of
+     *    grace period remaining.
+     *
+     * 2. If a renewal is made with 50 days incremental duration,
+     *    the "registration lifecycle" for this name will no longer be
+     *    "expired" and will become "active", but the "registration lifecycle"
+     *    will now be scheduled to expire again in 20 days.
+     *
+     * After the "registration lifecycle" for a name becomes expired by more
+     * than its grace period, it can no longer be renewed by anyone and is
+     * considered "released". The name must first be registered again, starting
+     * a new "registration lifecycle" of
+     * active / expired / grace period / released.
+     *
+     * May be 0.
+     *
+     * Guaranteed to be a non-negative bigint value.
+     */
+    incrementalDuration: Duration;
+    /**
+     * Registrant
+     *
+     * Identifies the address that initiated the "logical registrar action" and
+     * is paying the `pricing.total` cost (if applicable).
+     *
+     * It may not be the owner of the name:
+     * 1. When a name is registered, the initial owner of the name may be
+     *    distinct from the registrant.
+     * 2. There are no restrictions on who may renew a name.
+     *    Therefore the owner of the name may be distinct from the registrant.
+     *
+     * The "chainId" of this address is the same as is referenced in
+     * `registrationLifecycle.subregistry.subregistryId`.
+     */
+    registrant: Address;
+    /**
+     * Registration Lifecycle associated with this "logical registrar action".
+     */
+    registrationLifecycle: RegistrationLifecycle;
+    /**
+     * Pricing information associated with this "logical registrar action".
+     */
+    pricing: RegistrarActionPricing;
+    /**
+     * Referral information associated with this "logical registrar action".
+     */
+    referral: RegistrarActionReferral;
+    /**
+     * Block ref
+     *
+     * References the block where the "logical registrar action" was executed.
+     *
+     * The "chainId" of this block is the same as is referenced in
+     * `registrationLifecycle.subregistry.subregistryId`.
+     */
+    block: BlockRef;
+    /**
+     * Transaction hash
+     *
+     * Transaction hash of the transaction associated with
+     * the "logical registrar action".
+     *
+     * The "chainId" of this transaction is the same as is referenced in
+     * `registrationLifecycle.subregistry.subregistryId`.
+     *
+     * Note that a single transaction may be associated with any number of
+     * "logical registrar actions".
+     */
+    transactionHash: Hash;
+    /**
+     * Event IDs
+     *
+     * Array of the eventIds that have contributed to the state of
+     * the "logical registrar action" record.
+     *
+     * Each eventId is a deterministic and globally unique onchain event
+     * identifier.
+     *
+     * Guarantees:
+     * - Each eventId is of events that occurred within the block
+     *   referenced by `block.number`.
+     * - At least 1 eventId.
+     * - Ordered chronologically (ascending) by logIndex within `block.number`.
+     * - The first element in the array is equal to the `id` of
+     *   the overall "logical registrar action" record.
+     *
+     * The following ideas are not generalized for ENS overall but happen to
+     * be a characteristic of the scope of our current indexing logic:
+     * 1. These id's always reference events emitted by
+     *    a related "BaseRegistrar" contract.
+     * 2. These id's optionally reference events emitted by
+     *    a related "Registrar Controller" contract. This is because our
+     *    current indexing logic doesn't guarantee to index
+     *    all "Registrar Controller" contracts.
+     */
+    eventIds: [RegistrarActionEventId, ...RegistrarActionEventId[]];
+}
+/**
+ * Serialized representation of {@link RegistrarActionPricingUnknown}.
+ */
+type SerializedRegistrarActionPricingUnknown = RegistrarActionPricingUnknown;
+/**
+ * Serialized representation of {@link RegistrarActionPricingAvailable}.
+ */
+interface SerializedRegistrarActionPricingAvailable {
+    baseCost: SerializedPriceEth;
+    premium: SerializedPriceEth;
+    total: SerializedPriceEth;
+}
+/**
+ * Serialized representation of {@link RegistrarActionPricing}.
+ */
+type SerializedRegistrarActionPricing = SerializedRegistrarActionPricingAvailable | SerializedRegistrarActionPricingUnknown;
+/**
+ * Serialized representation of {@link RegistrarAction}.
+ */
+interface SerializedRegistrarAction extends Omit<RegistrarAction, "pricing"> {
+    pricing: SerializedRegistrarActionPricing;
+}
+declare function serializeRegistrarActionPricing(pricing: RegistrarActionPricing): SerializedRegistrarActionPricing;
+declare function serializeRegistrarAction(registrarAction: RegistrarAction): SerializedRegistrarAction;
+
+/**
+ * Interprets a NormalizedAddress. zeroAddress is interpreted as null, otherwise as-is.
+ */
+declare const interpretAddress: (owner: NormalizedAddress) => NormalizedAddress | 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-existent or deletion of the record, or
+ * b) an {@link InterpretedName}.
+ *
+ * @param value - The name record value string to interpret.
+ * @returns The interpreted name string, or null if deleted.
+ */
+declare function interpretNameRecordValue(value: LiteralName): InterpretedName | 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-existent 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-existent 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;
+
+/**
+ * Interprets an ENSIP-7 contenthash value. Empty bytes are interpreted as deletion.
+ */
+declare function interpretContenthashValue(value: Hex): Hex | null;
+/**
+ * Interprets a PubkeyResolver (x, y) pair. A (zeroHash, zeroHash) pair is interpreted as deletion.
+ *
+ * Invariant: both null together, or both set together.
+ */
+declare function interpretPubkeyValue(x: Hex, y: Hex): {
+    x: Hex;
+    y: Hex;
+} | null;
+/**
+ * Interprets an IDNSZoneResolver zonehash value. Empty bytes are interpreted as deletion.
+ */
+declare function interpretDnszonehashValue(value: Hex): Hex | null;
+
+/**
+ * A value that varies by ENS namespace, with a required default.
+ *
+ * @example
+ * ```ts
+ * const exampleNames: NamespaceSpecificValue<string[]> = {
+ *   default: ["vitalik.eth", "nick.eth"],
+ *   [ENSNamespaceIds.EnsTestEnv]: ["test.eth", "demo.eth"],
+ * };
+ * ```
+ */
+type NamespaceSpecificValue<T> = {
+    default: T;
+} & Partial<Record<ENSNamespaceId, T>>;
+/**
+ * Resolves a {@link NamespaceSpecificValue} for a given namespace,
+ * falling back to the default.
+ */
+declare function getNamespaceSpecificValue<T>(namespace: ENSNamespaceId, value: NamespaceSpecificValue<T>): T;
+
+export { type SerializedCurrencyAmount as $, type EncodedReferrer as A, type BlockNumber as B, type CurrencyAmount as C, type Datetime as D, type EnsRainbowPublicConfig as E, type EnsRainbowVersionInfo as F, type RegistrarActionEventId as G, type RegistrarActionPricing as H, type RegistrarActionPricingAvailable as I, type RegistrarActionPricingUnknown as J, type RegistrarActionReferral as K, type LabelSetId as L, type RegistrarActionReferralAvailable as M, type NamespaceSpecificValue as N, type RegistrarActionReferralNotApplicable as O, PluginName as P, type RegistrarActionType as Q, type RegistrarAction as R, type SerializedRegistrarAction as S, type TheGraphFallback as T, type Unvalidated as U, RegistrarActionTypes as V, type RegistrationLifecycle as W, type RegistrationLifecycleStage as X, type RequiredAndNotNull as Y, type RequiredAndNull as Z, type RpcUrl as _, type EnsIndexerPublicConfig as a, type SerializedRegistrarActionPricing as a0, type SerializedRegistrarActionPricingAvailable as a1, type SerializedRegistrarActionPricingUnknown as a2, type Subregistry as a3, type TheGraphCannotFallbackReason as a4, TheGraphCannotFallbackReasonSchema as a5, TheGraphFallbackSchema as a6, ZERO_ENCODED_REFERRER as a7, addPrices as a8, buildEncodedReferrer as a9, priceEth as aA, priceUsdc as aB, scalePrice as aC, serializeRegistrarAction as aD, serializeRegistrarActionPricing as aE, subtractPrice as aF, decodeEncodedReferrer as aa, getCurrencyInfo as ab, getNamespaceSpecificValue as ac, interpretAddress as ad, interpretAddressRecordValue as ae, interpretContenthashValue as af, interpretDnszonehashValue as ag, interpretNameRecordValue as ah, interpretPubkeyValue as ai, interpretTextRecordKey as aj, interpretTextRecordValue as ak, isPriceCurrencyEqual as al, isPriceEqual as am, isRegistrarActionPricingAvailable as an, isRegistrarActionReferralAvailable as ao, makeENSApiPublicConfigSchema as ap, makeEnsApiPublicConfigSchema as aq, makeSerializedEnsApiPublicConfigSchema as ar, maxPrice as as, minPrice as at, parseDai as au, parseEnsTokens as av, parseEth as aw, parseUsdc as ax, priceDai as ay, priceEnsTokens as az, type EnsIndexerVersionInfo as b, type BlockRef as c, type LabelSetVersion as d, type EnsRainbowClientLabelSet as e, type EnsRainbowServerLabelSet as f, type PriceDai as g, type PriceEnsTokens as h, type PriceEth as i, type PriceUsdc as j, type Price as k, type SerializedPrice as l, makeErrorResponseSchema as m, type SerializedPriceDai as n, type SerializedPriceEnsTokens as o, type SerializedPriceEth as p, type SerializedPriceUsdc as q, type CurrencyId as r, CurrencyIds as s, type CurrencyInfo as t, type DeepPartial as u, ENCODED_REFERRER_BYTE_LENGTH as v, ENCODED_REFERRER_BYTE_OFFSET as w, type ENSIndexerPublicConfig as x, type ENSIndexerVersionInfo as y, EXPECTED_ENCODED_REFERRER_PADDING as z };