import { BigNumber, BigNumberish } from 'ethers';
import { Connector, ConnectorData } from '@wagmi/connectors';
import { BytesLike } from 'ethers/lib/utils';

interface AptosSignMessagePayload {
    address?: boolean;
    application?: boolean;
    chainId?: boolean;
    message: string;
    nonce: string;
}
interface AptosSignMessageResponse {
    address?: string;
    application?: string;
    chainId?: number;
    fullMessage: string;
    message: string;
    nonce: string;
    prefix: 'APTOS';
    signature: string | string[];
    bitmap?: Uint8Array;
}
type AptosTxOptions = {
    max_gas_amount?: string;
    gas_unit_price?: string;
    [key: string]: any;
};

declare const LoginProvider: {
    readonly Google: "google.com";
    readonly Apple: "apple.com";
    readonly Twitter: "twitter.com";
    readonly Discord: "discord.com";
    readonly Facebook: "facebook.com";
    readonly Kakao: "kakao.com";
};
type LoginProviderType = typeof LoginProvider[keyof typeof LoginProvider];
interface LoginWithIdTokenRequest {
    idToken: string;
    sig: string;
}
interface LoginWithAccessTokenRequest {
    accessToken: string;
    issuer: LoginProviderType;
    sig: string;
}
type PinCode = string | undefined;

declare enum Network {
    ETHEREUM = "ethereum",
    SEPOLIA = "sepolia",
    POLYGON = "polygon",
    AMOY = "amoy",
    TEZOS = "tezos",
    GHOSTNET = "ghostnet",
    BNB_SMART_CHAIN = "bnb_smart_chain",
    BNB_SMART_CHAIN_TESTNET = "bnb_smart_chain_testnet",
    KLAYTN = "klaytn",
    BAOBAB = "baobab",
    SOLANA = "solana",
    SOLANA_DEVNET = "solana_devnet",
    NEAR = "near",
    NEAR_TESTNET = "near_testnet",
    BORA = "bora",
    BORA_TESTNET = "bora_testnet",
    APTOS = "aptos",
    APTOS_TESTNET = "aptos_testnet",
    MEVERSE = "meverse",
    MEVERSE_TESTNET = "meverse_testnet",
    PSM = "psm",
    PSM_TESTNET = "psm_testnet",
    PSM_TESTNET_TEST = "psm_testnet_test",
    PSM_TESTNET_DEV = "psm_testnet_dev",
    HOME_VERSE = "home_verse",
    HOME_VERSE_TESTNET = "home_verse_testnet",
    YOOLDO_VERSE = "yooldo_verse",
    YOOLDO_VERSE_TESTNET = "yooldo_verse_testnet",
    SAND_VERSE = "sand_verse",
    OASYS = "oasys",
    OASYS_TESTNET = "oasys_testnet",
    MCH_VERSE = "mch_verse",
    MCH_VERSE_TESTNET = "mch_verse_testnet",
    HEDERA = "hedera",
    HEDERA_TESTNET = "hedera_testnet",
    DEFI_VERSE_TESTNET = "defi_verse_testnet",
    DEFI_VERSE = "defi_verse",
    KROMA = "kroma",
    KROMA_SEPOLIA = "kroma_sepolia",
    LITH = "lith",
    ASM_QA = "asm_qa",
    ASM_TEST = "asm_test",
    ASM_DEV = "asm_dev",
    ASM_STAGE = "asm_stage",
    LINEA = "linea",
    LINEA_GOERLI = "linea_goerli",
    DM2_VERSE_TESTNET = "dm2verse_testnet",
    DM2_VERSE = "dm2verse"
}
declare enum Blockchain {
    ETHEREUM = "ETHEREUM",
    POLYGON = "POLYGON",
    BNB_SMART_CHAIN = "BNB_SMART_CHAIN",
    KLAYTN = "KLAYTN",
    SOLANA = "SOLANA",
    TEZOS = "TEZOS",
    NEAR = "NEAR",
    BORA = "BORA",
    APTOS = "APTOS",
    MEVERSE = "MEVERSE",
    PSM = "PSM",
    PSM_TEST = "PSM_TEST",
    PSM_DEV = "PSM_DEV",
    HOME_VERSE = "HOME_VERSE",
    YOOLDO_VERSE = "YOOLDO_VERSE",
    SAND_VERSE = "SAND_VERSE",
    OASYS = "OASYS",
    MCH_VERSE = "MCH_VERSE",
    HEDERA = "HEDERA",
    DEFI_VERSE = "DEFI_VERSE",
    KROMA = "KROMA",
    LITH = "LITH",
    ASM_TEST = "ASM_TEST",
    ASM_QA = "ASM_QA",
    ASM_DEV = "ASM_DEV",
    ASM_STAGE = "ASM_STAGE",
    LINEA = "LINEA",
    DM2_VERSE = "DM2_VERSE"
}
interface KeyPair {
    privateKey: Uint8Array;
    publicKey: Uint8Array;
}

declare enum BoraPortalConnectStatusEnum {
    Connected = "CONNECTED",
    Unconnected = "UNCONNECTED"
}
interface BoraPortalConnectRequest {
    bappUsn: string;
    signature: string;
}
interface BoraPortalConnectStatusResponse {
    status: BoraPortalConnectStatusEnum;
    bappUsn?: string;
    boraPortalUsn?: string;
    walletAddressHash?: string;
}

/**
 * binary 데이터를 hex 형태료 표현한 타입. 0x로 시작.
 */
type HexString = string;
/**
 * 암호화에 사용할 바이너리 데이터를 표현합니다.
 * 필요에 따라 hex string, byte array 등으로 바꿀 수 있습니다.
 */
declare class CryptoBuffer {
    hex: string;
    length: number;
    constructor(hex: HexString, length: number);
    static empty(): CryptoBuffer;
    static fromUint8Array(array: Uint8Array): CryptoBuffer;
    static fromHex(hex: HexString, length: number): CryptoBuffer;
    static ensureHexString(hex: HexString): void;
    static checkLength(hex: HexString, length: number): void;
    toString(): string;
    toHex(): string;
    toBigNumber(): BigNumber;
    toJSON(): {
        hex: string;
        length: number;
    };
    static fromJSON(jsonStr: string): CryptoBuffer;
    static fromBigNumber(source: BigNumber, length: number): CryptoBuffer;
    toUInt8Array(): Uint8Array;
    static concat(elem1: CryptoBuffer, elem2: CryptoBuffer): CryptoBuffer;
    split(firstLength: number): [CryptoBuffer, CryptoBuffer];
    clone(): CryptoBuffer;
    unsafeSetLength(length: number): void;
}

type Coin = 'ETH' | 'MATIC';
type Token = 'USDT';
type Currency = Coin | Token;

interface DappMetaData {
    appName: string;
    appUrl: string | null;
    thumbnail: string | null;
}

declare enum Env {
    Local = "Local",
    Dev = "Dev",
    StageTest = "StageTest",
    StageMainnet = "StageMainnet",
    ProdTest = "ProdTest",
    ProdMainnet = "ProdMainnet"
}
type Platform = 'web' | 'native' | 'standalone';
type ScreenSize = 'pc' | 'mobile';
type FaceService = 'inApp' | 'standalone';
type FaceSDK = 'web' | 'rn' | 'unity';
type FacePlatform = 'web' | 'ios' | 'android';
type OS = DesktopOS | MobileOS;
declare enum DesktopOS {
    Linux = "linux",
    MacOS = "mac_os",
    Unix = "unix",
    Unknown = "unknown",
    Windows = "windows"
}
declare enum MobileOS {
    Android = "android",
    iOS = "ios",
    Unknown = "unknown",
    WindowsPhone = "Windows Phone"
}

declare enum JsonRpcMethod {
    face_logInSignUp = "face_logInSignUp",
    face_loggedIn = "face_loggedIn",
    face_logOut = "face_logOut",
    face_open2fa = "face_open2fa",
    face_currentUser = "face_currentUser",
    face_accounts = "face_accounts",
    face_getUserVerificationToken = "face_getUserVerificationToken",
    face_openIframe = "face_openIframe",
    face_closeIframe = "face_closeIframe",
    face_ready = "face_ready",
    face_openHome = "face_openHome",
    face_openBuy = "face_openBuy",
    face_openKit = "face_openKit",
    face_connectExternalWallet = "face_connectExternalWallet",
    face_openWalletConnect = "face_openWalletConnect",
    face_confirmWalletConnectDapp = "face_confirmWalletConnectDapp",
    face_switchNetwork = "face_switchNetwork",
    face_switchNetworkWalletConnect = "face_switchNetworkWalletConnect",
    face_directSocialLogin = "face_directSocialLogin",
    face_getIdToken = "face_getIdToken",
    face_loginWithIdToken = "face_loginWithIdToken",
    face_loginWithAccessToken = "face_loginWithAccessToken",
    face_showToast = "face_showToast",
    bora_connect = "bora_connect",
    bora_isConnected = "bora_isConnected",
    eth_sendTransaction = "eth_sendTransaction",
    eth_sendTransactionFromWalletConnect = "eth_sendTransactionFromWalletConnect",
    eth_getBalance = "eth_getBalance",
    eth_call = "eth_call",
    eth_estimateGas = "eth_estimateGas",
    eth_sign = "eth_sign",
    eth_signTypedData_v3 = "eth_signTypedData_v3",
    eth_signTypedData_v4 = "eth_signTypedData_v4",
    eth_chainId = "eth_chainId",
    eth_accounts = "eth_accounts",
    personal_sign = "personal_sign",
    personal_listAccounts = "personal_listAccounts",
    wallet_switchEthereumChain = "wallet_switchEthereumChain",
    solana_sendTransaction = "solana_sendTransaction",
    near_broadcast_tx_async = "near_broadcast_tx_async",
    near_get_balance = "near_get_balance",
    aptos_signMultiAgentTransaction = "aptos_signMultiAgentTransaction",
    aptos_signMessage = "aptos_signMessage",
    aptos_signTransaction = "aptos_signTransaction",
    aptos_signAndSubmitTransaction = "aptos_signAndSubmitTransaction",
    hedera_associate = "hedera_associate",
    tezos_publicKey = "tezos_publicKey",
    tezos_transferFA2 = "tezos_transferFA2",
    tezos_transferCoin = "tezos_transferCoin",
    hedera_getAccountId = "hedera_getAccountId",
    hedera_getHashConnectPairString = "hedera_getHashConnectPairString",
    hedera_initHashConnect = "hedera_initHashConnect",
    hedera_pairHashConnect = "hedera_pairHashConnect",
    hedera_disconnectHashConnect = "hedera_disconnectHashConnect"
}
declare enum JsonRpcSource {
    FACE_SDK = "FACE_SDK",
    FACE_IFRAME = "FACE_IFRAME",
    FACE_WALLET_CONNECT = "FACE_WALLET_CONNECT",
    FACE_NATIVE_SDK = "FACE_NATIVE_SDK"
}
interface JsonRpcRequestPayload<TParams = any> {
    id?: string | number | null;
    method: JsonRpcMethod | string;
    params?: TParams;
    jsonrpc?: string;
    userId?: string;
    blockchainNetwork?: Network;
    to?: JsonRpcSource;
    from?: JsonRpcSource;
    metaData?: DappMetaData;
    result?: any;
}
interface JsonRpcRequestCallback {
    /** Callback executed upon JSON RPC response. */
    (err: JsonRpcError | null, result?: JsonRpcResponsePayload | null): void;
}
interface JsonRpcBatchRequestCallback {
    /** Callback executed upon JSON RPC response. */
    (err: JsonRpcError | null, result?: (JsonRpcResponsePayload | null)[] | null): void;
}
interface JsonRpcError {
    message: string;
    code?: number;
    data?: any;
}
interface JsonRpcResponsePayload<ResultType = any> {
    jsonrpc?: string;
    id?: string | number | null;
    result?: ResultType | null;
    error?: JsonRpcError | null;
    to?: JsonRpcSource;
    from?: JsonRpcSource;
}
declare enum RpcErrorCode {
    PARSE_ERROR = -32700,
    INVALID_REQUEST = -32600,
    METHOD_NOT_FOUND = -32601,
    INVALID_PARAMS = -32602,
    INTERNAL_ERROR = -32603
}
type HomeOptions = {
    networks?: Network[];
};
interface ProviderRpcError extends Error {
    code: number;
    data?: unknown;
}

declare enum HttpStatus {
    SUCCESS = 200,
    CREATED = 201,
    BAD_REQUEST = 400,
    UNAUTHORIZED = 401,
    FORBIDDEN = 403,
    NOT_FOUND = 404,
    INTERNAL_SERVER_ERROR = 500
}
declare enum FaceErrorCode {
    INVALID_ARGUMENT = 4000,
    USER_REJECTED_REQUEST = 4001,
    NOT_IMPLEMENTED = 4002,
    BAD_REQUEST = 4003,
    SEND_TRANSACTION_FAILED = 4004,
    SIGN_FAILED = 4005,
    UNAUTHORIZED = 4100,
    NO_USER_DATA = 4101,
    AUTHENTICATION = 4102,
    UNSUPPORTED_SOCIAL_PROVIDER = 4103,
    INVALID_ENVIRONMENT = 4200,
    UNSUPPORTED_METHOD = 4201,
    UNSUPPORTED_CHAIN = 4202,
    INVALID_WALLET = 4300,
    PROVIDERS_AND_WALLETS_CONFIG_ERROR = 4301,
    NO_COIN_AVAILABLE_TO_BUY = 4400,
    INVALID_SIGNATURE_MESSAGE = 4906,
    INVALID_BORA_API_AND_SECRET_KEY = 4907,
    ALREADY_CONNECTED_OTHER_BAPP_USN = 4909,
    BORA_SERVICE_REGION_IS_WRONG = 4910,
    BAPP_USN_ALREADY_CONNECTED_OTHER_WALLET = 4911,
    INTERNAL = 5000
}
declare class FaceError extends Error {
    readonly code: FaceErrorCode | RpcErrorCode | number;
    data?: any;
    origin: any;
    isFaceError: boolean;
    static isFaceError(error: any): error is FaceError;
    private isValidErrorCode;
    constructor(error: {
        code: FaceErrorCode | RpcErrorCode;
        message?: string;
        origin?: any;
        data?: any;
    });
}
declare function userRejectedRequest(path?: string): FaceError;
declare function sendTransactionError(err: JsonRpcError): FaceError;
declare function invalidEnvironmentError(env: string): FaceError;
declare function invalidArgumentError(argumentName: string, description?: string): FaceError;
declare function notImplementedError(message: string): FaceError;
declare function unsupportedProviderError(provider: string): FaceError;
declare function unsupportedTokenProviderError(provider: string): FaceError;
declare function unknownError(origin?: any): FaceError;
declare function invalidApiKeyError(origin?: any): FaceError;
declare function invalidHostNameError(origin?: any): FaceError;
declare function noCoinAvailableToBuy(blockchains?: string[], contractAddress?: string): FaceError;
declare function invalidSignatureError(origin?: any): FaceError;
declare function invalidBoraPortalIdAndSecretKey(origin?: any): FaceError;
declare function alreadyConnectedToOtherBappusn(origin?: any): FaceError;
declare function bappusnAlreadyConnectedToOtherWallet(origin?: any): FaceError;
declare function boraServiceRegionIsWrong(origin?: any): FaceError;
declare function unsupportedChainError(origin?: any): FaceError;
declare function invalidWallet(): FaceError;
declare function kitProvidersAndWalletsConfigError(): FaceError;
declare function noUserDataError(): FaceError;
declare function oauthError(reason?: string, origin?: any): FaceError;
declare function signError(message: string): FaceError;
declare function makeError(args: ConstructorParameters<typeof FaceError>[0]): FaceError;
declare function assert<T extends (...args: any[]) => FaceError>(check: unknown, errorFn: T, args?: Parameters<typeof errorFn>): asserts check;
declare function assertArgument(arg: any, check: unknown, name: string, isRequired?: boolean): asserts check;

type FaceTransactionPayload = FaceEthereumTransactionPayload | FaceSolanaNearTransactionPayload | FaceAptosTransactionPayload | FaceTezosTransferPayload | FaceHederaTransactionPayload;
interface FaceAptosTransactionPayload {
    senderAddress: Uint8Array;
    serializedTx: Uint8Array;
    serializedTxOptions?: Uint8Array;
    signOnly: boolean;
    isMultiAgentTransaction: boolean;
    network?: Network;
    blockchain?: Blockchain;
}
interface FaceEthereumTransactionPayload {
    from: string;
    to: string;
    value?: BigNumberish;
    data?: string;
    gas?: BigNumber;
    network?: Network;
    blockchain?: Blockchain;
}
interface FaceSolanaNearTransactionPayload {
    serializedHex: string;
    network?: Network;
    blockchain?: Blockchain;
}
interface FaceHederaTransactionPayload {
    tokenId: string;
    network?: Network;
    blockchain: Blockchain;
    isAssociate: boolean;
    isHashConnect: boolean;
    signOnly: boolean;
    data: Uint8Array;
}
interface FaceTezosTransferPayload {
    publicKey: string;
    from: string;
    to: string;
    amount: string;
    token?: {
        address: string;
        id: string;
    };
    network?: Network;
    blockchain?: Blockchain;
}
declare function parseFaceSolanaNearTransactionPayload(arg: unknown): FaceSolanaNearTransactionPayload | null;
interface FaceLoginResponse {
    wallet: {
        id?: string;
        userId?: string;
        keyId?: string;
        path?: string;
        address?: string;
        ecdsaPublicKey?: string;
        eddsaPublicKey?: string;
    } | undefined;
    faceUserId: string;
    userVerificationToken: string;
    loginProvider: LoginProviderType;
}
interface FaceIdTokenResponse {
    idToken: string;
}
type AccountsResponse = string[];

type IconTypes = LoginProviderType;

type WalletMetaData = {
    id: string;
    name: string;
    iconUrl: string;
    downloadUrls?: {
        ios?: string;
        android?: string;
        chrome?: string;
        firefox?: string;
        edge?: string;
        opera?: string;
        default?: string;
    };
};
type Wallet = WalletMetaData & {
    createConnector: () => Promise<Connector>;
};
type ConnectedWallet = WalletMetaData & {
    connector: Connector;
};
type ConnectionResult = Required<ConnectorData>;

type OnRampOptions = {
    blockchains: Blockchain[];
    contractAddress?: string;
    coinAmount?: number;
};

type AccountSecret = {
    privateKey?: string;
    pinCode?: string;
};

interface TezosTransferCoinRequest {
    to: string;
    amount: number;
}
interface TezosTransferFa2Params {
    from_: string;
    txs: {
        to_: string;
        token_id: number;
        amount: number;
    }[];
}
interface TezosTransferFtRequest extends TezosTransferCoinRequest {
    tokenAddress: string;
    tokenId: string;
}

declare enum TxType {
    COIN = "COIN",
    ERC20 = "ERC20",
    ERC721 = "ERC721",
    ERC1155 = "ERC1155",
    FT = "FT",
    CONVERT = "CONVERT",
    Associate = "ASSOCIATE",
    FA2_FT = "FA2_FT",
    FA2_NFT = "FA2_NFT",
    FA2_MFT = "FA2_MFT"
}
type EthTransactionRequest = {
    to?: string;
    from?: string;
    path?: string;
    nonce?: BigNumberish;
    gas?: BigNumberish;
    gasPrice?: BigNumberish;
    data?: BytesLike;
    value?: BigNumberish;
};
interface Receipt {
    status: 'success' | 'fail';
    internal: any;
}

declare const FaceVersionLocalKey = "Face-Version";
declare const FaceAuthSessionKey = "Face-Auth-Session";
declare const FaceOAuthResultKey = "Face-OAuth-Result";
declare const WalletPath = "m/44'/60'/1'/0/0";
declare enum UserStatus {
    isWalletCreated = "isWalletCreated",
    isNewUser = "isNewUser",
    isRegisteredPinCode = "isRegisteredPinCode",
    isAdmin = "isAdmin"
}
interface Share1LocalForage {
    share1: CryptoBuffer;
    user: {
        firebaseId: string;
        faceUserId: string;
    };
}
interface FaceAuthSession {
    session: string;
    decryptionToken: string;
}
interface FaceOAuthResult {
    idToken?: string;
    accessToken?: string;
}

export { AccountSecret, AccountsResponse, AptosSignMessagePayload, AptosSignMessageResponse, AptosTxOptions, Blockchain, BoraPortalConnectRequest, BoraPortalConnectStatusEnum, BoraPortalConnectStatusResponse, Coin, ConnectedWallet, ConnectionResult, CryptoBuffer, Currency, DappMetaData, DesktopOS, Env, EthTransactionRequest, FaceAptosTransactionPayload, FaceAuthSession, FaceAuthSessionKey, FaceError, FaceErrorCode, FaceEthereumTransactionPayload, FaceHederaTransactionPayload, FaceIdTokenResponse, FaceLoginResponse, FaceOAuthResult, FaceOAuthResultKey, FacePlatform, FaceSDK, FaceService, FaceSolanaNearTransactionPayload, FaceTezosTransferPayload, FaceTransactionPayload, FaceVersionLocalKey, HexString, HomeOptions, HttpStatus, IconTypes, JsonRpcBatchRequestCallback, JsonRpcError, JsonRpcMethod, JsonRpcRequestCallback, JsonRpcRequestPayload, JsonRpcResponsePayload, JsonRpcSource, KeyPair, LoginProvider, LoginProviderType, LoginWithAccessTokenRequest, LoginWithIdTokenRequest, MobileOS, Network, OS, OnRampOptions, PinCode, Platform, ProviderRpcError, Receipt, RpcErrorCode, ScreenSize, Share1LocalForage, TezosTransferCoinRequest, TezosTransferFa2Params, TezosTransferFtRequest, Token, TxType, UserStatus, Wallet, WalletMetaData, WalletPath, alreadyConnectedToOtherBappusn, assert, assertArgument, bappusnAlreadyConnectedToOtherWallet, boraServiceRegionIsWrong, invalidApiKeyError, invalidArgumentError, invalidBoraPortalIdAndSecretKey, invalidEnvironmentError, invalidHostNameError, invalidSignatureError, invalidWallet, kitProvidersAndWalletsConfigError, makeError, noCoinAvailableToBuy, noUserDataError, notImplementedError, oauthError, parseFaceSolanaNearTransactionPayload, sendTransactionError, signError, unknownError, unsupportedChainError, unsupportedProviderError, unsupportedTokenProviderError, userRejectedRequest };