import * as react from 'react';
import react__default, { RefObject, ReactNode, Dispatch, SetStateAction, HTMLAttributes, ReactElement } from 'react';
import * as viem from 'viem';
import { Address as Address$1, Abi, Hex as Hex$1 } from 'viem';
import * as _tanstack_react_query from '@tanstack/react-query';
import { FetchNextPageOptions, InfiniteQueryObserverResult, InfiniteData } from '@tanstack/react-query';
import * as abitype from 'abitype';
import * as viem_chains from 'viem/chains';
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as _tanstack_query_core from '@tanstack/query-core';

interface SignInWithEthereumProps {
    getNonce: () => Promise<string> | string;
    verifySignature: (message: string, nonce: string, signature: string) => Promise<void> | void;
    onSignInSuccess: (data: {
        address: string;
        message: string;
        signature: string;
    }) => void;
    onSignInError: (error: Error) => void;
    onDisconnectedClick?: (callback: () => void) => void;
    message: string;
    darkMode?: boolean;
    expirationTime?: number;
    autoSignInAfterConnection?: boolean;
}
interface SignInButtonProps extends SignInWithEthereumProps {
    onSignedInClick?: () => void;
    isSignedIn?: boolean;
    isDropdown?: boolean;
    isDropdownOpen?: boolean;
    hideName?: boolean;
    hideAvatar?: boolean;
    hideHeader?: boolean;
}

declare const useSiwe: ({ verifySignature, onSignInSuccess, onSignInError, message, getNonce, expirationTime, }: SignInWithEthereumProps) => {
    handleSignIn: () => Promise<void>;
    isSigningMessage: boolean;
    connectedAddress: `0x${string}` | undefined;
};

/**
 * useChain hook - keeps track of the current chain id and switching between chains
 *
 * @returns the current chain id and a function to switch chains
 */
declare const useChain: () => {
    getChain: (chainId: number | undefined) => viem.Chain | undefined;
    checkChain: ({ chainId, onSuccess, onError }: {
        chainId?: number;
        onSuccess?: () => void;
        onError?: () => void;
    }) => Promise<boolean>;
    currentChainId: number;
    setCurrentChainId: react.Dispatch<react.SetStateAction<number>>;
};

type Address = `0x${string}`;
type Hex = `0x${string}`;

/**
 * Profile list identifier type
 * Can be a number (list ID), string (ENS name), or null/undefined for no list
 */
type ProfileListType = number | string | null | undefined;
/**
 * ENS profile data structure containing all profile information
 */
type ENSProfile = {
    /** ENS name (e.g., "vitalik.eth") */
    name?: string;
    /** Avatar image URL or NFT reference */
    avatar?: string;
    /** Display name for the profile */
    display?: string;
    /** Header/banner image URL */
    header?: string;
    /** IPFS content hash for decentralized content */
    contenthash?: string;
    /** Key-value pairs of ENS text records */
    records?: Record<string, string>;
    /** Cross-chain address mappings */
    chains?: Record<string, string>;
    /** Timestamp of last data refresh */
    fresh?: number;
    /** ENS resolver contract address */
    resolver?: string;
    /** Any errors encountered during profile resolution */
    errors?: Record<string, string>;
};
type ENSMetadataProfile = {
    uri: string;
    is_owner: boolean;
    full_image: string;
    full_svg: string;
    svg: string;
    host_meta: {
        chain_id: string | number;
        namespace: string;
        contract_address: string;
        token_id: string | number;
        reference_url: string;
    };
    name: string;
    description: string;
    attribute: string;
    image: string;
    image_url: string;
    image_data: string;
    background_color: string;
    youtube_url: string;
};
type LeaderboardItem = {
    address: Address;
    name: string | null;
    avatar: string | null;
    mutuals_rank: string;
    followers_rank: string;
    following_rank: string;
    top8_rank: string;
    blocks_rank: string;
    top8?: string;
    following?: string;
    followers: string;
    blocks?: string;
    mutuals?: string;
};
type StatsResponse = {
    followers_count: number;
    following_count: number;
};
type ProfileRanks = {
    mutuals_rank: number;
    followers_rank: number;
    following_rank: number;
    blocks_rank: number;
    top8_rank: number;
};
type ProfileDetailsResponse = {
    address: Address;
    ens: ENSProfile;
    primary_list?: string | null;
    ranks: ProfileRanks;
};
type ProfileAccountResponse = {
    address: Address;
    ens: ENSProfile;
    primary_list?: string | null;
};
interface ProfileBadgesResponse {
    eventId: string;
    participated: boolean;
    collection: ProfileBadgeColletionType | null;
}
interface ProfileBadgeColletionType {
    event: {
        id: number;
        fancy_id: string;
        name: string;
        event_url: string;
        image_url: string;
        country: string;
        city: string;
        description: string;
        year: number;
        start_date: string;
        end_date: string;
        expiry_date: string;
    };
    tokenId: string;
    owner: string;
}
interface ProfileDetailsWithStats extends ProfileDetailsResponse {
    stats: StatsResponse;
}
interface ProfileListsResponse {
    primary_list?: string | null;
    lists?: string[];
}
type ProfileRoles = {
    isOwner: boolean;
    isManager: boolean;
    isUser: boolean;
    listChainId: number;
    listRecordsContract: Address;
    listSlot: bigint;
};
type AccountResponseType = {
    address: Address;
    ens?: {
        name: string | null;
        avatar: string | null;
        records: Record<string, string>;
    };
    primary_list?: string | null;
};
type ProfileStatType = 'followers' | 'following';
type ProfileStatsClickProps = {
    addressOrName: Address | string;
    stat: ProfileStatType;
};
type RecommendedItemType = {
    address: Address;
    name?: string;
    avatar?: string;
    header?: string;
};
type DiscoverResponseType = {
    latestFollows: RecommendedItemType[];
    recommended: RecommendedItemType[];
};
type FollowerYouKnow = {
    address: Address;
    name: string | null;
    avatar: string | null;
    mutuals_rank: string;
    header: string | null;
};
interface FollowersYouKnowResponse {
    results: FollowerYouKnow[];
    length: number;
}
interface ProfileEFPPoapResponse {
    eventId: string;
    participated: boolean;
    collection: ProfileEFPPoapColletionType | null;
}
interface ProfileEFPPoapColletionType {
    event: {
        id: number;
        fancy_id: string;
        name: string;
        event_url: string;
        image_url: string;
        country: string;
        city: string;
        description: string;
        year: number;
        start_date: string;
        end_date: string;
        expiry_date: string;
    };
    tokenId: string;
    owner: string;
}
type NotificationItemType = {
    address: Address;
    name: string | null;
    avatar: string | null;
    token_id: number;
    action: string;
    opcode: number;
    op: Address;
    tag: string;
    updated_at: string;
};
type NotificationsResponse = {
    summary: {
        interval: string;
        opcode: string;
        total: number;
        total_follows: number;
        total_unfollows: number;
        total_tags: number;
        total_untags: number;
    };
    notifications: NotificationItemType[];
};
type ProfileTabType = 'following' | 'followers';
type BlockedMutedTabType = 'Blocked/Muted' | 'Blocked/Muted By';
type ProfileTableTitleType = ProfileTabType | BlockedMutedTabType;
type FollowSortType = 'latest first' | 'earliest first' | 'follower count';
interface FollowerResponse {
    address: Address;
    tags: string[];
    is_muted: boolean;
    is_blocked: boolean;
    is_following: boolean;
}
interface FollowingResponse {
    version: 1;
    record_type: 'address' & string;
    address: Address;
    tags: string[];
    ens?: ENSProfile;
}
type TagCountType = {
    tag: string;
    count: number;
};
interface InfiniteProfileQueryProps {
    addressOrName: string;
    list?: number | string;
    limit: number;
    tags?: string[];
    sort?: FollowSortType;
    pageParam: number;
    allResults?: boolean;
    search?: string;
    fresh?: boolean;
}
interface FollowingTagsResponse {
    token_id: string | number;
    tags: string[];
    tagCounts: TagCountType[];
    taggedAddresses: {
        address: Address;
        tag: string;
    }[];
}
type ProfileEFPSocialType = 'etherscan' | 'com.twitter' | 'com.github' | 'org.telegram' | 'com.discord' | 'etherscan' | 'grails' | 'opensea' | 'vision' | 'website' | 'email' | 'ens';

/**
 * Follow state indicating the relationship between two addresses
 */
type FollowState = 'follows' | 'blocks' | 'mutes' | 'none';
/**
 * Type of follow state being queried
 */
type FollowStatePropType = 'following' | 'follower';
interface FollowStateProps {
    lookupAddressOrName: Address | string;
    connectedAddress?: Address;
    list?: ProfileListType;
    type: FollowStatePropType;
    fresh?: boolean;
}
interface BatchFollowStateProps {
    lookupAddressesOrNames: (Address | string)[];
    list?: ProfileListType;
    fresh?: boolean;
}
type BatchFollowStateResponse = {
    token_id?: string;
    address?: Address;
    state: FollowStateResponse;
}[];
type FollowStateResponse = {
    follow: boolean;
    block: boolean;
    mute: boolean;
};
interface FollowStatusResponse {
    token_id?: string;
    address?: Address;
    state: FollowStateResponse;
}
type ForceFollowingState = {
    state: FollowStateResponse;
    isLoading: boolean;
};
/**
 * Following state for UI display and interaction
 * Includes both current states and pending/loading states
 */
type FollowingState = 'Block' | 'Blocked' | 'Follow' | 'Pending Following' | 'Following' | 'Unfollow' | 'Mute' | 'Muted' | 'Pending Block' | 'Pending Mute' | 'Unblock' | 'Unmute' | 'Block Back' | 'Mute Back';
/**
 * Initial following state when component mounts
 */
type InitialFollowingState = 'Follow' | 'Blocked' | 'Muted' | 'Following';

/**
 * Return type for useFollowingState hook
 */
interface UseFollowingStateReturn {
    /** Current follow state */
    state: FollowState;
    /** Whether the follow state is loading */
    isLoading: boolean;
}
/**
 * Return type for useUserInfo hook
 */
interface UseUserInfoReturn {
    /** The list number for the user */
    listNum: number | undefined;
    /** Array of followers */
    followers: FollowerResponse[];
    /** Array of following */
    following: FollowingResponse[];
    /** Follower tag counts */
    followerTags: FollowingTagsResponse | undefined;
    /** Following tag counts */
    followingTags: FollowingTagsResponse | undefined;
    /** Whether the user is a list */
    userIsList: boolean;
    /** Whether followers are loading */
    followersIsLoading: boolean;
    /** Whether following are loading */
    followingIsLoading: boolean;
    /** Whether follower tags are loading */
    followerTagsLoading: boolean;
    /** Whether following tags are loading */
    followingTagsLoading: boolean;
    /** Function to fetch more followers */
    fetchMoreFollowers: (options?: FetchNextPageOptions | undefined) => Promise<InfiniteQueryObserverResult<InfiniteData<{
        followers: FollowerResponse[];
        nextPageParam: number;
    }, unknown>, Error>>;
    /** Function to fetch more following */
    fetchMoreFollowing: (options?: FetchNextPageOptions | undefined) => Promise<InfiniteQueryObserverResult<InfiniteData<{
        following: FollowingResponse[];
        nextPageParam: number;
    }, unknown>, Error>>;
    /** Whether we've reached the end of following */
    isEndOfFollowing: boolean;
    /** Whether we've reached the end of followers */
    isEndOfFollowers: boolean;
    /** Whether we're fetching more followers */
    isFetchingMoreFollowers: boolean;
    /** Whether we're fetching more following */
    isFetchingMoreFollowing: boolean;
    /** Current following tags filter */
    followingTagsFilter: string[];
    /** Current followers tags filter */
    followersTagsFilter: string[];
    /** Current following search term */
    followingSearch: string;
    /** Current followers search term */
    followersSearch: string;
    /** Function to set followers search */
    setFollowersSearch: (search: string) => void;
    /** Function to set following search */
    setFollowingSearch: (search: string) => void;
    /** Current following sort */
    followingSort: FollowSortType;
    /** Function to set following sort */
    setFollowingSort: (sort: FollowSortType) => void;
    /** Current followers sort */
    followersSort: FollowSortType;
    /** Function to toggle tag filter */
    toggleTag: (tab: ProfileTableTitleType, tag: string) => void;
    /** Function to set followers sort */
    setFollowersSort: (sort: FollowSortType) => void;
    /** Function to set followers tags filter */
    setFollowersTagsFilter: (filter: string[]) => void;
    /** Function to set following tags filter */
    setFollowingTagsFilter: (filter: string[]) => void;
}
/**
 * Return type for useFollowButton hook
 */
interface UseFollowButtonReturn {
    /** Current follow button text */
    buttonText: string;
    /** Whether the follow button is disabled */
    disableHover: boolean;
    /** Function to set disable hover */
    setDisableHover: (disableHover: boolean) => void;
    /** Current follow button state */
    buttonState: FollowingState;
    /** Pending state of the follow action */
    pendingState: false | 'Pending Following' | 'Unfollow' | 'Pending Block' | 'Pending Mute' | 'Unblock' | 'Unmute' | undefined;
    /** Whether the follow action is loading */
    isLoading: boolean;
    /** Function to handle follow/unfollow */
    handleAction: () => void;
    /** Whether the button should be disabled */
    isDisabled: boolean;
    /** Current error state */
    error: Error | null;
    /** Function to clear error state */
    clearError: () => void;
    /** Accessibility label for screen readers */
    ariaLabel: string;
    /** Whether the button is in pressed state (for following) */
    ariaPressed: boolean;
}
/**
 * Return type for useProfileDetails hook
 */
interface UseProfileDetailsReturn {
    /** Profile details data */
    ens: ENSProfile | undefined;
    ranks: ProfileRanks | undefined;
    address: Address | undefined;
    primaryList: ProfileListType | undefined;
    detailsLoading: boolean;
    refreshProfileDetails: () => void;
}

type UseUserInfoProps = {
    user: string;
    showBlocked?: boolean;
    showOnlyBlocked?: boolean;
};
declare const useUserInfo: ({ user, showBlocked, showOnlyBlocked, }: UseUserInfoProps) => UseUserInfoReturn;

interface SiweMessageParams {
    domain: string;
    address: string;
    statement?: string;
    uri: string;
    version: string;
    chainId: number;
    nonce: string;
    issuedAt: string;
    expirationTime?: string;
    notBefore?: string;
    requestId?: string;
    resources?: string[];
    scheme?: string;
}

type SizeType = 'xs' | 'sm' | 'md' | 'lg' | 'xl';

type EFPActionType = 'CreateEFPList' | 'UpdateEFPList' | 'SetEFPListSettings' | 'UpdateENSProfile';
/**
 * Represents a blockchain transaction for EFP operations
 */
type TransactionType = {
    /** Human-readable title for the transaction */
    title?: string;
    /** Detailed description of what the transaction does */
    description?: string;
    /** Unique identifier for the transaction type */
    id: EFPActionType | string;
    /** Contract address to interact with */
    address: Address$1;
    /** Blockchain chain ID (optional, uses default if not provided) */
    chainId?: number;
    /** Contract ABI for the transaction */
    abi: Abi;
    /** Name of the contract function to call */
    functionName: string;
    /** Arguments to pass to the contract function */
    args: any[];
    /** Transaction hash after execution (populated after submission) */
    hash?: Hex$1;
};
type SubmitButtonText = 'switchChain' | 'initiate' | 'pending' | 'reInitiate' | 'indexing' | 'finish' | 'next';
type OpCodeType = 1 | 2 | 3 | 4;
type ListOpType = {
    version?: number;
    opcode: OpCodeType;
    data: Hex$1;
};
type GetListOpsTransactionProps = {
    nonce?: bigint;
    chainId?: number;
    listOps: ListOpType[];
    connectedAddress: Address$1;
    isMintingNewList?: boolean;
};

type TranslationKey = 'connect' | 'disconnect' | 'follow' | 'unfollow' | 'following' | 'followers' | 'loading' | 'error' | 'success' | 'mute' | 'unmute' | 'block' | 'unblock' | 'save' | 'cancel' | 'confirm' | 'close' | 'viewAll' | 'noData' | 'retry' | 'lists' | 'blocked' | 'muted' | 'block back' | 'mute back' | 'following.title' | 'following.empty' | 'following.empty.connectedUser' | 'followers.title' | 'followers.empty' | 'blocked.title' | 'blocking.title' | 'blocked.empty' | 'blocking.empty' | 'blocking.empty.connectedUser' | 'recommendations.title' | 'recommendations.empty' | 'recommendations.connectedUser' | 'signInWithEthereum' | 'signingMessage' | 'signIn' | 'singingIn' | 'notifications.empty' | 'notifications.error' | 'notifications.follow' | 'notifications.unfollow' | 'notifications.tag' | 'notifications.untag' | 'notifications.block' | 'notifications.unblock' | 'notifications.mute' | 'notifications.unmute' | 'and' | 'others' | 'other' | 'search placeholder' | 'no tags' | 'followersYouKnow.title' | 'followersYouKnow.viewAll' | 'followersYouKnow.noCommon' | 'followersYouKnow.followsThem' | 'followersYouKnow.followThem' | 'followersYouKnow.oneOtherFollows' | 'followersYouKnow.othersFollow' | 'followersYouKnow.and' | 'latest first' | 'earliest first' | 'follower count' | 'transaction.switchChain' | 'transaction.initiate' | 'transaction.pending' | 'transaction.reInitiate' | 'transaction.indexing' | 'transaction.finish' | 'transaction.next' | 'transaction.selectChain' | 'transaction.selectChainDescription' | 'transaction.selectChainLater' | 'transaction.updateListSettings' | 'listSettings.owner' | 'listSettings.manager' | 'listSettings.user' | 'listSettings.listStorageLocation' | 'listSettings.setPrimaryList' | 'listSettings.resetList' | 'transaction.onchainUpdate' | 'transaction.claimPOAPTitle' | 'transaction.claimPOAPDescription' | 'transaction.claimPOAP' | 'transaction.noThanks' | 'followerState.blocksYou' | 'followerState.mutesYou' | 'followerState.followsYou' | 'modal.cancelTransactions.title' | 'modal.cancelTransactions.description' | 'modal.cancelTransactions.confirm' | 'cart.clearCart' | 'cart.clearCart.description' | 'cart.clearCart' | 'goBack' | 'notifications.title' | 'profile.editProfile' | 'profile.noUser' | 'profile.noBio' | 'profile.showMore' | 'profile.showLess' | 'profile.notConfirmedByUser' | 'profile.notConfirmedByUserDescription' | 'recommended.empty' | 'recommended.title' | 'cart.title' | 'cart.changes' | 'cart.clearCart' | 'cart.noItems' | 'cart.action' | 'cart.actions' | 'cart.transaction' | 'cart.transactions' | 'backToTop' | 'summary.title' | 'summary.txn' | 'summary.txns' | 'summary.on' | 'summary.changeChain' | 'summary.insufficientEth' | 'manualAdd.add' | 'manualAdd.alreadyInCart' | 'manualAdd.alreadyFollowing' | 'manualAdd.accountNotFound';
type TranslationFunction = (key: TranslationKey, fallback?: string) => string;
type LanguageCode = string;
type TranslationObject = Partial<Record<TranslationKey, string>>;
type TranslationsMap = Record<LanguageCode, TranslationObject>;
interface TranslationConfig {
    translateFn?: TranslationFunction;
    translations?: TranslationsMap;
    translationsFromJSON?: TranslationsMap;
    activeLanguage?: LanguageCode;
    fallbackLanguage?: LanguageCode;
}

interface GrailsAPIResponse<T> {
    success?: boolean;
    data?: T | null;
    meta?: {
        timestamp?: string;
        version?: string;
    };
}
type GrailsProfileResponse = GrailsAPIResponse<{
    lastSeenAt?: string | null;
    lastSeenOnchain?: string | null;
    stats?: {
        totalNames?: number;
    };
    ownedNames?: Array<Record<string, unknown>>;
}>;
type ENSNameMetadataValue = string | number | boolean | null | undefined | {
    protocol?: string;
    value?: string;
} | {
    chainName: string;
    address: string;
}[];
type ENSNameMetadataResponse = Record<string, ENSNameMetadataValue>;
type GrailsNameMetadataResponse = GrailsAPIResponse<{
    metadata: ENSNameMetadataResponse;
}>;
type RolesType = {
    name: string;
    owner: Address;
    manager: Address;
    ethAddress: Address;
    isWrapped: boolean;
    fuses: null | number;
    expiryDate: number;
    resolver: Address;
};
type GrailsRolesResponse = GrailsAPIResponse<RolesType>;

interface UseEFPPoapsProps {
    addressOrName?: Address | string | null;
    list?: number | null;
}
declare const useEFPPoaps: ({ addressOrName, list }: UseEFPPoapsProps) => {
    ownedBadges: ProfileEFPPoapResponse[];
    isLoading: boolean;
};

declare const useIsClient: () => boolean;

declare const useRecommended: (connectedAddress: Address$1, endpoint: "recommended" | "discover", limit: number, list?: string) => {
    recommended: {
        ens: {
            name: string | undefined;
            avatar: string | undefined;
            records: {
                header: string;
            } | undefined;
        };
        tags: never[];
        address: Address;
        name?: string;
        avatar?: string;
        header?: string;
    }[] | undefined;
    isLoading: boolean;
    isRefetching: boolean;
    fetchMoreRef: (element: HTMLElement | null) => void;
    hasNextPage: boolean;
};

declare const useCoolMode: (imageUrl?: string, isLoading?: boolean, disabled?: boolean) => react.RefObject<HTMLButtonElement>;

interface UseFollowerStateProps {
    connectedAddress: Address;
    lookupAddressOrName: Address | string;
    list?: ProfileListType;
}
declare const useFollowerState: ({ connectedAddress, lookupAddressOrName, list }: UseFollowerStateProps) => {
    followState: FollowState;
    followerTag: {
        text: string;
        className: string;
    } | {
        text: string;
        className: string;
    } | {
        text: string;
        className: string;
    } | {
        text: string;
        className: string;
    };
    isFollowerStateLoading: boolean;
};

declare function useWindowSize(): {
    width: number | null;
    height: number | null;
};

interface UseFollowingStateProps {
    lookupAddressOrName: Address | string;
    connectedAddress?: Address;
    list?: ProfileListType;
    initialState?: InitialFollowingState;
    forceState?: ForceFollowingState;
}
declare const useFollowingState: ({ lookupAddressOrName, connectedAddress, list, initialState, forceState, }: UseFollowingStateProps) => UseFollowingStateReturn;

type TooltipPlacement = 'auto' | 'top' | 'bottom';
type FlipBehavior = 'flip' | 'shift' | 'hide';
type Boundary = 'viewport' | 'scrollParent' | HTMLElement;
interface Position {
    top?: number | string;
    bottom?: number | string;
    left?: number | string;
    right?: number | string;
}
interface UseTooltipPositionOptions {
    verticalPlacement?: TooltipPlacement;
    horizontalPlacement?: 'left' | 'right';
    verticalOffset?: number;
    horizontalOffset?: number;
    boundary?: Boundary;
    flipBehavior?: FlipBehavior;
    arrowPadding?: number;
}
interface UseTooltipPositionReturn {
    position: Position;
    actualPlacement: TooltipPlacement;
    arrowPosition: Position;
    updatePosition: () => void;
    isColliding: boolean;
}
declare const useTooltipPosition: (triggerRef: RefObject<HTMLElement>, tooltipRef: RefObject<HTMLElement>, options?: UseTooltipPositionOptions) => UseTooltipPositionReturn;

declare const useTransactionItem: (id: number, transaction: TransactionType) => {
    isActive: boolean;
    poapLink: string;
    claimPOAP: boolean;
    setClaimPOAP: react.Dispatch<react.SetStateAction<boolean>>;
    handleClick: () => void;
    handleCancel: () => void;
    submitButtonText: SubmitButtonText;
    transactionDetails: {
        hash: `0x${string}` | undefined;
        chain: {
            id: number | undefined;
            name: string;
            icon: react.FC<react.SVGProps<SVGSVGElement>> | null;
        };
        gasEth: string;
        gasUsd: string;
    };
    currentTxIndex: number | undefined;
    setCurrentTxIndex: (currentTxIndex: number | undefined) => void;
    usesPaymaster: boolean;
};

interface UseProfileStatsProps {
    addressOrName: Address | string;
    list?: ProfileListType;
    prefetchedData?: StatsResponse | null;
    refetchPrefetchedData?: () => void;
}
declare const useProfileStats: ({ addressOrName, list, prefetchedData, refetchPrefetchedData, }: UseProfileStatsProps) => {
    data: StatsResponse | undefined;
    followers: number | undefined;
    following: number | undefined;
    statsLoading: boolean;
    refreshProfileStats: () => void;
};

declare const useOutsideClick: (callbackFn: () => void) => react.RefObject<HTMLElement>;

interface UseProfileDetailsProps {
    addressOrName: Address | string;
    list?: ProfileListType;
    prefetchedData?: ProfileDetailsResponse;
    refetchPrefetchedData?: () => void;
}
declare const useProfileDetails: ({ addressOrName, list, prefetchedData, refetchPrefetchedData, }: UseProfileDetailsProps) => UseProfileDetailsReturn;

declare const useFollowersAndFollowing: ({ user, defaultTab, showTagsByDefault, isConnectedUserProfile, showBlocked, showOnlyBlocked, }: {
    user: string;
    defaultTab: ProfileTabType;
    showTagsByDefault?: boolean;
    isConnectedUserProfile?: boolean;
    showBlocked?: boolean;
    showOnlyBlocked?: boolean;
}) => {
    activeTab: ProfileTabType;
    showTags: boolean;
    search: string;
    profiles: {
        tags: string[];
        address: `0x${string}`;
    }[];
    loadMoreRef: (element: HTMLElement | null) => void;
    showFollowsYouBadges: boolean;
    profilesEmpty: boolean;
    displayHeaders: boolean;
    isMobile: boolean;
    isFollowingTable: boolean;
    toggleTag: (tab: ProfileTableTitleType, tag: string) => void;
    setShowTags: react.Dispatch<react.SetStateAction<boolean>>;
    setSearch: react.Dispatch<react.SetStateAction<string>>;
    setActiveTab: react.Dispatch<react.SetStateAction<ProfileTabType>>;
    params: {
        profile: FollowingResponse[];
        tags: FollowingTagsResponse | undefined;
        isLoading: boolean;
        results: FollowingResponse[];
        tagsLoading: boolean;
        selectedTags: string[];
        setSelectedTags: (filter: string[]) => void;
        sort: FollowSortType;
        setSort: (sort: FollowSortType) => void;
        tagsFilter: string[];
        setTagsFilter: (filter: string[]) => void;
        isEndOfResults: boolean;
        fetchMore: (options?: _tanstack_query_core.FetchNextPageOptions | undefined) => Promise<_tanstack_query_core.InfiniteQueryObserverResult<_tanstack_query_core.InfiniteData<{
            following: FollowingResponse[];
            nextPageParam: number;
        }, unknown>, Error>>;
        search: string;
        setSearch: (search: string) => void;
        isFetchingMore?: undefined;
    } | {
        profile: FollowerResponse[];
        tags: FollowingTagsResponse | undefined;
        isLoading: boolean;
        results: FollowerResponse[];
        tagsLoading: boolean;
        selectedTags: string[];
        setSelectedTags: (filter: string[]) => void;
        sort: FollowSortType;
        setSort: (sort: FollowSortType) => void;
        tagsFilter: string[];
        setTagsFilter: (filter: string[]) => void;
        isEndOfResults: boolean;
        isFetchingMore: boolean;
        fetchMore: (options?: _tanstack_query_core.FetchNextPageOptions | undefined) => Promise<_tanstack_query_core.InfiniteQueryObserverResult<_tanstack_query_core.InfiniteData<{
            followers: FollowerResponse[];
            nextPageParam: number;
        }, unknown>, Error>>;
        search: string;
        setSearch: (search: string) => void;
    };
};

type ProfileListProps = {
    profiles: ProfileItemType[];
    connectedAddress?: Address;
    selectedList?: ProfileListType;
    isLoading?: boolean;
    loadingRows?: number;
    tags?: string[];
    darkMode?: boolean;
    showTags?: boolean;
    canEditTags?: boolean;
    initialFollowState?: InitialFollowingState;
    onProfileClick?: (address: Address) => void;
    showHeaderImage?: boolean;
    rowHeight?: number;
    visibleCount?: number;
    overscanCount?: number;
    listHeight?: string;
    showFollowsYouBadges?: boolean;
    loadMoreElement?: React.ReactNode;
    useVirtualList?: boolean;
    showBlockBack?: boolean;
    showProfileTooltip?: boolean;
};
type ProfileItemType = {
    address: Address;
    tags: string[];
    ens?: ENSProfile;
    followState?: ForceFollowingState;
};

interface FollowersYouKnowModalProps {
    connectedAddress: Address;
    lookupAddressOrName: Address | string;
}
declare const useFollowersYouKnowModal: ({ connectedAddress, lookupAddressOrName }: FollowersYouKnowModalProps) => {
    isEndOfFollowing: boolean;
    followersYouKnowProfiles: ProfileItemType[];
    fetchMoreFollowersYouKnow: (options?: _tanstack_react_query.FetchNextPageOptions) => Promise<_tanstack_react_query.InfiniteQueryObserverResult<_tanstack_react_query.InfiniteData<{
        followersYouKnow: FollowerYouKnow[];
        nextPageParam: number;
    }, unknown>, Error>>;
    followersYouKnowIsLoading: boolean;
    followersYouKnowSearch: string;
    setFollowersYouKnowSearch: react.Dispatch<react.SetStateAction<string>>;
    loadMoreRef: (element: HTMLElement | null) => void;
};

interface UseFollowButtonParams {
    lookupAddress: Address$1;
    connectedAddress?: Address$1;
    selectedList?: ProfileListType;
    initialState?: InitialFollowingState;
    forceState?: ForceFollowingState;
    showBlockBack?: boolean;
    showMuteBack?: boolean;
}
declare const useFollowButton: ({ lookupAddress, connectedAddress, selectedList, initialState, forceState, showBlockBack, showMuteBack, }: UseFollowButtonParams) => UseFollowButtonReturn;

declare const useFollowersYouKnow: (connectedAddress: Address, lookupAddressOrName: Address | string) => {
    isLoading: boolean;
    displayedAvatars: {
        avatar: string | null;
        address: `0x${string}`;
    }[];
    displayedNames: string[];
    displayedAddresses: `0x${string}`[];
    resultLength: number;
};

declare const fetchAccount: (addressOrName: string, list?: ProfileListType) => Promise<AccountResponseType | null>;

declare const isAddress: (address: string) => boolean;
declare const truncateAddress: (address: Address) => string;

declare const fetchNameRoles: (name: string) => Promise<RolesType | null>;

declare const fetchRecommended: (endpoint: "discover" | "recommended", addressOrName?: string | Address, list?: string | null, limit?: number, pageParam?: number) => Promise<RecommendedItemType[]>;

declare const fetchFollowState: ({ lookupAddressOrName, connectedAddress, list, type, fresh, }: FollowStateProps) => Promise<FollowStatusResponse | null>;

declare const fetchNameMetadata: (name: string) => Promise<ENSNameMetadataResponse>;

declare const fetchProfileLists: (addressOrName: string, fresh?: boolean) => Promise<ProfileListsResponse>;

declare const fetchProfileStats: (addressOrName: string, list?: ProfileListType, isLive?: boolean) => Promise<StatsResponse>;

declare const fetchNotifications: (userAddress?: string, interval?: "hour" | "day" | "week" | "month" | "all") => Promise<NotificationsResponse | null>;

declare const fetchProfileDetails: (addressOrName: string, list?: ProfileListType, fresh?: boolean) => Promise<ProfileDetailsResponse | null>;

declare const fetchProfileEFPPoaps: (addressOrName: Address | string | null, list?: number | null, fresh?: boolean) => Promise<ProfileEFPPoapResponse[]>;

declare const fetchFollowersYouKnow: (connectedAddress: Address$1, lookupAddressOrName: string) => Promise<FollowersYouKnowResponse>;

interface FetchAllFollowersYouKnowProps {
    connectedAddress: Address;
    lookupAddressOrName: Address | string;
    limit?: number;
    search?: string;
    pageParam: number;
}
declare const fetchAllFollowersYouKnow: ({ connectedAddress, lookupAddressOrName, limit, search, pageParam, }: FetchAllFollowersYouKnowProps) => Promise<{
    followersYouKnow: FollowerYouKnow[];
    nextPageParam: number;
}>;

declare const fetchBatchFollowState: ({ lookupAddressesOrNames, list }: BatchFollowStateProps) => Promise<BatchFollowStateResponse | null>;

declare const createSiweMessageString: (params: SiweMessageParams) => string;

declare const defaultOnStatClick: ({ addressOrName, stat }: ProfileStatsClickProps) => void;

declare const loadTranslationsFromJSON: (filePaths: Record<LanguageCode, string>) => Promise<TranslationsMap>;

declare const isLinkValid: (link?: string) => boolean;
declare const isValidEnsName: (name: string) => boolean;
declare const validateEnsHeader: (headerUrl: string | undefined, name: string | null | undefined) => string | undefined;

declare const listOpAddListRecord: (address: Address) => ListOpType;
declare const listOpRemoveListRecord: (address: Address) => ListOpType;
declare const listOpAddTag: (address: Address, tag: string) => ListOpType;
declare const listOpRemoveTag: (address: Address, tag: string) => ListOpType;

/**
 * Formats a number using the user's locale
 * @param number - The number to format
 * @returns Formatted number string
 * @example
 * formatNumber(1234567) // Returns: "1,234,567" (en-US locale)
 */
declare const formatNumber: (number: number) => string;
/**
 * Formats the text shown in the common followers component next to the avatars
 * @param resultLength - Number of common followers
 * @param t - Translation function
 * @returns Formatted text string
 */
declare const formatFollowersYouKnowText: (resultLength: number, t: TranslationFunction) => string;
/**
 * Formats an object into a URL query string
 * @param inputs - Object with string keys and various value types
 * @returns Formatted query string (without leading '?')
 * @example
 * formatQueryParams({ name: 'john', age: 30, tags: ['dev', 'web3'] })
 * // Returns: "name=john&age=30&tags=dev,web3"
 */
declare const formatQueryParams: (inputs: Record<string, string | number | string[] | null | undefined>) => string;
/**
 * Formats a time difference in seconds into a human-readable string
 * @param timeDiff - Time difference in seconds
 * @returns Formatted time string (e.g., "5m", "2h", "3d")
 * @example
 * formatTimeDiff(3600) // Returns: "1h"
 * formatTimeDiff(86400) // Returns: "1d"
 */
declare const formatTimeDiff: (timeDiff: number) => string;
declare const formatNameMetadata: (metadata: GrailsNameMetadataResponse) => {
    label: string;
    value: string;
}[];
declare const formatNameMetadataRecord: (metadata: GrailsNameMetadataResponse) => Record<string, string>;

declare const formatListOpsTransaction: ({ nonce, chainId, listOps, connectedAddress, isMintingNewList, }: GetListOpsTransactionProps) => {
    id: string;
    title: string;
    address: `0x${string}`;
    abi: readonly [{
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "manager";
            readonly type: "address";
        }];
        readonly name: "SlotAlreadyClaimed";
        readonly type: "error";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "bytes";
            readonly name: "op";
            readonly type: "bytes";
        }];
        readonly name: "ListOp";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "previousOwner";
            readonly type: "address";
        }, {
            readonly indexed: true;
            readonly internalType: "address";
            readonly name: "newOwner";
            readonly type: "address";
        }];
        readonly name: "OwnershipTransferred";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Paused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: false;
            readonly internalType: "address";
            readonly name: "account";
            readonly type: "address";
        }];
        readonly name: "Unpaused";
        readonly type: "event";
    }, {
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly indexed: true;
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }, {
            readonly indexed: false;
            readonly internalType: "string";
            readonly name: "key";
            readonly type: "string";
        }, {
            readonly indexed: false;
            readonly internalType: "bytes";
            readonly name: "value";
            readonly type: "bytes";
        }];
        readonly name: "UpdateListMetadata";
        readonly type: "event";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }, {
            readonly internalType: "bytes";
            readonly name: "op";
            readonly type: "bytes";
        }];
        readonly name: "applyListOp";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }, {
            readonly internalType: "bytes[]";
            readonly name: "ops";
            readonly type: "bytes[]";
        }];
        readonly name: "applyListOps";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }];
        readonly name: "claimListManager";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "manager";
            readonly type: "address";
        }];
        readonly name: "claimListManagerForAddress";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "contract ENS";
            readonly name: "ens";
            readonly type: "address";
        }, {
            readonly internalType: "address";
            readonly name: "claimant";
            readonly type: "address";
        }];
        readonly name: "claimReverseENS";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }];
        readonly name: "getAllListOps";
        readonly outputs: readonly [{
            readonly internalType: "bytes[]";
            readonly name: "";
            readonly type: "bytes[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }];
        readonly name: "getListManager";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "index";
            readonly type: "uint256";
        }];
        readonly name: "getListOp";
        readonly outputs: readonly [{
            readonly internalType: "bytes";
            readonly name: "";
            readonly type: "bytes";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }];
        readonly name: "getListOpCount";
        readonly outputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "start";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "end";
            readonly type: "uint256";
        }];
        readonly name: "getListOpsInRange";
        readonly outputs: readonly [{
            readonly internalType: "bytes[]";
            readonly name: "";
            readonly type: "bytes[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }];
        readonly name: "getListUser";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "tokenId";
            readonly type: "uint256";
        }, {
            readonly internalType: "string";
            readonly name: "key";
            readonly type: "string";
        }];
        readonly name: "getMetadataValue";
        readonly outputs: readonly [{
            readonly internalType: "bytes";
            readonly name: "";
            readonly type: "bytes";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "tokenId";
            readonly type: "uint256";
        }, {
            readonly internalType: "string[]";
            readonly name: "keys";
            readonly type: "string[]";
        }];
        readonly name: "getMetadataValues";
        readonly outputs: readonly [{
            readonly internalType: "bytes[]";
            readonly name: "";
            readonly type: "bytes[]";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }, {
            readonly internalType: "uint256";
            readonly name: "";
            readonly type: "uint256";
        }];
        readonly name: "listOps";
        readonly outputs: readonly [{
            readonly internalType: "bytes";
            readonly name: "";
            readonly type: "bytes";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "owner";
        readonly outputs: readonly [{
            readonly internalType: "address";
            readonly name: "";
            readonly type: "address";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly internalType: "bool";
            readonly name: "";
            readonly type: "bool";
        }];
        readonly stateMutability: "view";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "renounceOwnership";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "manager";
            readonly type: "address";
        }];
        readonly name: "setListManager";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }, {
            readonly internalType: "address";
            readonly name: "user";
            readonly type: "address";
        }];
        readonly name: "setListUser";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }, {
            readonly internalType: "string";
            readonly name: "key";
            readonly type: "string";
        }, {
            readonly internalType: "bytes";
            readonly name: "value";
            readonly type: "bytes";
        }];
        readonly name: "setMetadataValue";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }, {
            readonly components: readonly [{
                readonly internalType: "string";
                readonly name: "key";
                readonly type: "string";
            }, {
                readonly internalType: "bytes";
                readonly name: "value";
                readonly type: "bytes";
            }];
            readonly internalType: "struct IEFPListMetadata.KeyValue[]";
            readonly name: "records";
            readonly type: "tuple[]";
        }];
        readonly name: "setMetadataValues";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "uint256";
            readonly name: "slot";
            readonly type: "uint256";
        }, {
            readonly components: readonly [{
                readonly internalType: "string";
                readonly name: "key";
                readonly type: "string";
            }, {
                readonly internalType: "bytes";
                readonly name: "value";
                readonly type: "bytes";
            }];
            readonly internalType: "struct IEFPListMetadata.KeyValue[]";
            readonly name: "records";
            readonly type: "tuple[]";
        }, {
            readonly internalType: "bytes[]";
            readonly name: "ops";
            readonly type: "bytes[]";
        }];
        readonly name: "setMetadataValuesAndApplyListOps";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "contract ENS";
            readonly name: "ens";
            readonly type: "address";
        }, {
            readonly internalType: "string";
            readonly name: "name";
            readonly type: "string";
        }];
        readonly name: "setReverseENS";
        readonly outputs: readonly [{
            readonly internalType: "bytes32";
            readonly name: "";
            readonly type: "bytes32";
        }];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [{
            readonly internalType: "address";
            readonly name: "newOwner";
            readonly type: "address";
        }];
        readonly name: "transferOwnership";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }, {
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
        readonly stateMutability: "nonpayable";
        readonly type: "function";
    }];
    chainId: number | undefined;
    functionName: string;
    args: (bigint | `0x${string}`[] | {
        key: string;
        value: `0x${string}`;
    }[] | undefined)[];
};
declare const getListOpData: (address: Address$1, tag?: string) => Hex$1;
declare const getListOpsFromTransaction: (transaction: TransactionType) => ListOpType[];
declare const getMintTxNonce: (transaction: TransactionType) => bigint;
declare const getMintTxChainId: (transaction: TransactionType) => number;
declare const getMintTxRecordsAddress: (transaction: TransactionType) => string;
declare const getPendingTxAddresses: (txs: TransactionType[]) => string[];
declare const extractAddressAndTag: (data: Hex$1) => {
    address: `0x${string}`;
    tag: string;
};
declare const getPendingTxListOps: (txs: TransactionType[]) => ListOpType[];
declare const getPendingTxAddressesAndTags: (txs: TransactionType[]) => {
    address: `0x${string}`;
    tag: string;
}[];
declare const prepareMintTransaction: (mintNonce: bigint, chainId?: number) => {
    title: string;
    description: string;
    id: string;
    chainId: 8453;
    address: `0x${string}`;
    abi: readonly [{
        readonly stateMutability: "nonpayable";
        readonly type: "constructor";
        readonly inputs: readonly [{
            readonly name: "_registryAddress";
            readonly internalType: "address";
            readonly type: "address";
        }, {
            readonly name: "_accountMetadataAddress";
            readonly internalType: "address";
            readonly type: "address";
        }, {
            readonly name: "_listRecordsL1";
            readonly internalType: "address";
            readonly type: "address";
        }];
    }, {
        readonly stateMutability: "view";
        readonly type: "function";
        readonly inputs: readonly [];
        readonly name: "accountMetadata";
        readonly outputs: readonly [{
            readonly name: "";
            readonly internalType: "contract IEFPAccountMetadata";
            readonly type: "address";
        }];
    }, {
        readonly stateMutability: "nonpayable";
        readonly type: "function";
        readonly inputs: readonly [{
            readonly name: "ens";
            readonly internalType: "contract ENS";
            readonly type: "address";
        }, {
            readonly name: "claimant";
            readonly internalType: "address";
            readonly type: "address";
        }];
        readonly name: "claimReverseENS";
        readonly outputs: readonly [{
            readonly name: "";
            readonly internalType: "bytes32";
            readonly type: "bytes32";
        }];
    }, {
        readonly stateMutability: "payable";
        readonly type: "function";
        readonly inputs: readonly [{
            readonly name: "listStorageLocation";
            readonly internalType: "bytes";
            readonly type: "bytes";
        }];
        readonly name: "easyMint";
        readonly outputs: readonly [];
    }, {
        readonly stateMutability: "payable";
        readonly type: "function";
        readonly inputs: readonly [{
            readonly name: "to";
            readonly internalType: "address";
            readonly type: "address";
        }, {
            readonly name: "listStorageLocation";
            readonly internalType: "bytes";
            readonly type: "bytes";
        }];
        readonly name: "easyMintTo";
        readonly outputs: readonly [];
    }, {
        readonly stateMutability: "view";
        readonly type: "function";
        readonly inputs: readonly [];
        readonly name: "listRecordsL1";
        readonly outputs: readonly [{
            readonly name: "";
            readonly internalType: "contract IEFPListRecords";
            readonly type: "address";
        }];
    }, {
        readonly stateMutability: "payable";
        readonly type: "function";
        readonly inputs: readonly [{
            readonly name: "listStorageLocation";
            readonly internalType: "bytes";
            readonly type: "bytes";
        }];
        readonly name: "mintNoMeta";
        readonly outputs: readonly [];
    }, {
        readonly stateMutability: "payable";
        readonly type: "function";
        readonly inputs: readonly [{
            readonly name: "listStorageLocation";
            readonly internalType: "bytes";
            readonly type: "bytes";
        }];
        readonly name: "mintPrimaryListNoMeta";
        readonly outputs: readonly [];
    }, {
        readonly stateMutability: "payable";
        readonly type: "function";
        readonly inputs: readonly [{
            readonly name: "to";
            readonly internalType: "address";
            readonly type: "address";
        }, {
            readonly name: "listStorageLocation";
            readonly internalType: "bytes";
            readonly type: "bytes";
        }];
        readonly name: "mintToNoMeta";
        readonly outputs: readonly [];
    }, {
        readonly stateMutability: "view";
        readonly type: "function";
        readonly inputs: readonly [];
        readonly name: "owner";
        readonly outputs: readonly [{
            readonly name: "";
            readonly internalType: "address";
            readonly type: "address";
        }];
    }, {
        readonly stateMutability: "nonpayable";
        readonly type: "function";
        readonly inputs: readonly [];
        readonly name: "pause";
        readonly outputs: readonly [];
    }, {
        readonly stateMutability: "view";
        readonly type: "function";
        readonly inputs: readonly [];
        readonly name: "paused";
        readonly outputs: readonly [{
            readonly name: "";
            readonly internalType: "bool";
            readonly type: "bool";
        }];
    }, {
        readonly stateMutability: "view";
        readonly type: "function";
        readonly inputs: readonly [];
        readonly name: "registry";
        readonly outputs: readonly [{
            readonly name: "";
            readonly internalType: "contract IEFPListRegistry_ERC721";
            readonly type: "address";
        }];
    }, {
        readonly stateMutability: "nonpayable";
        readonly type: "function";
        readonly inputs: readonly [];
        readonly name: "renounceOwnership";
        readonly outputs: readonly [];
    }, {
        readonly stateMutability: "nonpayable";
        readonly type: "function";
        readonly inputs: readonly [{
            readonly name: "ens";
            readonly internalType: "contract ENS";
            readonly type: "address";
        }, {
            readonly name: "name";
            readonly internalType: "string";
            readonly type: "string";
        }];
        readonly name: "setReverseENS";
        readonly outputs: readonly [{
            readonly name: "";
            readonly internalType: "bytes32";
            readonly type: "bytes32";
        }];
    }, {
        readonly stateMutability: "nonpayable";
        readonly type: "function";
        readonly inputs: readonly [{
            readonly name: "newOwner";
            readonly internalType: "address";
            readonly type: "address";
        }];
        readonly name: "transferOwnership";
        readonly outputs: readonly [];
    }, {
        readonly stateMutability: "nonpayable";
        readonly type: "function";
        readonly inputs: readonly [];
        readonly name: "unpause";
        readonly outputs: readonly [];
    }, {
        readonly type: "event";
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly name: "previousOwner";
            readonly internalType: "address";
            readonly type: "address";
            readonly indexed: true;
        }, {
            readonly name: "newOwner";
            readonly internalType: "address";
            readonly type: "address";
            readonly indexed: true;
        }];
        readonly name: "OwnershipTransferred";
    }, {
        readonly type: "event";
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly name: "account";
            readonly internalType: "address";
            readonly type: "address";
            readonly indexed: false;
        }];
        readonly name: "Paused";
    }, {
        readonly type: "event";
        readonly anonymous: false;
        readonly inputs: readonly [{
            readonly name: "account";
            readonly internalType: "address";
            readonly type: "address";
            readonly indexed: false;
        }];
        readonly name: "Unpaused";
    }];
    functionName: string;
    args: `0x${string}`[];
};
declare const transformTxsForLocalStorage: (txs: TransactionType[]) => {
    args: any[];
    title?: string;
    description?: string;
    id: EFPActionType | string;
    address: Address$1;
    chainId?: number;
    abi: viem.Abi;
    functionName: string;
    hash?: Hex$1;
}[];

/**
 * Get the list storage location from the list registry contract
 *
 * @param list - the list to get the storage location for
 * @returns the chain id and slot of the list storage location
 */
declare const getListStorageLocation: (list: string) => Promise<{
    chainId: number;
    slot: bigint;
}>;

declare const normalizeEnsName: (name: string) => string;
declare const beautifyEnsName: (name: string) => string;

type TransactionContextType = {
    txModalOpen: boolean;
    batchTransactions: boolean;
    paymasterService?: string;
    setTxModalOpen: (txModalOpen: boolean) => void;
    changesOpen: boolean;
    setChangesOpen: (changesOpen: boolean) => void;
    selectedList?: string;
    setSelectedList: (selectedList: string | undefined) => void;
    pendingTxs: TransactionType[];
    setPendingTxs: Dispatch<SetStateAction<TransactionType[]>>;
    lists?: ProfileListsResponse | null;
    listsLoading: boolean;
    nonce: bigint | undefined;
    addTransactions: (txs: TransactionType[]) => void;
    addListOpsTransaction: (listOps: ListOpType[]) => void;
    removeTransactions: (ids: (EFPActionType | string)[]) => void;
    removeListOpsTransaction: (txData: Hex$1[]) => void;
    currentTxIndex: number | undefined;
    setCurrentTxIndex: (currentTxIndex: number | undefined) => void;
    goToNextTransaction: () => void;
    resetTransactions: (keepModalOpen?: boolean) => void;
    refetchAssociatedQueries: () => void;
    selectedChainId: number | undefined;
    setSelectedChainId: (chainId: number | undefined) => void;
    defaultChainId: number | undefined;
    isCheckoutFinished: boolean;
    followingAddressesToFetchFresh: string[];
    setIsCheckoutFinished: (isCheckoutFinished: boolean) => void;
};
interface TransactionProviderProps {
    batchTransactions?: boolean;
    paymasterService?: string;
    defaultChainId?: number;
    disableAutoListSelection?: boolean;
    children: ReactNode;
}
/**
 * TransactionProvider component - provides the transaction context to the app
 *
 * @param batchTransactions - whether to batch transactions (cart)
 * @param paymasterService - the paymaster service to use
 * @param defaultChainId - the default chain id to use for users without a list (new list)
 * @param disableAutoListSelection - whether to disable auto list selection
 * @param children - the children to render
 */
declare const TransactionProvider: React.FC<TransactionProviderProps>;
/**
 * useTransactions hook - enables use of the transaction context
 *
 * @returns the transaction context
 */
declare const useTransactions: () => TransactionContextType;

interface TranslationContextType {
    t: TranslationFunction;
    activeLanguage: LanguageCode;
    availableLanguages: LanguageCode[];
    setLanguage: (language: LanguageCode) => void;
}
interface TranslationProviderProps extends TranslationConfig {
    children: ReactNode;
}
/**
 * TranslationProvider component
 *
 * @param children - The child components to render
 * @param translateFn - Custom translarion function if you want to use your own (optional)
 * @param translations - The translations to use - in object format
 * @param activeLanguage - The active language to use
 * @param fallbackLanguage - The fallback language to use
 *
 * @returns The TranslationProvider component
 */
declare const TranslationProvider: react__default.FC<TranslationProviderProps>;
declare const useTranslation: () => TranslationContextType;

declare const efpAccountMetadataAbi: readonly [{
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "proxy";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "addProxy";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "addr";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "key";
        readonly internalType: "string";
        readonly type: "string";
    }];
    readonly name: "getValue";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "addr";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "keys";
        readonly internalType: "string[]";
        readonly type: "string[]";
    }];
    readonly name: "getValues";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bytes[]";
        readonly type: "bytes[]";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "proxy";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "isProxy";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bool";
        readonly type: "bool";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "owner";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "address";
        readonly type: "address";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "proxy";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "removeProxy";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "renounceOwnership";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "key";
        readonly internalType: "string";
        readonly type: "string";
    }, {
        readonly name: "value";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "setValue";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "addr";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "key";
        readonly internalType: "string";
        readonly type: "string";
    }, {
        readonly name: "value";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "setValueForAddress";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "records";
        readonly internalType: "struct IEFPAccountMetadata.KeyValue[]";
        readonly type: "tuple[]";
        readonly components: readonly [{
            readonly name: "key";
            readonly internalType: "string";
            readonly type: "string";
        }, {
            readonly name: "value";
            readonly internalType: "bytes";
            readonly type: "bytes";
        }];
    }];
    readonly name: "setValues";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "addr";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "records";
        readonly internalType: "struct IEFPAccountMetadata.KeyValue[]";
        readonly type: "tuple[]";
        readonly components: readonly [{
            readonly name: "key";
            readonly internalType: "string";
            readonly type: "string";
        }, {
            readonly name: "value";
            readonly internalType: "bytes";
            readonly type: "bytes";
        }];
    }];
    readonly name: "setValuesForAddress";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "newOwner";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "transferOwnership";
    readonly outputs: readonly [];
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "previousOwner";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "newOwner";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: true;
    }];
    readonly name: "OwnershipTransferred";
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "proxy";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: false;
    }];
    readonly name: "ProxyAdded";
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "proxy";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: false;
    }];
    readonly name: "ProxyRemoved";
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "addr";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "key";
        readonly internalType: "string";
        readonly type: "string";
        readonly indexed: false;
    }, {
        readonly name: "value";
        readonly internalType: "bytes";
        readonly type: "bytes";
        readonly indexed: false;
    }];
    readonly name: "UpdateAccountMetadata";
}];

declare const efpListMinterAbi: readonly [{
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
    readonly inputs: readonly [{
        readonly name: "_registryAddress";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "_accountMetadataAddress";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "_listRecordsL1";
        readonly internalType: "address";
        readonly type: "address";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "accountMetadata";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "contract IEFPAccountMetadata";
        readonly type: "address";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "ens";
        readonly internalType: "contract ENS";
        readonly type: "address";
    }, {
        readonly name: "claimant";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "claimReverseENS";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bytes32";
        readonly type: "bytes32";
    }];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "listStorageLocation";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "easyMint";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "to";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "listStorageLocation";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "easyMintTo";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "listRecordsL1";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "contract IEFPListRecords";
        readonly type: "address";
    }];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "listStorageLocation";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "mintNoMeta";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "listStorageLocation";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "mintPrimaryListNoMeta";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "to";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "listStorageLocation";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "mintToNoMeta";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "owner";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "address";
        readonly type: "address";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "pause";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "paused";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bool";
        readonly type: "bool";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "registry";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "contract IEFPListRegistry_ERC721";
        readonly type: "address";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "renounceOwnership";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "ens";
        readonly internalType: "contract ENS";
        readonly type: "address";
    }, {
        readonly name: "name";
        readonly internalType: "string";
        readonly type: "string";
    }];
    readonly name: "setReverseENS";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bytes32";
        readonly type: "bytes32";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "newOwner";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "transferOwnership";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "unpause";
    readonly outputs: readonly [];
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "previousOwner";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "newOwner";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: true;
    }];
    readonly name: "OwnershipTransferred";
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "account";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: false;
    }];
    readonly name: "Paused";
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "account";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: false;
    }];
    readonly name: "Unpaused";
}];

declare const efpListRecordsAbi: readonly [{
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "manager";
        readonly type: "address";
    }];
    readonly name: "SlotAlreadyClaimed";
    readonly type: "error";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "bytes";
        readonly name: "op";
        readonly type: "bytes";
    }];
    readonly name: "ListOp";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "previousOwner";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "newOwner";
        readonly type: "address";
    }];
    readonly name: "OwnershipTransferred";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: false;
        readonly internalType: "address";
        readonly name: "account";
        readonly type: "address";
    }];
    readonly name: "Paused";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: false;
        readonly internalType: "address";
        readonly name: "account";
        readonly type: "address";
    }];
    readonly name: "Unpaused";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "string";
        readonly name: "key";
        readonly type: "string";
    }, {
        readonly indexed: false;
        readonly internalType: "bytes";
        readonly name: "value";
        readonly type: "bytes";
    }];
    readonly name: "UpdateListMetadata";
    readonly type: "event";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }, {
        readonly internalType: "bytes";
        readonly name: "op";
        readonly type: "bytes";
    }];
    readonly name: "applyListOp";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }, {
        readonly internalType: "bytes[]";
        readonly name: "ops";
        readonly type: "bytes[]";
    }];
    readonly name: "applyListOps";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }];
    readonly name: "claimListManager";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "manager";
        readonly type: "address";
    }];
    readonly name: "claimListManagerForAddress";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "contract ENS";
        readonly name: "ens";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "claimant";
        readonly type: "address";
    }];
    readonly name: "claimReverseENS";
    readonly outputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "";
        readonly type: "bytes32";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }];
    readonly name: "getAllListOps";
    readonly outputs: readonly [{
        readonly internalType: "bytes[]";
        readonly name: "";
        readonly type: "bytes[]";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }];
    readonly name: "getListManager";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "index";
        readonly type: "uint256";
    }];
    readonly name: "getListOp";
    readonly outputs: readonly [{
        readonly internalType: "bytes";
        readonly name: "";
        readonly type: "bytes";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }];
    readonly name: "getListOpCount";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "start";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "end";
        readonly type: "uint256";
    }];
    readonly name: "getListOpsInRange";
    readonly outputs: readonly [{
        readonly internalType: "bytes[]";
        readonly name: "";
        readonly type: "bytes[]";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }];
    readonly name: "getListUser";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "tokenId";
        readonly type: "uint256";
    }, {
        readonly internalType: "string";
        readonly name: "key";
        readonly type: "string";
    }];
    readonly name: "getMetadataValue";
    readonly outputs: readonly [{
        readonly internalType: "bytes";
        readonly name: "";
        readonly type: "bytes";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "tokenId";
        readonly type: "uint256";
    }, {
        readonly internalType: "string[]";
        readonly name: "keys";
        readonly type: "string[]";
    }];
    readonly name: "getMetadataValues";
    readonly outputs: readonly [{
        readonly internalType: "bytes[]";
        readonly name: "";
        readonly type: "bytes[]";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly name: "listOps";
    readonly outputs: readonly [{
        readonly internalType: "bytes";
        readonly name: "";
        readonly type: "bytes";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "owner";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "pause";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "paused";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "renounceOwnership";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "manager";
        readonly type: "address";
    }];
    readonly name: "setListManager";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "user";
        readonly type: "address";
    }];
    readonly name: "setListUser";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }, {
        readonly internalType: "string";
        readonly name: "key";
        readonly type: "string";
    }, {
        readonly internalType: "bytes";
        readonly name: "value";
        readonly type: "bytes";
    }];
    readonly name: "setMetadataValue";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }, {
        readonly components: readonly [{
            readonly internalType: "string";
            readonly name: "key";
            readonly type: "string";
        }, {
            readonly internalType: "bytes";
            readonly name: "value";
            readonly type: "bytes";
        }];
        readonly internalType: "struct IEFPListMetadata.KeyValue[]";
        readonly name: "records";
        readonly type: "tuple[]";
    }];
    readonly name: "setMetadataValues";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "slot";
        readonly type: "uint256";
    }, {
        readonly components: readonly [{
            readonly internalType: "string";
            readonly name: "key";
            readonly type: "string";
        }, {
            readonly internalType: "bytes";
            readonly name: "value";
            readonly type: "bytes";
        }];
        readonly internalType: "struct IEFPListMetadata.KeyValue[]";
        readonly name: "records";
        readonly type: "tuple[]";
    }, {
        readonly internalType: "bytes[]";
        readonly name: "ops";
        readonly type: "bytes[]";
    }];
    readonly name: "setMetadataValuesAndApplyListOps";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "contract ENS";
        readonly name: "ens";
        readonly type: "address";
    }, {
        readonly internalType: "string";
        readonly name: "name";
        readonly type: "string";
    }];
    readonly name: "setReverseENS";
    readonly outputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "";
        readonly type: "bytes32";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "newOwner";
        readonly type: "address";
    }];
    readonly name: "transferOwnership";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [];
    readonly name: "unpause";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}];

declare const efpListRegistryAbi: readonly [{
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
    readonly inputs: readonly [];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "to";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "approve";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "balanceOf";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "explicitOwnershipOf";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "struct IERC721A.TokenOwnership";
        readonly type: "tuple";
        readonly components: readonly [{
            readonly name: "addr";
            readonly internalType: "address";
            readonly type: "address";
        }, {
            readonly name: "startTimestamp";
            readonly internalType: "uint64";
            readonly type: "uint64";
        }, {
            readonly name: "burned";
            readonly internalType: "bool";
            readonly type: "bool";
        }, {
            readonly name: "extraData";
            readonly internalType: "uint24";
            readonly type: "uint24";
        }];
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "tokenIds";
        readonly internalType: "uint256[]";
        readonly type: "uint256[]";
    }];
    readonly name: "explicitOwnershipsOf";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "struct IERC721A.TokenOwnership[]";
        readonly type: "tuple[]";
        readonly components: readonly [{
            readonly name: "addr";
            readonly internalType: "address";
            readonly type: "address";
        }, {
            readonly name: "startTimestamp";
            readonly internalType: "uint64";
            readonly type: "uint64";
        }, {
            readonly name: "burned";
            readonly internalType: "bool";
            readonly type: "bool";
        }, {
            readonly name: "extraData";
            readonly internalType: "uint24";
            readonly type: "uint24";
        }];
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "getApproved";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "address";
        readonly type: "address";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "getListStorageLocation";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "getMaxMintBatchSize";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "getMintState";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "enum IEFPListRegistry.MintState";
        readonly type: "uint8";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "getPriceOracle";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "address";
        readonly type: "address";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "operator";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "isApprovedForAll";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bool";
        readonly type: "bool";
    }];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "listStorageLocation";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "mint";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "quantity";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "mintBatch";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "to";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "quantity";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "mintBatchTo";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "to";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "listStorageLocation";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "mintTo";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "name";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "string";
        readonly type: "string";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "owner";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "address";
        readonly type: "address";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "ownerOf";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "address";
        readonly type: "address";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "renounceOwnership";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "from";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "to";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "safeTransferFrom";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "from";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "to";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "_data";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "safeTransferFrom";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "operator";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "approved";
        readonly internalType: "bool";
        readonly type: "bool";
    }];
    readonly name: "setApprovalForAll";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "listStorageLocation";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "setListStorageLocation";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "_maxMintBatchSize";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "setMaxMintBatchSize";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "_mintState";
        readonly internalType: "enum IEFPListRegistry.MintState";
        readonly type: "uint8";
    }];
    readonly name: "setMintState";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "priceOracle_";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "setPriceOracle";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "interfaceId";
        readonly internalType: "bytes4";
        readonly type: "bytes4";
    }];
    readonly name: "supportsInterface";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bool";
        readonly type: "bool";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "symbol";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "string";
        readonly type: "string";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "tokenURI";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "string";
        readonly type: "string";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "tokensOfOwner";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "uint256[]";
        readonly type: "uint256[]";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "start";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "stop";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "tokensOfOwnerIn";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "uint256[]";
        readonly type: "uint256[]";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "totalSupply";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "from";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "to";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "transferFrom";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "newOwner";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "transferOwnership";
    readonly outputs: readonly [];
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "approved";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
        readonly indexed: true;
    }];
    readonly name: "Approval";
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "owner";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "operator";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "approved";
        readonly internalType: "bool";
        readonly type: "bool";
        readonly indexed: false;
    }];
    readonly name: "ApprovalForAll";
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "fromTokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
        readonly indexed: true;
    }, {
        readonly name: "toTokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
        readonly indexed: false;
    }, {
        readonly name: "from";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "to";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: true;
    }];
    readonly name: "ConsecutiveTransfer";
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "maxMintBatchSize";
        readonly internalType: "uint256";
        readonly type: "uint256";
        readonly indexed: false;
    }];
    readonly name: "MaxMintBatchSizeChange";
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "mintState";
        readonly internalType: "enum IEFPListRegistry.MintState";
        readonly type: "uint8";
        readonly indexed: false;
    }];
    readonly name: "MintStateChange";
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "previousOwner";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "newOwner";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: true;
    }];
    readonly name: "OwnershipTransferred";
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "priceOracle";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: false;
    }];
    readonly name: "PriceOracleChange";
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "from";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "to";
        readonly internalType: "address";
        readonly type: "address";
        readonly indexed: true;
    }, {
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
        readonly indexed: true;
    }];
    readonly name: "Transfer";
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
        readonly indexed: true;
    }, {
        readonly name: "listStorageLocation";
        readonly internalType: "bytes";
        readonly type: "bytes";
        readonly indexed: false;
    }];
    readonly name: "UpdateListStorageLocation";
}, {
    readonly type: "error";
    readonly inputs: readonly [];
    readonly name: "ApprovalCallerNotOwnerNorApproved";
}, {
    readonly type: "error";
    readonly inputs: readonly [];
    readonly name: "ApprovalQueryForNonexistentToken";
}, {
    readonly type: "error";
    readonly inputs: readonly [];
    readonly name: "BalanceQueryForZeroAddress";
}, {
    readonly type: "error";
    readonly inputs: readonly [];
    readonly name: "InvalidQueryRange";
}, {
    readonly type: "error";
    readonly inputs: readonly [];
    readonly name: "MintERC2309QuantityExceedsLimit";
}, {
    readonly type: "error";
    readonly inputs: readonly [];
    readonly name: "MintToZeroAddress";
}, {
    readonly type: "error";
    readonly inputs: readonly [];
    readonly name: "MintZeroQuantity";
}, {
    readonly type: "error";
    readonly inputs: readonly [];
    readonly name: "OwnerQueryForNonexistentToken";
}, {
    readonly type: "error";
    readonly inputs: readonly [];
    readonly name: "OwnershipNotInitializedForExtraData";
}, {
    readonly type: "error";
    readonly inputs: readonly [];
    readonly name: "TransferCallerNotOwnerNorApproved";
}, {
    readonly type: "error";
    readonly inputs: readonly [];
    readonly name: "TransferFromIncorrectOwner";
}, {
    readonly type: "error";
    readonly inputs: readonly [];
    readonly name: "TransferToNonERC721ReceiverImplementer";
}, {
    readonly type: "error";
    readonly inputs: readonly [];
    readonly name: "TransferToZeroAddress";
}, {
    readonly type: "error";
    readonly inputs: readonly [];
    readonly name: "URIQueryForNonexistentToken";
}];

declare const efpListRegistryErc721Abi: readonly [{
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "getListStorageLocation";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "getMaxMintBatchSize";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "getMintState";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "enum IEFPListRegistry.MintState";
        readonly type: "uint8";
    }];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "listStorageLocation";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "mint";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "quantity";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "mintBatch";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "to";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "quantity";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "mintBatchTo";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "payable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "to";
        readonly internalType: "address";
        readonly type: "address";
    }, {
        readonly name: "listStorageLocation";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "mintTo";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "ownerOf";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "address";
        readonly type: "address";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "listStorageLocation";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "setListStorageLocation";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "_maxMintBatchSize";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "setMaxMintBatchSize";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "_mintState";
        readonly internalType: "enum IEFPListRegistry.MintState";
        readonly type: "uint8";
    }];
    readonly name: "setMintState";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [];
    readonly name: "totalSupply";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
        readonly indexed: true;
    }, {
        readonly name: "listStorageLocation";
        readonly internalType: "bytes";
        readonly type: "bytes";
        readonly indexed: false;
    }];
    readonly name: "UpdateListStorageLocation";
}];

declare const listMetadataAbi: readonly [{
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "claimListManager";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "manager";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "claimListManagerForAddress";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "getListManager";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "address";
        readonly type: "address";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "getListUser";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "address";
        readonly type: "address";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "key";
        readonly internalType: "string";
        readonly type: "string";
    }];
    readonly name: "getMetadataValue";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "keys";
        readonly internalType: "string[]";
        readonly type: "string[]";
    }];
    readonly name: "getMetadataValues";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bytes[]";
        readonly type: "bytes[]";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "manager";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "setListManager";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "user";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "setListUser";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "key";
        readonly internalType: "string";
        readonly type: "string";
    }, {
        readonly name: "value";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "setMetadataValue";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "records";
        readonly internalType: "struct IEFPListMetadata.KeyValue[]";
        readonly type: "tuple[]";
        readonly components: readonly [{
            readonly name: "key";
            readonly internalType: "string";
            readonly type: "string";
        }, {
            readonly name: "value";
            readonly internalType: "bytes";
            readonly type: "bytes";
        }];
    }];
    readonly name: "setMetadataValues";
    readonly outputs: readonly [];
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
        readonly indexed: true;
    }, {
        readonly name: "key";
        readonly internalType: "string";
        readonly type: "string";
        readonly indexed: false;
    }, {
        readonly name: "value";
        readonly internalType: "bytes";
        readonly type: "bytes";
        readonly indexed: false;
    }];
    readonly name: "UpdateListMetadata";
}, {
    readonly type: "error";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "manager";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "NonceAlreadyClaimed";
}];

declare const listRecordsAbi: readonly [{
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "op";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "applyListOp";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "ops";
        readonly internalType: "bytes[]";
        readonly type: "bytes[]";
    }];
    readonly name: "applyListOps";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "claimListManager";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "manager";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "claimListManagerForAddress";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "getAllListOps";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bytes[]";
        readonly type: "bytes[]";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "getListManager";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "address";
        readonly type: "address";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "index";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "getListOp";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "getListOpCount";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "start";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "end";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "getListOpsInRange";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bytes[]";
        readonly type: "bytes[]";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "getListUser";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "address";
        readonly type: "address";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "key";
        readonly internalType: "string";
        readonly type: "string";
    }];
    readonly name: "getMetadataValue";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "tokenId";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "keys";
        readonly internalType: "string[]";
        readonly type: "string[]";
    }];
    readonly name: "getMetadataValues";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bytes[]";
        readonly type: "bytes[]";
    }];
}, {
    readonly stateMutability: "view";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }];
    readonly name: "listOps";
    readonly outputs: readonly [{
        readonly name: "";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "manager";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "setListManager";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "user";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "setListUser";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "key";
        readonly internalType: "string";
        readonly type: "string";
    }, {
        readonly name: "value";
        readonly internalType: "bytes";
        readonly type: "bytes";
    }];
    readonly name: "setMetadataValue";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "records";
        readonly internalType: "struct IEFPListMetadata.KeyValue[]";
        readonly type: "tuple[]";
        readonly components: readonly [{
            readonly name: "key";
            readonly internalType: "string";
            readonly type: "string";
        }, {
            readonly name: "value";
            readonly internalType: "bytes";
            readonly type: "bytes";
        }];
    }];
    readonly name: "setMetadataValues";
    readonly outputs: readonly [];
}, {
    readonly stateMutability: "nonpayable";
    readonly type: "function";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "records";
        readonly internalType: "struct IEFPListMetadata.KeyValue[]";
        readonly type: "tuple[]";
        readonly components: readonly [{
            readonly name: "key";
            readonly internalType: "string";
            readonly type: "string";
        }, {
            readonly name: "value";
            readonly internalType: "bytes";
            readonly type: "bytes";
        }];
    }, {
        readonly name: "ops";
        readonly internalType: "bytes[]";
        readonly type: "bytes[]";
    }];
    readonly name: "setMetadataValuesAndApplyListOps";
    readonly outputs: readonly [];
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
        readonly indexed: true;
    }, {
        readonly name: "op";
        readonly internalType: "bytes";
        readonly type: "bytes";
        readonly indexed: false;
    }];
    readonly name: "ListOp";
}, {
    readonly type: "event";
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
        readonly indexed: true;
    }, {
        readonly name: "key";
        readonly internalType: "string";
        readonly type: "string";
        readonly indexed: false;
    }, {
        readonly name: "value";
        readonly internalType: "bytes";
        readonly type: "bytes";
        readonly indexed: false;
    }];
    readonly name: "UpdateListMetadata";
}, {
    readonly type: "error";
    readonly inputs: readonly [{
        readonly name: "nonce";
        readonly internalType: "uint256";
        readonly type: "uint256";
    }, {
        readonly name: "manager";
        readonly internalType: "address";
        readonly type: "address";
    }];
    readonly name: "NonceAlreadyClaimed";
}];

declare const PublicResolverAbi: readonly [{
    readonly inputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "node";
        readonly type: "bytes32";
    }, {
        readonly internalType: "string";
        readonly name: "key";
        readonly type: "string";
    }];
    readonly name: "text";
    readonly outputs: readonly [{
        readonly internalType: "string";
        readonly name: "";
        readonly type: "string";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "node";
        readonly type: "bytes32";
    }, {
        readonly internalType: "string";
        readonly name: "key";
        readonly type: "string";
    }, {
        readonly internalType: "string";
        readonly name: "value";
        readonly type: "string";
    }];
    readonly name: "setText";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "node";
        readonly type: "bytes32";
    }];
    readonly name: "addr";
    readonly outputs: readonly [{
        readonly internalType: "address payable";
        readonly name: "";
        readonly type: "address";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "node";
        readonly type: "bytes32";
    }, {
        readonly internalType: "uint256";
        readonly name: "coinType";
        readonly type: "uint256";
    }];
    readonly name: "addr";
    readonly outputs: readonly [{
        readonly internalType: "bytes";
        readonly name: "";
        readonly type: "bytes";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "node";
        readonly type: "bytes32";
    }, {
        readonly internalType: "address";
        readonly name: "a";
        readonly type: "address";
    }];
    readonly name: "setAddr";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "node";
        readonly type: "bytes32";
    }, {
        readonly internalType: "uint256";
        readonly name: "coinType";
        readonly type: "uint256";
    }, {
        readonly internalType: "bytes";
        readonly name: "a";
        readonly type: "bytes";
    }];
    readonly name: "setAddr";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "node";
        readonly type: "bytes32";
    }, {
        readonly internalType: "bytes";
        readonly name: "hash";
        readonly type: "bytes";
    }];
    readonly name: "setContenthash";
    readonly outputs: readonly [];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "node";
        readonly type: "bytes32";
    }];
    readonly name: "contenthash";
    readonly outputs: readonly [{
        readonly internalType: "bytes";
        readonly name: "";
        readonly type: "bytes";
    }];
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly inputs: readonly [{
        readonly internalType: "bytes[]";
        readonly name: "data";
        readonly type: "bytes[]";
    }];
    readonly name: "multicall";
    readonly outputs: readonly [{
        readonly internalType: "bytes[]";
        readonly name: "results";
        readonly type: "bytes[]";
    }];
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}];

declare const BaseRegistrarAbi: readonly [{
    readonly inputs: readonly [{
        readonly internalType: "contract ENS";
        readonly name: "_ens";
        readonly type: "address";
    }, {
        readonly internalType: "bytes32";
        readonly name: "_baseNode";
        readonly type: "bytes32";
    }];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "approved";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "tokenId";
        readonly type: "uint256";
    }];
    readonly name: "Approval";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "operator";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "bool";
        readonly name: "approved";
        readonly type: "bool";
    }];
    readonly name: "ApprovalForAll";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "controller";
        readonly type: "address";
    }];
    readonly name: "ControllerAdded";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "controller";
        readonly type: "address";
    }];
    readonly name: "ControllerRemoved";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "id";
        readonly type: "uint256";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "expires";
        readonly type: "uint256";
    }];
    readonly name: "NameMigrated";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "id";
        readonly type: "uint256";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "expires";
        readonly type: "uint256";
    }];
    readonly name: "NameRegistered";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "id";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "expires";
        readonly type: "uint256";
    }];
    readonly name: "NameRenewed";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "previousOwner";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "newOwner";
        readonly type: "address";
    }];
    readonly name: "OwnershipTransferred";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "from";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "uint256";
        readonly name: "tokenId";
        readonly type: "uint256";
    }];
    readonly name: "Transfer";
    readonly type: "event";
}, {
    readonly constant: true;
    readonly inputs: readonly [];
    readonly name: "GRACE_PERIOD";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "controller";
        readonly type: "address";
    }];
    readonly name: "addController";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "tokenId";
        readonly type: "uint256";
    }];
    readonly name: "approve";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "id";
        readonly type: "uint256";
    }];
    readonly name: "available";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }];
    readonly name: "balanceOf";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [];
    readonly name: "baseNode";
    readonly outputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "";
        readonly type: "bytes32";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly name: "controllers";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [];
    readonly name: "ens";
    readonly outputs: readonly [{
        readonly internalType: "contract ENS";
        readonly name: "";
        readonly type: "address";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "tokenId";
        readonly type: "uint256";
    }];
    readonly name: "getApproved";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "operator";
        readonly type: "address";
    }];
    readonly name: "isApprovedForAll";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [];
    readonly name: "isOwner";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "id";
        readonly type: "uint256";
    }];
    readonly name: "nameExpires";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [];
    readonly name: "owner";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "tokenId";
        readonly type: "uint256";
    }];
    readonly name: "ownerOf";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "id";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }];
    readonly name: "reclaim";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "id";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "duration";
        readonly type: "uint256";
    }];
    readonly name: "register";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "id";
        readonly type: "uint256";
    }, {
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "duration";
        readonly type: "uint256";
    }];
    readonly name: "registerOnly";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "controller";
        readonly type: "address";
    }];
    readonly name: "removeController";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "id";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "duration";
        readonly type: "uint256";
    }];
    readonly name: "renew";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [];
    readonly name: "renounceOwnership";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "from";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "tokenId";
        readonly type: "uint256";
    }];
    readonly name: "safeTransferFrom";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "from";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "tokenId";
        readonly type: "uint256";
    }, {
        readonly internalType: "bytes";
        readonly name: "_data";
        readonly type: "bytes";
    }];
    readonly name: "safeTransferFrom";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly internalType: "bool";
        readonly name: "approved";
        readonly type: "bool";
    }];
    readonly name: "setApprovalForAll";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "resolver";
        readonly type: "address";
    }];
    readonly name: "setResolver";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [{
        readonly internalType: "bytes4";
        readonly name: "interfaceID";
        readonly type: "bytes4";
    }];
    readonly name: "supportsInterface";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "from";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "to";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "tokenId";
        readonly type: "uint256";
    }];
    readonly name: "transferFrom";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "newOwner";
        readonly type: "address";
    }];
    readonly name: "transferOwnership";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}];

declare const RegistrarControllerAbi: readonly [{
    readonly inputs: readonly [{
        readonly internalType: "contract BaseRegistrar";
        readonly name: "_base";
        readonly type: "address";
    }, {
        readonly internalType: "contract PriceOracle";
        readonly name: "_prices";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "_minCommitmentAge";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "_maxCommitmentAge";
        readonly type: "uint256";
    }];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "constructor";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: false;
        readonly internalType: "string";
        readonly name: "name";
        readonly type: "string";
    }, {
        readonly indexed: true;
        readonly internalType: "bytes32";
        readonly name: "label";
        readonly type: "bytes32";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "cost";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "expires";
        readonly type: "uint256";
    }];
    readonly name: "NameRegistered";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: false;
        readonly internalType: "string";
        readonly name: "name";
        readonly type: "string";
    }, {
        readonly indexed: true;
        readonly internalType: "bytes32";
        readonly name: "label";
        readonly type: "bytes32";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "cost";
        readonly type: "uint256";
    }, {
        readonly indexed: false;
        readonly internalType: "uint256";
        readonly name: "expires";
        readonly type: "uint256";
    }];
    readonly name: "NameRenewed";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "oracle";
        readonly type: "address";
    }];
    readonly name: "NewPriceOracle";
    readonly type: "event";
}, {
    readonly anonymous: false;
    readonly inputs: readonly [{
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "previousOwner";
        readonly type: "address";
    }, {
        readonly indexed: true;
        readonly internalType: "address";
        readonly name: "newOwner";
        readonly type: "address";
    }];
    readonly name: "OwnershipTransferred";
    readonly type: "event";
}, {
    readonly constant: true;
    readonly inputs: readonly [];
    readonly name: "MIN_REGISTRATION_DURATION";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [{
        readonly internalType: "string";
        readonly name: "name";
        readonly type: "string";
    }];
    readonly name: "available";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "commitment";
        readonly type: "bytes32";
    }];
    readonly name: "commit";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "";
        readonly type: "bytes32";
    }];
    readonly name: "commitments";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [];
    readonly name: "isOwner";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [{
        readonly internalType: "string";
        readonly name: "name";
        readonly type: "string";
    }, {
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly internalType: "bytes32";
        readonly name: "secret";
        readonly type: "bytes32";
    }];
    readonly name: "makeCommitment";
    readonly outputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "";
        readonly type: "bytes32";
    }];
    readonly payable: false;
    readonly stateMutability: "pure";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [{
        readonly internalType: "string";
        readonly name: "name";
        readonly type: "string";
    }, {
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly internalType: "bytes32";
        readonly name: "secret";
        readonly type: "bytes32";
    }, {
        readonly internalType: "address";
        readonly name: "resolver";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "addr";
        readonly type: "address";
    }];
    readonly name: "makeCommitmentWithConfig";
    readonly outputs: readonly [{
        readonly internalType: "bytes32";
        readonly name: "";
        readonly type: "bytes32";
    }];
    readonly payable: false;
    readonly stateMutability: "pure";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [];
    readonly name: "maxCommitmentAge";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [];
    readonly name: "minCommitmentAge";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [];
    readonly name: "owner";
    readonly outputs: readonly [{
        readonly internalType: "address";
        readonly name: "";
        readonly type: "address";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "string";
        readonly name: "name";
        readonly type: "string";
    }, {
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "duration";
        readonly type: "uint256";
    }, {
        readonly internalType: "bytes32";
        readonly name: "secret";
        readonly type: "bytes32";
    }];
    readonly name: "register";
    readonly outputs: readonly [];
    readonly payable: true;
    readonly stateMutability: "payable";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "string";
        readonly name: "name";
        readonly type: "string";
    }, {
        readonly internalType: "address";
        readonly name: "owner";
        readonly type: "address";
    }, {
        readonly internalType: "uint256";
        readonly name: "duration";
        readonly type: "uint256";
    }, {
        readonly internalType: "bytes32";
        readonly name: "secret";
        readonly type: "bytes32";
    }, {
        readonly internalType: "address";
        readonly name: "resolver";
        readonly type: "address";
    }, {
        readonly internalType: "address";
        readonly name: "addr";
        readonly type: "address";
    }];
    readonly name: "registerWithConfig";
    readonly outputs: readonly [];
    readonly payable: true;
    readonly stateMutability: "payable";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "string";
        readonly name: "name";
        readonly type: "string";
    }, {
        readonly internalType: "uint256";
        readonly name: "duration";
        readonly type: "uint256";
    }];
    readonly name: "renew";
    readonly outputs: readonly [];
    readonly payable: true;
    readonly stateMutability: "payable";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [];
    readonly name: "renounceOwnership";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [{
        readonly internalType: "string";
        readonly name: "name";
        readonly type: "string";
    }, {
        readonly internalType: "uint256";
        readonly name: "duration";
        readonly type: "uint256";
    }];
    readonly name: "rentPrice";
    readonly outputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "";
        readonly type: "uint256";
    }];
    readonly payable: false;
    readonly stateMutability: "view";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "uint256";
        readonly name: "_minCommitmentAge";
        readonly type: "uint256";
    }, {
        readonly internalType: "uint256";
        readonly name: "_maxCommitmentAge";
        readonly type: "uint256";
    }];
    readonly name: "setCommitmentAges";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "contract PriceOracle";
        readonly name: "_prices";
        readonly type: "address";
    }];
    readonly name: "setPriceOracle";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [{
        readonly internalType: "bytes4";
        readonly name: "interfaceID";
        readonly type: "bytes4";
    }];
    readonly name: "supportsInterface";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly payable: false;
    readonly stateMutability: "pure";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [{
        readonly internalType: "address";
        readonly name: "newOwner";
        readonly type: "address";
    }];
    readonly name: "transferOwnership";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}, {
    readonly constant: true;
    readonly inputs: readonly [{
        readonly internalType: "string";
        readonly name: "name";
        readonly type: "string";
    }];
    readonly name: "valid";
    readonly outputs: readonly [{
        readonly internalType: "bool";
        readonly name: "";
        readonly type: "bool";
    }];
    readonly payable: false;
    readonly stateMutability: "pure";
    readonly type: "function";
}, {
    readonly constant: false;
    readonly inputs: readonly [];
    readonly name: "withdraw";
    readonly outputs: readonly [];
    readonly payable: false;
    readonly stateMutability: "nonpayable";
    readonly type: "function";
}];

declare const RegistryAbi: ({
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
    name?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    anonymous: boolean;
    inputs: {
        indexed: boolean;
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    type: string;
    payable?: undefined;
    stateMutability?: undefined;
    constant?: undefined;
    outputs?: undefined;
} | {
    constant: boolean;
    inputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    name: string;
    outputs: {
        internalType: string;
        name: string;
        type: string;
    }[];
    payable: boolean;
    stateMutability: string;
    type: string;
    anonymous?: undefined;
})[];

declare const SECOND = 1000;
declare const MINUTE: number;
declare const HOUR: number;
declare const DAY: number;
declare const WEEK: number;
declare const MONTH: number;

declare const chains: readonly [{
    blockExplorers: {
        readonly default: {
            readonly name: "Basescan";
            readonly url: "https://basescan.org";
            readonly apiUrl: "https://api.basescan.org/api";
        };
    };
    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;
    };
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://mainnet.base.org"];
        };
    };
    sourceId: 1;
    testnet?: boolean | undefined | undefined;
    custom?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters: {
        readonly block: {
            exclude: [] | undefined;
            format: (args: viem_chains.OpStackRpcBlock) => {
                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: abitype.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) => ({
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                from: abitype.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: abitype.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: abitype.Address | null;
                from: abitype.Address;
                gas: bigint;
                nonce: number;
                value: bigint;
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                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;
                from: abitype.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: abitype.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;
                from: abitype.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: abitype.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;
                from: abitype.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: abitype.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;
                from: abitype.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: abitype.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) => {
                blobGasPrice?: bigint | undefined;
                blobGasUsed?: bigint | undefined;
                blockHash: viem.Hash;
                blockNumber: bigint;
                contractAddress: abitype.Address | null | undefined;
                cumulativeGasUsed: bigint;
                effectiveGasPrice: bigint;
                from: abitype.Address;
                gasUsed: bigint;
                logs: viem.Log<bigint, number, false>[];
                logsBloom: viem.Hex;
                root?: `0x${string}` | undefined;
                status: "success" | "reverted";
                to: abitype.Address | null;
                transactionHash: viem.Hash;
                transactionIndex: number;
                type: viem.TransactionType;
                l1GasPrice: bigint | null;
                l1GasUsed: bigint | null;
                l1Fee: bigint | null;
                l1FeeScalar: number | null;
            } & {};
            type: "transactionReceipt";
        };
    };
    serializers: {
        readonly transaction: typeof viem_chains.serializeTransactionOpStack;
    };
}, {
    blockExplorers: {
        readonly default: {
            readonly name: "Optimism Explorer";
            readonly url: "https://optimistic.etherscan.io";
            readonly apiUrl: "https://api-optimistic.etherscan.io/api";
        };
    };
    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;
    };
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://mainnet.optimism.io"];
        };
    };
    sourceId: 1;
    testnet?: boolean | undefined | undefined;
    custom?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters: {
        readonly block: {
            exclude: [] | undefined;
            format: (args: viem_chains.OpStackRpcBlock) => {
                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: abitype.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) => ({
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                from: abitype.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: abitype.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: abitype.Address | null;
                from: abitype.Address;
                gas: bigint;
                nonce: number;
                value: bigint;
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                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;
                from: abitype.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: abitype.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;
                from: abitype.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: abitype.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;
                from: abitype.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: abitype.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;
                from: abitype.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: abitype.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) => {
                blobGasPrice?: bigint | undefined;
                blobGasUsed?: bigint | undefined;
                blockHash: viem.Hash;
                blockNumber: bigint;
                contractAddress: abitype.Address | null | undefined;
                cumulativeGasUsed: bigint;
                effectiveGasPrice: bigint;
                from: abitype.Address;
                gasUsed: bigint;
                logs: viem.Log<bigint, number, false>[];
                logsBloom: viem.Hex;
                root?: `0x${string}` | undefined;
                status: "success" | "reverted";
                to: abitype.Address | null;
                transactionHash: viem.Hash;
                transactionIndex: number;
                type: viem.TransactionType;
                l1GasPrice: bigint | null;
                l1GasUsed: bigint | null;
                l1Fee: bigint | null;
                l1FeeScalar: number | null;
            } & {};
            type: "transactionReceipt";
        };
    };
    serializers: {
        readonly transaction: typeof viem_chains.serializeTransactionOpStack;
    };
}, {
    blockExplorers: {
        readonly default: {
            readonly name: "Etherscan";
            readonly url: "https://etherscan.io";
            readonly apiUrl: "https://api.etherscan.io/api";
        };
    };
    contracts: {
        readonly ensRegistry: {
            readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
        };
        readonly ensUniversalResolver: {
            readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
            readonly blockCreated: 19258213;
        };
        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;
    };
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://eth.merkle.io"];
        };
    };
    sourceId?: number | undefined | undefined;
    testnet?: boolean | undefined | undefined;
    custom?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters?: undefined;
    serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
}];
declare const DEFAULT_CHAIN: {
    blockExplorers: {
        readonly default: {
            readonly name: "Basescan";
            readonly url: "https://basescan.org";
            readonly apiUrl: "https://api.basescan.org/api";
        };
    };
    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;
    };
    rpcUrls: {
        readonly default: {
            readonly http: readonly ["https://mainnet.base.org"];
        };
    };
    sourceId: 1;
    testnet?: boolean | undefined | undefined;
    custom?: Record<string, unknown> | undefined;
    fees?: viem.ChainFees<undefined> | undefined;
    formatters: {
        readonly block: {
            exclude: [] | undefined;
            format: (args: viem_chains.OpStackRpcBlock) => {
                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: abitype.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) => ({
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                from: abitype.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: abitype.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: abitype.Address | null;
                from: abitype.Address;
                gas: bigint;
                nonce: number;
                value: bigint;
                blockHash: `0x${string}` | null;
                blockNumber: bigint | null;
                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;
                from: abitype.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: abitype.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;
                from: abitype.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: abitype.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;
                from: abitype.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: abitype.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;
                from: abitype.Address;
                gas: bigint;
                hash: viem.Hash;
                input: viem.Hex;
                nonce: number;
                r: viem.Hex;
                s: viem.Hex;
                to: abitype.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) => {
                blobGasPrice?: bigint | undefined;
                blobGasUsed?: bigint | undefined;
                blockHash: viem.Hash;
                blockNumber: bigint;
                contractAddress: abitype.Address | null | undefined;
                cumulativeGasUsed: bigint;
                effectiveGasPrice: bigint;
                from: abitype.Address;
                gasUsed: bigint;
                logs: viem.Log<bigint, number, false>[];
                logsBloom: viem.Hex;
                root?: `0x${string}` | undefined;
                status: "success" | "reverted";
                to: abitype.Address | null;
                transactionHash: viem.Hash;
                transactionIndex: number;
                type: viem.TransactionType;
                l1GasPrice: bigint | null;
                l1GasUsed: bigint | null;
                l1Fee: bigint | null;
                l1FeeScalar: number | null;
            } & {};
            type: "transactionReceipt";
        };
    };
    serializers: {
        readonly transaction: typeof viem_chains.serializeTransactionOpStack;
    };
};
declare const ChainIcons: {
    readonly 8453: react.FC<react.SVGProps<SVGSVGElement>>;
    readonly 10: react.FC<react.SVGProps<SVGSVGElement>>;
    readonly 1: react.FC<react.SVGProps<SVGSVGElement>>;
};
type Chain = (typeof chains)[number];
declare const LIST_OP_LIMITS: Record<number, number>;
declare const BLOCK_EXPLORERS: {
    1: {
        name: string;
        icon: react.FC<react.SVGProps<SVGSVGElement>>;
        url: (hash: Hex | string) => string;
    }[];
    10: {
        name: string;
        icon: react.FC<react.SVGProps<SVGSVGElement>>;
        url: (hash: Hex | string) => string;
    }[];
    8453: {
        name: string;
        icon: react.FC<react.SVGProps<SVGSVGElement>>;
        url: (hash: Hex | string) => string;
    }[];
};

declare const PROFILE_CARD_SOCIALS: readonly [{
    readonly name: "etherscan";
    readonly url: (address: string) => string;
    readonly icon: {
        readonly light: react.FC<react.SVGProps<SVGSVGElement>>;
        readonly dark: react.FC<react.SVGProps<SVGSVGElement>>;
    };
}, {
    readonly name: "ens";
    readonly url: (address: string) => string;
    readonly icon: {
        readonly light: react.FC<react.SVGProps<SVGSVGElement>>;
        readonly dark: react.FC<react.SVGProps<SVGSVGElement>>;
    };
}, {
    readonly name: "grails";
    readonly url: (address: string) => string;
    readonly icon: {
        readonly light: react.FC<{
            height: number;
            width: number;
        }>;
        readonly dark: react.FC<{
            height: number;
            width: number;
        }>;
    };
}, {
    readonly name: "opensea";
    readonly url: (address: string) => string;
    readonly icon: {
        readonly light: react.FC<{
            height: number;
            width: number;
        }>;
        readonly dark: react.FC<{
            height: number;
            width: number;
        }>;
    };
}, {
    readonly name: "vision";
    readonly url: (address: string) => string;
    readonly icon: {
        readonly light: react.FC<{
            height: number;
            width: number;
        }>;
        readonly dark: react.FC<{
            height: number;
            width: number;
        }>;
    };
}, {
    readonly name: "com.twitter";
    readonly url: (username: string) => string;
    readonly icon: {
        readonly light: react.FC<react.SVGProps<SVGSVGElement>>;
        readonly dark: react.FC<react.SVGProps<SVGSVGElement>>;
    };
}, {
    readonly name: "com.github";
    readonly url: (username: string) => string;
    readonly icon: {
        readonly light: react.FC<react.SVGProps<SVGSVGElement>>;
        readonly dark: react.FC<react.SVGProps<SVGSVGElement>>;
    };
}, {
    readonly name: "org.telegram";
    readonly url: (username: string) => string;
    readonly icon: {
        readonly light: react.FC<react.SVGProps<SVGSVGElement>>;
        readonly dark: react.FC<react.SVGProps<SVGSVGElement>>;
    };
}, {
    readonly name: "com.discord";
    readonly url: (username: string) => string;
    readonly icon: {
        readonly light: react.FC<react.SVGProps<SVGSVGElement>>;
        readonly dark: react.FC<react.SVGProps<SVGSVGElement>>;
    };
}, {
    readonly name: "email";
    readonly url: (email: string) => string;
    readonly icon: {
        readonly light: react.FC<react.SVGProps<SVGSVGElement>>;
        readonly dark: react.FC<react.SVGProps<SVGSVGElement>>;
    };
}];

declare const TEXT_RECORD_KEYS: readonly ["description", "status", "location", "url", "email", "com.twitter", "com.github", "org.telegram", "com.discord", "avatar", "header"];
declare const ADDRESS_RECORD_KEYS: readonly ["btc"];
declare const COIN_TYPES: Record<string, number>;
declare const SOCIAL_RECORDS: readonly [{
    readonly key: "com.twitter";
    readonly label: "Twitter / X";
    readonly icon: {
        readonly light: react.FC<react.SVGProps<SVGSVGElement>>;
        readonly dark: react.FC<react.SVGProps<SVGSVGElement>>;
    };
    readonly placeholder: "username";
}, {
    readonly key: "com.github";
    readonly label: "GitHub";
    readonly icon: {
        readonly light: react.FC<react.SVGProps<SVGSVGElement>>;
        readonly dark: react.FC<react.SVGProps<SVGSVGElement>>;
    };
    readonly placeholder: "username";
}, {
    readonly key: "org.telegram";
    readonly label: "Telegram";
    readonly icon: {
        readonly light: react.FC<react.SVGProps<SVGSVGElement>>;
        readonly dark: react.FC<react.SVGProps<SVGSVGElement>>;
    };
    readonly placeholder: "username";
}, {
    readonly key: "com.discord";
    readonly label: "Discord";
    readonly icon: {
        readonly light: react.FC<react.SVGProps<SVGSVGElement>>;
        readonly dark: react.FC<react.SVGProps<SVGSVGElement>>;
    };
    readonly placeholder: "username";
}];
declare const ADDRESS_LABELS: Record<string, string>;

declare const coreEfpContracts: {
    EFPAccountMetadata: Address$1;
    EFPListRegistry: Address$1;
    EFPListRecords: Address$1;
    EFPListMinter: Address$1;
};
declare const ListRecordContracts: Record<number, Address$1>;

declare const transports: {
    1: viem.HttpTransport<undefined, false>;
    8453: viem.HttpTransport<undefined, false>;
    10: viem.HttpTransport<undefined, false>;
};

declare const EFPActionIds: Record<EFPActionType, string>;
declare const TRANSACTION_TITLES: {
    [EFPActionIds.CreateEFPList]: string;
    [EFPActionIds.UpdateEFPList]: string;
};
declare const ACTION_ITEM_ICON: {
    follow: {
        icon: react.FC<react.SVGProps<SVGSVGElement>>;
        color: string;
    };
    unfollow: {
        icon: react.FC<react.SVGProps<SVGSVGElement>>;
        color: string;
    };
    tag: {
        icon: react.FC<react.SVGProps<SVGSVGElement>>;
        color: string;
    };
    untag: {
        icon: react.FC<react.SVGProps<SVGSVGElement>>;
        color: string;
    };
    block: {
        icon: react.FC<react.SVGProps<SVGSVGElement>>;
        color: string;
    };
    unblock: {
        icon: react.FC<react.SVGProps<SVGSVGElement>>;
        color: string;
    };
    mute: {
        icon: react.FC<react.SVGProps<SVGSVGElement>>;
        color: string;
    };
    unmute: {
        icon: react.FC<react.SVGProps<SVGSVGElement>>;
        color: string;
    };
    'add to Top 8': {
        icon: react.FC<react.SVGProps<SVGSVGElement>>;
        color: string;
    };
    'remove from Top 8': {
        icon: react.FC<react.SVGProps<SVGSVGElement>>;
        color: string;
    };
};
/**
 * Opcodes for list operations
 */
declare const Opcode: {
    readonly FOLLOW: 1;
    readonly UNFOLLOW: 2;
    readonly TAG: 3;
    readonly UNTAG: 4;
};

declare const defaultTranslations: Record<TranslationKey, string>;

declare const FOLLOW_BUTTON_STYLES: Record<FollowingState, string>;
declare const FOLLOW_BUTTON_COOL_EMOJI: Record<FollowingState, string | undefined>;

declare const EFP_API_URL = "https://data.ethfollow.xyz/api/v1";
declare const GRAILS_API_URL = "https://api.grails.app/api/v1";
declare const ENS_METADATA_URL = "https://metadata.ethid.org";
declare const DEFAULT_FALLBACK_AVATAR = "https://efp.app/assets/art/default-avatar.svg";
declare const DEFAULT_FALLBACK_HEADER = "https://efp.app/assets/art/default-header.svg";
declare const DEFAULT_RECENT_TAGS: string[];
declare const DEFAULT_LOADING_GRADIENT = "linear-gradient(90deg, rgba(200, 200, 200, 0.7) 0%, rgba(172, 172, 172, 0.05) 50%, rgba(200, 200, 200, 0.7) 100%)";
declare const LIGHT_LOADING_GRADIENT = "linear-gradient(90deg, rgba(212, 212, 212, 0.9) 0%, rgba(132, 132, 132, 0.2) 50%, rgba(212, 212, 212, 0.9) 100%)";
declare const THEMES: readonly ["light", "dark"];
declare const noFollowersYouKnow: {
    results: never[];
    length: number;
};
declare const FETCH_LIMIT = 20;

type LoadingCellProps = {
    gradient?: string;
    height?: string | number;
    width?: string | number;
    radius?: string | number;
} & React.HTMLAttributes<HTMLDivElement>;

/**
 * LoadingCell component - displays a loading cell
 *
 * @param gradient - the gradient of the loading cell
 *
 * @param height - the height of the loading cell
 *
 * @param width - the width of the loading cell
 *
 * @param radius - the radius of the loading cell
 *
 * @param props - HTML div element props
 *
 * @returns LoadingCell component
 */
declare const LoadingCell: react__default.FC<LoadingCellProps>;

interface ImageWithFallbackProps {
    src?: string;
    fallback: string;
    alt: string;
    style?: React.CSSProperties;
}

/**
 * ImageWithFallback component - displays an image with a fallback
 *
 * @param src - the source of the image
 * @param fallback - the fallback image
 * @param alt - the alt text of the image
 * @param style - the style of the image
 * @returns ImageWithFallback component
 */
declare const ImageWithFallback: react__default.FC<ImageWithFallbackProps>;

type InputProps = {
    darkMode?: boolean;
    label?: string;
} & react__default.InputHTMLAttributes<HTMLInputElement>;

/**
 * Input component - a styled single-line text input
 *
 * @param label - optional label displayed above the input (optional)
 *
 * @param darkMode - render the input in dark mode (optional)
 *
 * @param className - additional CSS class applied to the input element (optional)
 *
 * @param props - native HTML input element props
 *
 * @returns Input component
 */
declare const Input: react__default.FC<InputProps>;

type TextareaProps = {
    darkMode?: boolean;
    label?: string;
} & react__default.TextareaHTMLAttributes<HTMLTextAreaElement>;

/**
 * Textarea component - a styled multi-line text input
 *
 * @param label - optional label displayed above the textarea (optional)
 *
 * @param darkMode - render the textarea in dark mode (optional)
 *
 * @param className - additional CSS class applied to the textarea element (optional)
 *
 * @param props - native HTML textarea element props
 *
 * @returns Textarea component
 */
declare const Textarea: react__default.FC<TextareaProps>;

type Tab = {
    label: string;
    value: string;
};
type TabSelectorProps = {
    tabs: Tab[];
    selectedTab: string;
    setSelectedTab: (value: string) => void;
    darkMode?: boolean;
} & Omit<react__default.HTMLAttributes<HTMLDivElement>, 'onChange'>;

/**
 * TabSelector component - a segmented control for switching between tabs
 *
 * @param tabs - array of tabs to display, each with a label and value
 *
 * @param selectedTab - the value of the currently selected tab
 *
 * @param setSelectedTab - callback fired with the value of the newly selected tab
 *
 * @param darkMode - render the selector in dark mode (optional)
 *
 * @param className - additional CSS class applied to the container (optional)
 *
 * @param props - native HTML div element props
 *
 * @returns TabSelector component
 */
declare const TabSelector: react__default.FC<TabSelectorProps>;

type AvatarProps = {
    address?: string | null;
    src?: string | null;
    name?: string | null;
    fallback?: string;
    onClick?: (e: React.MouseEvent<HTMLDivElement>) => void;
    style?: React.CSSProperties;
} & React.HTMLAttributes<HTMLDivElement>;

/**
 * Avatar component - displays an avatar image of a profile
 *
 * @param address - the address for the profile of the avatar
 *
 * @param src - the source of the avatar image
 *
 * @param name - the ENS name of the avatar
 *
 * @param fallback - the fallback avatar image
 *
 * @param style - the style of the avatar
 *
 * @param onClick - the function to be called when the avatar is clicked
 *
 * @param props - HTML div element props
 *
 * @returns Avatar component
 */
declare const Avatar: react__default.FC<AvatarProps>;

type EFPPoapsProps = {
    addressOrName?: Address | string | null;
    isLoading: boolean;
    list?: number | null;
    style?: React.CSSProperties;
    hideEFPPoaps?: boolean;
    customPoaps?: ProfileEFPPoapResponse[];
};

declare const EFPPoaps: react__default.FC<EFPPoapsProps>;

interface TagsProps {
    address: Address;
    existingTags?: string[];
    canEditTags?: boolean;
}
declare const Tags: React.FC<TagsProps>;

type FollowerTagProps = {
    lookupAddressOrName: Address | string;
    connectedAddress: Address;
    list?: ProfileListType;
    showLoading?: boolean;
} & React.HTMLAttributes<HTMLDivElement>;

/**
 * Follower State Tag - displays the relation of address to connectedAddress/list
 *
 * @param address - the address of the follower
 *
 * @param connectedAddress - the address of the currently connected user
 *
 * @param list - the list of the user (selected list in EFP app)
 *
 * @param className - the class name to apply to the follower tag
 *
 * @param showLoading - whether to show the loading cell
 *
 * @param props - HTML div element props
 *
 * @returns FollowerTag component
 */
declare const FollowerTag: React.FC<FollowerTagProps>;

/**
 * ProfileList component - displays a list of profiles
 *
 * @param profiles - the profiles to display
 *
 * @param darkMode - whether the component is in dark mode
 *
 * @param connectedAddress - the address of the connected user
 *
 * @param selectedList - the list to display
 *
 * @param isLoading - whether the component is loading
 *
 * @param loadingRows - the number of loading rows to display
 *
 * @param tags - the tags to display
 *
 * @param showTags - whether to show the tags
 *
 * @param canEditTags - whether to allow editing of the tags
 *
 * @param initialFollowState - the initial follow state for FollowButton
 *
 * @param onProfileClick - the function to call when the name/address or avatar is clicked
 *
 * @param showHeaderImage - whether to show the header image
 *
 * @param rowHeight - the height of each row
 *
 * @param visibleCount - the number of visible rows
 *
 * @param overscanCount - the number of rows to overscan
 *
 * @param listHeight - the height of the list
 *
 * @param showFollowsYouBadges - whether to show the follows you badges
 *
 * @param showBlockBack - whether to show block back
 *
 * @param showProfileTooltip - whether to show profile tooltip
 */
declare const ProfileList: react.ForwardRefExoticComponent<ProfileListProps & react.RefAttributes<HTMLDivElement>>;

interface ProfileStatsProps {
    addressOrName: Address | string;
    list?: ProfileListType;
    fontSize?: SizeType;
    gap?: string;
    prefetched?: {
        stats: StatsResponse | undefined;
        isLoading: boolean;
    };
    containerDirection?: 'row' | 'column';
    statsDirection?: 'row' | 'column';
    onStatClick?: ({ addressOrName, stat }: ProfileStatsClickProps) => void;
}

/**
 * Component for displaying follower and following stats for a given address or list
 *
 * @param addressOrName - Address or ENS name to lookup stats for (required)
 *
 * @param list - List to lookup stats for - will override addressOrName (optional)
 *
 * @param containerDirection - Direction of the container (optional, default: 'row')
 *
 * @param statsDirection - Direction of the stats (optional, default: 'column')
 *
 * @param fontSize - Font size of the stats (optional, default: 'md')
 *
 * @param gap - Gap between the stats (optional, default: '32px')
 *
 * @param isPrefetchedStatsLoading - Whether the stats are prefetched and loading (optional, default: false)
 *
 * @param onStatClick - Function to be called when a stat is clicked (optional)
 *
 * @param props - HTML div element props
 *
 * @returns ProfileStats component
 */
declare const ProfileStats: react__default.FC<ProfileStatsProps>;

interface ProfileSocialsProps {
    name?: string;
    userAddress?: Address;
    records: ProfileDetailsResponse['ens']['records'];
    includeUrls?: boolean;
    showEmptySocials?: boolean;
    iconSize?: number;
    isLoading?: boolean;
    darkMode?: boolean;
    style?: React.CSSProperties;
    hideSocials?: ProfileEFPSocialType[];
}

/**
 * Component to display the social links of a user
 *
 * @param userAddress - The address of the user (required)
 *
 * @param name - The name of the user (optional)
 *
 * @param records - The records of the user (required)
 *
 * @param darkMode - Whether the profile is in dark mode (optional)
 *
 * @param includeUrls - Whether to include the URLs in the profile (optional)
 *
 * @param iconSize - The size of the icons (optional)
 *
 * @param isLoading - Whether the profile is loading (optional)
 *
 * @returns ProfileSocials component
 */
declare const ProfileSocials: react__default.FC<ProfileSocialsProps>;

type ProfileListRowProps = {
    profile: ProfileItemType;
    connectedAddress?: Address;
    selectedList?: ProfileListType;
    tags?: string[];
    showTags?: boolean;
    canEditTags?: boolean;
    initialFollowState?: InitialFollowingState;
    onProfileClick?: (address: Address) => void;
    showHeaderImage?: boolean;
    showFollowsYouBadges?: boolean;
    rowHeight?: number;
    showBlockBack?: boolean;
    showProfileTooltip?: boolean;
};

/**
 * ProfileListRow component - displays a row of a profile in a list
 *
 * @param profile - the profile to display
 *
 * @param connectedAddress - the address of the connected user
 *
 * @param selectedList - the list to display
 *
 * @param showTags - whether to show the tags
 *
 * @param canEditTags - whether to allow editing of the tags
 *
 * @param tags - the tags to display
 *
 * @param initialFollowState - the initial follow state for FollowButton
 *
 * @param onProfileClick - the function to call when the name/address or avatar is clicked
 */
declare const ProfileListRow: react__default.FC<ProfileListRowProps>;

type TransactionModalProps = React.HTMLAttributes<HTMLDivElement> & {
    darkMode?: boolean;
    onCartProfileClick?: (address: Address) => void;
    showRecommendations?: boolean;
    showPoapClaim?: boolean;
};

/**
 * Transaction Modal - allows user to initiate transactions on-chain
 *
 * @param darkMode - whether the component is in dark mode
 * @param className - additional class name for the transaction modal
 * @param onCartProfileClick - the function to call when the profile displayed in the cart is clicked
 * @param showRecommendations - whether to show recommendations and manual add beside the items in the cart
 * @param showPoapClaim - whether to show claim poap modal after minting a new list
 * @param props - HTML div element props
 *
 * @returns TransactionModal component
 */
declare const TransactionModal: React.FC<TransactionModalProps>;

type FollowersYouKnowProps = {
    connectedAddress: Address;
    selectedList?: ProfileListType;
    lookupAddressOrName: Address | string;
    onProfileClick?: (address: Address) => void;
    hasModal?: boolean;
    showEmpty?: boolean;
    showLoading?: boolean;
    darkMode?: boolean;
};

/**
 * FollowersYouKnow component - displays the common followers between two addresses
 * The component is used to display how many people you follow also follow a given address
 *
 * @param connectedAddress - the address of the connected user
 *
 * @param lookupAddressOrName - the address or ENS name to compare followers with
 *
 * @param showEmpty (optional) - whether to display the component when there are no common followers (no common followers text)
 *
 * @param showLoading (optional) - whether to show the loading skeleton
 *
 * @param onProfileClick (optional) - the function to call when a profile is clicked
 *
 * @param hasModal (optional) - whether to show the modal when the component is clicked
 *
 * @param darkMode (optional) - whether to use dark mode
 *
 * @param selectedList (optional) - the list to use for the common followers
 *
 * @returns FollowersYouKnow component
 */
declare const FollowersYouKnow: React.FC<FollowersYouKnowProps>;

/**
 * Component to  allow signing in with Ethereum (SIWE) - https://login.xyz/
 *
 * @param message - The message to display to the user (optional)
 *
 * @param verifySignature - The function to verify the signature on your backend (required)
 *
 * @param getNonce - The function to get the nonce from your backend (required)
 *
 * @param onSignInSuccess - The function to call when the user signs in successfully (optional)
 *
 * @param onSignInError - The function to call when the user signs in fails (optional)
 *
 * @param onDisconnectedClick - The function to call when the user is not connected (optional)
 *
 * @param darkMode - Whether the profile is in dark mode (optional)
 *
 * @param expirationTime - The expiration time of the nonce (optional) default is 5 minutes
 *
 * @param autoSignInAfterConnection - Whether to automatically sign in after wallet connection (optional) default is false
 *
 * @returns SignInWithEthereum Button component
 */
declare const SignInWithEthereum$1: ({ verifySignature, onSignInSuccess, onSignInError, message, getNonce, onDisconnectedClick, darkMode, expirationTime, autoSignInAfterConnection, }: SignInWithEthereumProps) => react_jsx_runtime.JSX.Element;

/**
 * Component to  allow signing in with Ethereum (SIWE) - https://login.xyz/
 *
 * @param message - The message to display to the user (optional)
 *
 * @param verifySignature - The function to verify the signature on your backend (required)
 *
 * @param getNonce - The function to get the nonce from your backend (required)
 *
 * @param onSignInSuccess - The function to call when the user signs in successfully (optional)
 *
 * @param onSignInError - The function to call when the user signs in fails (optional)
 *
 * @param onDisconnectedClick - The function to call when the user is not connected (optional)
 *
 * @param darkMode - Whether the profile is in dark mode (optional)
 *
 * @param expirationTime - The expiration time of the nonce (optional) default is 5 minutes
 *
 * @param autoSignInAfterConnection - Whether to automatically sign in after wallet connection (optional) default is false
 *
 * @param onSignedInClick - The function to call when the user is signed in (optional)
 *
 * @param isSignedIn - Whether the user is signed in (optional)
 *
 * @param isDropdown - Whether the profile is in a dropdown (optional)
 *
 * @param isDropdownOpen - Whether the dropdown is open (optional)
 *
 * @param hideName - Whether to hide the name (optional)
 *
 * @param hideAvatar - Whether to hide the avatar (optional)
 *
 * @param hideHeader - Whether to hide the header (optional)
 *
 * @returns SignInWithEthereum Button component
 */
declare const SignInWithEthereum: ({ verifySignature, onSignInSuccess, onSignInError, message, getNonce, onDisconnectedClick, darkMode, expirationTime, autoSignInAfterConnection, onSignedInClick, isSignedIn, isDropdown, isDropdownOpen, hideName, hideAvatar, hideHeader, }: SignInButtonProps) => react_jsx_runtime.JSX.Element;

interface BioProps {
    description?: string;
    fontSize?: number;
    maxLines?: number;
    className?: string;
    showMore?: boolean;
    onBioLinkClick?: (link: string) => void;
}
declare const Bio: react__default.FC<BioProps>;

type ProfileExtraOptions = {
    role?: string;
    customFollowButton?: React.ReactNode;
    nameMenu?: React.ReactNode;
    openListSettings?: () => void;
    onEditProfileClick?: () => void;
    prefetched?: {
        profile: {
            data: ProfileDetailsResponse | undefined;
            isLoading: boolean;
            refetch: () => void;
        };
        stats: {
            data: StatsResponse | undefined;
            isLoading: boolean;
            refetch: () => void;
        };
    };
    customPoaps?: ProfileEFPPoapResponse[];
    hideEFPPoaps?: boolean;
    hideSocials?: ProfileEFPSocialType[];
    onBioLinkClick?: (link: string) => void;
};
interface FullWidthProfileProps {
    addressOrName: Address | string;
    connectedAddress?: Address;
    list?: ProfileListType;
    selectedList?: string;
    darkMode?: boolean;
    showPoaps?: boolean;
    showFollowerState?: boolean;
    showFollowButton?: boolean;
    showEmptySocials?: boolean;
    onProfileClick?: (addressOrName: Address | string) => void;
    onStatClick?: ({ addressOrName, stat }: ProfileStatsClickProps) => void;
    extraOptions?: ProfileExtraOptions;
    className?: string;
    style?: React.CSSProperties;
    alignProfileContent?: 'center' | 'start' | 'end';
}

type ProfileCardProps$1 = {
    addressOrName: Address | string;
    list?: ProfileListType;
    connectedAddress?: Address;
    darkMode?: boolean;
    showFollowerState?: boolean;
    showPoaps?: boolean;
    showFollowButton?: boolean;
    showEmptySocials?: boolean;
    onProfileClick?: (addressOrName: Address | string) => void;
    onStatClick?: ({ addressOrName, stat }: ProfileStatsClickProps) => void;
    extraOptions?: ProfileExtraOptions;
    selectedList?: ProfileListType;
    hasCommonFollowersModal?: boolean;
} & React.HTMLAttributes<HTMLDivElement>;

/**
 * Profile Card for an Ethereum Profile. Includes ENS and EFP profile data to be displayed in any Web3 app.
 *
 * @param addressOrName - Ethereum Address or ENS name to fetch profile data for (required)
 *
 * @param list - Search profile data by list number - will override addressOrName if provided (used in EFP app) (optional)
 *
 * @param connectedAddress - Address of the user connected to the app (optional)
 *
 * @param darkMode - (optional)
 *
 * @param showFollowerState - shows follower state tag (follows you, blocks you, mutes you) (optional)
 *
 * @param showPoaps - shows EFP POAPs on the profile card (optional)
 *
 * @param onStatClick - action to be performed when a stat is clicked - default goes to EFP profile with selected stat (optional)
 *
 * @param options - see ProfileCardOption type for all options (optional)
 *
 * @param className - string (optional)
 *
 * @param style - CSS Properties (optional)
 *
 * @param props - HTML div element props (optional)
 *
 * @param hasCommonFollowersModal - Whether to show the common followers modal (optional)
 *
 * @returns ProfileCard component
 */
declare const ProfileCard: react__default.FC<ProfileCardProps$1>;

type FollowButtonProps = {
    lookupAddress: Address;
    connectedAddress?: Address;
    customOnClick?: (state: FollowingState) => void;
    onDisconnectedClick?: () => void;
    disabled?: boolean;
    sounds?: Record<FollowingState, string | undefined>;
    customClassNames?: Record<FollowingState, string>;
    customLoader?: React.ReactNode;
    selectedList?: ProfileListType;
    initialState?: InitialFollowingState;
    forceState?: ForceFollowingState;
    showBlockBack?: boolean;
    showMuteBack?: boolean;
} & React.HTMLAttributes<HTMLButtonElement>;

/**
 * Follow Button - displays current state of the relation between lookupAddress and connectedAddress
 * and allows the user to perform actions towards the lookupAddress
 *
 * @param lookupAddress - the address of the follower
 *
 * @param connectedAddress (optional) - the address of the currently connected user
 *
 * @param disabled (optional) - whether the button is disabled
 *
 * @param onDisconnectedClick (optional) - the function to call when the button is clicked and the user is not connected
 *
 * @param sounds (optional) - the sounds to play when the button is clicked
 *
 * @param customClassNames (optional) - the custom class names to apply to the button depending on the state of the button
 *
 * @param className (optional) - the additional class name to apply to the follower tag
 *
 * @param customLoader (optional) - the custom loader to use instead of the default one
 *
 * @param selectedList (optional) - the selected list to use for the follow state lookup
 *
 * @param initialState (optional) - the initial state to use for the follow state
 *
 * @param forceState (optional) - the force state to use instead of the initial state
 *
 * @param showBlockBack (optional) - whether to show the block back button
 *
 * @param showMuteBack (optional) - whether to show the mute back button
 *
 * @param props - HTML button element props
 *
 * @returns FollowButton component
 */
declare const FollowButton: React.FC<FollowButtonProps>;

interface NotificationsProps {
    addressOrName: Address | string;
    position?: 'top' | 'bottom' | 'left' | 'right';
    align?: 'left' | 'center' | 'right' | 'top' | 'bottom';
    darkMode?: boolean;
    onProfileClick?: (address: Address) => void;
}

/**
 * Notifications component
 *
 * @param addressOrName - the address or name of the user to display notifications for
 *
 * @param position - the position of the notifications bell
 *
 * @param align - the alignment of the notifications bell
 *
 * @param darkMode - whether the dark mode is enabled
 *
 * @param onProfileClick - the function to call when a profile is clicked
 *
 */
declare const Notifications: react__default.FC<NotificationsProps>;

interface HeaderImageProps {
    src?: string;
    isLoading: boolean;
    name?: string | null;
    style?: react__default.CSSProperties;
}
/**
 * HeaderImage component - displays a header image of a profile
 * @param src - the source of the header image
 * @param isLoading - whether the header image is loading
 * @param style - the style of the header image
 * @param name - the name of the profile
 * @returns HeaderImage component
 */
declare const HeaderImage: react__default.FC<HeaderImageProps>;

/**
 * Full Width Profile for any Ethereum Profile. Includes ENS and EFP profile data to be displayed in any Web3 app.
 *
 * @param addressOrName - Ethereum Address or ENS name to fetch profile data for (required)
 *
 * @param list - Search profile data by list number - will override addressOrName if provided (used in EFP app) (optional)
 *
 * @param connectedAddress - Address of the user connected to the app (optional)
 *
 * @param darkMode - (optional)
 *
 * @param role - can be used to add any additional information to the profile (used to display roles on https://ethid.org) (optional)
 *
 * @param showFollowerState - shows follower state tag (follows you, blocks you, mutes you) (optional)
 *
 * @param onStatClick - action to be performed when a stat (following, followers) is clicked - default goes to EFP profile with selected stat (optional)
 *
 * @param selectedList - list number selected in you application for the connected user (optional)
 *
 * @param onProfileClick - action to be performed when the profile is clicked (optional)
 *
 * @param showPoaps - shows EFP related poaps on the profile (optional)
 *
 * @param alignProfileContent - can be used to align the profile content when max-width is surpassed (center, start, end) (optional)
 *
 * @param extraOptions - see ProfileCardOption type for all options (optional)
 *
 * @param className - string (optional)
 *
 * @param style - CSS Properties (optional)
 *
 * @param props - HTML div element props (optional)
 *
 * @returns ProfileCard component
 */
declare const FullWidthProfile: React.FC<FullWidthProfileProps>;

interface FollowersAndFollowingProps {
    user: string | Address;
    defaultTab: ProfileTabType;
    showTagsByDefault?: boolean;
    showBlocked?: boolean;
    showOnlyBlocked?: boolean;
    showRecommendations?: boolean;
    isConnectedUserProfile?: boolean;
    darkMode?: boolean;
    connectedAddress?: Address;
    selectedList?: string;
    onProfileClick?: (address: Address) => void;
    showHeaderImage?: boolean;
    useVirtualList?: boolean;
    rowHeight?: number;
    preventDefaultScroll?: boolean;
    showProfileTooltip?: boolean;
}

/**
 * Followers and Following component
 *
 * @param user - the user to display followers and following for
 *
 * @param defaultTab - the default tab to display
 *
 * @param canEditTags - whether the user can edit tags
 *
 * @param showTagsByDefault - whether to show tags by default (tags open by default)
 *
 * @param includeBlocked - whether to display blocked and muted users in the results
 *
 * @param showOnlyBlocked - whether to display only blocked and muted users in the results
 *
 * @param showRecommendations - whether to show recommendations on the following tab of a connected user with no lists
 *
 * @param isConnectedUserProfile - whether the user is the connected user
 *
 * @param darkMode - whether the dark mode is enabled
 *
 * @param connectedAddress - the address of the connected user
 *
 * @param onProfileClick - the function to call when a profile is clicked
 *
 * @param showHeaderImage - whether to show the header image
 *
 * @param rowHeight - the height of each row
 *
 * @param useVirtualList - whether to use virtual list
 *
 * @param showProfileTooltip - whether to show profile tooltip
 *
 * @param ref - the ref to the container
 *
 * @returns FollowersAndFollowing component
 */
declare const FollowersAndFollowing: react.ForwardRefExoticComponent<FollowersAndFollowingProps & react.RefAttributes<HTMLDivElement>>;

type ProfileTooltipExtraOptions = ProfileExtraOptions;
type ProfileCardProps = {
    addressOrName: Address | string;
    list?: ProfileListType;
    connectedAddress?: Address;
    darkMode?: boolean;
    showFollowerState?: boolean;
    showFollowButton?: boolean;
    showSocials?: boolean;
    showEmptySocials?: boolean;
    showBio?: boolean;
    showStatus?: boolean;
    includeGrails?: boolean;
    onProfileClick?: (addressOrName: Address | string) => void;
    onStatClick?: ({ addressOrName, stat }: ProfileStatsClickProps) => void;
    extraOptions?: ProfileTooltipExtraOptions;
    selectedList?: ProfileListType;
} & HTMLAttributes<HTMLDivElement>;
type ProfileTooltipProps = ProfileCardProps;
interface ProfileTooltipWrapperProps extends ProfileTooltipProps {
    children: ReactElement;
    inline?: boolean;
    verticalPlacement?: TooltipPlacement;
    horizontalPlacement?: 'left' | 'right';
    verticalOffset?: number;
    horizontalOffset?: number;
    showArrow?: boolean;
    showDelay?: number;
    hideDelay?: number;
    flipBehavior?: FlipBehavior;
    boundary?: Boundary;
    keepTooltipOnHover?: boolean;
}

/**
 * ProfileTooltip component
 *
 * @param children - elements that tooltip is wrapping (React.ReactElement)
 * @param inline - whether to display as inline (for text spans) or inline-block (boolean, default: false)
 * @param verticalPlacement - where to position the tooltip by default (TooltipPlacement)
 * @param horizontalPlacement - where to align the tooltip (left | right)
 * @param offset - number
 * @param showArrow - show arrow that points to the wrapped element (boolean)
 * @param showDelay - wait before showing the tooltip (number)
 * @param hideDelay - wait before hiding the tooltip (number)
 * @param flipBehavior - flip the tooltip to the opposite side if no space is available (FlipBehavior)
 * @param boundary - boundary of the tooltip (Boundary)
 * @param keepTooltipOnHover - keep the tooltip open when hovering over it (boolean)
 * @param profileCardProps - props for the ProfileTooltipCard component (ProfileTooltipProps)
 *
 * @returns ProfileTooltip component
 */
declare const ProfileTooltip: react__default.FC<ProfileTooltipWrapperProps>;

type ENSRecordsProps = {
    name: string;
    defaultTab: 'records' | 'roles';
    darkMode?: boolean;
    style?: React.CSSProperties;
    onClose?: () => void;
    onImageUpload?: (dataURL: string, type: 'avatar' | 'header') => Promise<string>;
    onSuccess?: () => void;
    onError?: (error: Error) => void;
};

declare const ENSRecords: React.FC<ENSRecordsProps>;

interface ResolvedInputProps {
    value: string;
    onChange: (value: string) => void;
    label?: string;
    placeholder?: string;
    className?: string;
    disabled?: boolean;
    darkMode?: boolean;
}

declare const ResolvedInput: React.FC<ResolvedInputProps>;

declare const Note: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Link: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Check: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Clock: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Arrow: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Cross: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Wallet: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Refresh: React.FC<React.SVGProps<SVGSVGElement>>;

declare const FollowIcon: React.FC<React.SVGProps<SVGSVGElement>>;

declare const MapPin: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Key$2: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Top8: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Pencil: React.FC<React.SVGProps<SVGSVGElement>>;

declare const PersonCircle: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Photo: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Quotes: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Key$1: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Tag: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Trash: React.FC<React.SVGProps<SVGSVGElement>>;

declare const ShortArrow$1: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Person: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Mute: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Key: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Calendar: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Bell: React.FC<React.SVGProps<SVGSVGElement>>;

declare const ShortArrow: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Ethereum$1: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Base: react__default.FC<react__default.SVGProps<SVGSVGElement>>;

declare const Ethereum: react__default.FC<react__default.SVGProps<SVGSVGElement>>;

declare const Optimism: react__default.FC<react__default.SVGProps<SVGSVGElement>>;

declare const X: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Ens$1: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Ens: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Dweb: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Email: react__default.FC<react__default.SVGProps<SVGSVGElement>>;

declare const Github$1: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Discord: react__default.FC<react__default.SVGProps<SVGSVGElement>>;

declare const Telegram: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Etherscan: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Github: React.FC<React.SVGProps<SVGSVGElement>>;

declare const EtherscanDark: React.FC<React.SVGProps<SVGSVGElement>>;

declare const Grails: React.FC<{
    height: number;
    width: number;
}>;

declare const Opensea: React.FC<{
    height: number;
    width: number;
}>;

declare const Vision: React.FC<{
    height: number;
    width: number;
}>;

export { ACTION_ITEM_ICON, ADDRESS_LABELS, ADDRESS_RECORD_KEYS, type AccountResponseType, type Address, Arrow, Avatar, type AvatarProps, BLOCK_EXPLORERS, Base, BaseRegistrarAbi, type BatchFollowStateProps, type BatchFollowStateResponse, Bell, Bio, type BlockedMutedTabType, COIN_TYPES, Calendar, type Chain, ChainIcons, Check, Clock, Cross, DAY, DEFAULT_CHAIN, DEFAULT_FALLBACK_AVATAR, DEFAULT_FALLBACK_HEADER, DEFAULT_LOADING_GRADIENT, DEFAULT_RECENT_TAGS, Discord, type DiscoverResponseType, Dweb, EFPActionIds, type EFPActionType, EFPPoaps, type EFPPoapsProps, EFP_API_URL, Ens$1 as ENS, Ens as ENSCircle, type ENSMetadataProfile, type ENSNameMetadataResponse, type ENSNameMetadataValue, type ENSProfile, ENSRecords, type ENSRecordsProps, ENS_METADATA_URL, Email, Ethereum, Ethereum$1 as EthereumIcon, Etherscan, EtherscanDark, FETCH_LIMIT, FOLLOW_BUTTON_COOL_EMOJI, FOLLOW_BUTTON_STYLES, FollowButton, type FollowButtonProps, FollowIcon, type FollowSortType, type FollowState, type FollowStatePropType, type FollowStateProps, type FollowStateResponse, type FollowStatusResponse, type FollowerResponse, FollowerTag, type FollowerTagProps, type FollowerYouKnow, FollowersAndFollowing, type FollowersAndFollowingProps, FollowersYouKnow, type FollowersYouKnowProps, type FollowersYouKnowResponse, type FollowingResponse, type FollowingState, type FollowingTagsResponse, type ForceFollowingState, FullWidthProfile, type FullWidthProfileProps, GRAILS_API_URL, type GetListOpsTransactionProps, Github$1 as Github, Github as GithubDark, Grails, type GrailsAPIResponse, type GrailsNameMetadataResponse, type GrailsProfileResponse, type GrailsRolesResponse, HOUR, HeaderImage, type Hex, ImageWithFallback, type ImageWithFallbackProps, type InfiniteProfileQueryProps, type InitialFollowingState, Input, type InputProps, Key, LIGHT_LOADING_GRADIENT, LIST_OP_LIMITS, type LanguageCode, type LeaderboardItem, Link, Key$2 as List, type ListOpType, ListRecordContracts, LoadingCell, type LoadingCellProps, MINUTE, MONTH, ShortArrow as MagnifyingGlass, MapPin, Mute, Note, type NotificationItemType, Notifications, type NotificationsProps, type NotificationsResponse, type OpCodeType, Opcode, Opensea, Optimism, PROFILE_CARD_SOCIALS, Pencil, Person, PersonCircle, Photo, type ProfileAccountResponse, type ProfileBadgeColletionType, type ProfileBadgesResponse, ProfileCard, type ProfileCardProps$1 as ProfileCardProps, type ProfileDetailsResponse, type ProfileDetailsWithStats, type ProfileEFPPoapColletionType, type ProfileEFPPoapResponse, type ProfileEFPSocialType, ProfileList, type ProfileListProps, ProfileListRow, type ProfileListRowProps, type ProfileListType, type ProfileListsResponse, type ProfileRanks, type ProfileRoles, ProfileSocials, type ProfileSocialsProps, type ProfileStatType, ProfileStats, type ProfileStatsClickProps, type ProfileStatsProps, type ProfileTabType, type ProfileTableTitleType, ProfileTooltip, type ProfileTooltipProps, PublicResolverAbi, Quotes, type RecommendedItemType, Refresh, RegistrarControllerAbi, RegistryAbi, Key$1 as Reset, ResolvedInput, type RolesType, SECOND, SOCIAL_RECORDS, ShortArrow$1 as ShortArrow, SignInWithEthereum as SignInButton, type SignInButtonProps, SignInWithEthereum$1 as SignInWithEthereum, type SignInWithEthereumProps, type SizeType, type StatsResponse, type SubmitButtonText, TEXT_RECORD_KEYS, THEMES, TRANSACTION_TITLES, type Tab, TabSelector, type TabSelectorProps, Tag, type TagCountType, Tags, Telegram, Textarea, type TextareaProps, Top8, TransactionModal, type TransactionModalProps, TransactionProvider, type TransactionType, type TranslationConfig, type TranslationFunction, type TranslationKey, type TranslationObject, TranslationProvider, type TranslationsMap, Trash, Vision, WEEK, Wallet, X, beautifyEnsName, chains, coreEfpContracts, createSiweMessageString, defaultOnStatClick, defaultTranslations, efpAccountMetadataAbi, efpListMinterAbi, efpListRecordsAbi, efpListRegistryAbi, efpListRegistryErc721Abi, extractAddressAndTag, fetchAccount, fetchAllFollowersYouKnow, fetchBatchFollowState, fetchFollowState, fetchFollowersYouKnow, fetchNameMetadata, fetchNameRoles, fetchNotifications, fetchProfileDetails, fetchProfileEFPPoaps, fetchProfileLists, fetchProfileStats, fetchRecommended, formatFollowersYouKnowText, formatListOpsTransaction, formatNameMetadata, formatNameMetadataRecord, formatNumber, formatQueryParams, formatTimeDiff, getListOpData, getListOpsFromTransaction, getListStorageLocation, getMintTxChainId, getMintTxNonce, getMintTxRecordsAddress, getPendingTxAddresses, getPendingTxAddressesAndTags, getPendingTxListOps, isAddress, isLinkValid, isValidEnsName, listMetadataAbi, listOpAddListRecord, listOpAddTag, listOpRemoveListRecord, listOpRemoveTag, listRecordsAbi, loadTranslationsFromJSON, noFollowersYouKnow, normalizeEnsName, prepareMintTransaction, transformTxsForLocalStorage, transports, truncateAddress, useChain, useCoolMode, useEFPPoaps, useFollowButton, useFollowerState, useFollowersAndFollowing, useFollowersYouKnow, useFollowersYouKnowModal, useFollowingState, useIsClient, useOutsideClick, useProfileDetails, useProfileStats, useRecommended, useSiwe, useTooltipPosition, useTransactionItem, useTransactions, useTranslation, useUserInfo, useWindowSize, validateEnsHeader };