import * as react_jsx_runtime from 'react/jsx-runtime';
import { ChainId, UnixTimestamp, Duration, Address, Name } from 'enssdk';
import * as React$1 from 'react';
import React__default, { SVGProps, PropsWithChildren, ReactNode } from 'react';
import * as TooltipPrimitive from '@radix-ui/react-tooltip';
import { LucideIcon } from 'lucide-react';
import { ENSNamespaceId } from '@ensnode/datasources';
import * as _ensnode_ensnode_sdk from '@ensnode/ensnode-sdk';
import { Identity, ENSNamespaceId as ENSNamespaceId$1, UnresolvedIdentity, NamedRegistrarAction, EnsNodeClientOptions, ResolvePrimaryNameRequest, ResolvePrimaryNameResponse, ResolvePrimaryNamesRequest, ResolvePrimaryNamesResponse, ResolverRecordsSelection, ResolveRecordsRequest, ResolveRecordsResponse, AcceleratableRequest, EnsApiIndexingStatusRequest, EnsApiIndexingStatusResponse, NameTokensRequest, NameTokensResponse, RegistrarActionsRequest, RegistrarActionsResponse } from '@ensnode/ensnode-sdk';
import * as class_variance_authority_types from 'class-variance-authority/types';
import { VariantProps } from 'class-variance-authority';
import * as _tanstack_react_query from '@tanstack/react-query';
import { QueryObserverOptions, DefaultError, QueryKey, DefinedInitialDataOptions, QueryClient, DefinedUseQueryResult, UndefinedInitialDataOptions, UseQueryResult, UseQueryOptions, skipToken } from '@tanstack/react-query';
import * as viem from 'viem';
import { Hash } from 'viem';
import * as viem_chains from 'viem/chains';

interface ChainIconProps {
    chainId: ChainId;
    width?: number;
    height?: number;
}
/**
 * Renders an icon for the provided chain ID.
 */
declare function ChainIcon({ chainId, width, height }: ChainIconProps): react_jsx_runtime.JSX.Element;

interface ChainNameProps {
    chainId: ChainId;
    className: string;
}
/**
 * Renders a prettified chain name for the provided {@link ChainId}.
 */
declare const ChainName: ({ chainId, className }: ChainNameProps) => react_jsx_runtime.JSX.Element;

/**
 * Client-only absolute time component
 */
declare function AbsoluteTime({ timestamp, options, }: {
    timestamp: UnixTimestamp;
    options: Intl.DateTimeFormatOptions;
}): react_jsx_runtime.JSX.Element;

/**
 * Display Duration component
 */
declare function DisplayDuration({ duration }: {
    duration: Duration;
}): string;

declare function TooltipContent({ className, sideOffset, children, ...props }: React$1.ComponentProps<typeof TooltipPrimitive.Content>): react_jsx_runtime.JSX.Element;

/**
 * Formats a Unix timestamp as its relative distance with now
 *
 * @param timestamp - the timestamp to format as a relative time
 * @param enforcePast - if true, enforces that the return value won't relate to the future.
 * Helpful for UI contexts where it's nonsensical for a value to relate to the future. Ex: how long ago an event happened.
 * Note how different systems may have misaligned clocks. `enforcePast` aims to protect from UI confusion when
 * the client's clock is set incorrectly in the past, such that events happening "now" might otherwise appear to
 * be coming from the future.
 * @param includeSeconds - if true includes seconds in the result
 * @param conciseFormatting - if true removes special prefixes / suffixes such as "about ..." or "in almost ..."
 * @param relativeTo - if defined represents the timestamp to compare with. Otherwise, the timestamp param is compared with the present.
 */
declare function formatRelativeTime(timestamp: UnixTimestamp, enforcePast?: boolean, includeSeconds?: boolean, conciseFormatting?: boolean, relativeTo?: UnixTimestamp): string;
/**
 * Client-only relative time component
 */
declare function RelativeTime({ timestamp, enforcePast, includeSeconds, conciseFormatting, tooltipPosition, tooltipStyles, relativeTo, prefix, contentWrapper, }: {
    timestamp: UnixTimestamp;
    enforcePast?: boolean;
    includeSeconds?: boolean;
    conciseFormatting?: boolean;
    tooltipPosition?: React$1.ComponentProps<typeof TooltipContent>["side"];
    tooltipStyles?: string;
    relativeTo?: UnixTimestamp;
    prefix?: string;
    /**
     * A component to be rendered as a wrapper for the Relative Time component content.
     */
    contentWrapper?: ({ children }: React$1.PropsWithChildren) => React$1.ReactNode;
}): react_jsx_runtime.JSX.Element;

declare function Footer(): react_jsx_runtime.JSX.Element;

declare const ChainExplorerIcon: LucideIcon;

declare const EnsIcon: LucideIcon;

declare const EnsServiceProviderIcon: (props: React__default.SVGAttributes<SVGElement>) => react_jsx_runtime.JSX.Element;

declare const InfoIcon: (props: SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;

declare const EfpIcon: (props: React__default.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;

declare const EmailIcon: (props: React__default.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;

declare const FarcasterIcon: (props: React__default.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;

declare const GitHubIcon: (props: React__default.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;

declare const TelegramIcon: (props: React__default.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;

declare const TwitterIcon: (props: React__default.SVGProps<SVGSVGElement>) => react_jsx_runtime.JSX.Element;

interface AddressDisplayProps {
    address: Address;
    className?: string;
}
/**
 * Displays a truncated checksummed address without any navigation.
 * Pure display component for showing addresses.
 */
declare function AddressDisplay({ address, className }: AddressDisplayProps): react_jsx_runtime.JSX.Element;

interface EnsAvatarProps {
    name: Name;
    namespaceId: ENSNamespaceId;
    className?: string;
    isSquare?: boolean;
}
declare const EnsAvatar: ({ name, namespaceId, className, isSquare }: EnsAvatarProps) => react_jsx_runtime.JSX.Element;

interface IdentityLinkDetails {
    isExternal: boolean;
    link: URL | null;
}
interface IdentityLinkProps {
    linkDetails: IdentityLinkDetails;
    className?: string;
}
/**
 * Displays an identifier (address or name) with a link to the identity details URL.
 * If the ENS namespace has a known ENS Manager App,
 * includes a link to the view details of the address within that ENS namespace.
 *
 * Can take other components (ex.ChainIcon) as children
 * and display them alongside the link as one common interaction area.
 */
declare function IdentityLink({ linkDetails, className, children, }: PropsWithChildren<IdentityLinkProps>): react_jsx_runtime.JSX.Element;
interface IdentityTooltipProps {
    identity: Identity;
    namespaceId: ENSNamespaceId$1;
}
/**
 * On hover displays details on how the primary name for
 * the address of the identity was resolved.
 */
declare const IdentityTooltip: ({ identity, namespaceId, children, }: PropsWithChildren<IdentityTooltipProps>) => string | number | bigint | boolean | react_jsx_runtime.JSX.Element | Iterable<React$1.ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<React$1.ReactNode> | null | undefined> | null | undefined;

interface NameDisplayProps {
    name: Name;
    className?: string;
}
/**
 * Displays an ENS name in beautified form.
 *
 * @param name - The name to display in beautified form.
 *
 */
declare function NameDisplay({ name, className }: NameDisplayProps): react_jsx_runtime.JSX.Element;

interface ResolveAndDisplayIdentityProps {
    identity: UnresolvedIdentity;
    namespaceId: ENSNamespaceId$1;
    accelerate?: boolean;
    withLink?: boolean;
    identityLinkDetails?: IdentityLinkDetails;
    withTooltip?: boolean;
    withAvatar?: boolean;
    withIdentifier?: boolean;
    className?: string;
}
/**
 * Resolves the provided `UnresolvedIdentity` through ENSNode and displays the result.
 *
 * @param identity - The `UnresolvedIdentity` to resolve and display.
 * @param namespaceId - The ENSNamespace identifier (e.g. 'mainnet', 'sepolia', 'ens-test-env')
 * @param accelerate - Whether to attempt Protocol Acceleration (default: false)
 *                      when resolving the primary name.
 * @param withLink - Whether to wrap the displayed identity in an `IdentityLink` component.
 * @param identityLinkDetails - If the `withLink` is true, provides info on where should it lead and should it be an external link.
 * @param withTooltip - Whether to wrap the displayed identity in an `IdentityInfoTooltip` component.
 * @param withAvatar - Whether to display an avatar image.
 * @param withIdentifier - Whether to display identity's textual identifier (address or name).
 * @param className - The class name to apply to the displayed identity.
 */
declare function ResolveAndDisplayIdentity({ identity, namespaceId, accelerate, withLink, identityLinkDetails, withTooltip, withAvatar, withIdentifier, className, }: ResolveAndDisplayIdentityProps): react_jsx_runtime.JSX.Element;
interface DisplayIdentityProps {
    identity: Identity;
    namespaceId: ENSNamespaceId$1;
    withLink?: boolean;
    identityLinkDetails?: IdentityLinkDetails;
    withTooltip?: boolean;
    withAvatar?: boolean;
    withIdentifier?: boolean;
    className?: string;
}
/**
 * Displays the provided `Identity`.
 *
 * Performs _NO_ resolution if the provided `identity` is not already a `ResolvedIdentity`.
 *
 * @param identity - The identity to display. May be a `ResolvedIdentity` or an `UnresolvedIdentity`.
 *                      If not a `ResolvedIdentity` (and therefore just an `UnresolvedIdentity`) then displays a loading state.
 * @param namespaceId - The ENSNamespace identifier (e.g. 'mainnet', 'sepolia', 'ens-test-env')
 * @param withLink - Whether to wrap the displayed identity in an `IdentityLink` component.
 * @param identityLinkDetails - If the `withLink` is true, provides info on where should it lead and should it be an external link.
 * @param withTooltip - Whether to wrap the displayed identity in an `IdentityInfoTooltip` component.
 * @param withAvatar - Whether to display an avatar image.
 * @param withIdentifier - Whether to display identity's textual identifier (address or name).
 * @param className - The class name to apply to the displayed identity.
 *
 * @throws Error - if `withLink` is true, but no `identityLinkDetails` are provided.
 */
declare function DisplayIdentity({ identity, namespaceId, withLink, identityLinkDetails, withTooltip, withAvatar, withIdentifier, className, }: DisplayIdentityProps): react_jsx_runtime.JSX.Element;

interface LabeledFieldProps {
    fieldLabel: string;
    className?: string;
}
/**
 * Display a labeled field.
 */
declare function LabeledField({ fieldLabel, className, children, }: PropsWithChildren<LabeledFieldProps>): react_jsx_runtime.JSX.Element;
interface ReferrerLinkData {
    isExternal: boolean;
    getLink: (address: Address, namespaceId: ENSNamespaceId$1) => URL | null;
}
interface RegistrarActionCardLoadingProps {
    showReferrer?: boolean;
    showReferralProgramField?: boolean;
}
/**
 * Display Registrar Action Card loading state
 */
declare function RegistrarActionCardLoading({ showReferrer, showReferralProgramField, }: RegistrarActionCardLoadingProps): react_jsx_runtime.JSX.Element;
interface RegistrarActionCardProps {
    namespaceId: ENSNamespaceId$1;
    namedRegistrarAction: NamedRegistrarAction;
    now: UnixTimestamp;
    links: {
        name: IdentityLinkDetails;
        registrant: IdentityLinkDetails;
        referrer: ReferrerLinkData;
    };
    showIdentityTooltips?: {
        registrant: boolean;
        referrer: boolean;
    };
    showReferrer?: boolean;
    referralProgramField?: ReactNode;
}
/**
 * Display a single Registrar Action
 */
declare function RegistrarActionCard({ namespaceId, namedRegistrarAction, now, links, showIdentityTooltips, showReferrer, referralProgramField, }: RegistrarActionCardProps): react_jsx_runtime.JSX.Element;
declare const RegistrarActionCardMemo: React$1.MemoExoticComponent<typeof RegistrarActionCard>;

declare const buttonVariants: (props?: ({
    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost" | null | undefined;
    size?: "default" | "sm" | "lg" | "icon" | "icon-sm" | "icon-lg" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
interface ButtonProps extends React$1.ComponentProps<"button">, VariantProps<typeof buttonVariants> {
    asChild?: boolean;
}

interface CopyButtonProps extends Omit<ButtonProps, "onClick"> {
    value: string;
    message?: string;
    showToast?: boolean;
    icon?: React$1.ReactNode;
    successIcon?: React$1.ReactNode;
}
declare function CopyButton({ value, message, variant, size, showToast, icon, successIcon, className, children, ...props }: CopyButtonProps): react_jsx_runtime.JSX.Element;

/**
 * Configuration options for the ENSNode provider
 */
interface EnsNodeProviderOptions {
    /** The ENSNode client configuration */
    client: EnsNodeClientOptions;
}
/**
 * Base query parameters that can be passed to hooks
 */
interface QueryParameter<TData = unknown, TError = Error> {
    query?: Partial<QueryObserverOptions<TData, TError, TData, TData, readonly unknown[]>>;
}
/**
 * Configuration parameter for hooks that need access to config
 */
interface WithEnsNodeProviderOptions<TOptions extends EnsNodeProviderOptions = EnsNodeProviderOptions> {
    options?: TOptions | undefined;
}
/**
 * Parameters for the useRecords hook.
 *
 * If `name` is null, the query will not be executed.
 */
interface UseRecordsParameters<SELECTION extends ResolverRecordsSelection> extends Omit<ResolveRecordsRequest<SELECTION>, "name">, QueryParameter<ResolveRecordsResponse<SELECTION>> {
    name: ResolveRecordsRequest<SELECTION>["name"] | null;
}
/**
 * Parameters for the usePrimaryName hook.
 *
 * If `address` is null, the query will not be executed.
 */
interface UsePrimaryNameParameters extends Omit<ResolvePrimaryNameRequest, "address">, QueryParameter<ResolvePrimaryNameResponse> {
    address: ResolvePrimaryNameRequest["address"] | null;
}
/**
 * Parameters for the usePrimaryNames hook.
 *
 * If `address` is null, the query will not be executed.
 */
interface UsePrimaryNamesParameters extends Omit<ResolvePrimaryNamesRequest, "address">, QueryParameter<ResolvePrimaryNamesResponse> {
    address: ResolvePrimaryNamesRequest["address"] | null;
}
/**
 * Parameters for the useResolvedIdentity hook.
 */
interface UseResolvedIdentityParameters extends QueryParameter<ResolvePrimaryNameResponse>, AcceleratableRequest {
    identity: UnresolvedIdentity;
    namespace: ENSNamespaceId$1;
}

/**
 * React context for ENSNodeProvider options
 */
declare const EnsNodeContext: React$1.Context<EnsNodeProviderOptions | undefined>;

/**
 * Hook to access the {@link EnsNodeProviderOptions} from context or parameters.
 *
 * @param options - Options parameter that overrides context
 * @throws Error if no options are available in context or parameters
 */
declare function useEnsNodeProviderOptions<ProviderOptionsType extends EnsNodeProviderOptions = EnsNodeProviderOptions>(options?: ProviderOptionsType): ProviderOptionsType;

interface UseIndexingStatusParameters extends EnsApiIndexingStatusRequest, QueryParameter<EnsApiIndexingStatusResponse> {
}
declare function useIndexingStatus(parameters?: WithEnsNodeProviderOptions & UseIndexingStatusParameters): _tanstack_react_query.UseQueryResult<EnsApiIndexingStatusResponse, Error>;

type UseNameTokensParameters = NameTokensRequest & QueryParameter<NameTokensResponse>;
/**
 * Use Name Tokens hook
 *
 * Query ENSNode Name Tokens API.
 */
declare function useNameTokens(parameters: WithEnsNodeProviderOptions & UseNameTokensParameters): _tanstack_react_query.UseQueryResult<NameTokensResponse, Error>;

/**
 * Resolves the primary name of a specified address (Reverse Resolution).
 *
 * The returned Primary Name, if set, is guaranteed to be a normalized name.
 * If the primary name set for the address is not normalized, `null` is returned as if no primary name was set.
 *
 * @param parameters - Configuration for the address resolution
 * @returns Query result with resolved primary name
 *
 * @example
 * ```typescript
 * import { usePrimaryName } from "@namehash/namehash-ui";
 *
 * function DisplayPrimaryNameAndAvatar() {
 *   const { data, isLoading, error } = usePrimaryName({
 *     address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
 *     chainId: 1, // Ethereum Mainnet
 *     accelerate: true, // Attempt Protocol Acceleration
 *   });
 *
 *   if (isLoading) return <div>Loading...</div>;
 *   if (error) return <div>Error: {error.message}</div>;
 *
 *   return (
 *     <div>
 *       <h3>Primary Name (for Mainnet)</h3>
 *       <p>{data.name ?? "No Primary Name"}</p>
 *     </div>
 *   );
 * }
 * ```
 */
declare function usePrimaryName(parameters: UsePrimaryNameParameters & WithEnsNodeProviderOptions): _tanstack_react_query.UseQueryResult<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse, Error>;

/**
 * Resolves the primary names of a specified address across multiple chains.
 *
 * Each returned Primary Name, if set, is guaranteed to be a normalized name.
 * If the primary name set for the address on any chain is not normalized, `null` is returned for that chain as if no primary name was set.
 *
 * @param parameters - Configuration for the address resolution
 * @returns Query result with resolved primary names
 *
 * @example
 * ```typescript
 * import { usePrimaryNames } from "@namehash/namehash-ui";
 *
 * function DisplayPrimaryNames() {
 *   const { data, isLoading, error } = usePrimaryNames({
 *     address: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
 *   });
 *
 *   if (isLoading) return <div>Loading...</div>;
 *   if (error) return <div>Error: {error.message}</div>;
 *
 *   return (
 *     <div>
 *       {Object.entries(data.names).map(([chainId, name]) => (
 *         <div key={chainId}>
 *           <h3>Primary Name (Chain Id: {chainId})</h3>
 *           <p>{name}</p>
 *         </div>
 *       ))}
 *     </div>
 *   );
 * }
 * ```
 */
declare function usePrimaryNames(parameters: UsePrimaryNamesParameters & WithEnsNodeProviderOptions): _tanstack_react_query.UseQueryResult<_ensnode_ensnode_sdk.ResolvePrimaryNamesResponse, Error>;

/**
 * Resolves records for an ENS name (Forward Resolution).
 *
 * The returned `name` field, if set, is guaranteed to be a normalized name.
 * If the name record returned by the resolver is not normalized, `null` is returned as if no name record was set.
 *
 * @param parameters - Configuration for the ENS name resolution
 * @returns Query result with resolved records
 *
 * @example
 * ```typescript
 * import { useRecords } from "@namehash/namehash-ui";
 *
 * function DisplayNameRecords() {
 *   const { data, isLoading, error } = useRecords({
 *     name: "jesse.base.eth",
 *     selection: {
 *       addresses: [60], // ETH CoinType
 *       texts: ["avatar", "com.twitter"]
 *     }
 *   });
 *
 *   if (isLoading) return <div>Loading...</div>;
 *   if (error) return <div>Error: {error.message}</div>;
 *
 *   return (
 *     <div>
 *       <h3>Resolved Records for vitalik.eth</h3>
 *       {data.records.addresses && (
 *         <p>ETH Address: {data.records.addresses[60]}</p>
 *       )}
 *       {data.records.texts && (
 *         <div>
 *           <p>Avatar: {data.records.texts.avatar}</p>
 *           <p>Twitter: {data.records.texts["com.twitter"]}</p>
 *         </div>
 *       )}
 *     </div>
 *   );
 * }
 * ```
 */
declare function useRecords<SELECTION extends ResolverRecordsSelection>(parameters: UseRecordsParameters<SELECTION> & WithEnsNodeProviderOptions): _tanstack_react_query.UseQueryResult<_ensnode_ensnode_sdk.ResolveRecordsResponse<SELECTION>, Error>;

interface UseRegistrarActionsParameters extends RegistrarActionsRequest, QueryParameter<RegistrarActionsResponse> {
}
/**
 * Use Registrar Actions hook
 *
 * Query ENSNode Registrar Actions API.
 */
declare function useRegistrarActions(parameters?: WithEnsNodeProviderOptions & UseRegistrarActionsParameters): _tanstack_react_query.UseQueryResult<RegistrarActionsResponse, Error>;

/**
 * Hook to perform ENSIP-19 primary name resolution to resolve an
 * {@link UnresolvedIdentity} into a {@link ResolvedIdentity}.
 *
 * @param parameters - Configuration object for the hook
 * @param parameters.identity - An {@link UnresolvedIdentity} containing the {@link DefaultableChainId}
 *                              and {@link Address} to resolve.
 * @param parameters.namespace - The {@link ENSNamespaceId} that `identity.chainId` should be interpreted
 *                                 through (via {@link getResolvePrimaryNameChainIdParam}) to determine the literal
 *                                 chainId that should be used for ENSIP-19 primary name resolution.
 * @param parameters.accelerate - Whether to attempt Protocol Acceleration (default: false)
 *                                when resolving the primary name.
 *
 * @returns An object containing:
 * - `identity`: An {@link Identity} with one of four possible {@link ResolutionStatusIds}:
 *   - {@link ResolutionStatusIds.Unresolved}: While the query is pending (loading state).
 *   - {@link ResolutionStatusIds.Unknown}: If an error occurs during resolution.
 *   - {@link ResolutionStatusIds.Unnamed}: If the resolution found no primary name.
 *   - {@link ResolutionStatusIds.Named}: If a primary name is successfully resolved.
 * - All other properties from the underlying {@link usePrimaryName} query (e.g., `isLoading`, `error`, `refetch`, etc.)
 */
declare function useResolvedIdentity(parameters: UseResolvedIdentityParameters): {
    identity: Identity;
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: true;
    isSuccess: false;
    isPlaceholderData: false;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse>;
} | {
    identity: Identity;
    error: null;
    isError: false;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: false;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse>;
} | {
    identity: Identity;
    error: Error;
    isError: true;
    isPending: false;
    isLoading: false;
    isLoadingError: true;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse>;
} | {
    identity: Identity;
    error: null;
    isError: false;
    isPending: true;
    isLoading: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse>;
} | {
    identity: Identity;
    error: null;
    isError: false;
    isPending: true;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: false;
    isPlaceholderData: false;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isLoading: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse>;
} | {
    identity: Identity;
    isError: false;
    error: null;
    isPending: false;
    isLoading: false;
    isLoadingError: false;
    isRefetchError: false;
    isSuccess: true;
    isPlaceholderData: true;
    dataUpdatedAt: number;
    errorUpdatedAt: number;
    failureCount: number;
    failureReason: Error | null;
    errorUpdateCount: number;
    isFetched: boolean;
    isFetchedAfterMount: boolean;
    isFetching: boolean;
    isInitialLoading: boolean;
    isPaused: boolean;
    isRefetching: boolean;
    isStale: boolean;
    isEnabled: boolean;
    refetch: (options?: _tanstack_react_query.RefetchOptions) => Promise<_tanstack_react_query.QueryObserverResult<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse, Error>>;
    fetchStatus: _tanstack_react_query.FetchStatus;
    promise: Promise<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse>;
};

/**
 * Use Stale-While-Revalidate Query
 *
 * This hooks is a proxy for {@link useQuery} with addition of the following
 * semantics:
 * - if the query has been resolved successfully just once,
 *   the query result will always be success with data being the previously
 *   cached result,
 * - the cached result can never go stale, or be garbage collected
 * - the cached result can be only overridden by the current result when
 *   the query is successfully re-fetched (in other words,
 *   the `options.queryFn` returns a resolved promise).
 *
 * Please note how there can be any number of failed queries before one
 * succeeds. In such case, no successful result has ever been cached and
 * the query fails (`isError: true`, `error` is available) until
 * the first successful resolution (`isSuccess: true`, `data` is available).
 *
 * @example
 * ```tsx
 * const swrQuery = useSwrQuery({
 *   queryKey: ['data'],
 *   queryFn: fetchData,
 * });
 *
 * if (swrQuery.isPending) {
 *   // Show loading state while there's no cached successful result and
 *   // no query attempt was finished yet.
 *   return <>Loading...</>;
 * }
 *
 * if (swrQuery.isError) {
 *   // Show error state when query attempt fails and
 *   // no cached successful result is available.
 *   return <>Error: {swrQuery.error.message}</>;
 * }
 *
 * // Otherwise, show data when the cached successful result is available.
 * return <>Data: {JSON.stringify(swrQuery.data)}</>;
 * ```
 */
declare function useSwrQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): DefinedUseQueryResult<NoInfer<TData>, TError>;
declare function useSwrQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<NoInfer<TData>, TError>;
declare function useSwrQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: QueryClient): UseQueryResult<NoInfer<TData>, TError>;

interface EnsNodeProviderProps {
    /** ENSNode Provider Options */
    options: EnsNodeProviderOptions;
    /**
     * Optional QueryClient instance. If provided, you must wrap your app with QueryClientProvider yourself.
     * If not provided, EnsNodeProvider will create and manage its own QueryClient internally.
     */
    queryClient?: QueryClient;
    /**
     * Custom query client options when auto-creating a QueryClient.
     * Only used when queryClient is not provided.
     */
    queryClientOptions?: ConstructorParameters<typeof QueryClient>[0];
}
declare function EnsNodeProvider(parameters: React.PropsWithChildren<EnsNodeProviderProps>): React$1.FunctionComponentElement<{
    children?: React.ReactNode;
    options: EnsNodeProviderOptions;
}> | React$1.FunctionComponentElement<_tanstack_react_query.QueryClientProviderProps>;
/**
 * Helper function to create ENSNode Provider Options
 */
declare function createEnsNodeProviderOptions(options?: {
    url?: string | URL;
}): EnsNodeProviderOptions;

/**
 * Immutable query options for data that is assumed to be immutable and should only be fetched once per full page refresh per unique key.
 * Similar to SWR's immutable: true API.
 *
 * Use this for data that is assumed not to change (e.g., records for a specific name) until the next full page refresh.
 *
 * @example
 * ```tsx
 * useRecords({
 *   name: "vitalik.eth",
 *   selection: { texts: ["avatar"] },
 *   query: ASSUME_IMMUTABLE_QUERY
 * })
 * ```
 */
declare const ASSUME_IMMUTABLE_QUERY: {
    readonly staleTime: number;
    readonly gcTime: number;
    readonly refetchOnWindowFocus: false;
    readonly refetchOnReconnect: false;
    readonly refetchOnMount: false;
};
/**
 * Query options that disable a useQuery call. Uses `skipToken` so tanstack-query
 * does not warn about a missing `queryFn`.
 */
declare const DISABLED_QUERY: {
    readonly queryKey: readonly ["disabled"];
    readonly queryFn: typeof skipToken;
};
/**
 * Query keys for hooks. Simply keys by path and arguments.
 */
declare const queryKeys: {
    base: (url: string) => readonly ["ensnode", string];
    resolve: (url: string) => readonly ["ensnode", string, "resolve"];
    records: (url: string, args: ResolveRecordsRequest<any>) => readonly ["ensnode", string, "resolve", "records", ResolveRecordsRequest<any>];
    primaryName: (url: string, args: ResolvePrimaryNameRequest) => readonly ["ensnode", string, "resolve", "primary-name", ResolvePrimaryNameRequest];
    primaryNames: (url: string, args: ResolvePrimaryNamesRequest) => readonly ["ensnode", string, "resolve", "primary-names", ResolvePrimaryNamesRequest];
    indexingStatus: (url: string) => readonly ["ensnode", string, "indexing-status"];
    registrarActions: (url: string, args: RegistrarActionsRequest) => readonly ["ensnode", string, "registrar-actions", RegistrarActionsRequest];
    nameTokens: (url: string, args: NameTokensRequest) => readonly ["ensnode", string, "name-tokens", NameTokensRequest];
};
/**
 * Creates query options for Records Resolution
 */
declare function createRecordsQueryOptions<SELECTION extends ResolverRecordsSelection>(config: EnsNodeProviderOptions, args: ResolveRecordsRequest<SELECTION>): {
    enabled: boolean;
    queryKey: readonly ["ensnode", string, "resolve", "records", ResolveRecordsRequest<any>];
    queryFn: () => Promise<_ensnode_ensnode_sdk.ResolveRecordsResponse<SELECTION>>;
};
/**
 * Creates query options for Primary Name Resolution
 */
declare function createPrimaryNameQueryOptions(config: EnsNodeProviderOptions, args: ResolvePrimaryNameRequest): {
    enabled: boolean;
    queryKey: readonly ["ensnode", string, "resolve", "primary-name", ResolvePrimaryNameRequest];
    queryFn: () => Promise<_ensnode_ensnode_sdk.ResolvePrimaryNameResponse>;
};
/**
 * Creates query options for Primary Name Resolution
 */
declare function createPrimaryNamesQueryOptions(config: EnsNodeProviderOptions, args: ResolvePrimaryNamesRequest): {
    enabled: boolean;
    queryKey: readonly ["ensnode", string, "resolve", "primary-names", ResolvePrimaryNamesRequest];
    queryFn: () => Promise<_ensnode_ensnode_sdk.ResolvePrimaryNamesResponse>;
};
/**
 * Creates query options for ENSNode Indexing Status API
 */
declare function createIndexingStatusQueryOptions(config: EnsNodeProviderOptions): {
    enabled: boolean;
    queryKey: readonly ["ensnode", string, "indexing-status"];
    queryFn: () => Promise<_ensnode_ensnode_sdk.EnsApiIndexingStatusResponse>;
};
/**
 * Creates query options for ENSNode Registrar Actions API
 */
declare function createRegistrarActionsQueryOptions(config: EnsNodeProviderOptions, args: RegistrarActionsRequest): {
    enabled: boolean;
    queryKey: readonly ["ensnode", string, "registrar-actions", RegistrarActionsRequest];
    queryFn: () => Promise<_ensnode_ensnode_sdk.RegistrarActionsResponse>;
};
/**
 * Creates query options for Name Tokens API
 */
declare function createNameTokensQueryOptions(config: EnsNodeProviderOptions, args: NameTokensRequest): {
    enabled: boolean;
    queryKey: readonly ["ensnode", string, "name-tokens", NameTokensRequest];
    queryFn: () => Promise<_ensnode_ensnode_sdk.NameTokensResponse>;
};

declare function useIsMobile(breakpoint?: number): boolean;

interface UseNowProps {
    /**
     * Duration after which time value will be refreshed.
     *
     * Defaults to {@link DEFAULT_TIME_TO_REFRESH}.
     */
    timeToRefresh?: Duration;
}
/**
 * Use now
 *
 * This hook returns the current system time while following `timeToRefresh` param.
 *
 * @param timeToRefresh Duration after which time value will be refreshed.
 *
 * @example
 * ```ts
 * // `now` will be updated each second (by default)
 * const now = useNow();
 * ```
 * @example
 * ```ts
 * // `now` will be updated each 5 seconds
 * const now = useNow({ timeToRefresh: 5 });
 * ```
 */
declare function useNow(props?: UseNowProps): UnixTimestamp;

/**
 * Gets the "base" block explorer URL for a given {@link ChainId}
 *
 * @returns default block explorer URL for the chain with the provided id,
 * or null if the referenced chain doesn't have a known block explorer
 */
declare const getBlockExplorerUrl: (chainId: ChainId) => URL | null;
/**
 * Gets the block explorer URL for a specific address on a specific chainId
 *
 * @returns complete block explorer URL for a specific address on a specific chainId,
 * or null if the referenced chain doesn't have a known block explorer
 */
declare const getBlockExplorerAddressDetailsUrl: (chainId: ChainId, address: Address) => URL | null;
/**
 * Gets the block explorer URL for a specific transaction hash on a specific chainId
 *
 * @returns complete block explorer URL for a specific transaction hash on a specific chainId,
 * or null if the referenced chain doesn't have a known block explorer
 */
declare const getBlockExplorerTransactionDetailsUrl: (chainId: ChainId, transactionHash: Hash) => URL | null;
/**
 * Gets the block explorer URL for a specific block on a specific chainId
 *
 * @returns complete block explorer URL for a specific block on a specific chainId,
 * or null if the referenced chain doesn't have a known block explorer
 */
declare const getBlockExplorerBlockUrl: (chainId: ChainId, blockNumber: number) => URL | null;

declare const SUPPORTED_CHAINS: ({
    readonly id: 31337;
    readonly name: "ens-test-env";
    readonly blockExplorers?: {
        [key: string]: {
            name: string;
            url: string;
            apiUrl?: string | undefined;
        };
        default: {
            name: string;
            url: string;
            apiUrl?: string | undefined;
        };
    } | undefined | undefined;
    readonly blockTime?: number | undefined | undefined;
    readonly contracts?: {
        [x: string]: viem.ChainContract | {
            [sourceId: number]: viem.ChainContract | undefined;
        } | undefined;
        ensRegistry?: viem.ChainContract | undefined;
        ensUniversalResolver?: viem.ChainContract | undefined;
        multicall3?: viem.ChainContract | undefined;
        erc6492Verifier?: viem.ChainContract | undefined;
    } | undefined;
    readonly ensTlds?: readonly string[] | undefined;
    readonly nativeCurrency: {
        readonly decimals: 18;
        readonly name: "Ether";
        readonly symbol: "ETH";
    };
    readonly experimental_preconfirmationTime?: number | undefined | undefined;
    readonly rpcUrls: {
        readonly default: {
            readonly http: readonly ["http://127.0.0.1:8545"];
            readonly webSocket: readonly ["ws://127.0.0.1:8545"];
        };
    };
    readonly sourceId?: number | undefined | undefined;
    readonly testnet?: boolean | undefined | undefined;
    readonly custom?: Record<string, unknown> | undefined;
    readonly extendSchema?: Record<string, unknown> | undefined;
    readonly fees?: viem.ChainFees<undefined> | undefined;
    readonly formatters?: undefined;
    readonly prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
    }] | undefined;
    readonly serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
    readonly verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
} | {
    blockExplorers: {
        readonly default: {
            readonly name: "Etherscan";
            readonly url: "https://etherscan.io";
            readonly apiUrl: "https://api.etherscan.io/api";
        };
    };
    blockTime: 12000;
    contracts: {
        readonly ensUniversalResolver: {
            readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
            readonly blockCreated: 23085558;
        };
        readonly multicall3: {
            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
            readonly blockCreated: 14353601;
        };
    };
    ensTlds?: readonly string[] | undefined;
    id: 1;
    name: "Ethereum";
    nativeCurrency: {
        readonly name: "Ether";
        readonly symbol: "ETH";
        readonly decimals: 18;
    };
    experimental_preconfirmationTime?: number | undefined | undefined;
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://eth.merkle.io"];
        };
    };
    sourceId?: number | undefined | undefined;
    testnet?: boolean | undefined | undefined;
    custom?: Record<string, unknown> | undefined;
    extendSchema?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters?: undefined;
    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
    }] | undefined;
    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
} | {
    blockExplorers: {
        readonly default: {
            readonly name: "Basescan";
            readonly url: "https://basescan.org";
            readonly apiUrl: "https://api.basescan.org/api";
        };
    };
    blockTime: 2000;
    contracts: {
        readonly disputeGameFactory: {
            readonly 1: {
                readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
            };
        };
        readonly l2OutputOracle: {
            readonly 1: {
                readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
            };
        };
        readonly multicall3: {
            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
            readonly blockCreated: 5022;
        };
        readonly portal: {
            readonly 1: {
                readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
                readonly blockCreated: 17482143;
            };
        };
        readonly l1StandardBridge: {
            readonly 1: {
                readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
                readonly blockCreated: 17482143;
            };
        };
        readonly gasPriceOracle: {
            readonly address: "0x420000000000000000000000000000000000000F";
        };
        readonly l1Block: {
            readonly address: "0x4200000000000000000000000000000000000015";
        };
        readonly l2CrossDomainMessenger: {
            readonly address: "0x4200000000000000000000000000000000000007";
        };
        readonly l2Erc721Bridge: {
            readonly address: "0x4200000000000000000000000000000000000014";
        };
        readonly l2StandardBridge: {
            readonly address: "0x4200000000000000000000000000000000000010";
        };
        readonly l2ToL1MessagePasser: {
            readonly address: "0x4200000000000000000000000000000000000016";
        };
    };
    ensTlds?: readonly string[] | undefined;
    id: 8453;
    name: "Base";
    nativeCurrency: {
        readonly name: "Ether";
        readonly symbol: "ETH";
        readonly decimals: 18;
    };
    experimental_preconfirmationTime?: number | undefined | undefined;
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://mainnet.base.org"];
        };
    };
    sourceId: 1;
    testnet?: boolean | undefined | undefined;
    custom?: Record<string, unknown> | undefined;
    extendSchema?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters: {
        readonly block: {
            exclude: [] | undefined;
            format: (args: viem_chains.OpStackRpcBlock, action?: string | undefined) => {
                baseFeePerGas: bigint | null;
                blobGasUsed: bigint;
                difficulty: bigint;
                excessBlobGas: bigint;
                extraData: viem.Hex;
                gasLimit: bigint;
                gasUsed: bigint;
                hash: `0x${string}` | null;
                logsBloom: `0x${string}` | null;
                miner: viem.Address;
                mixHash: viem.Hash;
                nonce: `0x${string}` | null;
                number: bigint | null;
                parentBeaconBlockRoot?: `0x${string}` | undefined;
                parentHash: viem.Hash;
                receiptsRoot: viem.Hex;
                sealFields: viem.Hex[];
                sha3Uncles: viem.Hash;
                size: bigint;
                stateRoot: viem.Hash;
                timestamp: bigint;
                totalDifficulty: bigint | null;
                transactions: `0x${string}`[] | viem_chains.OpStackTransaction<boolean>[];
                transactionsRoot: viem.Hash;
                uncles: viem.Hash[];
                withdrawals?: viem.Withdrawal[] | undefined | undefined;
                withdrawalsRoot?: `0x${string}` | undefined;
            } & {};
            type: "block";
        };
        readonly transaction: {
            exclude: [] | undefined;
            format: (args: viem_chains.OpStackRpcTransaction, action?: string | undefined) => ({
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                gasPrice?: undefined | undefined;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                isSystemTx?: boolean;
                mint?: bigint | undefined | undefined;
                sourceHash: viem.Hex;
                type: "deposit";
            } | {
                r: viem.Hex;
                s: viem.Hex;
                v: bigint;
                to: viem.Address | null;
                from: viem.Address;
                gas: bigint;
                nonce: number;
                value: bigint;
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                hash: viem.Hash;
                input: viem.Hex;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                accessList?: undefined | undefined;
                authorizationList?: undefined | undefined;
                blobVersionedHashes?: undefined | undefined;
                chainId?: number | undefined;
                yParity?: undefined | undefined;
                type: "legacy";
                gasPrice: bigint;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas?: undefined | undefined;
                maxPriorityFeePerGas?: undefined | undefined;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            } | {
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                accessList: viem.AccessList;
                authorizationList?: undefined | undefined;
                blobVersionedHashes?: undefined | undefined;
                chainId: number;
                type: "eip2930";
                gasPrice: bigint;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas?: undefined | undefined;
                maxPriorityFeePerGas?: undefined | undefined;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            } | {
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                accessList: viem.AccessList;
                authorizationList?: undefined | undefined;
                blobVersionedHashes?: undefined | undefined;
                chainId: number;
                type: "eip1559";
                gasPrice?: undefined | undefined;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            } | {
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                accessList: viem.AccessList;
                authorizationList?: undefined | undefined;
                blobVersionedHashes: readonly viem.Hex[];
                chainId: number;
                type: "eip4844";
                gasPrice?: undefined | undefined;
                maxFeePerBlobGas: bigint;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            } | {
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                accessList: viem.AccessList;
                authorizationList: viem.SignedAuthorizationList;
                blobVersionedHashes?: undefined | undefined;
                chainId: number;
                type: "eip7702";
                gasPrice?: undefined | undefined;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            }) & {};
            type: "transaction";
        };
        readonly transactionReceipt: {
            exclude: [] | undefined;
            format: (args: viem_chains.OpStackRpcTransactionReceipt, action?: string | undefined) => {
                blobGasPrice?: bigint | undefined;
                blobGasUsed?: bigint | undefined;
                blockHash: viem.Hash;
                blockNumber: bigint;
                blockTimestamp?: bigint | undefined;
                contractAddress: viem.Address | null | undefined;
                cumulativeGasUsed: bigint;
                effectiveGasPrice: bigint;
                from: viem.Address;
                gasUsed: bigint;
                logs: viem.Log<bigint, number, false>[];
                logsBloom: viem.Hex;
                root?: `0x${string}` | undefined;
                status: "success" | "reverted";
                to: viem.Address | null;
                transactionHash: viem.Hash;
                transactionIndex: number;
                type: viem.TransactionType;
                l1GasPrice: bigint | null;
                l1GasUsed: bigint | null;
                l1Fee: bigint | null;
                l1FeeScalar: number | null;
            } & {};
            type: "transactionReceipt";
        };
    };
    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
    }] | undefined;
    serializers: {
        readonly transaction: typeof viem_chains.serializeTransactionOpStack;
    };
    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
} | {
    blockExplorers: {
        readonly default: {
            readonly name: "Etherscan";
            readonly url: "https://lineascan.build";
            readonly apiUrl: "https://api.lineascan.build/api";
        };
    };
    blockTime: 2000;
    contracts: {
        readonly multicall3: {
            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
            readonly blockCreated: 42;
        };
        readonly ensRegistry: {
            readonly address: "0x50130b669B28C339991d8676FA73CF122a121267";
            readonly blockCreated: 6682888;
        };
        readonly ensUniversalResolver: {
            readonly address: "0x4D41762915F83c76EcaF6776d9b08076aA32b492";
            readonly blockCreated: 22222151;
        };
    };
    ensTlds: readonly [".linea.eth"];
    id: 59144;
    name: "Linea Mainnet";
    nativeCurrency: {
        readonly name: "Linea Ether";
        readonly symbol: "ETH";
        readonly decimals: 18;
    };
    experimental_preconfirmationTime?: number | undefined | undefined;
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://rpc.linea.build"];
            readonly webSocket: readonly ["wss://rpc.linea.build"];
        };
    };
    sourceId?: number | undefined | undefined;
    testnet: false;
    custom?: Record<string, unknown> | undefined;
    extendSchema?: Record<string, unknown> | undefined;
    fees: {
        readonly estimateFeesPerGas: ({ client, multiply, request, type, }: Parameters<viem.ChainEstimateFeesPerGasFn>[0]) => ReturnType<viem.ChainEstimateFeesPerGasFn>;
        readonly maxPriorityFeePerGas: ({ block, client, request }: viem.ChainFeesFnParameters<viem.ChainFormatters | undefined>) => Promise<bigint | null>;
    };
    formatters?: undefined;
    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
    }] | undefined;
    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
} | {
    blockExplorers: {
        readonly default: {
            readonly name: "Optimism Explorer";
            readonly url: "https://optimistic.etherscan.io";
            readonly apiUrl: "https://api-optimistic.etherscan.io/api";
        };
    };
    blockTime: 2000;
    contracts: {
        readonly disputeGameFactory: {
            readonly 1: {
                readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
            };
        };
        readonly l2OutputOracle: {
            readonly 1: {
                readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
            };
        };
        readonly multicall3: {
            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
            readonly blockCreated: 4286263;
        };
        readonly portal: {
            readonly 1: {
                readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
            };
        };
        readonly l1StandardBridge: {
            readonly 1: {
                readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
            };
        };
        readonly gasPriceOracle: {
            readonly address: "0x420000000000000000000000000000000000000F";
        };
        readonly l1Block: {
            readonly address: "0x4200000000000000000000000000000000000015";
        };
        readonly l2CrossDomainMessenger: {
            readonly address: "0x4200000000000000000000000000000000000007";
        };
        readonly l2Erc721Bridge: {
            readonly address: "0x4200000000000000000000000000000000000014";
        };
        readonly l2StandardBridge: {
            readonly address: "0x4200000000000000000000000000000000000010";
        };
        readonly l2ToL1MessagePasser: {
            readonly address: "0x4200000000000000000000000000000000000016";
        };
    };
    ensTlds?: readonly string[] | undefined;
    id: 10;
    name: "OP Mainnet";
    nativeCurrency: {
        readonly name: "Ether";
        readonly symbol: "ETH";
        readonly decimals: 18;
    };
    experimental_preconfirmationTime?: number | undefined | undefined;
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://mainnet.optimism.io"];
        };
    };
    sourceId: 1;
    testnet?: boolean | undefined | undefined;
    custom?: Record<string, unknown> | undefined;
    extendSchema?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters: {
        readonly block: {
            exclude: [] | undefined;
            format: (args: viem_chains.OpStackRpcBlock, action?: string | undefined) => {
                baseFeePerGas: bigint | null;
                blobGasUsed: bigint;
                difficulty: bigint;
                excessBlobGas: bigint;
                extraData: viem.Hex;
                gasLimit: bigint;
                gasUsed: bigint;
                hash: `0x${string}` | null;
                logsBloom: `0x${string}` | null;
                miner: viem.Address;
                mixHash: viem.Hash;
                nonce: `0x${string}` | null;
                number: bigint | null;
                parentBeaconBlockRoot?: `0x${string}` | undefined;
                parentHash: viem.Hash;
                receiptsRoot: viem.Hex;
                sealFields: viem.Hex[];
                sha3Uncles: viem.Hash;
                size: bigint;
                stateRoot: viem.Hash;
                timestamp: bigint;
                totalDifficulty: bigint | null;
                transactions: `0x${string}`[] | viem_chains.OpStackTransaction<boolean>[];
                transactionsRoot: viem.Hash;
                uncles: viem.Hash[];
                withdrawals?: viem.Withdrawal[] | undefined | undefined;
                withdrawalsRoot?: `0x${string}` | undefined;
            } & {};
            type: "block";
        };
        readonly transaction: {
            exclude: [] | undefined;
            format: (args: viem_chains.OpStackRpcTransaction, action?: string | undefined) => ({
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                gasPrice?: undefined | undefined;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                isSystemTx?: boolean;
                mint?: bigint | undefined | undefined;
                sourceHash: viem.Hex;
                type: "deposit";
            } | {
                r: viem.Hex;
                s: viem.Hex;
                v: bigint;
                to: viem.Address | null;
                from: viem.Address;
                gas: bigint;
                nonce: number;
                value: bigint;
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                hash: viem.Hash;
                input: viem.Hex;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                accessList?: undefined | undefined;
                authorizationList?: undefined | undefined;
                blobVersionedHashes?: undefined | undefined;
                chainId?: number | undefined;
                yParity?: undefined | undefined;
                type: "legacy";
                gasPrice: bigint;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas?: undefined | undefined;
                maxPriorityFeePerGas?: undefined | undefined;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            } | {
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                accessList: viem.AccessList;
                authorizationList?: undefined | undefined;
                blobVersionedHashes?: undefined | undefined;
                chainId: number;
                type: "eip2930";
                gasPrice: bigint;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas?: undefined | undefined;
                maxPriorityFeePerGas?: undefined | undefined;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            } | {
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                accessList: viem.AccessList;
                authorizationList?: undefined | undefined;
                blobVersionedHashes?: undefined | undefined;
                chainId: number;
                type: "eip1559";
                gasPrice?: undefined | undefined;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            } | {
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                accessList: viem.AccessList;
                authorizationList?: undefined | undefined;
                blobVersionedHashes: readonly viem.Hex[];
                chainId: number;
                type: "eip4844";
                gasPrice?: undefined | undefined;
                maxFeePerBlobGas: bigint;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            } | {
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                accessList: viem.AccessList;
                authorizationList: viem.SignedAuthorizationList;
                blobVersionedHashes?: undefined | undefined;
                chainId: number;
                type: "eip7702";
                gasPrice?: undefined | undefined;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            }) & {};
            type: "transaction";
        };
        readonly transactionReceipt: {
            exclude: [] | undefined;
            format: (args: viem_chains.OpStackRpcTransactionReceipt, action?: string | undefined) => {
                blobGasPrice?: bigint | undefined;
                blobGasUsed?: bigint | undefined;
                blockHash: viem.Hash;
                blockNumber: bigint;
                blockTimestamp?: bigint | undefined;
                contractAddress: viem.Address | null | undefined;
                cumulativeGasUsed: bigint;
                effectiveGasPrice: bigint;
                from: viem.Address;
                gasUsed: bigint;
                logs: viem.Log<bigint, number, false>[];
                logsBloom: viem.Hex;
                root?: `0x${string}` | undefined;
                status: "success" | "reverted";
                to: viem.Address | null;
                transactionHash: viem.Hash;
                transactionIndex: number;
                type: viem.TransactionType;
                l1GasPrice: bigint | null;
                l1GasUsed: bigint | null;
                l1Fee: bigint | null;
                l1FeeScalar: number | null;
            } & {};
            type: "transactionReceipt";
        };
    };
    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
    }] | undefined;
    serializers: {
        readonly transaction: typeof viem_chains.serializeTransactionOpStack;
    };
    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
} | {
    blockExplorers: {
        readonly default: {
            readonly name: "Arbiscan";
            readonly url: "https://arbiscan.io";
            readonly apiUrl: "https://api.arbiscan.io/api";
        };
    };
    blockTime: 250;
    contracts: {
        readonly multicall3: {
            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
            readonly blockCreated: 7654707;
        };
    };
    ensTlds?: readonly string[] | undefined;
    id: 42161;
    name: "Arbitrum One";
    nativeCurrency: {
        readonly name: "Ether";
        readonly symbol: "ETH";
        readonly decimals: 18;
    };
    experimental_preconfirmationTime?: number | undefined | undefined;
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
        };
    };
    sourceId?: number | undefined | undefined;
    testnet?: boolean | undefined | undefined;
    custom?: Record<string, unknown> | undefined;
    extendSchema?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters?: undefined;
    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
    }] | undefined;
    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
} | {
    blockExplorers: {
        readonly default: {
            readonly name: "Scrollscan";
            readonly url: "https://scrollscan.com";
            readonly apiUrl: "https://api.scrollscan.com/api";
        };
    };
    blockTime: 3000;
    contracts: {
        readonly multicall3: {
            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
            readonly blockCreated: 14;
        };
    };
    ensTlds?: readonly string[] | undefined;
    id: 534352;
    name: "Scroll";
    nativeCurrency: {
        readonly name: "Ether";
        readonly symbol: "ETH";
        readonly decimals: 18;
    };
    experimental_preconfirmationTime?: number | undefined | undefined;
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://rpc.scroll.io"];
            readonly webSocket: readonly ["wss://wss-rpc.scroll.io/ws"];
        };
    };
    sourceId?: number | undefined | undefined;
    testnet: false;
    custom?: Record<string, unknown> | undefined;
    extendSchema?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters?: undefined;
    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
    }] | undefined;
    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
} | {
    blockExplorers: {
        readonly default: {
            readonly name: "Etherscan";
            readonly url: "https://sepolia.etherscan.io";
            readonly apiUrl: "https://api-sepolia.etherscan.io/api";
        };
    };
    blockTime?: number | undefined | undefined;
    contracts: {
        readonly multicall3: {
            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
            readonly blockCreated: 751532;
        };
        readonly ensUniversalResolver: {
            readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
            readonly blockCreated: 8928790;
        };
    };
    ensTlds?: readonly string[] | undefined;
    id: 11155111;
    name: "Sepolia";
    nativeCurrency: {
        readonly name: "Sepolia Ether";
        readonly symbol: "ETH";
        readonly decimals: 18;
    };
    experimental_preconfirmationTime?: number | undefined | undefined;
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://11155111.rpc.thirdweb.com"];
        };
    };
    sourceId?: number | undefined | undefined;
    testnet: true;
    custom?: Record<string, unknown> | undefined;
    extendSchema?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters?: undefined;
    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
    }] | undefined;
    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
} | {
    blockExplorers: {
        readonly default: {
            readonly name: "Basescan";
            readonly url: "https://sepolia.basescan.org";
            readonly apiUrl: "https://api-sepolia.basescan.org/api";
        };
    };
    blockTime: 2000;
    contracts: {
        readonly disputeGameFactory: {
            readonly 11155111: {
                readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
            };
        };
        readonly l2OutputOracle: {
            readonly 11155111: {
                readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
            };
        };
        readonly portal: {
            readonly 11155111: {
                readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
                readonly blockCreated: 4446677;
            };
        };
        readonly l1StandardBridge: {
            readonly 11155111: {
                readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
                readonly blockCreated: 4446677;
            };
        };
        readonly multicall3: {
            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
            readonly blockCreated: 1059647;
        };
        readonly gasPriceOracle: {
            readonly address: "0x420000000000000000000000000000000000000F";
        };
        readonly l1Block: {
            readonly address: "0x4200000000000000000000000000000000000015";
        };
        readonly l2CrossDomainMessenger: {
            readonly address: "0x4200000000000000000000000000000000000007";
        };
        readonly l2Erc721Bridge: {
            readonly address: "0x4200000000000000000000000000000000000014";
        };
        readonly l2StandardBridge: {
            readonly address: "0x4200000000000000000000000000000000000010";
        };
        readonly l2ToL1MessagePasser: {
            readonly address: "0x4200000000000000000000000000000000000016";
        };
    };
    ensTlds?: readonly string[] | undefined;
    id: 84532;
    name: "Base Sepolia";
    nativeCurrency: {
        readonly name: "Sepolia Ether";
        readonly symbol: "ETH";
        readonly decimals: 18;
    };
    experimental_preconfirmationTime?: number | undefined | undefined;
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://sepolia.base.org"];
        };
    };
    sourceId: 11155111;
    testnet: true;
    custom?: Record<string, unknown> | undefined;
    extendSchema?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters: {
        readonly block: {
            exclude: [] | undefined;
            format: (args: viem_chains.OpStackRpcBlock, action?: string | undefined) => {
                baseFeePerGas: bigint | null;
                blobGasUsed: bigint;
                difficulty: bigint;
                excessBlobGas: bigint;
                extraData: viem.Hex;
                gasLimit: bigint;
                gasUsed: bigint;
                hash: `0x${string}` | null;
                logsBloom: `0x${string}` | null;
                miner: viem.Address;
                mixHash: viem.Hash;
                nonce: `0x${string}` | null;
                number: bigint | null;
                parentBeaconBlockRoot?: `0x${string}` | undefined;
                parentHash: viem.Hash;
                receiptsRoot: viem.Hex;
                sealFields: viem.Hex[];
                sha3Uncles: viem.Hash;
                size: bigint;
                stateRoot: viem.Hash;
                timestamp: bigint;
                totalDifficulty: bigint | null;
                transactions: `0x${string}`[] | viem_chains.OpStackTransaction<boolean>[];
                transactionsRoot: viem.Hash;
                uncles: viem.Hash[];
                withdrawals?: viem.Withdrawal[] | undefined | undefined;
                withdrawalsRoot?: `0x${string}` | undefined;
            } & {};
            type: "block";
        };
        readonly transaction: {
            exclude: [] | undefined;
            format: (args: viem_chains.OpStackRpcTransaction, action?: string | undefined) => ({
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                gasPrice?: undefined | undefined;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                isSystemTx?: boolean;
                mint?: bigint | undefined | undefined;
                sourceHash: viem.Hex;
                type: "deposit";
            } | {
                r: viem.Hex;
                s: viem.Hex;
                v: bigint;
                to: viem.Address | null;
                from: viem.Address;
                gas: bigint;
                nonce: number;
                value: bigint;
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                hash: viem.Hash;
                input: viem.Hex;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                accessList?: undefined | undefined;
                authorizationList?: undefined | undefined;
                blobVersionedHashes?: undefined | undefined;
                chainId?: number | undefined;
                yParity?: undefined | undefined;
                type: "legacy";
                gasPrice: bigint;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas?: undefined | undefined;
                maxPriorityFeePerGas?: undefined | undefined;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            } | {
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                accessList: viem.AccessList;
                authorizationList?: undefined | undefined;
                blobVersionedHashes?: undefined | undefined;
                chainId: number;
                type: "eip2930";
                gasPrice: bigint;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas?: undefined | undefined;
                maxPriorityFeePerGas?: undefined | undefined;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            } | {
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                accessList: viem.AccessList;
                authorizationList?: undefined | undefined;
                blobVersionedHashes?: undefined | undefined;
                chainId: number;
                type: "eip1559";
                gasPrice?: undefined | undefined;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            } | {
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                accessList: viem.AccessList;
                authorizationList?: undefined | undefined;
                blobVersionedHashes: readonly viem.Hex[];
                chainId: number;
                type: "eip4844";
                gasPrice?: undefined | undefined;
                maxFeePerBlobGas: bigint;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            } | {
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                accessList: viem.AccessList;
                authorizationList: viem.SignedAuthorizationList;
                blobVersionedHashes?: undefined | undefined;
                chainId: number;
                type: "eip7702";
                gasPrice?: undefined | undefined;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            }) & {};
            type: "transaction";
        };
        readonly transactionReceipt: {
            exclude: [] | undefined;
            format: (args: viem_chains.OpStackRpcTransactionReceipt, action?: string | undefined) => {
                blobGasPrice?: bigint | undefined;
                blobGasUsed?: bigint | undefined;
                blockHash: viem.Hash;
                blockNumber: bigint;
                blockTimestamp?: bigint | undefined;
                contractAddress: viem.Address | null | undefined;
                cumulativeGasUsed: bigint;
                effectiveGasPrice: bigint;
                from: viem.Address;
                gasUsed: bigint;
                logs: viem.Log<bigint, number, false>[];
                logsBloom: viem.Hex;
                root?: `0x${string}` | undefined;
                status: "success" | "reverted";
                to: viem.Address | null;
                transactionHash: viem.Hash;
                transactionIndex: number;
                type: viem.TransactionType;
                l1GasPrice: bigint | null;
                l1GasUsed: bigint | null;
                l1Fee: bigint | null;
                l1FeeScalar: number | null;
            } & {};
            type: "transactionReceipt";
        };
    };
    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
    }] | undefined;
    serializers: {
        readonly transaction: typeof viem_chains.serializeTransactionOpStack;
    };
    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
    readonly network: "base-sepolia";
} | {
    blockExplorers: {
        readonly default: {
            readonly name: "Etherscan";
            readonly url: "https://sepolia.lineascan.build";
            readonly apiUrl: "https://api-sepolia.lineascan.build/api";
        };
    };
    blockTime?: number | undefined | undefined;
    contracts: {
        readonly multicall3: {
            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
            readonly blockCreated: 227427;
        };
        readonly ensRegistry: {
            readonly address: "0x5B2636F0f2137B4aE722C01dd5122D7d3e9541f7";
            readonly blockCreated: 2395094;
        };
        readonly ensUniversalResolver: {
            readonly address: "0x4D41762915F83c76EcaF6776d9b08076aA32b492";
            readonly blockCreated: 17168484;
        };
    };
    ensTlds: readonly [".linea.eth"];
    id: 59141;
    name: "Linea Sepolia Testnet";
    nativeCurrency: {
        readonly name: "Linea Ether";
        readonly symbol: "ETH";
        readonly decimals: 18;
    };
    experimental_preconfirmationTime?: number | undefined | undefined;
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://rpc.sepolia.linea.build"];
            readonly webSocket: readonly ["wss://rpc.sepolia.linea.build"];
        };
    };
    sourceId?: number | undefined | undefined;
    testnet: true;
    custom?: Record<string, unknown> | undefined;
    extendSchema?: Record<string, unknown> | undefined;
    fees: {
        readonly estimateFeesPerGas: ({ client, multiply, request, type, }: Parameters<viem.ChainEstimateFeesPerGasFn>[0]) => ReturnType<viem.ChainEstimateFeesPerGasFn>;
        readonly maxPriorityFeePerGas: ({ block, client, request }: viem.ChainFeesFnParameters<viem.ChainFormatters | undefined>) => Promise<bigint | null>;
    };
    formatters?: undefined;
    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
    }] | undefined;
    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
} | {
    blockExplorers: {
        readonly default: {
            readonly name: "Blockscout";
            readonly url: "https://optimism-sepolia.blockscout.com";
            readonly apiUrl: "https://optimism-sepolia.blockscout.com/api";
        };
    };
    blockTime: 2000;
    contracts: {
        readonly disputeGameFactory: {
            readonly 11155111: {
                readonly address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1";
            };
        };
        readonly l2OutputOracle: {
            readonly 11155111: {
                readonly address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F";
            };
        };
        readonly multicall3: {
            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
            readonly blockCreated: 1620204;
        };
        readonly portal: {
            readonly 11155111: {
                readonly address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC";
            };
        };
        readonly l1StandardBridge: {
            readonly 11155111: {
                readonly address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1";
            };
        };
        readonly gasPriceOracle: {
            readonly address: "0x420000000000000000000000000000000000000F";
        };
        readonly l1Block: {
            readonly address: "0x4200000000000000000000000000000000000015";
        };
        readonly l2CrossDomainMessenger: {
            readonly address: "0x4200000000000000000000000000000000000007";
        };
        readonly l2Erc721Bridge: {
            readonly address: "0x4200000000000000000000000000000000000014";
        };
        readonly l2StandardBridge: {
            readonly address: "0x4200000000000000000000000000000000000010";
        };
        readonly l2ToL1MessagePasser: {
            readonly address: "0x4200000000000000000000000000000000000016";
        };
    };
    ensTlds?: readonly string[] | undefined;
    id: 11155420;
    name: "OP Sepolia";
    nativeCurrency: {
        readonly name: "Sepolia Ether";
        readonly symbol: "ETH";
        readonly decimals: 18;
    };
    experimental_preconfirmationTime?: number | undefined | undefined;
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://sepolia.optimism.io"];
        };
    };
    sourceId: 11155111;
    testnet: true;
    custom?: Record<string, unknown> | undefined;
    extendSchema?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters: {
        readonly block: {
            exclude: [] | undefined;
            format: (args: viem_chains.OpStackRpcBlock, action?: string | undefined) => {
                baseFeePerGas: bigint | null;
                blobGasUsed: bigint;
                difficulty: bigint;
                excessBlobGas: bigint;
                extraData: viem.Hex;
                gasLimit: bigint;
                gasUsed: bigint;
                hash: `0x${string}` | null;
                logsBloom: `0x${string}` | null;
                miner: viem.Address;
                mixHash: viem.Hash;
                nonce: `0x${string}` | null;
                number: bigint | null;
                parentBeaconBlockRoot?: `0x${string}` | undefined;
                parentHash: viem.Hash;
                receiptsRoot: viem.Hex;
                sealFields: viem.Hex[];
                sha3Uncles: viem.Hash;
                size: bigint;
                stateRoot: viem.Hash;
                timestamp: bigint;
                totalDifficulty: bigint | null;
                transactions: `0x${string}`[] | viem_chains.OpStackTransaction<boolean>[];
                transactionsRoot: viem.Hash;
                uncles: viem.Hash[];
                withdrawals?: viem.Withdrawal[] | undefined | undefined;
                withdrawalsRoot?: `0x${string}` | undefined;
            } & {};
            type: "block";
        };
        readonly transaction: {
            exclude: [] | undefined;
            format: (args: viem_chains.OpStackRpcTransaction, action?: string | undefined) => ({
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                gasPrice?: undefined | undefined;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                isSystemTx?: boolean;
                mint?: bigint | undefined | undefined;
                sourceHash: viem.Hex;
                type: "deposit";
            } | {
                r: viem.Hex;
                s: viem.Hex;
                v: bigint;
                to: viem.Address | null;
                from: viem.Address;
                gas: bigint;
                nonce: number;
                value: bigint;
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                hash: viem.Hash;
                input: viem.Hex;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                accessList?: undefined | undefined;
                authorizationList?: undefined | undefined;
                blobVersionedHashes?: undefined | undefined;
                chainId?: number | undefined;
                yParity?: undefined | undefined;
                type: "legacy";
                gasPrice: bigint;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas?: undefined | undefined;
                maxPriorityFeePerGas?: undefined | undefined;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            } | {
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                accessList: viem.AccessList;
                authorizationList?: undefined | undefined;
                blobVersionedHashes?: undefined | undefined;
                chainId: number;
                type: "eip2930";
                gasPrice: bigint;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas?: undefined | undefined;
                maxPriorityFeePerGas?: undefined | undefined;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            } | {
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                accessList: viem.AccessList;
                authorizationList?: undefined | undefined;
                blobVersionedHashes?: undefined | undefined;
                chainId: number;
                type: "eip1559";
                gasPrice?: undefined | undefined;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            } | {
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                accessList: viem.AccessList;
                authorizationList?: undefined | undefined;
                blobVersionedHashes: readonly viem.Hex[];
                chainId: number;
                type: "eip4844";
                gasPrice?: undefined | undefined;
                maxFeePerBlobGas: bigint;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            } | {
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                blockTimestamp?: bigint | undefined;
                from: viem.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: viem.Address | null;
                transactionIndex: number | null;
                typeHex: viem.Hex | null;
                v: bigint;
                value: bigint;
                yParity: number;
                accessList: viem.AccessList;
                authorizationList: viem.SignedAuthorizationList;
                blobVersionedHashes?: undefined | undefined;
                chainId: number;
                type: "eip7702";
                gasPrice?: undefined | undefined;
                maxFeePerBlobGas?: undefined | undefined;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                isSystemTx?: undefined | undefined;
                mint?: undefined | undefined;
                sourceHash?: undefined | undefined;
            }) & {};
            type: "transaction";
        };
        readonly transactionReceipt: {
            exclude: [] | undefined;
            format: (args: viem_chains.OpStackRpcTransactionReceipt, action?: string | undefined) => {
                blobGasPrice?: bigint | undefined;
                blobGasUsed?: bigint | undefined;
                blockHash: viem.Hash;
                blockNumber: bigint;
                blockTimestamp?: bigint | undefined;
                contractAddress: viem.Address | null | undefined;
                cumulativeGasUsed: bigint;
                effectiveGasPrice: bigint;
                from: viem.Address;
                gasUsed: bigint;
                logs: viem.Log<bigint, number, false>[];
                logsBloom: viem.Hex;
                root?: `0x${string}` | undefined;
                status: "success" | "reverted";
                to: viem.Address | null;
                transactionHash: viem.Hash;
                transactionIndex: number;
                type: viem.TransactionType;
                l1GasPrice: bigint | null;
                l1GasUsed: bigint | null;
                l1Fee: bigint | null;
                l1FeeScalar: number | null;
            } & {};
            type: "transactionReceipt";
        };
    };
    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
    }] | undefined;
    serializers: {
        readonly transaction: typeof viem_chains.serializeTransactionOpStack;
    };
    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
} | {
    blockExplorers: {
        readonly default: {
            readonly name: "Arbiscan";
            readonly url: "https://sepolia.arbiscan.io";
            readonly apiUrl: "https://api-sepolia.arbiscan.io/api";
        };
    };
    blockTime: 250;
    contracts: {
        readonly multicall3: {
            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
            readonly blockCreated: 81930;
        };
    };
    ensTlds?: readonly string[] | undefined;
    id: 421614;
    name: "Arbitrum Sepolia";
    nativeCurrency: {
        readonly name: "Arbitrum Sepolia Ether";
        readonly symbol: "ETH";
        readonly decimals: 18;
    };
    experimental_preconfirmationTime?: number | undefined | undefined;
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://sepolia-rollup.arbitrum.io/rpc"];
        };
    };
    sourceId?: number | undefined | undefined;
    testnet: true;
    custom?: Record<string, unknown> | undefined;
    extendSchema?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters?: undefined;
    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
    }] | undefined;
    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
} | {
    blockExplorers: {
        readonly default: {
            readonly name: "Scrollscan";
            readonly url: "https://sepolia.scrollscan.com";
            readonly apiUrl: "https://api-sepolia.scrollscan.com/api";
        };
    };
    blockTime?: number | undefined | undefined;
    contracts: {
        readonly multicall3: {
            readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
            readonly blockCreated: 9473;
        };
    };
    ensTlds?: readonly string[] | undefined;
    id: 534351;
    name: "Scroll Sepolia";
    nativeCurrency: {
        readonly name: "Ether";
        readonly symbol: "ETH";
        readonly decimals: 18;
    };
    experimental_preconfirmationTime?: number | undefined | undefined;
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://sepolia-rpc.scroll.io"];
        };
    };
    sourceId?: number | undefined | undefined;
    testnet: true;
    custom?: Record<string, unknown> | undefined;
    extendSchema?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters?: undefined;
    prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
    }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
    }] | undefined;
    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
    verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
})[];
/**
 * Returns a prettified chain name for the provided chain id.
 */
declare function getChainName(chainId: ChainId): string;

/**
 * Get the ENS Manager App URL for the provided namespace.
 *
 * @param {ENSNamespaceId} namespaceId - ENS Namespace identifier
 * @returns ENS Manager App URL for the provided namespace, or null if the provided namespace
 * doesn't have a known ENS Manager App
 */
declare function getEnsManagerUrl(namespaceId: ENSNamespaceId): URL | null;
/**
 * Builds the URL of the external ENS Manager App Profile page for a given name and ENS Namespace.
 *
 * @returns URL to the Profile page in the external ENS Manager App for a given name and ENS Namespace,
 * or null if this URL is not known
 */
declare function getEnsManagerNameDetailsUrl(name: Name, namespaceId: ENSNamespaceId): URL | null;
/**
 * Get the URL of the address details page in ENS Manager App for a given address and ENS Namespace.
 *
 * @returns URL to the address details page in the ENS Manager App for a given address and ENS
 * Namespace, or null if this URL is not known
 */
declare function getEnsManagerAddressDetailsUrl(address: Address, namespaceId: ENSNamespaceId): URL | null;

export { ASSUME_IMMUTABLE_QUERY, AbsoluteTime, AddressDisplay, ChainExplorerIcon, ChainIcon, type ChainIconProps, ChainName, type ChainNameProps, CopyButton, type CopyButtonProps, DISABLED_QUERY, DisplayDuration, DisplayIdentity, EfpIcon, EmailIcon, EnsAvatar, EnsIcon, EnsNodeContext, EnsNodeProvider, type EnsNodeProviderOptions, type EnsNodeProviderProps, EnsServiceProviderIcon, FarcasterIcon, Footer, GitHubIcon, IdentityLink, type IdentityLinkDetails, IdentityTooltip, type IdentityTooltipProps, InfoIcon, LabeledField, NameDisplay, type QueryParameter, type ReferrerLinkData, RegistrarActionCard, RegistrarActionCardLoading, type RegistrarActionCardLoadingProps, RegistrarActionCardMemo, type RegistrarActionCardProps, RelativeTime, ResolveAndDisplayIdentity, type ResolveAndDisplayIdentityProps, SUPPORTED_CHAINS, TelegramIcon, TwitterIcon, type UsePrimaryNameParameters, type UsePrimaryNamesParameters, type UseRecordsParameters, type UseResolvedIdentityParameters, type WithEnsNodeProviderOptions, createEnsNodeProviderOptions, createIndexingStatusQueryOptions, createNameTokensQueryOptions, createPrimaryNameQueryOptions, createPrimaryNamesQueryOptions, createRecordsQueryOptions, createRegistrarActionsQueryOptions, formatRelativeTime, getBlockExplorerAddressDetailsUrl, getBlockExplorerBlockUrl, getBlockExplorerTransactionDetailsUrl, getBlockExplorerUrl, getChainName, getEnsManagerAddressDetailsUrl, getEnsManagerNameDetailsUrl, getEnsManagerUrl, queryKeys, useEnsNodeProviderOptions, useIndexingStatus, useIsMobile, useNameTokens, useNow, usePrimaryName, usePrimaryNames, useRecords, useRegistrarActions, useResolvedIdentity, useSwrQuery };