import { Network, Signature, InputGenerateTransactionPayloadData, InputGenerateTransactionOptions, AccountAddress } from '@endlesslab/endless-ts-sdk';

type ColorMode = 'light' | 'dark';
type EndlessWalletOptions = {
    colorMode?: ColorMode;
    network: Network;
    fullnode?: string;
    indexer?: string;
    walletUrl?: string;
    prover?: string;
    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;
    chainId: number;
    url?: string;
}
type EndlessSignMessageInput = {
    address?: boolean;
    application?: boolean;
    chainId?: boolean;
    message: string;
    nonce: string;
};
type EndlessSignMessageOutput = {
    address?: string;
    application?: string;
    chainId?: number;
    fullMessage: string;
    publicKey: string;
    message: string;
    nonce: string;
    prefix: 'Endless::Message';
    signature: Signature;
};
interface EndlessSignAndSubmitTransactionInput {
    payload: InputGenerateTransactionPayloadData;
    options?: InputGenerateTransactionOptions;
}
declare enum EndlessSendTransactionType {
    SIGNATURE_ONLY = "signatureOnly",
    SIGN_AND_SUBMIT = "signAndSubmit"
}
declare enum EndlessWalletTransactionType {
    SIMPLE = "simple",
    MULTI_AGENT = "multiAgent"
}
declare global {
    interface Window {
        WeixinJSBridge: {
            invoke(api: string, data: any, callback: (res: any) => void): void;
            on(api: string, callback: (res: any) => void): void;
        };
    }
}

interface IRequestData {
    method: MethodName;
    data?: unknown;
}
declare enum EndLessSDKEvent {
    INIT = "init",
    WALLET_INIT_LOAD = "walletInitLoad",
    CONNECT = "connect",
    GETACCOUNT = "getAccount",
    DISCONNECT = "disconnect",
    ACCOUNT_CHANGE = "accountChange",
    NETWORK_CHANGE = "networkChange",
    COLOR_MODE_CHANGE = "colorModeChange",
    OPEN = "open",
    CLOSE = "close"
}
type EndLessSDKEventType = (typeof EndLessSDKEvent)[keyof typeof EndLessSDKEvent];
interface EndLessSDKEventsMap {
    [EndLessSDKEvent.CONNECT]: AccountInfo;
    [EndLessSDKEvent.DISCONNECT]: void;
    [EndLessSDKEvent.ACCOUNT_CHANGE]: AccountInfo;
    [EndLessSDKEvent.GETACCOUNT]: AccountInfo[];
    [EndLessSDKEvent.COLOR_MODE_CHANGE]: {
        colorMode: string;
    };
    [EndLessSDKEvent.NETWORK_CHANGE]: NetworkInfo;
}
type EndLessSDKEventPayload<T extends EndLessSDKEventType> = T extends keyof EndLessSDKEventsMap ? EndLessSDKEventsMap[T] : undefined;

declare const ENDLESS_WALLET_WEB3_SDK_ENABLETHEME_TOGGLE_KEY = "endless-wallet-web3-sdk-enableThemeToggle";
declare const ENDLESS_WALLET_COLOR_MODE_KEY = "endless-wallet-web3-sdk-color-mode";

declare const ENDLESS_MESSAGE_TARGET = "endless-web3-sdk";
declare const ENDLESS_WALLET_TARGET = "endless-wallet-sdk";

interface Metadata {
    title: string;
    url: string;
    origin: string;
    icon: string;
    gameId: string;
    userId: string;
    walletAddress: string;
}

declare enum MethodName {
    INIT = "init",
    SET_COLOR_MODE = "setColorMode",
    CONNECT = "connect",
    CREATE_WALLET = "createWallet",
    GETACCOUNT = "getAccount",
    DISCONNECT = "disconnect",
    NETWORK_CHANGE = "switchNetwork",
    SIGN_MESSAGE = "signMessage",
    SEND_TRANSACTION = "sendTransaction",
    SIGN_AND_SUBMIT_TRANSACTION = "signAndSubmitTransaction",
    SIGN_TRANSACTION = "signTransaction",
    ACCOUNT_CHANGE = "accountChange",
    OPEN = "open",
    CLOSE = "close"
}
declare class EndlessJsSdk {
    static readonly version: string;
    private static _instance;
    private message;
    private _metadata;
    private _initData;
    private _walletAddress;
    private _endless;
    private _endlessConfig;
    accountAddress: AccountAddress | null;
    static getIninData: () => {};
    static getAccountAddress: () => AccountAddress | null;
    static setAccountAddress: (accountAddress: AccountAddress | null) => void;
    constructor(initData: EndlessWalletOptions);
    private initConfig;
    private initWallet;
    private initWalletEvent;
    changeNetwork(initData: EndlessWalletOptions): void;
    getNetwork: () => Promise<UserResponse<NetworkInfo>>;
    private getMetadata;
    open: (callback?: () => void) => void;
    close: (callback?: () => void) => void;
    request: (data: IRequestData, callback?: (data: unknown) => void) => void;
    getAccount: () => Promise<UserResponse<AccountInfo>>;
    connect: (callback?: (data: AccountInfo) => void) => Promise<UserResponse<AccountInfo>>;
    disconnect: (callback?: (data: unknown) => void) => Promise<void>;
    createWallet: (callback?: (data: unknown) => void) => void;
    setWalletColorMode: (data: {
        colorMode: ColorMode;
    }) => void;
    signMessage: (data: EndlessSignMessageInput, callback?: (data: unknown) => void) => Promise<UserResponse<EndlessSignMessageOutput>>;
    on: <K extends EndLessSDKEventType>(methodName: K, callback: (payload: EndLessSDKEventPayload<K>) => void) => void;
    off: <K extends EndLessSDKEventType>(methodName: K, callback?: (payload: EndLessSDKEventPayload<K>) => void) => void;
    signAndSubmitTransaction: (data: EndlessSignAndSubmitTransactionInput) => Promise<UserResponse<{
        hash: string;
    }>>;
    signTransaction: (transactionHex: string, transactionType: EndlessWalletTransactionType) => Promise<UserResponse<{
        data: string;
    }>>;
    onAccountChange: (callback: (data: AccountInfo) => void) => void;
    onNetworkChange: (callback: (data: NetworkInfo) => void) => void;
}

export { type AccountInfo, ENDLESS_MESSAGE_TARGET, ENDLESS_WALLET_COLOR_MODE_KEY, ENDLESS_WALLET_TARGET, ENDLESS_WALLET_WEB3_SDK_ENABLETHEME_TOGGLE_KEY, EndLessSDKEvent, EndlessJsSdk, EndlessSendTransactionType, type EndlessSignAndSubmitTransactionInput, type EndlessWalletOptions, EndlessWalletTransactionType, type Metadata, MethodName, type UserResponse, UserResponseStatus };