/// <reference types="react" />

import { bsc } from 'viem/chains';
import { bscTestnet } from 'viem/chains';
import { Chain } from 'viem';
import { Contract } from 'ethers';
import { default as default_2 } from 'react';
import { ethers } from 'ethers';
import { JSX as JSX_2 } from 'react/jsx-runtime';
import { OpenOptions } from '@web3modal/scaffold/dist/types/src/client';
import { providers } from 'ethers';
import { PublicClient } from 'wagmi';
import { RefObject } from 'react';
import { Signer } from 'ethers';
import { toast } from 'react-toastify';
import { TypeOptions } from 'react-toastify';
import { UseMutateFunction } from '@tanstack/react-query';
import { WalletClient } from 'wagmi';
import { WalletConnectConnector } from 'wagmi/connectors/walletConnect';

export declare class BigIntFormater {
    static toNumber(value?: bigint): number;
    static format(value: bigint): string;
    static roundUp(num: bigint, precision?: number): number;
    static toDate(value?: bigint): Date | undefined;
}

export { bsc }

export { bscTestnet }

declare type BuyMetadata = {
    minBuy?: number;
    maxBuy?: number;
    minBuyUSDT?: number;
    maxBuyUSDT?: number;
    salePrice?: number;
    salePriceUSDT?: number;
};

export declare type BuyMethod = "usdt" | "bnb";

export declare function BuyPresaleProvider(props: React.PropsWithChildren): JSX_2.Element;

export declare class DateFormater {
    static format(date?: Date): string;
    static formatDateTime(date?: Date): string;
}

declare interface IContext {
    fromValue: number;
    toValue: number;
    setFromValue: (val: number) => void;
    balance: number;
    balanceToken: number;
    buy: () => Promise<boolean>;
    refAddr?: string;
    createInvite(): Promise<void>;
    method: BuyMethod;
    setMethod(val: BuyMethod): void;
    bnbUsdtPrice: number;
    isAllowBuy: boolean;
}

declare type IWeb3TsContext = {
    gasFee: number;
    contract?: Contract;
    contractBuy?: Contract;
    contractUsdt?: Contract;
    setContract: (value?: Contract) => void;
    setContractBuy: (value?: Contract) => void;
    setContractUsdt: (value?: Contract) => void;
    config: Web3TsConfig;
    setConfig: (config: Web3TsConfig) => void;
    walletConnectConnector: WalletConnectConnector;
    buyMetadata: BuyMetadata;
    setBuyMetadata: (val: BuyMetadata) => void;
};

export declare class MoneyFormater {
    static format(value: number): string;
}

export declare const myToast: {
    toast: typeof toast;
    toastWait: ({ type, message }: {
        type?: TypeOptions;
        message: string;
    }) => () => void;
    waitTransaction: () => () => void;
};

export declare class NumberFormater {
    static format(value: number): string;
    static roundUp(num: number, precision?: number): number;
}

export declare type PropsWithClass = {
    className?: string;
};

export declare function publicClientToProvider(publicClient: PublicClient): providers.FallbackProvider | providers.JsonRpcProvider;

export declare const useAccount: () => {
    account: `0x${string}` | undefined;
    shortAccount: string;
    isConnected: boolean;
};

export declare const useAddToken: () => {
    addToken: () => Promise<void>;
    isSupport: boolean;
};

export declare const useBalance: () => {
    balance: number;
    balanceToken: number;
};

export declare const useBuy: () => {
    buy: ({ value, method, }: {
        value: number;
        method?: BuyMethod;
    }) => Promise<boolean>;
};

export declare function useBuyPresale(): IContext;

export declare const useConnect: () => {
    connect: () => void;
    disconnect: UseMutateFunction<void, Error, void, unknown>;
    isConnected: boolean;
    openWeb3: (options?: OpenOptions | undefined) => Promise<void>;
};

export declare const useContract: () => {
    contractUsdt: ethers.Contract | undefined;
    contract: ethers.Contract | undefined;
    contractBuy: ethers.Contract | undefined;
};

export declare const useContractAddress: (props?: {
    autoShort?: boolean;
}) => {
    address: string;
    shortAddress: string;
};

export declare function useData<T>(props: {
    default: T;
    path: string;
    init?: RequestInit;
    map?(result: unknown): unknown;
}): {
    data: T;
};

/** Hook to convert a viem Public Client to an ethers.js Provider. */
export declare function useEthersProvider({ chainId }?: {
    chainId?: number;
}): providers.FallbackProvider | providers.JsonRpcProvider;

/** Hook to convert a viem Wallet Client to an ethers.js Signer. */
export declare function useEthersSigner({ chainId }?: {
    chainId?: number;
}): Signer | undefined;

export declare const useProvider: () => {
    provider: {
        isWalletConnect: boolean;
        request: (opts: unknown) => Promise<unknown>;
    } | undefined;
    isWalletConnect: boolean;
};

export declare const useRefAddress: (props?: {
    origin?: string;
}) => {
    refAddr: string | undefined;
    referral: string;
    createInvite: () => Promise<void>;
};

export declare const useScroll: () => {
    scrollY: number;
};

export declare const useScrollMotion: ({ delay }: {
    delay?: number;
}) => {
    ref: RefObject<HTMLDivElement>;
    display: boolean;
};

export declare const useWeb3Ts: () => IWeb3TsContext;

export declare function useWindowResize(): {
    width: number;
};

export declare function walletClientToSigner(walletClient: WalletClient): providers.JsonRpcSigner;

export declare interface Web3TsConfig {
    mainContract: {
        contractAddress: string;
        symbol: string;
        logo: string;
    };
    buyContract: {
        contractAddress: string;
        buyMethod: string;
        buyUSDTMethod?: string;
        referralPath: string;
        disableBuy?: boolean;
    };
    projectId: string;
    walletIds: string[];
    metadata: {
        icons: string[];
        url: string;
        name: string;
        description: string;
    };
    chains: Chain[];
    addToken?: {
        message: string;
    };
}

export declare const Web3TsProvider: (p: default_2.PropsWithChildren & {
    config: Web3TsConfig;
}) => JSX_2.Element;

export { }