@thenamespace/ens-components 0.9.0 → 0.10.0

package/dist/types/backend/index.d.ts

@@ -0,0 +1 @@
+export * from "./list-manager";

package/dist/types/backend/list-manager/index.d.ts

@@ -0,0 +1,57 @@
+import { SupportedNetwork } from "@/types";
+import { CreateListingRequest, GetRegistryParametersRequest, GetRegistryParametersResponse, ListingNetwork, ListingStatusDTO, ListingSuggestion, ListingSuggestionRequest, NamespaceListing } from "@/types/list-manager";
+import { Address } from "viem";
+export interface GetListedNamesQuery {
+    owner?: Address;
+    isVerified?: boolean;
+    page: number;
+    size: number;
+    nameNetwork: ListingNetwork;
+}
+interface PageResponse<T> {
+    totalItems: number;
+    page: number;
+    size: number;
+    items: T[];
+}
+export interface WidgetConfiguration {
+    widgetType: string;
+    widgetId: string;
+    widgetOwner: string;
+    logo?: string;
+    selectedNames: string[];
+    showRegisterEns: boolean;
+    name: string;
+}
+export interface CreateWidgetRequest {
+    widgetType: string;
+    name: string;
+    selectedNames?: string[];
+    logo?: string;
+    showRegisterEns: boolean;
+    widgetId?: string;
+}
+export declare class ListManagerClient {
+    private readonly backendURI;
+    private httpClient;
+    constructor(backendURI: string);
+    getListedName(ensName: string): Promise<NamespaceListing>;
+    deleteListing(ensName: string, network: SupportedNetwork, siweToken: string): Promise<import("axios").AxiosResponse<any, any, {}>>;
+    getListedNames(query: GetListedNamesQuery): Promise<PageResponse<NamespaceListing>>;
+    verifyListing(name: string, nameNetwork: SupportedNetwork): Promise<boolean>;
+    getListingStatus(name: string, network: SupportedNetwork, refreshCache?: boolean): Promise<ListingStatusDTO>;
+    getListingSuggestions(request: ListingSuggestionRequest): Promise<PageResponse<ListingSuggestion>>;
+    waitForVerificationStatus(name: string, retries?: number, waitSeconds?: number): Promise<boolean>;
+    private waitForSeconds;
+    getRegistryDeploymentParameters(request: GetRegistryParametersRequest, siweToken: string): Promise<GetRegistryParametersResponse>;
+    toListingNetwork(network: SupportedNetwork): ListingNetwork;
+    createListing(request: CreateListingRequest, siweToken: string): Promise<import("axios").AxiosResponse<any, any, {}>>;
+    updateListing(request: CreateListingRequest, siweToken: string): Promise<import("axios").AxiosResponse<any, any, {}>>;
+    private getSiweHeaders;
+    getOwnedWidgets(owner: Address): Promise<WidgetConfiguration[]>;
+    createWidget(request: CreateWidgetRequest, siweToken: string): Promise<string>;
+    updateWidget(widgetId: string, request: CreateWidgetRequest, siweToken: string): Promise<any>;
+    deleteWidget(widgetId: string, siweToken: string): Promise<any>;
+}
+export declare const createListingManagerClient: (backendUri: string) => ListManagerClient;
+export {};

package/dist/types/components/ens-names-registrar-component/ENSNamesRegistrarComponent.d.ts

@@ -0,0 +1,17 @@
+import "./ENSNamesRegistrarComponent.css";
+export interface ENSNamesRegistrarComponentProps {
+    name?: string;
+    duration?: number;
+    onNameChange?: (name: string) => void;
+    onDurationChange?: (duration: number) => void;
+    onBack?: () => void;
+    onClose?: () => void;
+    onNext?: () => void;
+    onCompleteProfile?: () => void;
+    onOpenWallet?: () => void;
+    onCompleteRegistration?: () => void;
+    onRegisterAnother?: () => void;
+    onViewName?: () => void;
+}
+export declare function ENSNamesRegistrarComponent({ name, duration: initialDuration, onNameChange, onDurationChange, onBack, onClose, onNext, onCompleteProfile, onOpenWallet, onCompleteRegistration, onRegisterAnother, onViewName, }: ENSNamesRegistrarComponentProps): import("react/jsx-runtime").JSX.Element;
+export default ENSNamesRegistrarComponent;

package/dist/types/components/{ens-names-register-component → ens-names-registrar-component}/sub-components/CostSummary.d.ts

@@ -5,6 +5,8 @@ interface CostSummaryProps {
     total: number;
     showExpiry?: boolean;
     expiryDate?: string;
+    isLoading?: boolean;
+    priceError?: string | null;
 }
-export declare function CostSummary({ duration, registrationCost, networkFee, total, showExpiry, expiryDate, }: CostSummaryProps): import("react/jsx-runtime").JSX.Element;
+export declare function CostSummary({ duration, registrationCost, networkFee, total, showExpiry, expiryDate, isLoading, priceError, }: CostSummaryProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/ens-names-registrar-component/sub-components/Header.d.ts

@@ -0,0 +1,8 @@
+interface HeaderProps {
+    showBack?: boolean;
+    showClose?: boolean;
+    onBack?: () => void;
+    onClose?: () => void;
+}
+export declare function Header({ showBack, showClose, onBack, onClose }: HeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/{ens-names-register-component → ens-names-registrar-component}/sub-components/NameSearch.d.ts

@@ -4,6 +4,9 @@ interface NameSearchProps {
     onBack?: () => void;
     onClose?: () => void;
     onNext: () => void;
+    isChecking?: boolean;
+    isAvailable?: boolean;
+    isTaken?: boolean;
 }
-export declare function NameSearch({ ensName, onNameChange, onBack, onClose, onNext, }: NameSearchProps): import("react/jsx-runtime").JSX.Element;
+export declare function NameSearch({ ensName, onNameChange, onBack, onClose, onNext, isChecking, isAvailable, isTaken, }: NameSearchProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/{ens-names-register-component → ens-names-registrar-component}/sub-components/RegistrationForm.d.ts

@@ -10,6 +10,13 @@ interface RegistrationFormProps {
     onClose?: () => void;
     onNext: () => void;
     onCompleteProfile?: () => void;
+    isLoadingPrice?: boolean;
+    priceError?: string | null;
+    nameAvailability?: {
+        isAvailable: boolean;
+        isChecking: boolean;
+    };
+    canProceed?: boolean;
 }
-export declare function RegistrationForm({ ensName, duration, registrationCost, networkFee, total, onNameChange, onDurationChange, onBack, onClose, onNext, onCompleteProfile, }: RegistrationFormProps): import("react/jsx-runtime").JSX.Element;
+export declare function RegistrationForm({ ensName, duration, registrationCost, networkFee, total, onNameChange, onDurationChange, onBack, onClose, onNext, onCompleteProfile, isLoadingPrice, priceError, nameAvailability, canProceed, }: RegistrationFormProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/ens-names-registrar-component/sub-components/RegistrationProcess.d.ts

@@ -0,0 +1,10 @@
+import { EnsRegistrationContext } from "@/hooks";
+interface RegistrationProcessProps {
+    registrations: EnsRegistrationContext[];
+    onBack: () => void;
+    onClose?: () => void;
+    onCompleteProfile?: () => void;
+    onRegistrationComplete?: () => void;
+}
+export declare function RegistrationProcess({ registrations, onBack, onClose, onCompleteProfile, onRegistrationComplete, }: RegistrationProcessProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/index.d.ts

@@ -3,8 +3,8 @@ export { PendingTransaction, TransactionState, } from "./pending-transaction/Pen
 export { ENSNameCard } from "./ens-names-card/EnsNameCard";
 export { ProfileCard } from "./ens-profile-card/ProfileCard";
 export { NavbarProfileCard } from "./ens-navbar-profile-card/NavbarProfileCard";
-export { EnsOnChainRegisterModal } from "./ens-onchain-register-modal/EnsOnChainRegisterModal";
-export { EnsOffChainRegisterModal } from "./ens-offchain-register-modal/EnsOffChainRegisterModal";
-export { ENSNamesRegisterComponent } from "./ens-names-register-component/ENSNamesRegisterComponent";
+export { SubnameOnChainRegistrarModal } from "./subname-onchain-registrar-modal/SubnameOnChainRegistrarModal";
+export { SubnameOffChainRegistrarModal } from "./subname-offchain-registrar-modal/SubnameOffChainRegistrarModal";
+export { ENSNamesRegistrarComponent } from "./ens-names-registrar-component/ENSNamesRegistrarComponent";
 export * from "./atoms";
 export * from "./molecules";

package/dist/types/components/{ens-offchain-register-modal/EnsOffChainRegisterModal.d.ts → subname-offchain-registrar-modal/SubnameOffChainRegistrarModal.d.ts}

@@ -1,5 +1,5 @@
-import "./EnsOffChainRegisterModal.css";
-export interface EnsOffChainRegisterModalProps {
+import "./SubnameOffChainRegistrarModal.css";
+export interface SubnameOffChainRegistrarModalProps {
     step?: number;
     name?: string;
     profileComplete?: boolean;
@@ -15,4 +15,4 @@ export interface EnsOffChainRegisterModalProps {
     onRegisterAnother?: () => void;
     onViewName?: () => void;
 }
-export declare function EnsOffChainRegisterModal({ step: initialStep, name: initialName, profileComplete, onStepChange, onNameChange, onProfileCompleteChange, onRegister, onCancel, onClose, onCompleteProfile, onOpenWallet, onCompleteRegistration, onRegisterAnother, onViewName, }: EnsOffChainRegisterModalProps): import("react/jsx-runtime").JSX.Element;
+export declare function SubnameOffChainRegistrarModal({ step: initialStep, name: initialName, profileComplete, onStepChange, onNameChange, onProfileCompleteChange, onRegister, onCancel, onClose, onCompleteProfile, onOpenWallet, onCompleteRegistration, onRegisterAnother, onViewName, }: SubnameOffChainRegistrarModalProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/{ens-onchain-register-modal/EnsOnChainRegisterModal.d.ts → subname-onchain-registrar-modal/SubnameOnChainRegistrarModal.d.ts}

@@ -1,5 +1,5 @@
-import "./EnsOnChainRegisterModal.css";
-export interface EnsOnChainRegisterModalProps {
+import "./SubnameOnChainRegistrarModal.css";
+export interface SubnameOnChainRegistrarModalProps {
     step?: number;
     name?: string;
     profileComplete?: boolean;
@@ -27,4 +27,4 @@ export interface EnsOnChainRegisterModalProps {
     onViewName?: () => void;
     onFinish?: () => void;
 }
-export declare function EnsOnChainRegisterModal({ step: initialStep, name: initialName, profileComplete, domainSuffix, owner: initialOwner, duration: initialDuration, registrationFee, networkFee, totalCost, useAsPrimary: initialUseAsPrimary, profileImageUrl, onStepChange, onNameChange, onProfileCompleteChange, onOwnerChange, onDurationChange, onUseAsPrimaryChange, onRegister, onCancel, onClose, onCompleteProfile, onOpenWallet, onCompleteRegistration, onRegisterAnother, onViewName, onFinish, }: EnsOnChainRegisterModalProps): import("react/jsx-runtime").JSX.Element;
+export declare function SubnameOnChainRegistrarModal({ step: initialStep, name: initialName, profileComplete, domainSuffix, owner: initialOwner, duration: initialDuration, registrationFee, networkFee, totalCost, useAsPrimary: initialUseAsPrimary, profileImageUrl, onStepChange, onNameChange, onProfileCompleteChange, onOwnerChange, onDurationChange, onUseAsPrimaryChange, onRegister, onCancel, onClose, onCompleteProfile, onOpenWallet, onCompleteRegistration, onRegisterAnother, onViewName, onFinish, }: SubnameOnChainRegistrarModalProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/{ens-onchain-register-modal → subname-onchain-registrar-modal}/sub-components/RegistrationStep.d.ts

@@ -12,11 +12,10 @@ export interface RegistrationStepProps {
     onBack?: () => void;
     onCancel?: () => void;
     onRegister?: () => void;
-    onNext?: () => void;
     onClose?: () => void;
     onOwnerChange?: (owner: string) => void;
     onDurationChange?: (duration: number) => void;
     onUseAsPrimaryChange?: (useAsPrimary: boolean) => void;
     onCompleteProfile?: () => void;
 }
-export declare function RegistrationStep({ name, domainSuffix, owner, duration: initialDuration, registrationFee, networkFee, totalCost, useAsPrimary: initialUseAsPrimary, profileComplete, profileImageUrl, onBack, onCancel, onRegister, onNext, onClose, onOwnerChange, onDurationChange, onUseAsPrimaryChange, onCompleteProfile, }: RegistrationStepProps): import("react/jsx-runtime").JSX.Element;
+export declare function RegistrationStep({ name, domainSuffix, owner, duration: initialDuration, registrationFee, networkFee, totalCost, useAsPrimary: initialUseAsPrimary, profileComplete, profileImageUrl, onBack, onCancel, onRegister, onClose, onOwnerChange, onDurationChange, onUseAsPrimaryChange, onCompleteProfile, }: RegistrationStepProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/constants/records/addressConstants.d.ts

@@ -1,4 +1,5 @@
 import { ChainName } from "@/types";
+import { IconName } from "@/components";
 export interface SupportedEnsAddress {
     validateFunc?: (value: string) => boolean;
     isEMV?: boolean;
@@ -12,3 +13,14 @@ export declare const supportedAddresses: SupportedEnsAddress[];
 export declare const getSupportedAddressMap: () => Record<number, SupportedEnsAddress>;
 export declare const getSupportedAddressByCoin: (coin: number) => SupportedEnsAddress | undefined;
 export declare const getSupportedAddressByName: (name: ChainName) => SupportedEnsAddress | undefined;
+export type TextCategory = "profile" | "social";
+export interface SupportedText {
+    iconUrl: string;
+    key: string;
+    category: TextCategory;
+    label: string;
+    placeholder: string;
+    iconName?: IconName;
+    hidden?: boolean;
+}
+export declare const SupportedTexts: SupportedText[];

package/dist/types/context/account-context.d.ts

@@ -0,0 +1,44 @@
+import { EnsName, GenericMintedName } from "@/types";
+import { NamespaceListing } from "@/types/list-manager";
+import { L2SubnameResponse } from "@namespacesdk/indexer";
+import { PropsWithChildren } from "react";
+import { Address } from "viem";
+interface ISelectNameState {
+    selectedName?: string;
+    isSelected: boolean;
+}
+interface IEnsNamesState {
+    ensNames: EnsName[];
+    subnames: GenericMintedName[];
+    isLoading: boolean;
+    isError: boolean;
+}
+interface IListedNamesState {
+    isLoading: boolean;
+    isError: boolean;
+    items: NamespaceListing[];
+}
+interface IAccountContext {
+    listModalOpen: boolean;
+    selectedName?: string;
+    accountOwner: Address;
+    namesState: IEnsNamesState;
+    listingState: IListedNamesState;
+    selectNameState: ISelectNameState;
+    updateSelectNameState: (state: ISelectNameState) => void;
+    toggleListModal: (open: boolean, ensName: string) => void;
+    setApprovalGiven: (value: boolean) => void;
+    handleRemoveListing: (name: string) => void;
+    contextWrapped: boolean;
+    handleListingCreated: (ensName: string, verified: boolean) => void;
+    handleListingVerified: (ensName: string) => void;
+}
+interface AccountContextProps extends PropsWithChildren {
+    accountOwner: Address;
+    isConnectedUserAccount?: boolean;
+}
+export declare const AccountContextProvider: ({ accountOwner, children, isConnectedUserAccount, }: AccountContextProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useAccountContext: () => IAccountContext;
+export declare const addL2SubnameToGenericNames: (items: L2SubnameResponse[], arr: GenericMintedName[]) => void;
+export declare const addL1SubnameToGenericName: (items: EnsName[], arr: GenericMintedName[]) => void;
+export {};

package/dist/types/context/account-filter-context.d.ts

@@ -0,0 +1,32 @@
+import { SupportedChainName } from "@/types";
+import { Dispatch, ReactNode, SetStateAction } from "react";
+export type NetworksLabels = "Base" | "Base Sepolia" | "Ethereum Mainnet" | "Optimism" | "Ethereum Sepolia";
+export type NetworksIcon = "base" | "mainnet" | "op" | "eth";
+export type NetworksOptionsType = Partial<Record<SupportedChainName, {
+    icon: NetworksIcon;
+    label: NetworksLabels;
+}>>;
+export declare const networks: NetworksOptionsType;
+export type NetworksFilterOptions = {
+    label: NetworksLabels;
+    icon: NetworksIcon;
+};
+type NetworkFilter = Partial<Record<SupportedChainName, NetworksFilterOptions>>;
+type AccountFilterContextType = {
+    searchString: string;
+    setSearchString: Dispatch<SetStateAction<string>>;
+    networksFilterOptions: NetworkFilter;
+    setNetworksFilterOptions: Dispatch<SetStateAction<{}>>;
+    selectedNetworks: SupportedChainName[];
+    setSelectedNetworks: Dispatch<SetStateAction<SupportedChainName[]>>;
+    alphabetOrder: "alphabetAsc" | "alphabetDesc" | null;
+    setAlphabetOrder: Dispatch<SetStateAction<"alphabetAsc" | "alphabetDesc" | null>>;
+    view: "grid" | "list";
+    setView: Dispatch<SetStateAction<"grid" | "list">>;
+};
+type AccountFilterProviderProps = {
+    children: ReactNode;
+};
+export declare const AccountFilterProvider: React.FC<AccountFilterProviderProps>;
+export declare const useAccountFilterContext: () => AccountFilterContextType;
+export {};

package/dist/types/context/auth-context.d.ts

@@ -0,0 +1,22 @@
+import { Address } from "viem";
+import { PropsWithChildren } from "react";
+export interface AccessTokens {
+    accessToken: string;
+    refreshToken: string;
+}
+interface IAuthContext {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    tokens: Record<Address, AccessTokens>;
+    siweTokens: Record<Address, string>;
+    authenticate?: () => void;
+    checkAuthenticationForAddr?: (principal: Address) => Promise<boolean>;
+    getAccessToken?: (principal: Address) => Promise<string>;
+    denyAuth?: (principal: Address) => void;
+    getSiweToken?: (principal: Address) => void;
+    hasValidSiweToken?: (principal: Address) => boolean;
+}
+export declare const AUTH_TOKEN_KEY = "auth-tokens";
+export declare const useAuthContext: () => IAuthContext;
+export declare const AuthContextProvider: ({ children }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/context/crop-image-context.d.ts

@@ -0,0 +1,27 @@
+import { Dispatch, ReactNode, SetStateAction } from "react";
+import { Area } from "react-easy-crop";
+export type CropImgContextType = {
+    newImgSrc: string;
+    setNewImgSrc: Dispatch<SetStateAction<string>>;
+    newCroppedImgSrc: string;
+    setNewCroppedImgSrc: Dispatch<SetStateAction<string>>;
+    croppedAreaPixels: Area;
+    setCroppedAreaPixels: Dispatch<SetStateAction<Area>>;
+    processingImg: boolean;
+    setProcessingImg: Dispatch<SetStateAction<boolean>>;
+    uploadedImgSrc: string;
+    setUploadedImgSrc: Dispatch<SetStateAction<string>>;
+    imageCategory: "avatar" | "header" | null;
+    setImageCategory: Dispatch<SetStateAction<"avatar" | "header" | null>>;
+    hideCoverUpload: boolean;
+    setHideCoverUpload: Dispatch<SetStateAction<boolean>>;
+    disableUploads: boolean;
+    setDisableUploads: Dispatch<SetStateAction<boolean>>;
+};
+export declare const CropImgContext: import("react").Context<CropImgContextType>;
+type CropImgContextProps = {
+    children: ReactNode;
+};
+export declare const CropImgProvider: React.FC<CropImgContextProps>;
+export declare const useCropImgContext: () => CropImgContextType;
+export {};

package/dist/types/context/current-user-context.d.ts

@@ -0,0 +1,19 @@
+import { PropsWithChildren } from "react";
+import { Address, Chain } from "viem";
+import { EnsRecords, IEnsNameFullProfile } from "@/types";
+interface IConnectedAccountContext {
+    connectedAddress?: Address;
+    isConnected: boolean;
+    isAuthenticated: boolean;
+    chain?: Chain;
+    primaryName: {
+        isFetching: boolean;
+        isError?: boolean;
+        isPresent: boolean;
+        data?: IEnsNameFullProfile;
+    };
+    handleRecordsUpdated?: (records: EnsRecords) => void;
+}
+export declare const ConnectedPrincipalProvider: ({ children }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+export declare const useConnectedPrincipal: () => IConnectedAccountContext;
+export {};

package/dist/types/context/edit-profile-context.d.ts

@@ -0,0 +1,13 @@
+import { Dispatch, ReactNode, SetStateAction } from "react";
+export type EditProfileStepsType = ["profile", "crop-image", "upload-image"];
+export type EditProfileContextType = {
+    step: "profile" | "crop-image" | "upload-image";
+    setStep: Dispatch<SetStateAction<"profile" | "crop-image" | "upload-image">>;
+};
+export declare const EditProfileContext: import("react").Context<EditProfileContextType>;
+type EditProfileProviderProps = {
+    children: ReactNode;
+};
+export declare const EditProfileProvider: React.FC<EditProfileProviderProps>;
+export declare const useEditProfileContext: () => EditProfileContextType;
+export {};

package/dist/types/context/ens-profile-context.d.ts

@@ -0,0 +1,54 @@
+import { EnsNameOwner, EnsRecords, EnsRecordsDecoded, GenericMintedName, Layer2Network } from "@/types";
+import { NamespaceListing } from "@/types/list-manager";
+import { ReactElement } from "react";
+import { Address } from "viem";
+export interface SubnamesFilter {
+    view: "grid" | "list";
+    searchString: string;
+}
+export interface NameProfileStats {
+    subnamesMinted: number;
+    totalSubnames: number;
+    totalVolume: number;
+    totalProfit: number;
+}
+interface EnsProfileState {
+    ensName: string;
+    ensRecords: EnsRecordsDecoded;
+    ownership: EnsNameOwner;
+    isFetching: boolean;
+    subnames: GenericMintedName[];
+    resolver: Address;
+    expiryUnix: number;
+    isL2: boolean;
+    listing: {
+        isListed: boolean;
+        listingData?: NamespaceListing;
+        isFetching: boolean;
+    };
+    stats: {
+        isLoading: boolean;
+        data: NameProfileStats;
+    };
+    isError?: boolean;
+    l2Metadata?: {
+        network: Layer2Network;
+        resolver: Address;
+    };
+    isListed: boolean;
+}
+interface EnsProfileContext extends EnsProfileState {
+    onRecordsUpdated?: (records: EnsRecords) => void;
+    onSubnameMinted?: (name: GenericMintedName) => void;
+    onL2SubnameBurned?: (subname: string | string[]) => void;
+    subnameFilter: SubnamesFilter;
+    onFilterChanged?: (filter: SubnamesFilter) => void;
+}
+export declare const EnsProfileContext: import("react").Context<EnsProfileContext>;
+export declare const EnsProfileContextProvider: ({ ensName, children, isSubname }: {
+    ensName: string;
+    isSubname: boolean;
+    children: ReactElement;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useEnsProfileContext: () => EnsProfileContext;
+export {};

package/dist/types/context/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./current-user-context";
+export * from "./auth-context";
+export * from "./ens-profile-context";
+export * from "./listing-form-context";
+export * from "./listing-status-context";
+export * from "./account-context";

package/dist/types/context/listing-form-context.d.ts

@@ -0,0 +1,55 @@
+import { L2Registry, ListingCurrency, ListingDeadline, ListingNetwork, ListingPrices, ListingType, ListingWhitelist, NamespaceListing, ReservedLabel, TokenGatedAccess } from "@/types/list-manager";
+import { ReactElement } from "react";
+import { Address } from "viem";
+export interface IListingFormContent {
+    prices: ListingPrices;
+    whitelist?: ListingWhitelist;
+    tokenGatedAccess?: TokenGatedAccess;
+    deadline?: ListingDeadline;
+    currency: ListingCurrency;
+    reservations: ReservedLabel[];
+    listingType: ListingType;
+}
+export interface IListingFeatures {
+    whitelist: boolean;
+    deadline: boolean;
+    tokenGatedAccess: boolean;
+}
+export declare enum ListingInputGroups {
+    Setup = "Setup",
+    Prices = "Prices",
+    Reservations = "Reservations",
+    Deadline = "Deadline",
+    Whitelist = "Whitelist",
+    TokenGatedAccess = "TokenGatedAccess"
+}
+export interface IListingFormContext extends IListingFormContent {
+    setPrices?: (prices: ListingPrices) => void;
+    setCurrency?: (currency: ListingCurrency) => void;
+    setDeadline?: (deadline: ListingDeadline) => void;
+    removeDeadline?: () => void;
+    setWhitelist?: (whitelist: ListingWhitelist) => void;
+    setReservations?: (reservations: ReservedLabel[]) => void;
+    removeWhitelist?: () => void;
+    toggleFeature?: (feature: keyof IListingFeatures, toggle: boolean) => void;
+    setTokenGatedAccess?: (tga: TokenGatedAccess) => void;
+    setListingType?: (type: ListingType) => void;
+    setL2Registry?: (registry: Partial<L2Registry>) => void;
+    setPaymentWallet?: (val: Address) => void;
+    features: IListingFeatures;
+    existingListing?: NamespaceListing;
+    ensName: string;
+    isStateUpdated: boolean;
+    l2Registry?: Partial<L2Registry>;
+    paymentWallet: Address;
+    listingInputsValid: Record<ListingInputGroups, boolean>;
+    refetch: () => void;
+}
+export declare const ListingFormContextProvider: ({ ensName, children, selectedListingType, selectedL2Chain, }: {
+    ensName: string;
+    selectedListingType?: ListingType;
+    selectedL2Chain?: ListingNetwork;
+    children: ReactElement;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useListingFormContext: () => IListingFormContext;
+export declare const getListingCurrencyLabel: (currency: ListingCurrency) => "ETH" | "USD";

package/dist/types/context/listing-status-context.d.ts

@@ -0,0 +1,19 @@
+import { ListingStatusDTO } from "@/types/list-manager";
+import { PropsWithChildren } from "react";
+interface IListingStatusState {
+    isLoading: boolean;
+    isRefetching: boolean;
+    isError: boolean;
+    status: ListingStatusDTO;
+}
+interface IListingContext extends IListingStatusState {
+    refetch: () => void;
+    handleUnlist: () => void;
+    updateStatus: (status: Partial<ListingStatusDTO>) => void;
+}
+interface ListingStatusCtxProps extends PropsWithChildren {
+    ensName: string;
+}
+export declare const ListingStatusContextProvider: ({ ensName, children, }: ListingStatusCtxProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useListingStatusContext: () => IListingContext;
+export {};

package/dist/types/context/mint-subname-context.d.ts

@@ -0,0 +1,12 @@
+import { Dispatch, ReactNode, SetStateAction } from "react";
+export type MintSubnameContextType = {
+    fullSubname: string | null;
+    setFullSubname: Dispatch<SetStateAction<string | null>>;
+};
+export declare const MintSubnameContext: import("react").Context<MintSubnameContextType>;
+type MintSubnameProviderProps = {
+    children: ReactNode;
+};
+export declare const MintSubnameProvider: React.FC<MintSubnameProviderProps>;
+export declare const useMintSubnameContext: () => MintSubnameContextType;
+export {};

package/dist/types/environment/index.d.ts

@@ -0,0 +1,9 @@
+interface AppEnvironment {
+    listManagerApi: string;
+    isTestnet: boolean;
+    testnetRpcUrl: string;
+    alchemyToken: string;
+    indexerUrl: string;
+}
+export declare const AppEnv: AppEnvironment;
+export {};

package/dist/types/hooks/efp/use-efp.d.ts

@@ -0,0 +1,11 @@
+import { Address } from "viem";
+export interface EFPState {
+    isFetching: boolean;
+    isError: boolean;
+    followers: number;
+    following: number;
+    primaryList?: string;
+}
+export declare const useEFP: ({ ownerAddress }: {
+    ownerAddress: Address;
+}) => EFPState;

package/dist/types/hooks/ens/ens-local-cache.d.ts

@@ -0,0 +1,18 @@
+import { EnsNameOwner, EnsTextRecord, EnsAddressRecord } from "@/types";
+declare class EnsLocalCache {
+    constructor();
+    private ownershipCache;
+    private textsCache;
+    private addressesCache;
+    getCachedOwnership(ensName: string): EnsNameOwner | null;
+    getCachedTexts(ensName: string): EnsTextRecord[] | null;
+    getCachedAddrs(ensName: string): EnsAddressRecord[] | null;
+    cacheOwnership(ensName: string, ownership: EnsNameOwner): void;
+    cacheAddrs(ensName: string, addrs: EnsAddressRecord[]): void;
+    cacheTexts(ensName: string, texts: EnsTextRecord[]): void;
+    private isExpired;
+    private setToStorage;
+    private getFromStorage;
+}
+export declare const EnsCache: EnsLocalCache;
+export {};