import * as _web3modal_ui from '@web3modal/ui';
import * as _wagmi_core from '@wagmi/core';
import { GetAccountResult, Chain as Chain$1, SwitchNetworkResult, watchAccount } from '@wagmi/core';
import * as _web3modal_core from '@web3modal/core';
import { ConfigCtrlState, Listing, ThemeCtrlState } from '@web3modal/core';
import * as _web3modal_core_dist__types_src_controllers_ModalCtrl from '@web3modal/core/dist/_types/src/controllers/ModalCtrl';
import * as _web3modal_core_dist__types_src_types_controllerTypes from '@web3modal/core/dist/_types/src/types/controllerTypes';
import * as viem__types_actions_wallet_signTransaction from 'viem/_types/actions/wallet/signTransaction';
import * as viem__types_actions_wallet_sendRawTransaction from 'viem/_types/actions/wallet/sendRawTransaction';
import * as viem from 'viem';
import * as _wagmi_core_dist_index_e744bbc2 from '@wagmi/core/dist/index-e744bbc2';
import { EthereumClient } from '@web3modal/ethereum';
import EthereumProvider from '@walletconnect/ethereum-provider';
import { IProvider } from '@walletconnect/universal-provider';
import * as zustand_vanilla from 'zustand/vanilla';
import { A as AuthcClientOptions, a as AuthcClient, R as RedirectLoginOptions, l as LogoutOptions } from './AuthcClient-e13f668e.js';
import { Chain } from '@wagmi/chains';

interface AuthcWalletOptions$1 extends AuthcWalletOptions {
}
interface AuthcOptions extends AuthcClientOptions {
    /**
     * unlock wallet on demand
     * @default false
     */
    unlockOnDemand?: boolean;
    walletOptions: AuthcWalletOptions$1;
    events?: {
        afterLogout?: () => void;
    };
}
declare class Authc extends AuthcClient {
    wallet: AuthcWalletLogin;
    private loginPromise;
    private opts;
    store: zustand_vanilla.StoreApi<{
        status: 'login' | 'loginFailed' | 'createWallet' | 'reconstruct' | 'viewAccount' | 'reconstructFailed' | '';
        loading: boolean;
    }>;
    get events(): {
        afterLogout: () => void;
    };
    constructor(_options: AuthcOptions);
    onConnectWalletByPostMessage(): void;
    private closeWatchHandler;
    walletHandler(): void;
    loginWithWallet<TAppState = any>(options?: RedirectLoginOptions<TAppState>): Promise<any>;
    connectWallet(): Promise<_wagmi_core.GetAccountResult>;
    toUnlockWallet(): void;
    logout(options?: LogoutOptions): Promise<void>;
}

interface EventMessage {
    modal: {
        state: boolean;
    };
    cancelLogin: void;
    lifecycle: {
        name: 'login' | 'loginFailed' | 'createWallet' | 'reconstruct' | 'viewAccount' | 'reconstructFailed';
    };
    loginFailed: {
        err?: Error;
        errorMessage: string;
    };
    initialized: void;
    connectWalletByWalletName: {
        name: string;
        walletAddress: string;
    };
    401: void;
    wcUri: {
        code: string;
    };
    logout: void;
    $all: any;
    signingMessage: {
        sid: string;
        message: string;
        name: string;
    };
}
type EventMessageCallback = ((type: keyof EventMessage, data: any, event: MessageEvent) => void);
interface ListenerCallback<T extends keyof EventMessage> {
    (data: EventMessage[T]): any;
}
declare const sendMessage: (iframe: HTMLIFrameElement, data: {
    [key: string]: any;
    type: string;
}) => void;

declare class CustomPostMessage {
    private iframe;
    type?: string;
    initialized: boolean;
    constructor(iframe: () => HTMLIFrameElement | null, type?: string);
    initializedCallbackQueue: (() => void)[];
    protected init(): void;
    postMessage(data: Parameters<typeof sendMessage>[1]): void;
    receiveMessage: (callback?: EventMessageCallback) => () => boolean;
    addMessageListener: <T extends keyof EventMessage>(type: T, callback: ListenerCallback<T>) => void;
    viewWallet(): void;
    push(path: string): void;
    replace(path: string, params?: Record<string, any>): void;
    checkWalletAddress(address: string): void;
    placement(): void;
    logout(): void;
    setLocale(locale: string): void;
}

interface AuthcWalletOptions extends ConfigCtrlState {
    customWallets?: ConfigCtrlState['mobileWallets'];
    chains?: Chain[];
    /**
     * @default authc.wallet.wagmi
     */
    storageKey?: string;
    /**
     * Using same wagmi client in multiple instances
     * @default false
     */
    wagmiClientCache?: boolean;
    /**
     * Authc instance
     */
    authc?: Authc;
    /**
     * @internal
     * @default false
     * Unlock wallet on demand
     */
    unlockOnDemand?: boolean;
    /**
     * @default en
     */
    locale?: () => string;
}

declare class CustomWalletLogin extends CustomPostMessage {
    private walletOption;
    private closeWatch;
    walletLoginPromise: Promise<GetAccountResult>;
    __resolve: (value: any) => void;
    __reject: (err: any) => void;
    CUSTOM_WALLET_KEY: string;
    authc: Authc;
    constructor(walletOption: AuthcWalletOptions);
    get isCustomWallet(): boolean;
    get walletName(): string;
    get customIframe(): HTMLIFrameElement;
    removeIframe(): Promise<void>;
    private onLoadLoginIframeError;
    toggleIframeVisible: (state: boolean) => void;
    getWalletConnectUri(): Promise<string>;
    createLoginPromise(): Promise<GetAccountResult>;
    reconnectWalletCustom(): Promise<GetAccountResult>;
    connectWalletCustom(name?: string): Promise<GetAccountResult>;
    getCustomWallet: (name: string) => _web3modal_core.MobileWallet;
    watchCustomLogin(): Promise<void>;
    watchCustomWallet(): void;
    watchAccount(callback: (account: GetAccountResult & {
        /**
         * is custom wallet login?
         */
        isCustomWallet: boolean;
        errMessage: string;
    }) => void, ...args: any[]): () => void;
    cancelLogin(): Promise<void>;
    disconnect(): void | Promise<void>;
    getWalletClient(_chainId?: number): Promise<_wagmi_core_dist_index_e744bbc2.P | {
        account: viem.Account;
        batch?: {
            multicall?: boolean | {
                batchSize?: number;
                wait?: number;
            };
        };
        cacheTime: number;
        chain: Chain$1;
        key: string;
        name: string;
        pollingInterval: number;
        request: viem.EIP1193RequestFn<viem.WalletRpcSchema>;
        transport: viem.TransportConfig<string, viem.EIP1193RequestFn> & Record<string, any>;
        type: string;
        uid: string;
        addChain: (args: viem.AddChainParameters) => Promise<void>;
        deployContract: <const TAbi extends viem.Abi | readonly unknown[], TChainOverride extends Chain$1>(args: viem.DeployContractParameters<TAbi, Chain$1, viem.Account, TChainOverride>) => Promise<`0x${string}`>;
        getAddresses: () => Promise<viem.GetAddressesReturnType>;
        getChainId: () => Promise<number>;
        getPermissions: () => Promise<viem.GetPermissionsReturnType>;
        prepareTransactionRequest: <TChainOverride_1 extends Chain$1>(args: viem.PrepareTransactionRequestParameters<Chain$1, viem.Account, TChainOverride_1>) => Promise<any>;
        requestAddresses: () => Promise<viem.RequestAddressesReturnType>;
        requestPermissions: (args: {
            [x: string]: Record<string, any>;
            eth_accounts: Record<string, any>;
        }) => Promise<viem.RequestPermissionsReturnType>;
        sendRawTransaction: (args: viem__types_actions_wallet_sendRawTransaction.SendRawTransactionParameters) => Promise<`0x${string}`>;
        sendTransaction: <TChainOverride_2 extends Chain$1>(args: viem.SendTransactionParameters<Chain$1, viem.Account, TChainOverride_2>) => Promise<`0x${string}`>;
        signMessage: (args: viem.SignMessageParameters<viem.Account>) => Promise<`0x${string}`>;
        signTransaction: <TChainOverride_3 extends Chain$1>(args: viem__types_actions_wallet_signTransaction.SignTransactionParameters<Chain$1, viem.Account, TChainOverride_3>) => Promise<`0x${string}`>;
        signTypedData: <const TTypedData extends {
            [key: string]: unknown;
        } | {
            [x: string]: readonly viem.TypedDataParameter[];
            [x: `string[${string}]`]: never;
            [x: `function[${string}]`]: never;
            [x: `address[${string}]`]: never;
            [x: `bool[${string}]`]: never;
            [x: `bytes[${string}]`]: never;
            [x: `bytes1[${string}]`]: never;
            [x: `bytes2[${string}]`]: never;
            [x: `bytes3[${string}]`]: never;
            [x: `bytes16[${string}]`]: never;
            [x: `bytes4[${string}]`]: never;
            [x: `bytes5[${string}]`]: never;
            [x: `bytes6[${string}]`]: never;
            [x: `bytes7[${string}]`]: never;
            [x: `bytes8[${string}]`]: never;
            [x: `bytes9[${string}]`]: never;
            [x: `bytes10[${string}]`]: never;
            [x: `bytes11[${string}]`]: never;
            [x: `bytes12[${string}]`]: never;
            [x: `bytes13[${string}]`]: never;
            [x: `bytes14[${string}]`]: never;
            [x: `bytes15[${string}]`]: never;
            [x: `bytes17[${string}]`]: never;
            [x: `bytes18[${string}]`]: never;
            [x: `bytes19[${string}]`]: never;
            [x: `bytes20[${string}]`]: never;
            [x: `bytes21[${string}]`]: never;
            [x: `bytes22[${string}]`]: never;
            [x: `bytes23[${string}]`]: never;
            [x: `bytes24[${string}]`]: never;
            [x: `bytes25[${string}]`]: never;
            [x: `bytes26[${string}]`]: never;
            [x: `bytes27[${string}]`]: never;
            [x: `bytes28[${string}]`]: never;
            [x: `bytes29[${string}]`]: never;
            [x: `bytes30[${string}]`]: never;
            [x: `bytes31[${string}]`]: never;
            [x: `bytes32[${string}]`]: never;
            [x: `int[${string}]`]: never;
            [x: `int16[${string}]`]: never;
            [x: `int8[${string}]`]: never;
            [x: `int24[${string}]`]: never;
            [x: `int32[${string}]`]: never;
            [x: `int40[${string}]`]: never;
            [x: `int48[${string}]`]: never;
            [x: `int56[${string}]`]: never;
            [x: `int64[${string}]`]: never;
            [x: `int72[${string}]`]: never;
            [x: `int80[${string}]`]: never;
            [x: `int88[${string}]`]: never;
            [x: `int96[${string}]`]: never;
            [x: `int104[${string}]`]: never;
            [x: `int112[${string}]`]: never;
            [x: `int120[${string}]`]: never;
            [x: `int128[${string}]`]: never;
            [x: `int136[${string}]`]: never;
            [x: `int144[${string}]`]: never;
            [x: `int152[${string}]`]: never;
            [x: `int160[${string}]`]: never;
            [x: `int168[${string}]`]: never;
            [x: `int176[${string}]`]: never;
            [x: `int184[${string}]`]: never;
            [x: `int192[${string}]`]: never;
            [x: `int200[${string}]`]: never;
            [x: `int208[${string}]`]: never;
            [x: `int216[${string}]`]: never;
            [x: `int224[${string}]`]: never;
            [x: `int232[${string}]`]: never;
            [x: `int240[${string}]`]: never;
            [x: `int248[${string}]`]: never;
            [x: `int256[${string}]`]: never;
            [x: `uint[${string}]`]: never;
            [x: `uint16[${string}]`]: never;
            [x: `uint8[${string}]`]: never;
            [x: `uint24[${string}]`]: never;
            [x: `uint32[${string}]`]: never;
            [x: `uint40[${string}]`]: never;
            [x: `uint48[${string}]`]: never;
            [x: `uint56[${string}]`]: never;
            [x: `uint64[${string}]`]: never;
            [x: `uint72[${string}]`]: never;
            [x: `uint80[${string}]`]: never;
            [x: `uint88[${string}]`]: never;
            [x: `uint96[${string}]`]: never;
            [x: `uint104[${string}]`]: never;
            [x: `uint112[${string}]`]: never;
            [x: `uint120[${string}]`]: never;
            [x: `uint128[${string}]`]: never;
            [x: `uint136[${string}]`]: never;
            [x: `uint144[${string}]`]: never;
            [x: `uint152[${string}]`]: never;
            [x: `uint160[${string}]`]: never;
            [x: `uint168[${string}]`]: never;
            [x: `uint176[${string}]`]: never;
            [x: `uint184[${string}]`]: never;
            [x: `uint192[${string}]`]: never;
            [x: `uint200[${string}]`]: never;
            [x: `uint208[${string}]`]: never;
            [x: `uint216[${string}]`]: never;
            [x: `uint224[${string}]`]: never;
            [x: `uint232[${string}]`]: never;
            [x: `uint240[${string}]`]: never;
            [x: `uint248[${string}]`]: never;
            [x: `uint256[${string}]`]: never;
            string?: never;
            address?: never;
            bool?: never;
            bytes?: never;
            bytes1?: never;
            bytes2?: never;
            bytes3?: never;
            bytes16?: never;
            bytes4?: never;
            bytes5?: never;
            bytes6?: never;
            bytes7?: never;
            bytes8?: never;
            bytes9?: never;
            bytes10?: never;
            bytes11?: never;
            bytes12?: never;
            bytes13?: never;
            bytes14?: never;
            bytes15?: never;
            bytes17?: never;
            bytes18?: never;
            bytes19?: never;
            bytes20?: never;
            bytes21?: never;
            bytes22?: never;
            bytes23?: never;
            bytes24?: never;
            bytes25?: never;
            bytes26?: never;
            bytes27?: never;
            bytes28?: never;
            bytes29?: never;
            bytes30?: never;
            bytes31?: never;
            bytes32?: never;
            int16?: never;
            int8?: never;
            int24?: never;
            int32?: never;
            int40?: never;
            int48?: never;
            int56?: never;
            int64?: never;
            int72?: never;
            int80?: never;
            int88?: never;
            int96?: never;
            int104?: never;
            int112?: never;
            int120?: never;
            int128?: never;
            int136?: never;
            int144?: never;
            int152?: never;
            int160?: never;
            int168?: never;
            int176?: never;
            int184?: never;
            int192?: never;
            int200?: never;
            int208?: never;
            int216?: never;
            int224?: never;
            int232?: never;
            int240?: never;
            int248?: never;
            int256?: never;
            uint16?: never;
            uint8?: never;
            uint24?: never;
            uint32?: never;
            uint40?: never;
            uint48?: never;
            uint56?: never;
            uint64?: never;
            uint72?: never;
            uint80?: never;
            uint88?: never;
            uint96?: never;
            uint104?: never;
            uint112?: never;
            uint120?: never;
            uint128?: never;
            uint136?: never;
            uint144?: never;
            uint152?: never;
            uint160?: never;
            uint168?: never;
            uint176?: never;
            uint184?: never;
            uint192?: never;
            uint200?: never;
            uint208?: never;
            uint216?: never;
            uint224?: never;
            uint232?: never;
            uint240?: never;
            uint248?: never;
            uint256?: never;
        }, TPrimaryType extends string>(args: viem.SignTypedDataParameters<TTypedData, TPrimaryType, viem.Account>) => Promise<`0x${string}`>;
        switchChain: (args: viem.SwitchChainParameters) => Promise<void>;
        watchAsset: (args: viem.WatchAssetParams) => Promise<boolean>;
        writeContract: <const TAbi_1 extends viem.Abi | readonly unknown[], TFunctionName extends string, TChainOverride_4 extends Chain$1>(args: viem.WriteContractParameters<TAbi_1, TFunctionName, Chain$1, viem.Account, TChainOverride_4>) => Promise<`0x${string}`>;
        extend: <const client extends {
            [x: string]: unknown;
            account?: undefined;
            batch?: undefined;
            cacheTime?: undefined;
            chain?: undefined;
            key?: undefined;
            name?: undefined;
            pollingInterval?: undefined;
            request?: undefined;
            transport?: undefined;
            type?: undefined;
            uid?: undefined;
        }>(fn: (client: viem.Client<viem.Transport, Chain$1, viem.Account, viem.WalletRpcSchema, viem.WalletActions<Chain$1, viem.Account>>) => client) => viem.Client<viem.Transport, Chain$1, viem.Account, viem.WalletRpcSchema, { [K in keyof client]: client[K]; } & viem.WalletActions<Chain$1, viem.Account>>;
    }>;
    getSignerProvider(): Promise<EthereumProvider>;
    getSignClient(): Promise<IProvider>;
    switchNetwork(params: {
        chainId: number;
    }): Promise<SwitchNetworkResult | void>;
    protected logoutWithIframe(url: string): Promise<void>;
    get modal(): {
        state: _web3modal_core_dist__types_src_types_controllerTypes.ModalCtrlState;
        subscribe(callback: (newState: _web3modal_core_dist__types_src_types_controllerTypes.ModalCtrlState) => void): () => void;
        open(options?: _web3modal_core_dist__types_src_controllers_ModalCtrl.OpenOptions): Promise<void>;
        close(): void;
    };
    get config(): {
        state: _web3modal_core.ConfigCtrlState;
        subscribe(callback: (newState: _web3modal_core.ConfigCtrlState) => void): () => void;
        setConfig(config: _web3modal_core.ConfigCtrlState): void;
    };
    get client(): () => EthereumClient;
    get explorer(): {
        state: _web3modal_core_dist__types_src_types_controllerTypes.ExplorerCtrlState;
        getRecomendedWallets(): Promise<_web3modal_core.Listing[]>;
        getWallets(params: _web3modal_core_dist__types_src_types_controllerTypes.ListingParams): Promise<(_web3modal_core.ListingResponse & {
            page: number;
        }) | {
            listings: _web3modal_core.Listing[];
            total: number;
        }>;
        getInjectedWallets(): Promise<_web3modal_core.Listing[]>;
        getWalletImageUrl(imageId: string): string;
        getAssetImageUrl(imageId: string): string;
        resetSearch(): void;
    };
    get options(): {
        state: _web3modal_core_dist__types_src_types_controllerTypes.OptionsCtrlState;
        subscribe(callback: (newState: _web3modal_core_dist__types_src_types_controllerTypes.OptionsCtrlState) => void): () => void;
        setChains(chains?: Chain$1[]): void;
        getSelectedChain(): _web3modal_core_dist__types_src_types_controllerTypes.Chain;
        setSelectedChain(selectedChain: _web3modal_core_dist__types_src_types_controllerTypes.Chain): void;
        setIsCustomDesktop(isCustomDesktop: boolean): void;
        setIsCustomMobile(isCustomMobile: boolean): void;
        setIsDataLoaded(isDataLoaded: boolean): void;
        setIsUiLoaded(isUiLoaded: boolean): void;
        setIsPreferInjected(isPreferInjected: boolean): void;
    };
}

declare class AuthcWalletLogin extends CustomWalletLogin {
    connectorNames: {
        metamask: string;
        coinbase: string;
    };
    constructor(config: AuthcWalletOptions);
    private onMobilePlatform;
    private onAndroidPlatform;
    private onConnectPlatformDesktop;
    private onConnectConnector;
    getWalletInfo(walletName: string): Promise<Listing>;
    connectWalletByWalletName(walletName: string): Promise<void | GetAccountResult | _wagmi_core.ConnectResult<any>>;
    onConnectWalletByPostMessage(postMessage?: Window['postMessage']): void;
    onWalletConnect(theme?: ThemeCtrlState): Promise<GetAccountResult>;
    importUi(): Promise<{
        default: typeof _web3modal_ui;
        W3mAccountButton: typeof _web3modal_ui.W3mAccountButton;
        W3mConnectButton: typeof _web3modal_ui.W3mConnectButton;
        W3mCoreButton: typeof _web3modal_ui.W3mCoreButton;
        W3mModal: typeof _web3modal_ui.W3mModal;
        W3mNetworkSwitch: typeof _web3modal_ui.W3mNetworkSwitch;
        W3mQrCode: typeof _web3modal_ui.W3mQrCode;
    }>;
}
type AccountType = Parameters<Parameters<typeof watchAccount>[0]>[0];

export { AuthcWalletLogin as A, AccountType as a, AuthcWalletOptions as b, AuthcOptions as c, Authc as d };