enssdk 0.0.1 → 1.10.1

package/dist/index.d.ts

@@ -0,0 +1,619 @@
+import { H as Hex, A as Address, N as NormalizedAddress, a as AccountId, b as AccountIdString, c as AssetId, d as AssetIdString, C as ChainId, e as Node, I as InterpretedName, D as DNSEncodedLiteralName, L as LiteralLabel, f as DNSEncodedName, E as ENSv1DomainId, S as StorageId, g as ENSv2DomainId, P as PermissionsId, h as PermissionsResourceId, i as PermissionsUserId, j as DomainId, R as RegistrationId, k as RegistryId, l as RenewalId, m as ResolverId, n as ResolverRecordsId, T as TokenId, o as LabelHash, p as Label, q as InterpretedLabel, r as Name, s as LiteralName, t as LabelHashPath, u as EncodedLabelHash } from './evm-2UZlELOe.js';
+export { v as AssetNamespace, w as AssetNamespaces, x as CanonicalPath, y as ChainIdString, z as DNSEncodedPartiallyInterpretedName, B as DatetimeISO8601, F as DefaultableChainId, G as Duration, J as DurationBigInt, K as SubgraphInterpretedLabel, M as SubgraphInterpretedName, U as UnixTimestamp, O as UnixTimestampBigInt, Q as UrlString, W as Wei } from './evm-2UZlELOe.js';
+import { EvmCoinType, CoinType } from '@ensdomains/address-encoder';
+export { CoinType, EvmCoinType } from '@ensdomains/address-encoder';
+import 'viem';
+
+/**
+ * Describes an EnhancedAccessControl (EAC) Resource.
+ *
+ * @see https://github.com/ensdomains/contracts-v2/blob/e8696c6787e2e7a2fc17c67a3b06955a6b890adc/contracts/src/access-control/EnhancedAccessControl.sol#L17
+ */
+type EACResource = bigint;
+/**
+ * Describes an EnhancedAccessControl (EAC) Role Bitmap.
+ *
+ * @see https://github.com/ensdomains/contracts-v2/blob/e8696c6787e2e7a2fc17c67a3b06955a6b890adc/contracts/src/access-control/EnhancedAccessControl.sol#L33
+ */
+type EACRoleBitmap = bigint;
+
+/**
+ * ABI content type per ENSIP-4.
+ *
+ * Single-bit values (1=JSON, 2=zlib-JSON, 4=CBOR, 8=URI) identify a stored ABI encoding.
+ * `setABI` requires a power-of-2 value.
+ *
+ * Bitmask unions of those bits are used when reading via `ABI(node, contentTypes)`; the
+ * resolver returns the first stored ABI whose bit is present in the mask (lowest bit first).
+ *
+ * @see https://github.com/ensdomains/ens-contracts/blob/91c966febd7b55494269df830fc6775f040b927b/contracts/resolvers/profiles/ABIResolver.sol
+ */
+type ContentType = bigint;
+/**
+ * ERC-165 4-byte interface selector.
+ *
+ * @see https://github.com/ensdomains/ens-contracts/blob/91c966febd7b55494269df830fc6775f040b927b/contracts/resolvers/profiles/InterfaceResolver.sol
+ */
+type InterfaceId = Hex;
+/**
+ * IVersionableResolver record version. Bumped by `VersionChanged`, which invalidates all prior
+ * records for the node.
+ *
+ * @see https://github.com/ensdomains/ens-contracts/blob/91c966febd7b55494269df830fc6775f040b927b/contracts/resolvers/profiles/IVersionableResolver.sol
+ */
+type RecordVersion = bigint;
+
+/**
+ * Determines whether an {@link Address} is a {@link NormalizedAddress}.
+ */
+declare function isNormalizedAddress(maybeAddress: string): maybeAddress is NormalizedAddress;
+/**
+ * Converts an {@link Address} to a {@link NormalizedAddress}.
+ *
+ * @throws if `address` does not represent an EVM Address
+ */
+declare function toNormalizedAddress(maybeAddress: string): NormalizedAddress;
+/**
+ * Validates that an {@link Address} is already a {@link NormalizedAddress}.
+ *
+ * @throws if the address is not already normalized
+ */
+declare function asNormalizedAddress(address: Address): NormalizedAddress;
+
+/**
+ * Stringify an {@link AccountId} as a fully lowercase CAIP-10 AccountId string.
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-10
+ */
+declare function stringifyAccountId({ chainId, address }: AccountId): AccountIdString;
+/**
+ * Stringify an {@link AssetId} as a fully lowercase CAIP-19 AssetId string.
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-19
+ */
+declare function stringifyAssetId({ assetNamespace, contract: { chainId, address }, tokenId, }: AssetId): AssetIdString;
+
+/**
+ * The ETH coinType.
+ *
+ * @see https://docs.ens.domains/ensip/9
+ */
+declare const ETH_COIN_TYPE: CoinType;
+/**
+ * The 'default' chainId corresponding to the below {@link DEFAULT_EVM_COIN_TYPE} in the context of
+ * ENSIP-19.
+ *
+ * @see https://docs.ens.domains/ensip/19
+ */
+declare const DEFAULT_EVM_CHAIN_ID = 0;
+/**
+ * ENSIP-19 EVM CoinType representing the 'default' coinType for EVM chains in ENS.
+ *
+ * @see https://docs.ens.domains/ensip/19/#reverse-resolution
+ */
+declare const DEFAULT_EVM_COIN_TYPE: EvmCoinType;
+/**
+ * Converts a CoinType to an EVM Chain Id.
+ *
+ * NOTE: for whatever reason @ensdomains/address-encoder#coinTypeToEvmChainId doesn't handle the
+ * mainnet case so we implement that here
+ *
+ * @see https://docs.ens.domains/ensip/11
+ */
+declare const coinTypeToEvmChainId: (coinType: CoinType) => ChainId;
+/**
+ * Converts an EVM Chain Id to a CoinType.
+ *
+ * NOTE: for whatever reason @ensdomains/address-encoder#evmChainIdToCoinType doesn't handle the
+ * mainnet case so we implement that here
+ */
+declare const evmChainIdToCoinType: (chainId: ChainId) => CoinType;
+/**
+ * Converts a bigint value representing a CoinType into a valid CoinType.
+ *
+ * This is useful when onchain events emit coinTypes as bigint but we want to constrain them to
+ * the CoinType type.
+ *
+ * @throws if `value` is too large to fit in Number.MAX_SAFE_INTEGER
+ */
+declare const bigintToCoinType: (value: bigint) => CoinType;
+
+/**
+ * Name for the ENS Root
+ *
+ * @dev manually cast to InterpretedName to avoid circular import
+ */
+declare const ENS_ROOT_NAME: InterpretedName;
+/**
+ * The {@link Node} that identifies the ENS Root Name ("").
+ */
+declare const ENS_ROOT_NODE: Node;
+/**
+ * The {@link Node} that identifies the ETH Name ("eth").
+ *
+ * @dev manually cast to InterpretedName to avoid circular import
+ */
+declare const ETH_NODE: Node;
+/**
+ * The {@link Node} that identifies the addr.reverse Name ("addr.reverse").
+ *
+ * @dev manually cast to InterpretedName to avoid circular import
+ */
+declare const ADDR_REVERSE_NODE: Node;
+/**
+ * ROOT_RESOURCE represents the 'root' resource in an EnhancedAccessControl contract.
+ */
+declare const ROOT_RESOURCE: EACResource;
+
+/**
+ * Decodes a DNS-Encoded name consisting of Literal Labels into an ordered list of Literal Labels.
+ *
+ * For discussion on DNS-Encoding, see the {@link DNSEncodedName} and {@link DNSEncodedLiteralName} types.
+ *
+ * Due to the constraints of DNS-Encoding, there is an additional guarantee that each Literal Label
+ * in the resulting list is guaranteed to have a maximum byte length of 255.
+ *
+ * @param packet a hex string that encodes a DNSEncodedLiteralName
+ * @returns A list of the LiteralLabels contained in packet
+ * @throws If the packet is malformed
+ * @dev This is just `decodeDNSEncodedName` with semantic input/output
+ */
+declare function decodeDNSEncodedLiteralName(packet: DNSEncodedLiteralName): LiteralLabel[];
+/**
+ * Decodes a DNS-Encoded Name into an ordered list of string segments.
+ *
+ * For discussion on DNS-Encoding, see the {@link DNSEncodedName} type.
+ *
+ * Due to the constraints of DNS-Encoding, there is an additional guarantee that each segment
+ * in the resulting list is guaranteed to have a maximum byte length of 255.
+ *
+ * @param packet a hex string that encodes a DNSEncodedName
+ * @returns A UTF-8 string array of the segments contained in packet
+ * @throws If the packet is malformed
+ * @dev This is the generic implementation of DNS-Encoded Name Decoding
+ */
+declare function decodeDNSEncodedName(packet: DNSEncodedName): string[];
+
+declare const makeRegistryId: (accountId: AccountId) => RegistryId;
+declare const makeResolverId: (contract: AccountId) => ResolverId;
+declare const makeENSv1DomainId: (node: Node) => ENSv1DomainId;
+declare const makeENSv2DomainId: (registry: AccountId, storageId: StorageId) => ENSv2DomainId;
+/**
+ * Computes a Label's {@link StorageId} given its TokenId or LabelHash.
+ */
+declare const makeStorageId: (labelRef: TokenId | LabelHash) => StorageId;
+declare const makePermissionsId: (contract: AccountId) => PermissionsId;
+declare const makePermissionsResourceId: (contract: AccountId, resource: EACResource) => PermissionsResourceId;
+declare const makePermissionsUserId: (contract: AccountId, resource: EACResource, user: NormalizedAddress) => PermissionsUserId;
+declare const makeResolverRecordsId: (resolver: AccountId, node: Node) => ResolverRecordsId;
+declare const makeRegistrationId: (domainId: DomainId, registrationIndex: number) => RegistrationId;
+declare const makeRenewalId: (domainId: DomainId, registrationIndex: number, index: number) => RenewalId;
+
+/**
+ * Whether `maybeInterfaceId` is a valid ERC-165 {@link InterfaceId} — a 4-byte hex selector.
+ */
+declare function isInterfaceId(maybeInterfaceId: string): maybeInterfaceId is InterfaceId;
+
+/**
+ * Decodes a uint256-encoded-LabelHash (eg. from a {@link TokenId}) into a {@link LabelHash}.
+ *
+ * @see https://github.com/ensdomains/ens-contracts/blob/db613bc/contracts/ethregistrar/ETHRegistrarController.sol#L215
+ */
+declare const interpretTokenIdAsLabelHash: (tokenId: TokenId) => LabelHash;
+/**
+ * Decodes a uint256-encoded-Node (eg. from a {@link TokenId}) into a {@link Node}.
+ *
+ * @see https://github.com/ensdomains/ens-contracts/blob/db613bc/contracts/wrapper/ERC1155Fuse.sol#L262
+ */
+declare const interpretTokenIdAsNode: (tokenId: TokenId) => Node;
+
+/**
+ * Interprets a user-provided {@link LiteralName} as an {@link InterpretedName}.
+ *
+ * A {@link LiteralName} may be any arbitrary string. The ENS Root Name ('') ({@link ENS_ROOT_NAME})
+ * is only accepted when `options.allowENSRootName` is `true`, and is returned as-is.
+ *
+ * This function walks each LiteralLabel of `name` and maps it to an {@link InterpretedLabel}
+ * according to the provided `options`:
+ *
+ * 0. If the LiteralLabel is an empty string (''), this function throws: an empty Label is not a valid
+ *    {@link InterpretedLabel}.
+ * 1. If the LiteralLabel is already a normalized LiteralLabel, it is kept as-is.
+ * 2. Otherwise, if the LiteralLabel looks like an {@link EncodedLabelHash} (e.g. `[abcd…]`) and
+ *    `options.allowEncodedLabelHashes` is `true`, it is kept as-is.
+ * 3. Otherwise, the LiteralLabel is unnormalized. If `options.coerceUnnormalizedLabelsToNormalizedLabels` is `false`,
+ *    this function throws. Otherwise (default), the LiteralLabel is passed through ENSIP-15 normalization
+ *    ({@link normalizeLabel}). If normalization succeeds, the normalized form is used (e.g. `"Vitalik"` →
+ *    `"vitalik"`).
+ * 4. Otherwise, the LiteralLabel is unnormalizable. If `options.coerceUnnormalizableLabelsToEncodedLabelHashes`
+ *    is `true`, the Label is replaced with the EncodedLabelHash of its literal bytes. Otherwise, this
+ *    function throws.
+ *
+ * Note that step 3 gates step 4: if `options.coerceUnnormalizedLabelsToNormalizedLabels` is `false`, the
+ * function throws immediately for any unnormalized Label, regardless of whether the Label would have been
+ * normalizable and regardless of `options.coerceUnnormalizableLabelsToEncodedLabelHashes`.
+ *
+ * @param name - The user-provided {@link LiteralName} to interpret.
+ * @param options - Controls how the interpretation handles edge cases.
+ * @param options.allowENSRootName - When `true`, an empty `name` is accepted and returned as the ENS Root Name.
+ *   When `false` (default), an empty `name` throws.
+ * @param options.allowEncodedLabelHashes - When `true`, a Label that is already formatted as an
+ *   {@link EncodedLabelHash} is preserved verbatim. When `false` (default), such a Label is treated like any other
+ *   input and passed through normalization, which will fail and fall through to the unnormalizable-Label handling.
+ * @param options.coerceUnnormalizedLabelsToNormalizedLabels - When `true` (default), a Label that is not already
+ *   normalized is passed through ENSIP-15 normalization (e.g. `"Vitalik"` → `"vitalik"`). When `false`, any
+ *   unnormalized Label causes this function to throw — no normalization is attempted and
+ *   `coerceUnnormalizableLabelsToEncodedLabelHashes` is not consulted.
+ * @param options.coerceUnnormalizableLabelsToEncodedLabelHashes - When `true`, a Label that cannot be normalized is
+ *   replaced with the EncodedLabelHash of its literal bytes. When `false` (default), encountering such a Label causes
+ *   this function to throw. Only consulted when `coerceUnnormalizedLabelsToNormalizedLabels` is `true`.
+ *
+ * @throws if `name` cannot be coerced into an {@link InterpretedName} under the provided `options`.
+ *
+ * @dev casts to {@link InterpretedLabel} to avoid an additional unnecessary `asInterpretedLabel` pass.
+ */
+declare function literalNameToInterpretedName(name: LiteralName, { allowENSRootName, allowEncodedLabelHashes, coerceUnnormalizedLabelsToNormalizedLabels, coerceUnnormalizableLabelsToEncodedLabelHashes, }?: {
+    allowENSRootName?: boolean | undefined;
+    allowEncodedLabelHashes?: boolean | undefined;
+    coerceUnnormalizedLabelsToNormalizedLabels?: boolean | undefined;
+    coerceUnnormalizableLabelsToEncodedLabelHashes?: boolean | undefined;
+}): InterpretedName;
+/**
+ * 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 LiteralName into a list of LiteralLabels.
+ */
+declare function literalNameToLiteralLabels(name: LiteralName): LiteralLabel[];
+/**
+ * Converts an Interpreted Name into a list of Interpreted Labels.
+ */
+declare function interpretedNameToInterpretedLabels(name: InterpretedName): InterpretedLabel[];
+declare function isInterpretedLabel(label: Label): label is InterpretedLabel;
+/**
+ * Determines whether `name` is an {@link InterpretedName}.
+ * The root name ("") is a valid InterpretedName.
+ *
+ * @param name
+ * @returns
+ */
+declare function isInterpretedName(name: Name): name is InterpretedName;
+/**
+ * Converts InterpretedLabels into a LabelHashPath.
+ */
+declare function interpretedLabelsToLabelHashPath(labels: InterpretedLabel[]): LabelHashPath;
+/**
+ * Constructs a new InterpretedName from an InterpretedLabel (child) and InterpretedName (parent).
+ *
+ * If no parent is available the InterpretedLabel is cast to an InterpretedName and returned.
+ *
+ * @dev the following is safe due to InterpretedLabel/InterpretedName semantics, see above.
+ */
+declare function constructSubInterpretedName(label: InterpretedLabel, name: InterpretedName | undefined): InterpretedName;
+/**
+ * Given a `labelHash` and optionally its healed InterpretedLabel, return an InterpretedLabel.
+ */
+declare function ensureInterpretedLabel(labelHash: LabelHash, label: InterpretedLabel | undefined): InterpretedLabel;
+/**
+ * Parses a Partial InterpretedName into concrete InterpretedLabels and the partial Label.
+ *
+ * @example
+ * ```ts
+ * const result = parsePartialInterpretedName("example.et")
+ * // { concrete: ["example"], partial: "et" }
+ * ```
+ *
+ * @throws if the provided `partialInterpretedName` is not composed of concrete InterpretedLabels.
+ */
+declare function parsePartialInterpretedName(partialInterpretedName: Name): {
+    concrete: InterpretedLabel[];
+    partial: string;
+};
+/**
+ * Casts a string to a {@link LiteralName}.
+ *
+ * A LiteralName is a name that should be interpreted as a string literal. It may or may not be
+ * normalized or normalizable. It may also include labels formatted as an EncodedLabelHash, but
+ * such labels must be interpreted literally and not as an EncodedLabelHash.
+ */
+declare function asLiteralName(name: Name): LiteralName;
+/**
+ * Casts a string to a {@link LiteralLabel}.
+ *
+ * A LiteralLabel is a label that should be interpreted as a string literal. It may or may not be
+ * normalized or normalizable. It may also be formatted as an EncodedLabelHash, but such labels must
+ * be interpreted literally and not as an EncodedLabelHash.
+ */
+declare function asLiteralLabel(label: Label): LiteralLabel;
+/**
+ * Validates and casts a string to an {@link InterpretedLabel}.
+ * An InterpretedLabel is either a normalized label or an EncodedLabelHash.
+ *
+ * @throws if the input is not a valid InterpretedLabel
+ */
+declare function asInterpretedLabel(label: Label): InterpretedLabel;
+/**
+ * Validates and casts a string to an {@link InterpretedName}.
+ * An InterpretedName is either the ENS Root Name ('') or a name made up of InterpretedLabels (which
+ * are either normalized Labels or EncodedLabelHashes).
+ *
+ * @throws if the input cannot be interpreted into an InterpretedName
+ */
+declare function asInterpretedName(name: Name): InterpretedName;
+
+/**
+ * Typed wrapper around viem's `labelhash` that returns a branded {@link LabelHash},
+ * requiring an {@link InterpretedLabel} input.
+ *
+ * Note: viem's labelhash has special-case handling for Encoded LabelHashes (e.g. `[hash]`).
+ * Use {@link labelhashLiteralLabel} if you need to hash a label's literal bytes without
+ * encoded labelhash detection.
+ *
+ * @see https://docs.ens.domains/ensip/1
+ */
+declare const labelhashInterpretedLabel: (label: InterpretedLabel) => LabelHash;
+/**
+ * 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;
+/**
+ * Checks if the input is a {@link LabelHash}.
+ *
+ * @see https://ensnode.io/docs/reference/terminology#label-processing-and-classification
+ */
+declare function isLabelHash(maybeLabelHash: string): maybeLabelHash is LabelHash;
+/**
+ * Formats a LabelHash as an Encoded LabelHash.
+ *
+ * @see https://ensnode.io/docs/reference/terminology#encoded-labelhash
+ *
+ * @param labelHash - A 32-byte lowercase hash string starting with '0x'
+ * @returns The encoded label hash in format `[labelhash_without_0x_prefix]`
+ */
+declare const encodeLabelHash: (labelHash: LabelHash) => EncodedLabelHash;
+/**
+ * Decodes an Encoded LabelHash as a LabelHash.
+ *
+ * @throws if a valid LabelHash cannot be decoded
+ *
+ * @see https://ensnode.io/docs/reference/terminology#encoded-labelhash
+ * @see https://github.com/wevm/viem/blob/main/src/utils/ens/encodedLabelToLabelhash.ts
+ *
+ * @param maybeEncodedLabelHash The encoded label hash in format `[labelhash_without_0x_prefix]`
+ * @returns A 32-byte lowercase hash string starting with '0x'
+ */
+declare const decodeEncodedLabelHash: (maybeEncodedLabelHash: string) => LabelHash;
+/**
+ * Checks if the value is an {@link EncodedLabelHash}.
+ */
+declare function isEncodedLabelHash(value: string): value is EncodedLabelHash;
+
+/**
+ * Typed wrapper around viem's `namehash` that returns a branded {@link Node},
+ * requiring an {@link InterpretedName} input and correctly parsing EncodedLabelHashes.
+ *
+ * @see https://docs.ens.domains/ensip/1
+ */
+declare const namehashInterpretedName: (name: InterpretedName) => Node;
+/**
+ * Implements one step of the namehash algorithm, combining `labelHash` with `node` to produce
+ * the `node` of a given subdomain. Note that the order of the arguments is 'reversed' (as compared to
+ * the actual concatenation) in order to improve readability (i.e. read as [labelHash].[node]).
+ */
+declare const makeSubdomainNode: (labelHash: LabelHash, node: Node) => Node;
+
+/**
+ * Constructs a name hierarchy from a given InterpretedName.
+ *
+ * @example
+ * ```
+ * getNameHierarchy("sub.example.eth") -> ["sub.example.eth", "example.eth", "eth"]
+ * ```
+ */
+declare const getNameHierarchy: (name: InterpretedName) => InterpretedName[];
+/**
+ * Derives the parent's {@link InterpretedName} of the provided `name`, or null if there is none.
+ */
+declare const getParentInterpretedName: (name: InterpretedName) => InterpretedName | null;
+/**
+ * Beautifies a name by converting each normalized label in the provided name to
+ * its "beautified" form. Labels that are not normalized retain their original value.
+ *
+ * Invariants:
+ * - The number of labels in the returned name is the same as the number of labels in the input name.
+ * - The order of the labels in the returned name is the same as the order of the labels in the input name.
+ * - If a label in the input is normalized, it is returned in its "beautified" form.
+ * - If a label in the input name is not normalized, it is returned without modification.
+ * - Therefore, the result of ens_normalize(beautifyName(name)) is the same as the result of ens_normalize(name).
+ *
+ * The "beautified form" of a normalized label converts special sequences of
+ * emojis and other special characters to their "beautified" equivalents. All
+ * such conversions transform X -> Y where Y is normalizable and normalizes back to X.
+ * Ex: '1⃣2⃣' (normalized) to '1️⃣2️⃣' (normalizable but not normalized).
+ * Ex: 'ξethereum' (normalized) to 'Ξethereum' (normalizable, but not normalized).
+ * Ex: 'abc' (normalized) to 'abc' (also normalized, no conversion).
+ * Ex: 'ABC' (normalizable but not normalized) to 'ABC' (no conversion).
+ * Ex: 'invalid|label' (not normalizable) to 'invalid|label' (no conversion).
+ * Ex: '' (unnormalized as a label) to '' (no conversion).
+ *
+ * @param name - The name to beautify.
+ * @returns The beautified name.
+ */
+declare const beautifyName: (name: Name) => Name;
+
+/**
+ * Normalizes a Name according to ENS normalization rules (ENSIP-15), returning an InterpretedName.
+ *
+ * @throws if the Name is not normalizable
+ * @see https://docs.ens.domains/ensip/15
+ */
+declare const normalizeName: (name: Name) => InterpretedName;
+/**
+ * Normalizes a Label according to ENS normalization rules (ENSIP-15), returning an InterpretedLabel.
+ *
+ * @throws if the Label is not normalizable
+ * @see https://docs.ens.domains/ensip/15
+ */
+declare const normalizeLabel: (label: Label) => InterpretedLabel;
+/**
+ * Determines whether the Name is normalized according to ENSIP-15 normalization rules.
+ */
+declare function isNormalizedName(name: Name): boolean;
+/**
+ * Determines whether the Label is normalized according to ENSIP-15 normalization rules.
+ */
+declare function isNormalizedLabel(label: Label): boolean;
+
+/**
+ * Parses a labelHash string and normalizes it to a canonical `LabelHash`.
+ *
+ * Normalization rules applied in order:
+ * 1. Adds `0x` prefix if missing
+ * 2. Validates all characters (excluding the optional `0x` prefix) are valid hex digits
+ *    (uppercase or lowercase A-F are accepted and normalized to lowercase)
+ * 3. If the hex digit count is odd, adds a leading `0` to make it even
+ * 4. Validates the result is exactly 64 hex digits (32 bytes)
+ *
+ * @param maybeLabelHash - The string to parse as a labelHash
+ * @throws {Error} If the input cannot be normalized to a valid labelHash
+ */
+declare function parseLabelHash(maybeLabelHash: string): LabelHash;
+/**
+ * Parses an encoded labelHash string (surrounded by square brackets) and normalizes it.
+ *
+ * This function is intentionally more lenient than {@link isEncodedLabelHash}: it accepts
+ * both the canonical format `[hash]` (no `0x` inside brackets) and the non-canonical
+ * `[0xhash]` format by delegating to {@link parseLabelHash} for the inner value.
+ * `isEncodedLabelHash("[0xhash]")` returns `false` for the same input.
+ *
+ * @param maybeEncodedLabelHash - The string to parse as an encoded labelHash
+ * @throws {Error} If the input is not properly enclosed in brackets or cannot be normalized
+ */
+declare function parseEncodedLabelHash(maybeEncodedLabelHash: string): LabelHash;
+/**
+ * Parses a labelHash or encoded labelHash string and normalizes it.
+ *
+ * Tries both formats to be maximally generous with accepted inputs:
+ * - If the input starts with `[` and ends with `]`, it is treated as an encoded labelHash
+ * - Otherwise, it is treated as a plain labelHash
+ *
+ * @param maybeLabelHash - The string to parse as a labelHash or encoded labelHash
+ * @throws {Error} If the input cannot be normalized to a valid labelHash
+ */
+declare function parseLabelHashOrEncodedLabelHash(maybeLabelHash: string): LabelHash;
+
+/**
+ * Parse the address and coinType out of an ENSIP-19 reverse name.
+ */
+declare function parseReverseName(name: string): {
+    address: NormalizedAddress;
+    coinType: CoinType;
+} | null;
+
+/**
+ * Reinterpret Label
+ *
+ * Reinterprets {@link InterpretedLabel} values received by "External System"
+ * into  {@link InterpretedLabel} values in "Internal System" where:
+ * 1. "External System" is not guaranteed to be using the same ENSNormalize
+ *    version as "Internal System", and therefore the `InterpretedLabel` passed into
+ *    this function (from "External System") is not guaranteed to 100% align
+ *    with the invariants of an `InterpretedLabel` in "Internal System".
+ * 2. The `InterpretedLabel` returned by this function is guaranteed to match
+ *    the invariants of `InterpretedLabel` in "Internal System".
+ *
+ * @returns reinterpreted label.
+ * @throws an error if the provided label is an empty label
+ *         (and therefore violates the invariants of an InterpretedLabel).
+ */
+declare function reinterpretLabel(label: InterpretedLabel): InterpretedLabel;
+/**
+ * Reinterpret Name
+ *
+ * Reinterprets {@link InterpretedName} values received by "External System"
+ * into  {@link InterpretedName} values in "Internal System" where:
+ * 1. "External System" is not guaranteed to be using the same ENSNormalize
+ *    version as "Internal System", and therefore the `InterpretedName` passed into
+ *    this function (from "External System") is not guaranteed to 100% align
+ *    with the invariants of an `InterpretedName` in "Internal System".
+ * 2. The `InterpretedName` returned by this function is guaranteed to match
+ *    the invariants of `InterpretedName` in "Internal System".
+ */
+declare function reinterpretName(name: InterpretedName): InterpretedName;
+
+/**
+ * Gets the Label used for the reverse names of subnames as per ENSIP-11 & ENSIP-19.
+ *
+ * @see https://docs.ens.domains/ensip/19/#reverse-resolution
+ */
+declare const addrReverseLabel: (address: NormalizedAddress) => LiteralLabel;
+/**
+ * Converts `coinType` to prefix-free hex string.
+ *
+ * @see https://docs.ens.domains/ensip/19
+ */
+declare const coinTypeReverseLabel: (coinType: CoinType) => LiteralLabel;
+/**
+ * Gets the reverse name for an address according to ENSIP-11 & ENSIP-19.
+ *
+ * @see https://docs.ens.domains/ensip/11#specification
+ * @see https://docs.ens.domains/ensip/19#specification
+ *
+ * @param address - The address to get the reverse name for
+ * @param coinType - The coin type to use for the reverse name
+ * @returns The reverse name for the address
+ *
+ * @example
+ * ```ts
+ * reverseName("0x1234", BigInt(ETH_COIN_TYPE)) // "1234.addr.reverse"
+ * reverseName("0x1234", BigInt(0x80000000)) // "1234.default.reverse"
+ * reverseName("0x1234", BigInt(0x5678)) // "1234.5678.reverse"
+ * ```
+ */
+declare function reverseName(address: NormalizedAddress, coinType: CoinType): LiteralName;
+
+export { ADDR_REVERSE_NODE, AccountId, AccountIdString, Address, AssetId, AssetIdString, ChainId, type ContentType, DEFAULT_EVM_CHAIN_ID, DEFAULT_EVM_COIN_TYPE, DNSEncodedLiteralName, DNSEncodedName, DomainId, type EACResource, type EACRoleBitmap, ENS_ROOT_NAME, ENS_ROOT_NODE, ENSv1DomainId, ENSv2DomainId, ETH_COIN_TYPE, ETH_NODE, EncodedLabelHash, Hex, type InterfaceId, InterpretedLabel, InterpretedName, Label, LabelHash, LabelHashPath, LiteralLabel, LiteralName, Name, Node, NormalizedAddress, PermissionsId, PermissionsResourceId, PermissionsUserId, ROOT_RESOURCE, type RecordVersion, RegistrationId, RegistryId, RenewalId, ResolverId, ResolverRecordsId, StorageId, TokenId, addrReverseLabel, asInterpretedLabel, asInterpretedName, asLiteralLabel, asLiteralName, asNormalizedAddress, beautifyName, bigintToCoinType, coinTypeReverseLabel, coinTypeToEvmChainId, constructSubInterpretedName, decodeDNSEncodedLiteralName, decodeDNSEncodedName, decodeEncodedLabelHash, encodeLabelHash, ensureInterpretedLabel, evmChainIdToCoinType, getNameHierarchy, getParentInterpretedName, interpretTokenIdAsLabelHash, interpretTokenIdAsNode, interpretedLabelsToInterpretedName, interpretedLabelsToLabelHashPath, interpretedNameToInterpretedLabels, isEncodedLabelHash, isInterfaceId, isInterpretedLabel, isInterpretedName, isLabelHash, isNormalizedAddress, isNormalizedLabel, isNormalizedName, labelhashInterpretedLabel, labelhashLiteralLabel, literalLabelToInterpretedLabel, literalLabelsToInterpretedName, literalLabelsToLiteralName, literalNameToInterpretedName, literalNameToLiteralLabels, makeENSv1DomainId, makeENSv2DomainId, makePermissionsId, makePermissionsResourceId, makePermissionsUserId, makeRegistrationId, makeRegistryId, makeRenewalId, makeResolverId, makeResolverRecordsId, makeStorageId, makeSubdomainNode, namehashInterpretedName, normalizeLabel, normalizeName, parseEncodedLabelHash, parseLabelHash, parseLabelHashOrEncodedLabelHash, parsePartialInterpretedName, parseReverseName, reinterpretLabel, reinterpretName, reverseName, stringifyAccountId, stringifyAssetId, toNormalizedAddress };