import tronWebModule, { TronWeb } from 'tronWeb';
import { TronWebOptions } from 'tronWeb/lib/esm/types';

type TronWebSDK = typeof tronWebModule;
declare enum Network {
    MAINNET = "mainnet",
    TESTNET = "testnet",
    ETH = "eth",
    BSC = "bsc"
}
type IInitData = {
    colorMode?: 'light' | 'dark';
    network: Network | string;
    fullnode?: string;
    indexer?: string;
    walletUrl?: string;
    prover?: string;
    callbackWalletName?: string;
    miniprogram?: Boolean;
    windowWidth?: number;
};
type ChainData = {
    targetNet: 'endless' | 'eds' | 'eth' | 'eth_sepolia' | 'bsc' | 'bsc_testnet' | 'tron' | 'tron_nile';
};
declare enum UserResponseStatus {
    APPROVED = "Approved",
    REJECTED = "Rejected"
}
interface UserApproval<TResponseArgs> {
    status: UserResponseStatus.APPROVED;
    args: TResponseArgs;
}
interface UserRejection {
    status: UserResponseStatus.REJECTED;
    message?: string;
}
type UserResponse<TResponseArgs> = UserApproval<TResponseArgs> | UserRejection;
interface AccountInfo {
    account: string;
    address: string;
    authKey: string;
    ansName?: string;
}
interface NetworkInfo {
    name: Network | string;
    chainId: number;
    url?: string;
}
interface EndlessSignAndSubmitTransactionInput {
    gasUnitPrice?: number;
    maxGasAmount?: number;
    payload: '';
    options?: '';
}
declare enum EndlessSendTransactionType {
    SIGNATURE_ONLY = "signatureOnly",
    SIGN_AND_SUBMIT = "signAndSubmit"
}
declare enum EndlessWalletTransactionType {
    SIMPLE = "simple",
    MULTI_AGENT = "multiAgent"
}
interface TronRequestArguments {
    readonly method: string;
    readonly params?: unknown[] | object;
}
interface ProviderRpcError extends Error {
    code: number;
    message: string;
    data?: unknown;
}
type TronEvent = 'connect' | 'disconnect' | 'chainChanged' | 'accountsChanged';
type TronConnectCallback = (data: {
    chainId: string;
}) => void;
type TronChainChangedCallback = TronConnectCallback;
type TronDisconnectCallback = (error: ProviderRpcError) => void;
type TronAccountsChangedCallback = (data: [string?]) => void;
interface Tron {
    request(args: {
        method: 'eth_requestAccounts';
    }): Promise<[string]>;
    request(args: TronRequestArguments): Promise<unknown>;
    on(event: 'connect', cb: TronConnectCallback): void;
    on(event: 'disconnect', cb: TronDisconnectCallback): void;
    on(event: 'chainChanged', cb: TronChainChangedCallback): void;
    on(event: 'accountsChanged', cb: TronAccountsChangedCallback): void;
    removeListener(event: TronEvent, cb: unknown): void;
    tronWeb: TronWeb | false;
    isTronLink: boolean;
}
declare global {
    const tronWeb: TronWeb;
    const TronWeb: TronWebSDK;
    const wx: any;
    interface Window {
        wx: any;
        webkit: any;
        endlessWallet?: {
            sendResponse: (response: any) => void;
        };
        _endlessWallet?: {
            sendMessage: (data: any) => void;
        };
        WeixinJSBridge: {
            invoke(api: string, data: any, callback: (res: any) => void): void;
            on(api: string, callback: (res: any) => void): void;
        };
        tronWallet?: {
            sendResponse: (response: any) => void;
        };
        _tronWallet?: {
            sendMessage: (data: any) => void;
        };
        tron: Tron;
        tronWeb: TronWeb;
        TronWeb: TronWebSDK;
    }
}

interface IRequestData {
    method: MethodName;
    data?: unknown;
    initData?: IInitData;
}
declare enum TronSDKEvent {
    CONNECT = "connect",
    GETACCOUNT = "getAccount",
    DISCONNECT = "disconnect",
    ACCOUNT_CHANGE = "accountChange",
    NETWORK_CHANGE = "luffa_switchChain",
    CHAIN_CHANGED = "chainChanged"
}
type TronSDKEventType = (typeof TronSDKEvent)[keyof typeof TronSDKEvent];
interface TronSDKEventsMap {
    [TronSDKEvent.CONNECT]: AccountInfo;
    [TronSDKEvent.DISCONNECT]: void;
    [TronSDKEvent.ACCOUNT_CHANGE]: AccountInfo;
    [TronSDKEvent.GETACCOUNT]: AccountInfo[];
    [TronSDKEvent.NETWORK_CHANGE]: NetworkInfo;
    [TronSDKEvent.CHAIN_CHANGED]: string;
}
type TronSDKEventPayload<T extends TronSDKEventType> = T extends keyof TronSDKEventsMap ? TronSDKEventsMap[T] : undefined;

declare const isLuffa: () => boolean;
declare const isLuffaMiniProgramWebview: () => boolean;
declare const isLuffaMiniProgram: () => boolean;

interface Metadata {
    title: string;
    url: string;
    origin: string;
    icon: string;
    gameId: string;
    userId: string;
    walletAddress: string;
}
interface TronRequestParams {
    method: 'eth_requestAccounts' | string;
    params?: any;
}

declare enum MethodName {
    CONNECT = "connect",
    GETACCOUNT = "getAccount",
    DISCONNECT = "disconnect",
    NETWORK_CHANGE = "luffa_switchChain",
    SIGN_MESSAGE = "signMessage",
    SEND_TRANSACTION = "sendTransaction",
    SIGN_AND_SUBMIT_TRANSACTION = "signAndSubmitTransaction",
    SIGN_TRANSACTION = "signTransaction",
    SIGN_BUILD_TRANSACTION = "signBuildTransaction",
    EVM_APPROVE = "evmApprove",
    ACCOUNT_CHANGE = "accountChange"
}
declare class LuffaTronSdk {
    static readonly version: string;
    private static _instance;
    private message;
    private _metadata;
    private _initData;
    private accountAddress;
    private _wallet;
    static getIninData: () => IInitData;
    static getAccountAddress: () => string | null;
    static setAccountAddress: (accountAddress: string | null) => void;
    constructor(initData: TronWebOptions & {
        network: string;
    });
    private initConfig;
    sendTransaction(params: any): Promise<any>;
    changeNetwork(chainData: ChainData): void;
    private getMetadata;
    request: (data: IRequestData, callback?: (data: unknown) => void) => void;
    getAccount: () => Promise<string[]>;
    connect: () => Promise<[string]>;
    disconnect: (callback?: (data: unknown) => void) => Promise<void>;
    on: <K extends TronSDKEventType>(methodName: K, callback: (payload: TronSDKEventPayload<K>) => void) => void;
    off: <K extends TronSDKEventType>(methodName: K, callback?: (payload: TronSDKEventPayload<K>) => void) => void;
    signAndSubmitTransaction: (params: any) => Promise<any>;
    signTransaction: (params: any, methodName?: MethodName) => Promise<any>;
    signMessage: (data: string, callback?: (data: unknown) => void) => Promise<UserResponse<any>>;
    onAccountChange: (callback: (data: AccountInfo) => void) => void;
    onNetworkChange: (callback: (data: NetworkInfo) => void) => void;
}

export { type AccountInfo, EndlessSendTransactionType, type EndlessSignAndSubmitTransactionInput, EndlessWalletTransactionType, LuffaTronSdk, type Metadata, MethodName, type TronRequestParams, TronSDKEvent, type UserResponse, UserResponseStatus, isLuffa, isLuffaMiniProgram, isLuffaMiniProgramWebview };