import { UiInterface, UItheme } from './ui';
import { TokenStore } from './tokenStore';
import { OffChainTokenConfig, OnChainTokenConfig, AuthenticateInterface, NegotiationInterface, MultiTokenInterface, TokenNegotiatorEventsArgs } from './interface';
import Web3WalletProvider from '../wallet/Web3WalletProvider';
import { ethers } from 'ethers';
declare global {
    interface Window {
        tokenToggleSelection: any;
        ethereum: any;
        solana: any;
        ultra: any;
        tn: unknown;
    }
}
export declare const defaultConfig: NegotiationInterface;
export declare const enum UIUpdateEventType {
    ISSUERS_LOADING = 0,
    ISSUERS_LOADED = 1,
    WALLET_DISCONNECTED = 2
}
export declare enum ClientError {
    POPUP_BLOCKED = "POPUP_BLOCKED",
    USER_ABORT = "USER_ABORT",
    ISSUER_UNAVAILABLE = "ISSUER_UNAVAILABLE"
}
export declare enum ClientErrorMessage {
    POPUP_BLOCKED = "Please add an exception to your popup blocker before continuing.",
    USER_ABORT = "The user aborted the process.",
    ISSUER_UNAVAILABLE = "The issuer is unavailable."
}
export declare class Client {
    issuersLoaded: boolean;
    config: NegotiationInterface;
    private web3WalletProvider;
    private messaging;
    private eventHookHandler;
    protected ui: UiInterface;
    protected tokenStore: TokenStore;
    externalUtils: {
        evm: {
            ethers: typeof ethers;
        };
    };
    private uiUpdateCallbacks;
    private userCancelTokenAutoload;
    private urlParams;
    constructor(config: NegotiationInterface);
    handleRecievedRedirectMessages(): Error;
    getDataFromQuery(itemKey: any): string;
    readProofCallback(): Promise<boolean>;
    private readProofCallbackMultiToken;
    private readProofCallbackLegacy;
    private removeCallbackParamsFromUrl;
    private emitRedirectProofEvent;
    private emitMultiRedirectProofEvent;
    private mergeConfig;
    getTokenStore(): TokenStore;
    getUi(): UiInterface;
    createUiInstance(): void;
    triggerUiUpdateCallback(type: UIUpdateEventType, data?: {}): void;
    registerUiUpdateCallback(type: UIUpdateEventType, callback: Function): void;
    safeConnectAvailable(): boolean;
    hasIssuerForBlockchain(blockchain: 'evm' | 'solana' | 'flow' | 'ultra', useOauth?: boolean): boolean;
    getWalletProvider(): Promise<Web3WalletProvider>;
    disconnectWallet(): Promise<void>;
    negotiatorConnectToWallet(walletType: string): Promise<any>;
    enrichTokenLookupDataOnChainTokens(): Promise<void>;
    checkUserAgentSupport(type: string): Promise<void>;
    private activeNegotiateRequired;
    getNoTokenMsg(collectionID: string): string;
    negotiate(issuers?: (OnChainTokenConfig | OffChainTokenConfig)[], openPopup?: boolean, refreshTokens?: boolean): Promise<void>;
    activeNegotiationStrategy(openPopup: boolean): Promise<void>;
    private tokensSelectedCallBackHandler;
    private cancelAutoload;
    tokenAutoLoad(onLoading: (issuer: string) => void, onComplete: (issuer: string, tokens: any[]) => void, refresh: boolean): Promise<void>;
    cancelTokenAutoload(): void;
    setPassiveNegotiationWebTokens(): Promise<void>;
    readTokensFromUrl(): Promise<void>;
    private handleRedirectTokensError;
    setPassiveNegotiationOnChainTokens(): Promise<void>;
    passiveNegotiationStrategy(): Promise<void>;
    connectTokenIssuer(issuer: string): Promise<unknown[] | void>;
    private loadOnChainTokens;
    prepareMultiOutletRequest(initialIssuer: OffChainTokenConfig): import("../utils").IssuerHashMap;
    private loadOutletTokens;
    private storeOutletTokenResponse;
    private loadRemoteOutletTokens;
    private loadLocalOutletTokens;
    updateSelectedTokens(selectedTokens: any): void;
    prepareToAuthenticateToken(authRequest: AuthenticateInterface): Promise<{
        unsignedToken: any;
        issuer: any;
        tokenId: string | number;
    }>;
    getMultiRequestBatch(authRequests: AuthenticateInterface[]): Promise<{
        onChain: {};
        offChain: {
            [origin: string]: {
                [issuer: string]: MultiTokenInterface;
            };
        };
    }>;
    authenticateMultiple(authRequests: AuthenticateInterface[]): any;
    authenticate(authRequest: any): any;
    authenticateToken(authRequest: AuthenticateInterface | any): any;
    enableAuthCancel(issuer: any): void;
    enableTokenAutoLoadCancel(): void;
    private handleWalletRequired;
    private handleProofError;
    eventSender<T extends keyof TokenNegotiatorEventsArgs, R extends TokenNegotiatorEventsArgs[T]>(eventName: T, data: R): Promise<void>;
    getOutletConfigForCurrentOrigin(origin?: string): false | OffChainTokenConfig;
    addTokenViaMagicLink(magicLink: any): Promise<any>;
    on<T extends keyof TokenNegotiatorEventsArgs, R extends (data: TokenNegotiatorEventsArgs[T]) => Promise<void> | void>(type: T, callback?: R, data?: TokenNegotiatorEventsArgs[T]): void;
    private processAttestationIdCallback;
    switchTheme(newTheme: UItheme): void;
}