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;
};
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;
}
declare global {
    var wx: any;
    interface Window {
        wx: any;
        webkit: any;
        WeixinJSBridge: {
            invoke(api: string, data: any, callback: (res: any) => void): void;
            on(api: string, callback: (res: any) => void): void;
        };
        evmWallet?: {
            sendResponse: (response: any) => void;
        };
        _evmWallet?: {
            sendMessage: (data: any) => void;
        };
    }
}

interface IRequestData {
    initData?: IInitData;
    method: string;
    params: any;
}
declare enum EvmSDKEvent {
    CONNECT = "connect",
    GETACCOUNT = "getAccount",
    DISCONNECT = "disconnect",
    ACCOUNT_CHANGE = "accountChange",
    ACCOUNTS_CHANGE = "accountsChanged",
    NETWORK_CHANGE = "luffa_switchChain",
    CHAIN_CHANGED = "chainChanged"
}
type EvmSDKEventType = (typeof EvmSDKEvent)[keyof typeof EvmSDKEvent];
interface EvmSDKEventsMap {
    [EvmSDKEvent.CONNECT]: string[];
    [EvmSDKEvent.DISCONNECT]: void;
    [EvmSDKEvent.ACCOUNT_CHANGE]: AccountInfo;
    [EvmSDKEvent.ACCOUNTS_CHANGE]: string[];
    [EvmSDKEvent.GETACCOUNT]: AccountInfo[];
    [EvmSDKEvent.NETWORK_CHANGE]: NetworkInfo;
    [EvmSDKEvent.CHAIN_CHANGED]: string;
}
type EvmSDKEventPayload<T extends EvmSDKEventType> = T extends keyof EvmSDKEventsMap ? EvmSDKEventsMap[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;
}

declare enum MethodName {
    CONNECT = "connect",
    GETACCOUNT = "getAccount",
    DISCONNECT = "disconnect",
    CURRENT_CHAIN = "currentChain",
    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 LuffaEvmSdk {
    static readonly version: string;
    private static _instance;
    private message;
    private _metadata;
    private _initData;
    private accountAddress;
    static getIninData: () => IInitData;
    static getAccountAddress: () => string | null;
    static setAccountAddress: (accountAddress: string | null) => void;
    constructor(initData: IInitData);
    private initConfig;
    sendTransaction(params: any): Promise<any>;
    private getMetadata;
    request: (data: IRequestData, callback?: (data: unknown) => void) => Promise<any>;
    luffa_switchChain: (data: IRequestData) => Promise<string | {
        status: string;
    }>;
    currentChain: () => Promise<string | {
        status: string;
    }>;
    getAccount: () => Promise<string[]>;
    connect: () => Promise<[string]>;
    disconnect: (callback?: (data: unknown) => void) => Promise<void>;
    on: <K extends EvmSDKEventType>(methodName: K, callback: (payload: EvmSDKEventPayload<K>) => void) => void;
    off: <K extends EvmSDKEventType>(methodName: K, callback?: (payload: EvmSDKEventPayload<K>) => void) => void;
    signAndSubmitTransaction: (data: IRequestData, methodName?: MethodName) => Promise<any>;
    signTransaction: (params: any, methodName?: MethodName) => Promise<any>;
    signMessage: (data: IRequestData, callback?: (data: unknown) => void) => Promise<UserResponse<any>>;
    onAccountChange: (callback: (data: AccountInfo) => void) => void;
    onNetworkChange: (callback: (data: NetworkInfo) => void) => void;
}

export { type AccountInfo, EvmSDKEvent, LuffaEvmSdk, type Metadata, MethodName, type UserResponse, UserResponseStatus, isLuffa, isLuffaMiniProgram, isLuffaMiniProgramWebview };