import * as mobx from 'mobx';
import { Account as Account$1 } from 'algosdk';
import { DeflyWalletConnect } from '@blockshake/defly-connect';
import MyAlgoConnect from '@randlabs/myalgo-connect';
import { createClient } from '@thencc/inkey-client-js';
import { InkeyConfig } from '@thencc/inkey-types';
import { PeraWalletConnect } from '@perawallet/connect';
import { StorageController } from 'mobx-persist-store';

declare function isBrowser(): boolean;
declare const arrayBufferToBase64: (buffer: ArrayBufferLike) => string;
declare const logger: {
    enabled: boolean;
    log(...args: any): void;
    warn(...args: any): void;
    debug(...args: any): void;
};

declare const WALLET_ID: {
    readonly PERA: "pera";
    readonly INKEY: "inkey";
    readonly MYALGO: "myalgo";
    readonly ALGOSIGNER: "algosigner";
    readonly EXODUS: "exodus";
    readonly DEFLY: "defly";
    readonly MNEMONIC: "mnemonic";
};
type ValueOf<T> = T[keyof T];
type W_ID = ValueOf<typeof WALLET_ID>;

interface Account {
    walletId: W_ID;
    name: string;
    address: string;
    chain: string;
    active: boolean;
    dateConnected: number;
    dateLastActive?: number;
}

declare const createWallet: <WalClient extends BaseClient = BaseClient>(state: AnyWalletState, id: W_ID, ip?: boolean | ClientInitParams) => {
    id: W_ID;
    metadata: ClientMetadata;
    client: WalClient | null;
    initParams: boolean | ClientInitParams;
    inited: boolean;
    initing: boolean;
    signing: boolean;
    connecting: boolean;
    loadClient: () => Promise<boolean>;
    unloadClient: () => Promise<void>;
    connect: (p?: any) => Promise<Account[]>;
    disconnect: () => Promise<void>;
    reconnect: () => Promise<void>;
    setAsActiveWallet: () => void;
    removeAccounts: () => void;
    signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
    readonly accounts: Account[];
    readonly isConnected: boolean;
    readonly isActive: boolean;
};
declare const signTransactions: (state: AnyWalletState, txns: Uint8Array[]) => Promise<Uint8Array[]>;
declare const setLogsEnabled: (isEnabled: boolean) => void;

type PeraSdk = Omit<PeraWalletConnect, 'connector'> & {
    connector: any;
};
type SdkConfig$6 = {
    bridge?: string;
    deep_link?: string;
    app_meta?: {
        logo: string;
        name: string;
        main_color: string;
    };
    shouldShowSignTxnToast?: boolean;
};
type PeraWalletClientConstructor = {
    sdk: PeraSdk;
};
type InitParams$6 = {
    config?: SdkConfig$6;
    sdk?: PeraSdk;
};

type InkeySdk = Awaited<ReturnType<typeof createClient>>;
type InkeyWalletClientConstructor = {
    sdk: InkeySdk;
};
type SdkConfig$5 = InkeyConfig;
type ClientConfig = SdkConfig$5;
type InitParams$5 = {
    config?: ClientConfig;
    sdk?: InkeySdk;
};

type MyAlgoSdk = MyAlgoConnect;
type MyAlgoClientConstructor = {
    sdk: MyAlgoSdk;
};
type SdkConfig$4 = {
    timeout?: number;
    bridgeUrl?: string;
    disableLedgerNano?: boolean;
};
type InitParams$4 = {
    config?: SdkConfig$4;
    sdk?: MyAlgoSdk;
};

type Network = 'betanet' | 'testnet' | 'mainnet' | string;
type AlgoSignerSdk = {
    connect: () => Promise<Record<string, never>>;
    accounts: (ledger: {
        ledger: SupportedLedgers;
    }) => Promise<{
        address: string;
    }[]>;
    signTxn: (transactions: AlgoSignerTransaction[]) => Promise<{
        txID: string;
        blob: string;
    }[]>;
    encoding: {
        msgpackToBase64(transaction: Uint8Array): string;
        byteArrayToString(transaction: Uint8Array): string;
    };
};
type AlgoSignerTransaction = {
    txn: string;
    signers?: [];
    multisig?: string;
};
type SupportedLedgers = 'MainNet' | 'TestNet' | 'BetaNet' | string;
type AlgoSignerClientConstructor = {
    sdk: AlgoSignerSdk;
    network: SupportedLedgers;
};
type SdkConfig$3 = {
    network?: Network;
};
type InitParams$3 = {
    config?: SdkConfig$3;
    sdk?: AlgoSignerSdk;
};

type ExodusSdk = {
    isConnected: boolean;
    address: string | null;
    connect: ({ onlyIfTrusted }: {
        onlyIfTrusted: boolean;
    }) => Promise<{
        address: string;
    }>;
    disconnect: () => void;
    signAndSendTransaction(transactions: Bytes[]): Promise<{
        txId: string;
    }>;
    signTransaction(transactions: Bytes[]): Promise<Bytes[]>;
};
type SdkConfig$2 = {
    onlyIfTrusted: boolean;
};
type Bytes = Readonly<Uint8Array>;
type ExodusClientConstructor = {
    sdk: ExodusSdk;
    onlyIfTrusted: boolean;
};
type InitParams$2 = {
    config?: SdkConfig$2;
    sdk?: ExodusSdk;
};

type DeflySdk = Omit<DeflyWalletConnect, 'connector'> & {
    connector: any;
};
type SdkConfig$1 = {
    bridge?: string;
    deep_link?: string;
    app_meta?: {
        logo: string;
        name: string;
        main_color: string;
    };
    shouldShowSignTxnToast?: boolean;
};
type DeflyWalletClientConstructor = {
    sdk: DeflySdk;
};
type InitParams$1 = {
    config?: SdkConfig$1;
    sdk?: DeflySdk;
};

type MnemonicSdk = Account$1;
type SdkConfig = {
    mnemonic?: string;
};
type MnemonicClientConstructor = {
    sdk?: MnemonicSdk;
};
type InitParamsBase = {
    config?: SdkConfig;
    sdk?: MnemonicSdk;
};
type InitParams = InitParamsBase | SdkConfig['mnemonic'];

type WalletInitParamsObj = {
    [WALLET_ID.PERA]?: boolean | {
        id?: typeof WALLET_ID.PERA;
        config?: InitParams$6['config'];
        sdk?: InitParams$6['sdk'];
    };
    [WALLET_ID.INKEY]?: boolean | {
        id?: typeof WALLET_ID.INKEY;
        config?: InitParams$5['config'];
        sdk?: InitParams$5['sdk'];
    };
    [WALLET_ID.MYALGO]?: boolean | {
        id?: typeof WALLET_ID.MYALGO;
        config?: InitParams$4['config'];
        sdk?: InitParams$4['sdk'];
    };
    [WALLET_ID.ALGOSIGNER]?: boolean | {
        id?: typeof WALLET_ID.ALGOSIGNER;
        config?: InitParams$3['config'];
        sdk?: InitParams$3['sdk'];
    };
    [WALLET_ID.EXODUS]?: boolean | {
        id?: typeof WALLET_ID.EXODUS;
        config?: InitParams$2['config'];
        sdk?: InitParams$2['sdk'];
    };
    [WALLET_ID.DEFLY]?: boolean | {
        id?: typeof WALLET_ID.DEFLY;
        config?: InitParams$1['config'];
        sdk?: InitParams$1['sdk'];
    };
    [WALLET_ID.MNEMONIC]?: string | {
        id?: typeof WALLET_ID.MNEMONIC;
        config?: InitParamsBase['config'];
        sdk?: InitParamsBase['sdk'];
    };
};
type WalletType<T extends W_ID = W_ID> = ReturnType<typeof createWallet<ClientType<T>>>;
type WalletsObj = {
    [WALLET_ID.PERA]?: WalletType<typeof WALLET_ID.PERA>;
    [WALLET_ID.INKEY]?: WalletType<typeof WALLET_ID.INKEY>;
    [WALLET_ID.MYALGO]?: WalletType<typeof WALLET_ID.MYALGO>;
    [WALLET_ID.ALGOSIGNER]?: WalletType<typeof WALLET_ID.ALGOSIGNER>;
    [WALLET_ID.EXODUS]?: WalletType<typeof WALLET_ID.EXODUS>;
    [WALLET_ID.DEFLY]?: WalletType<typeof WALLET_ID.DEFLY>;
    [WALLET_ID.MNEMONIC]?: WalletType<typeof WALLET_ID.MNEMONIC>;
};

type ClientMetadata = {
    id: W_ID;
    name: string;
    icon: string;
    chain: string;
    pkg: string;
};
type ClientInitParams = {
    config?: any;
    sdk?: any;
};
type ClientConstructorParams = {
    someField?: string;
};

declare abstract class BaseClient {
    static readonly metadata: ClientMetadata;
    static init: (cIP?: ClientInitParams) => Promise<BaseClient | null>;
    constructor(params?: ClientConstructorParams);
    abstract sdk: any;
    abstract connect(x: any): Promise<Account[]>;
    abstract disconnect(): Promise<void>;
    abstract reconnect(onDisconnect: () => void): Promise<Account[] | null>;
    abstract signTransactions(connectedAccounts: Account[], transactions: Array<Uint8Array>): Promise<Uint8Array[]>;
}

declare class PeraClient extends BaseClient {
    sdk: PeraSdk;
    static metadata: ClientMetadata;
    constructor({ sdk: clientSdk, }: PeraWalletClientConstructor);
    static init(initParams?: InitParams$6): Promise<PeraClient | null>;
    connect(onDisconnect: () => void): Promise<{
        name: string;
        address: string;
        walletId: W_ID;
        chain: string;
        active: boolean;
        dateConnected: number;
    }[]>;
    reconnect(onDisconnect: () => void): Promise<{
        name: string;
        address: string;
        walletId: W_ID;
        chain: string;
        active: boolean;
        dateConnected: number;
    }[] | null>;
    disconnect(): Promise<void>;
    signTransactions(connectedAccounts: Account[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
}

declare class InkeyClient extends BaseClient {
    sdk: InkeySdk;
    static metadata: ClientMetadata;
    constructor({ sdk: clientSdk, }: InkeyWalletClientConstructor);
    static init(initParams?: InitParams$5): Promise<InkeyClient | null>;
    connect(p?: {
        connectedAccounts?: Account[];
        siteName?: string;
        onDisconnect?: () => void;
    }): Promise<{
        name: string;
        address: string;
        walletId: W_ID;
        chain: string;
        active: boolean;
        dateConnected: number;
    }[]>;
    reconnect(): Promise<Account[] | null>;
    disconnect(): Promise<void>;
    signTransactions(connectedAccounts: Account[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
}

declare class MyAlgoClient extends BaseClient {
    sdk: MyAlgoSdk;
    constructor({ sdk: clientSdk, }: MyAlgoClientConstructor);
    static metadata: ClientMetadata;
    static init(initParams?: InitParams$4): Promise<MyAlgoClient | null>;
    connect(): Promise<{
        walletId: W_ID;
        chain: string;
        active: boolean;
        dateConnected: number;
        address: string;
        name: string;
    }[]>;
    reconnect(): Promise<null>;
    disconnect(): Promise<void>;
    signTransactions(connectedAccounts: Account[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
}

declare class AlgoSignerClient extends BaseClient {
    sdk: AlgoSignerSdk;
    network: Network;
    constructor({ sdk: clientSdk, network, }: AlgoSignerClientConstructor);
    static metadata: ClientMetadata;
    static init(initParams?: InitParams$3): Promise<AlgoSignerClient | null>;
    connect(): Promise<Account[]>;
    reconnect(onDisconnect: () => void): Promise<null>;
    disconnect(): Promise<void>;
    signTransactions(connectedAccounts: Account[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
}

declare class ExodusClient extends BaseClient {
    sdk: ExodusSdk;
    onlyIfTrusted: boolean;
    constructor({ sdk: clientSdk, onlyIfTrusted }: ExodusClientConstructor);
    static metadata: ClientMetadata;
    static init(initParams?: InitParams$2): Promise<ExodusClient | null>;
    connect(): Promise<{
        name: string;
        address: string;
        walletId: W_ID;
        chain: string;
        active: boolean;
        dateConnected: number;
    }[]>;
    reconnect(onDisconnect: () => void): Promise<null>;
    disconnect(): Promise<void>;
    signTransactions(connectedAccounts: Account[], transactions: Array<Uint8Array>, indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
}

declare class DeflyClient extends BaseClient {
    sdk: DeflySdk;
    constructor({ sdk: clientSdk }: DeflyWalletClientConstructor);
    static metadata: ClientMetadata;
    static init(initParams?: InitParams$1): Promise<DeflyClient | null>;
    connect(onDisconnect: () => void): Promise<Account[]>;
    reconnect(onDisconnect: () => void): Promise<{
        name: string;
        address: string;
        walletId: W_ID;
        chain: string;
        active: boolean;
        dateConnected: number;
    }[] | null>;
    disconnect(): Promise<void>;
    signTransactions(connectedAccounts: Account[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
}

declare const CLIENT_MAP: {
    readonly pera: {
        readonly client: typeof PeraClient;
    };
    readonly inkey: {
        readonly client: typeof InkeyClient;
    };
    readonly myalgo: {
        readonly client: typeof MyAlgoClient;
    };
    readonly algosigner: {
        readonly client: typeof AlgoSignerClient;
    };
    readonly exodus: {
        readonly client: typeof ExodusClient;
    };
    readonly defly: {
        readonly client: typeof DeflyClient;
    };
    readonly mnemonic: {
        readonly client: typeof MnemonicClient;
    };
};
declare const CLIENT_IDS: W_ID[];
declare const CLIENT_PKGS: string[];
declare const excludeClients: (idsToDisable: typeof CLIENT_IDS) => typeof CLIENT_PKGS;
type ClientType<T extends W_ID> = InstanceType<typeof CLIENT_MAP[T]['client']>;

declare class MnemonicClient extends BaseClient {
    sdk: undefined | MnemonicSdk;
    constructor({ sdk: clientSdk, }: MnemonicClientConstructor);
    static metadata: ClientMetadata;
    static init(initParams?: InitParams): Promise<MnemonicClient | null>;
    connect(): Promise<Account[]>;
    disconnect(): Promise<void>;
    reconnect(): Promise<Account[] | null>;
    signTransactions(connectedAccounts: Account[], transactions: Uint8Array[], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
}

declare const watchers: {};

type AnyWalletStateConfig = {
    storageKey?: string;
    storageController?: StorageController;
};
declare class AnyWalletState {
    allWallets: {
        pera: {
            id: W_ID;
            metadata: ClientMetadata;
            client: PeraClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        inkey: {
            id: W_ID;
            metadata: ClientMetadata;
            client: InkeyClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        myalgo: {
            id: W_ID;
            metadata: ClientMetadata;
            client: MyAlgoClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        algosigner: {
            id: W_ID;
            metadata: ClientMetadata;
            client: AlgoSignerClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        exodus: {
            id: W_ID;
            metadata: ClientMetadata;
            client: ExodusClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        defly: {
            id: W_ID;
            metadata: ClientMetadata;
            client: DeflyClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        mnemonic: {
            id: W_ID;
            metadata: ClientMetadata;
            client: MnemonicClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
    };
    activeAccount: null | Account;
    connectedAccounts: Account[];
    changedAccountHandlers: Set<any>;
    arr: mobx.IObservableArray<number[]>;
    constructor(config?: AnyWalletStateConfig);
    selfId: string;
    storageKey: string | undefined;
    storageController: StorageController | undefined;
    emitSyncStates: () => void;
    initVars(): void;
    addConnectedAccounts(accounts: Account[]): void;
    setAsActiveAccount: (acct: Account) => void;
    removeAccount: (acct: Account) => void;
    removeAllAccounts: () => void;
    removeAccountsByWalletId: (id: W_ID) => void;
    getAccountsByWalletId: (id: W_ID) => Account[];
    initWallet: <W extends W_ID, P extends WalletInitParamsObj[W]>(wId: W, wInitParams: P) => {
        pera: {
            id: W_ID;
            metadata: ClientMetadata;
            client: PeraClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        inkey: {
            id: W_ID;
            metadata: ClientMetadata;
            client: InkeyClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        myalgo: {
            id: W_ID;
            metadata: ClientMetadata;
            client: MyAlgoClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        algosigner: {
            id: W_ID;
            metadata: ClientMetadata;
            client: AlgoSignerClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        exodus: {
            id: W_ID;
            metadata: ClientMetadata;
            client: ExodusClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        defly: {
            id: W_ID;
            metadata: ClientMetadata;
            client: DeflyClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        mnemonic: {
            id: W_ID;
            metadata: ClientMetadata;
            client: MnemonicClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
    }[W];
    initWallets: (walletInits: WalletInitParamsObj) => {
        pera: {
            id: W_ID;
            metadata: ClientMetadata;
            client: PeraClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        inkey: {
            id: W_ID;
            metadata: ClientMetadata;
            client: InkeyClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        myalgo: {
            id: W_ID;
            metadata: ClientMetadata;
            client: MyAlgoClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        algosigner: {
            id: W_ID;
            metadata: ClientMetadata;
            client: AlgoSignerClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        exodus: {
            id: W_ID;
            metadata: ClientMetadata;
            client: ExodusClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        defly: {
            id: W_ID;
            metadata: ClientMetadata;
            client: DeflyClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
        mnemonic: {
            id: W_ID;
            metadata: ClientMetadata;
            client: MnemonicClient | null;
            initParams: boolean | ClientInitParams;
            inited: boolean;
            initing: boolean;
            signing: boolean;
            connecting: boolean;
            loadClient: () => Promise<boolean>;
            unloadClient: () => Promise<void>;
            connect: (p?: any) => Promise<Account[]>;
            disconnect: () => Promise<void>;
            reconnect: () => Promise<void>;
            setAsActiveWallet: () => void;
            removeAccounts: () => void;
            signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
            readonly accounts: Account[];
            readonly isConnected: boolean;
            readonly isActive: boolean;
        };
    };
    connectWallet: <W extends W_ID, P extends WalletInitParamsObj[W]>(wId: W, wInitParams?: P | undefined) => Promise<Account[]>;
    disconnectWallet: <W extends W_ID>(wId: W) => Promise<void>;
    disconnectAllWallets: () => Promise<void>;
    signTransactions: (txns: Uint8Array[]) => Promise<Uint8Array[]>;
    subscribeToAccountChanges: (handler: (a: null | Account) => void, opts?: {
        callOnSet: boolean;
    }) => () => void;
    get activeAddress(): string;
    get activeWalletId(): W_ID | null;
    get activeWallet(): {
        id: W_ID;
        metadata: ClientMetadata;
        client: PeraClient | InkeyClient | MyAlgoClient | AlgoSignerClient | ExodusClient | DeflyClient | MnemonicClient | null;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        signing: boolean;
        connecting: boolean;
        loadClient: () => Promise<boolean>;
        unloadClient: () => Promise<void>;
        connect: (p?: any) => Promise<Account[]>;
        disconnect: () => Promise<void>;
        reconnect: () => Promise<void>;
        setAsActiveWallet: () => void;
        removeAccounts: () => void;
        signTransactions: (transactions: Uint8Array[]) => Promise<Uint8Array[]>;
        readonly accounts: Account[];
        readonly isConnected: boolean;
        readonly isActive: boolean;
    } | undefined;
    get isSigning(): boolean;
    get isIniting(): boolean;
}

export { Account, AnyWalletState, AnyWalletStateConfig, BaseClient, CLIENT_IDS, CLIENT_MAP, CLIENT_PKGS, ClientConstructorParams, ClientInitParams, ClientMetadata, ClientType, WALLET_ID, W_ID, WalletInitParamsObj, WalletType, WalletsObj, arrayBufferToBase64, createWallet, excludeClients, isBrowser, logger, setLogsEnabled, signTransactions, watchers };