@yaswap/wallet-core 2.0.0

package/dist/src/store/index.d.ts

@@ -0,0 +1,3524 @@
+import { ActionContext as _ActionContext } from 'vuex';
+import * as actions from './actions';
+import { RootState } from './types';
+declare const store: {
+    readonly state: {
+        readonly version: number;
+        readonly key: string;
+        readonly wallets: import("./types").Wallet[];
+        readonly unlockedAt: number;
+        readonly brokerReady: boolean;
+        readonly encryptedWallets: string;
+        readonly enabledAssets: {
+            mainnet?: Record<string, string[]> | undefined;
+            testnet?: Record<string, string[]> | undefined;
+        };
+        readonly customTokens: {
+            mainnet?: Record<string, import("./types").CustomToken[]> | undefined;
+            testnet?: Record<string, import("./types").CustomToken[]> | undefined;
+        };
+        readonly accounts: {
+            [x: string]: Record<import("./types").Network, import("./types").Account[]> | undefined;
+        };
+        readonly fiatRates: {
+            [x: string]: number;
+        };
+        readonly currenciesInfo: {
+            [x: string]: import("bignumber.js").BigNumber;
+        };
+        readonly fees: {
+            mainnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+            testnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+        };
+        readonly history: {
+            mainnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+            testnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+        };
+        readonly marketData: {
+            mainnet?: import("./types").MarketData[] | undefined;
+            testnet?: import("./types").MarketData[] | undefined;
+        };
+        readonly activeNetwork: import("./types").Network;
+        readonly activeWalletId: string;
+        readonly keyUpdatedAt: number;
+        readonly keySalt: string;
+        readonly termsAcceptedAt: number;
+        readonly setupAt: number;
+        readonly injectEthereum: boolean;
+        readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+        readonly usbBridgeWindowsId: number;
+        readonly externalConnections: {
+            [x: string]: Record<string, import("./types").Connections>;
+        };
+        readonly rskLegacyDerivation: boolean;
+        readonly analytics: {
+            userId: string;
+            acceptedDate: number;
+            askedDate: number;
+            askedTimes: number;
+            notAskAgain: boolean;
+        };
+        readonly experiments: {
+            manageAccounts?: boolean | undefined;
+            reportErrors?: boolean | undefined;
+        };
+        readonly whatsNewModalVersion: string;
+        readonly enabledChains: {
+            [x: string]: Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]> | undefined;
+        };
+        readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+        readonly customChainSeetings: {
+            mainnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+            testnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+        };
+    };
+    getters: {
+        readonly client: ({ network, walletId, chainId, accountId, useCache, accountType, accountIndex, }: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            accountId?: string | undefined;
+            useCache?: boolean | undefined;
+            accountType?: import("./types").AccountType | undefined;
+            accountIndex?: number | undefined;
+        }) => import("@yaswap/client").Client<import("@yaswap/client").Chain<any, import("@yaswap/types").Network>, import("@yaswap/client").Wallet<any, any>, import("@yaswap/client").Swap<any, any, import("@yaswap/client").Wallet<any, any>>, import("@yaswap/client").Nft<any, any>>;
+        readonly historyItemById: (network: import("./types").Network, walletId: string, id: string) => import("./types").HistoryItem | undefined;
+        readonly cryptoassets: {
+            [x: string]: import("@yaswap/cryptoassets").IAsset;
+        };
+        readonly networkAccounts: readonly import("./types").Account[];
+        readonly networkAssets: readonly string[];
+        readonly allNetworkAssets: readonly string[];
+        readonly activity: readonly import("./types").HistoryItem[];
+        readonly totalFiatBalance: {
+            readonly c: number[] | null;
+            readonly e: number | null;
+            readonly s: number | null;
+            readonly absoluteValue: () => import("bignumber.js").BigNumber;
+            readonly abs: () => import("bignumber.js").BigNumber;
+            readonly comparedTo: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => number;
+            readonly decimalPlaces: {
+                (): number | null;
+                (decimalPlaces: number, roundingMode?: import("bignumber.js").BigNumber.RoundingMode | undefined): import("bignumber.js").BigNumber;
+            };
+            readonly dp: {
+                (): number | null;
+                (decimalPlaces: number, roundingMode?: import("bignumber.js").BigNumber.RoundingMode | undefined): import("bignumber.js").BigNumber;
+            };
+            readonly dividedBy: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => import("bignumber.js").BigNumber;
+            readonly div: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => import("bignumber.js").BigNumber;
+            readonly dividedToIntegerBy: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => import("bignumber.js").BigNumber;
+            readonly idiv: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => import("bignumber.js").BigNumber;
+            readonly exponentiatedBy: {
+                (n: import("bignumber.js").BigNumber.Value, m?: import("bignumber.js").BigNumber.Value | undefined): import("bignumber.js").BigNumber;
+                (n: number, m?: import("bignumber.js").BigNumber.Value | undefined): import("bignumber.js").BigNumber;
+            };
+            readonly pow: {
+                (n: import("bignumber.js").BigNumber.Value, m?: import("bignumber.js").BigNumber.Value | undefined): import("bignumber.js").BigNumber;
+                (n: number, m?: import("bignumber.js").BigNumber.Value | undefined): import("bignumber.js").BigNumber;
+            };
+            readonly integerValue: (rm?: import("bignumber.js").BigNumber.RoundingMode | undefined) => import("bignumber.js").BigNumber;
+            readonly isEqualTo: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => boolean;
+            readonly eq: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => boolean;
+            readonly isFinite: () => boolean;
+            readonly isGreaterThan: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => boolean;
+            readonly gt: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => boolean;
+            readonly isGreaterThanOrEqualTo: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => boolean;
+            readonly gte: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => boolean;
+            readonly isInteger: () => boolean;
+            readonly isLessThan: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => boolean;
+            readonly lt: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => boolean;
+            readonly isLessThanOrEqualTo: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => boolean;
+            readonly lte: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => boolean;
+            readonly isNaN: () => boolean;
+            readonly isNegative: () => boolean;
+            readonly isPositive: () => boolean;
+            readonly isZero: () => boolean;
+            readonly minus: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => import("bignumber.js").BigNumber;
+            readonly modulo: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => import("bignumber.js").BigNumber;
+            readonly mod: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => import("bignumber.js").BigNumber;
+            readonly multipliedBy: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => import("bignumber.js").BigNumber;
+            readonly times: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => import("bignumber.js").BigNumber;
+            readonly negated: () => import("bignumber.js").BigNumber;
+            readonly plus: (n: import("bignumber.js").BigNumber.Value, base?: number | undefined) => import("bignumber.js").BigNumber;
+            readonly precision: {
+                (includeZeros?: boolean | undefined): number;
+                (significantDigits: number, roundingMode?: import("bignumber.js").BigNumber.RoundingMode | undefined): import("bignumber.js").BigNumber;
+            };
+            readonly sd: {
+                (includeZeros?: boolean | undefined): number;
+                (significantDigits: number, roundingMode?: import("bignumber.js").BigNumber.RoundingMode | undefined): import("bignumber.js").BigNumber;
+            };
+            readonly shiftedBy: (n: number) => import("bignumber.js").BigNumber;
+            readonly squareRoot: () => import("bignumber.js").BigNumber;
+            readonly sqrt: () => import("bignumber.js").BigNumber;
+            readonly toExponential: {
+                (decimalPlaces: number, roundingMode?: import("bignumber.js").BigNumber.RoundingMode | undefined): string;
+                (): string;
+            };
+            readonly toFixed: {
+                (decimalPlaces: number, roundingMode?: import("bignumber.js").BigNumber.RoundingMode | undefined): string;
+                (): string;
+            };
+            readonly toFormat: {
+                (decimalPlaces: number, roundingMode: import("bignumber.js").BigNumber.RoundingMode, format?: import("bignumber.js").BigNumber.Format | undefined): string;
+                (decimalPlaces: number, roundingMode?: import("bignumber.js").BigNumber.RoundingMode | undefined): string;
+                (decimalPlaces?: number | undefined): string;
+                (decimalPlaces: number, format: import("bignumber.js").BigNumber.Format): string;
+                (format: import("bignumber.js").BigNumber.Format): string;
+            };
+            readonly toFraction: (max_denominator?: import("bignumber.js").BigNumber.Value | undefined) => [import("bignumber.js").BigNumber, import("bignumber.js").BigNumber];
+            readonly toJSON: () => string;
+            readonly toNumber: () => number;
+            readonly toPrecision: {
+                (significantDigits: number, roundingMode?: import("bignumber.js").BigNumber.RoundingMode | undefined): string;
+                (): string;
+            };
+            readonly toString: (base?: number | undefined) => string;
+            readonly valueOf: () => string;
+        };
+        readonly accountItem: (accountId: string) => import("./types").Account | undefined;
+        readonly suggestedFeePrices: (asset: string) => import("@yaswap/types").FeeDetails | undefined;
+        readonly accountsWithBalance: readonly import("./types").Account[];
+        readonly accountsData: readonly import("./types").Account[];
+        readonly accountFiatBalance: (walletId: string, network: import("./types").Network, accountId: string) => import("bignumber.js").BigNumber;
+        readonly assetFiatBalance: (asset: string, balance: import("bignumber.js").BigNumber) => import("bignumber.js").BigNumber | null;
+        readonly assetMarketCap: (asset: string) => import("@yaswap/types").Nullable<import("bignumber.js").BigNumber>;
+        readonly chainAssets: {
+            readonly yacoin?: string[] | undefined;
+            readonly bitcoin?: string[] | undefined;
+            readonly ethereum?: string[] | undefined;
+            readonly rsk?: string[] | undefined;
+            readonly bsc?: string[] | undefined;
+            readonly near?: string[] | undefined;
+            readonly polygon?: string[] | undefined;
+            readonly arbitrum?: string[] | undefined;
+            readonly solana?: string[] | undefined;
+            readonly fuse?: string[] | undefined;
+            readonly terra?: string[] | undefined;
+            readonly avalanche?: string[] | undefined;
+            readonly optimism?: string[] | undefined;
+        };
+        readonly analyticsEnabled: Readonly<boolean>;
+        readonly allNftCollections: {
+            [x: string]: import("./types").NFTWithAccount[];
+        };
+        readonly accountNftCollections: (accountId: string) => import("./types").NFTCollections<import("./types").NFT>;
+        readonly mergedChainSettings: {
+            readonly yacoin: import("../types").ChainifyNetwork;
+            readonly bitcoin: import("../types").ChainifyNetwork;
+            readonly ethereum: import("../types").ChainifyNetwork;
+            readonly rsk: import("../types").ChainifyNetwork;
+            readonly bsc: import("../types").ChainifyNetwork;
+            readonly near: import("../types").ChainifyNetwork;
+            readonly polygon: import("../types").ChainifyNetwork;
+            readonly arbitrum: import("../types").ChainifyNetwork;
+            readonly solana: import("../types").ChainifyNetwork;
+            readonly fuse: import("../types").ChainifyNetwork;
+            readonly terra: import("../types").ChainifyNetwork;
+            readonly avalanche: import("../types").ChainifyNetwork;
+            readonly optimism: import("../types").ChainifyNetwork;
+        };
+        readonly chainSettings: readonly {
+            chain: string;
+            asset: string;
+            network: import("../types").ChainifyNetwork;
+        }[];
+    };
+    commit: {
+        SET_STATE: (payload: {
+            newState: RootState;
+        }) => void;
+        CREATE_WALLET: (payload: {
+            key: string;
+            keySalt: string;
+            encryptedWallets: string;
+            wallet: import("./types").Wallet;
+        }) => void;
+        ACCEPT_TNC: () => void;
+        CHANGE_ACTIVE_WALLETID: (payload: {
+            walletId: string;
+        }) => void;
+        CHANGE_ACTIVE_NETWORK: (payload: {
+            network: import("./types").Network;
+        }) => void;
+        CHANGE_PASSWORD: (payload: {
+            key: string;
+            keySalt: string;
+            encryptedWallets: string;
+        }) => void;
+        LOCK_WALLET: () => void;
+        UNLOCK_WALLET: (payload: {
+            key: string;
+            wallets: import("./types").Wallet[];
+            unlockedAt: number;
+        }) => void;
+        NEW_SWAP: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            swap: import("./types").SwapHistoryItem;
+        }) => void;
+        NEW_TRASACTION: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            transaction: import("./types").SendHistoryItem;
+        }) => void;
+        NEW_NFT_TRASACTION: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            transaction: import("./types").NFTSendHistoryItem;
+        }) => void;
+        UPDATE_HISTORY: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            id: string;
+            updates: Partial<import("./types").HistoryItem>;
+        }) => void;
+        REMOVE_ORDER: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            id: string;
+        }) => void;
+        UPDATE_BALANCE: (payload: {
+            network: import("./types").Network;
+            accountId: string;
+            walletId: string;
+            asset: string;
+            balance: string;
+        }) => void;
+        UPDATE_MULTIPLE_BALANCES: (payload: {
+            network: import("./types").Network;
+            accountId: string;
+            walletId: string;
+            assets: string[];
+            balances: import("@yaswap/types").Nullable<string>[];
+        }) => void;
+        UPDATE_FEES: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            asset: string;
+            fees: import("@yaswap/types").FeeDetails;
+        }) => void;
+        UPDATE_FIAT_RATES: (payload: {
+            fiatRates: import("./types").FiatRates;
+        }) => void;
+        UPDATE_CURRENCIES_INFO: (payload: {
+            currenciesInfo: import("./types").CurrenciesInfo;
+        }) => void;
+        UPDATE_MARKET_DATA: (payload: {
+            network: import("./types").Network;
+            marketData: import("./types").MarketData[];
+        }) => void;
+        SET_ETHEREUM_INJECTION_CHAIN: (payload: {
+            chain: import("@yaswap/cryptoassets").ChainId;
+        }) => void;
+        ENABLE_ETHEREUM_INJECTION: () => void;
+        DISABLE_ETHEREUM_INJECTION: () => void;
+        ENABLE_ASSETS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+        }) => void;
+        DISABLE_ASSETS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+        }) => void;
+        DISABLE_ACCOUNT_ASSETS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            assets: string[];
+        }) => void;
+        ENABLE_ACCOUNT_ASSETS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            assets: string[];
+        }) => void;
+        ADD_CUSTOM_TOKEN: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            customToken: import("./types").CustomToken;
+        }) => void;
+        REMOVE_CUSTOM_TOKEN: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            symbol: string;
+        }) => void;
+        CREATE_ACCOUNT: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            account: import("./types").Account;
+        }) => void;
+        UPDATE_ACCOUNT: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            account: import("./types").Account;
+        }) => void;
+        REMOVE_ACCOUNT: (payload: {
+            walletId: string;
+            id: string;
+            network: import("./types").Network;
+        }) => void;
+        UPDATE_ACCOUNT_ADDRESSES: (payload: {
+            network: import("./types").Network;
+            accountId: string;
+            walletId: string;
+            addresses: string[];
+        }) => void;
+        SET_USB_BRIDGE_WINDOWS_ID: (payload: {
+            id: number;
+        }) => void;
+        SET_EXTERNAL_CONNECTION_DEFAULT: (payload: {
+            origin: string;
+            activeWalletId: string;
+            accountId: string;
+        }) => void;
+        ADD_EXTERNAL_CONNECTION: (payload: {
+            origin: string;
+            activeWalletId: string;
+            accountId: string;
+            chain: import("@yaswap/cryptoassets").ChainId;
+        }) => void;
+        REMOVE_EXTERNAL_CONNECTIONS: (payload: {
+            activeWalletId: string;
+        }) => void;
+        SET_ANALYTICS_PREFERENCES: (payload: Partial<import("./types").AnalyticsState>) => void;
+        UPDATE_NFTS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            nfts: import("./types").NFT[];
+        }) => void;
+        NFT_TOGGLE_STARRED: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            nft: import("./types").NFT;
+        }) => void;
+        TOGGLE_EXPERIMENT: (payload: {
+            name: import("./types").ExperimentType;
+        }) => void;
+        SET_WHATS_NEW_MODAL_VERSION: (payload: {
+            version: string;
+        }) => void;
+        TOGGLE_BLOCKCHAIN: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            enable: boolean;
+        }) => void;
+        TOGGLE_ACCOUNT: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            enable: boolean;
+        }) => void;
+        LOG_ERROR: (payload: import("@yaswap/error-parser").LiqualityErrorJSON) => void;
+        CLEAR_ERROR_LOG: () => void;
+        SET_CUSTOM_CHAIN_SETTINGS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            chanifyNetwork: import("@yaswap/types").Network;
+        }) => void;
+        REMOVE_CUSTOM_CHAIN_SETTINGS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+        }) => void;
+    };
+    dispatch: {
+        readonly acceptTermsAndConditions: (payload: {
+            analyticsAccepted: boolean;
+        }) => Promise<void>;
+        readonly createAccount: (payload: {
+            walletId: string;
+            network: import("./types").Network;
+            account: import("./types").Account;
+        }) => Promise<import("./types").Account>;
+        readonly removeAccount: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            id: string;
+        }) => Promise<string>;
+        readonly toggleAccount: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accounts: string[];
+            enable: boolean;
+        }) => Promise<void>;
+        readonly toggleBlockchain: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            enable: boolean;
+        }) => Promise<void>;
+        readonly updateAccount: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            account: import("./types").Account;
+        }) => Promise<{
+            updatedAt: number;
+            id: string;
+            walletId: string;
+            createdAt: number;
+            enabled: boolean;
+            derivationPath: string;
+            chainCode?: string | undefined;
+            publicKey?: string | undefined;
+            nfts?: import("./types").NFT[] | undefined;
+            type: import("./types").AccountType;
+            name: string;
+            alias?: string | undefined;
+            chain: import("@yaswap/cryptoassets").ChainId;
+            index: number;
+            addresses: string[];
+            assets: string[];
+            balances: Record<string, string>;
+            color: string;
+        }>;
+        readonly addCustomToken: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chain: import("@yaswap/cryptoassets").ChainId;
+            symbol: string;
+            name: string;
+            contractAddress: string;
+            decimals: number;
+        }) => Promise<void>;
+        readonly addExternalConnection: (payload: {
+            origin: string;
+            chain: import("@yaswap/cryptoassets").ChainId;
+            accountId: string;
+            setDefaultEthereum: boolean;
+        }) => Promise<void>;
+        readonly initializeAnalyticsPreferences: (payload: {
+            accepted: boolean;
+        }) => Promise<void>;
+        readonly updateAnalyticsPreferences: (payload: import("./types").AnalyticsState) => Promise<void>;
+        readonly setAnalyticsResponse: (payload: {
+            accepted: boolean;
+        }) => Promise<void>;
+        readonly initializeAnalytics: () => Promise<boolean>;
+        readonly trackAnalytics: (payload: {
+            event: string;
+            properties: actions.AmplitudeProperties;
+        }) => Promise<number> | Promise<undefined>;
+        readonly changeActiveNetwork: (payload: {
+            network: import("./types").Network;
+        }) => Promise<void>;
+        readonly changeActiveWalletId: (payload: {
+            walletId: string;
+        }) => Promise<void>;
+        readonly changePassword: (payload: {
+            key: string;
+        }) => Promise<void>;
+        readonly checkPendingActions: (payload: {
+            walletId: string;
+        }) => Promise<void>;
+        readonly createWallet: (payload: {
+            key: string;
+            mnemonic: string;
+            imported?: boolean | undefined;
+        }) => Promise<import("./types").Wallet>;
+        readonly disableAssets: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+        }) => Promise<void>;
+        readonly disableEthereumInjection: () => Promise<void>;
+        readonly enableAssets: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+        }) => Promise<void>;
+        readonly enableEthereumInjection: () => Promise<void>;
+        readonly exportPrivateKey: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+        }) => Promise<string>;
+        readonly fetchTokenDetails: (payload: actions.FetchTokenDetailsRequest) => Promise<import("@yaswap/types").Nullable<import("@yaswap/types").TokenDetails>>;
+        readonly forgetDappConnections: () => Promise<void>;
+        readonly getLockForAsset: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            asset: string;
+            item: import("./types").BaseHistoryItem;
+        }) => Promise<string>;
+        readonly getQuotes: (payload: import("../swaps/types").GetQuotesRequest) => Promise<actions.GetQuotesResult>;
+        readonly getSlowQuotes: (payload: {
+            requestId: string;
+        }) => Promise<import("../swaps/types").SwapQuote[]>;
+        readonly getUnusedAddresses: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+            accountId: string;
+        }) => Promise<string[]>;
+        readonly getLedgerAccounts: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            asset: string;
+            accountType: import("./types").AccountType;
+            startingIndex: number;
+            numAccounts: number;
+        }) => Promise<{
+            account: string;
+            index: number;
+            exists: boolean;
+        }[]>;
+        readonly initializeAddresses: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+        }) => Promise<void>;
+        readonly lockWallet: () => Promise<void>;
+        readonly newSwap: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            quote: import("../swaps/types").SwapQuote;
+            fee: number;
+            claimFee: number;
+            feeLabel: import("./types").FeeLabel;
+            claimFeeLabel: import("./types").FeeLabel;
+        }) => Promise<import("./types").SwapHistoryItem>;
+        readonly performNextAction: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            id: string;
+        }) => Promise<Partial<import("./types").HistoryItem> | undefined>;
+        readonly proxyMutation: (payload: {
+            type: string;
+            payload: any;
+        }) => Promise<void>;
+        readonly removeCustomToken: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            symbol: string;
+        }) => Promise<void>;
+        readonly retrySwap: (payload: {
+            swap: import("./types").SwapHistoryItem;
+        }) => Promise<Partial<import("./types").SwapHistoryItem> | undefined>;
+        readonly sendNFTTransaction: (payload: import("./types").NFTSendTransactionParams) => Promise<import("@yaswap/types").Transaction<any>>;
+        readonly sendTransaction: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            asset: string;
+            to: string;
+            amount: import("bignumber.js").BigNumber;
+            data: string;
+            fee: number;
+            feeAsset: string;
+            gas: number;
+            feeLabel: import("./types").FeeLabel;
+            fiatRate: number;
+        }) => Promise<import("./types").SendHistoryItem>;
+        readonly setEthereumInjectionChain: (payload: {
+            chain: import("@yaswap/cryptoassets").ChainId;
+        }) => Promise<void>;
+        readonly setWhatsNewModalVersion: (payload: {
+            version: string;
+        }) => Promise<void>;
+        readonly showNotification: (payload: import("../types").Notification) => Promise<void>;
+        readonly toggleExperiment: (payload: {
+            name: import("./types").ExperimentType;
+        }) => Promise<void>;
+        readonly toggleNFTStarred: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            nft: import("./types").NFT;
+        }) => Promise<void>;
+        readonly unlockWallet: (payload: {
+            key: string;
+        }) => Promise<void>;
+        readonly updateAccountBalance: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+        }) => Promise<void>;
+        readonly updateBalances: (payload: {
+            walletId: string;
+            network: import("./types").Network;
+            accountIds?: string[] | undefined;
+        }) => Promise<void>;
+        readonly updateCurrenciesInfo: (payload: {
+            assets: string[];
+        }) => Promise<import("./types").CurrenciesInfo>;
+        readonly updateFees: (payload: {
+            asset: string;
+        }) => Promise<import("@yaswap/types").FeeDetails>;
+        readonly updateFiatRates: (payload: {
+            assets: string[];
+        }) => Promise<import("./types").FiatRates>;
+        readonly updateMarketData: (payload: {
+            network: import("./types").Network;
+        }) => Promise<{
+            network: import("./types").Network;
+            marketData: import("./types").MarketData[];
+        }>;
+        readonly updateNFTs: (payload: {
+            walletId: string;
+            network: import("./types").Network;
+            accountIds: string[];
+        }) => Promise<import("./types").NFT[][]>;
+        readonly updateTransactionFee: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            asset: string;
+            id: string;
+            hash: string;
+            newFee: number;
+        }) => Promise<import("@yaswap/types").Transaction<any>>;
+        readonly logError: (payload: import("@yaswap/error-parser").LiqualityErrorJSON) => Promise<void>;
+        readonly clearErrorLog: () => Promise<void>;
+        readonly saveCustomChainSettings: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            chanifyNetwork: import("@yaswap/types").Network;
+        }) => Promise<void>;
+        readonly removeCustomChainSettings: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+        }) => Promise<void>;
+    };
+    original: {
+        readonly state: {
+            readonly version: number;
+            readonly key: string;
+            readonly wallets: import("./types").Wallet[];
+            readonly unlockedAt: number;
+            readonly brokerReady: boolean;
+            readonly encryptedWallets: string;
+            readonly enabledAssets: {
+                mainnet?: Record<string, string[]> | undefined;
+                testnet?: Record<string, string[]> | undefined;
+            };
+            readonly customTokens: {
+                mainnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                testnet?: Record<string, import("./types").CustomToken[]> | undefined;
+            };
+            readonly accounts: {
+                [x: string]: Record<import("./types").Network, import("./types").Account[]> | undefined;
+            };
+            readonly fiatRates: {
+                [x: string]: number;
+            };
+            readonly currenciesInfo: {
+                [x: string]: import("bignumber.js").BigNumber;
+            };
+            readonly fees: {
+                mainnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                testnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+            };
+            readonly history: {
+                mainnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                testnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+            };
+            readonly marketData: {
+                mainnet?: import("./types").MarketData[] | undefined;
+                testnet?: import("./types").MarketData[] | undefined;
+            };
+            readonly activeNetwork: import("./types").Network;
+            readonly activeWalletId: string;
+            readonly keyUpdatedAt: number;
+            readonly keySalt: string;
+            readonly termsAcceptedAt: number;
+            readonly setupAt: number;
+            readonly injectEthereum: boolean;
+            readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+            readonly usbBridgeWindowsId: number;
+            readonly externalConnections: {
+                [x: string]: Record<string, import("./types").Connections>;
+            };
+            readonly rskLegacyDerivation: boolean;
+            readonly analytics: {
+                userId: string;
+                acceptedDate: number;
+                askedDate: number;
+                askedTimes: number;
+                notAskAgain: boolean;
+            };
+            readonly experiments: {
+                manageAccounts?: boolean | undefined;
+                reportErrors?: boolean | undefined;
+            };
+            readonly whatsNewModalVersion: string;
+            readonly enabledChains: {
+                [x: string]: Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]> | undefined;
+            };
+            readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+            readonly customChainSeetings: {
+                mainnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                testnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+            };
+        };
+        readonly getters: any;
+        replaceState: (state: {
+            readonly version: number;
+            readonly key: string;
+            readonly wallets: import("./types").Wallet[];
+            readonly unlockedAt: number;
+            readonly brokerReady: boolean;
+            readonly encryptedWallets: string;
+            readonly enabledAssets: {
+                mainnet?: Record<string, string[]> | undefined;
+                testnet?: Record<string, string[]> | undefined;
+            };
+            readonly customTokens: {
+                mainnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                testnet?: Record<string, import("./types").CustomToken[]> | undefined;
+            };
+            readonly accounts: {
+                [x: string]: Record<import("./types").Network, import("./types").Account[]> | undefined;
+            };
+            readonly fiatRates: {
+                [x: string]: number;
+            };
+            readonly currenciesInfo: {
+                [x: string]: import("bignumber.js").BigNumber;
+            };
+            readonly fees: {
+                mainnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                testnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+            };
+            readonly history: {
+                mainnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                testnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+            };
+            readonly marketData: {
+                mainnet?: import("./types").MarketData[] | undefined;
+                testnet?: import("./types").MarketData[] | undefined;
+            };
+            readonly activeNetwork: import("./types").Network;
+            readonly activeWalletId: string;
+            readonly keyUpdatedAt: number;
+            readonly keySalt: string;
+            readonly termsAcceptedAt: number;
+            readonly setupAt: number;
+            readonly injectEthereum: boolean;
+            readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+            readonly usbBridgeWindowsId: number;
+            readonly externalConnections: {
+                [x: string]: Record<string, import("./types").Connections>;
+            };
+            readonly rskLegacyDerivation: boolean;
+            readonly analytics: {
+                userId: string;
+                acceptedDate: number;
+                askedDate: number;
+                askedTimes: number;
+                notAskAgain: boolean;
+            };
+            readonly experiments: {
+                manageAccounts?: boolean | undefined;
+                reportErrors?: boolean | undefined;
+            };
+            readonly whatsNewModalVersion: string;
+            readonly enabledChains: {
+                [x: string]: Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]> | undefined;
+            };
+            readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+            readonly customChainSeetings: {
+                mainnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                testnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+            };
+        }) => void;
+        dispatch: import("vuex").Dispatch;
+        commit: import("vuex").Commit;
+        subscribe: <P extends import("vuex").MutationPayload>(fn: (mutation: P, state: {
+            readonly version: number;
+            readonly key: string;
+            readonly wallets: import("./types").Wallet[];
+            readonly unlockedAt: number;
+            readonly brokerReady: boolean;
+            readonly encryptedWallets: string;
+            readonly enabledAssets: {
+                mainnet?: Record<string, string[]> | undefined;
+                testnet?: Record<string, string[]> | undefined;
+            };
+            readonly customTokens: {
+                mainnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                testnet?: Record<string, import("./types").CustomToken[]> | undefined;
+            };
+            readonly accounts: {
+                [x: string]: Record<import("./types").Network, import("./types").Account[]> | undefined;
+            };
+            readonly fiatRates: {
+                [x: string]: number;
+            };
+            readonly currenciesInfo: {
+                [x: string]: import("bignumber.js").BigNumber;
+            };
+            readonly fees: {
+                mainnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                testnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+            };
+            readonly history: {
+                mainnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                testnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+            };
+            readonly marketData: {
+                mainnet?: import("./types").MarketData[] | undefined;
+                testnet?: import("./types").MarketData[] | undefined;
+            };
+            readonly activeNetwork: import("./types").Network;
+            readonly activeWalletId: string;
+            readonly keyUpdatedAt: number;
+            readonly keySalt: string;
+            readonly termsAcceptedAt: number;
+            readonly setupAt: number;
+            readonly injectEthereum: boolean;
+            readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+            readonly usbBridgeWindowsId: number;
+            readonly externalConnections: {
+                [x: string]: Record<string, import("./types").Connections>;
+            };
+            readonly rskLegacyDerivation: boolean;
+            readonly analytics: {
+                userId: string;
+                acceptedDate: number;
+                askedDate: number;
+                askedTimes: number;
+                notAskAgain: boolean;
+            };
+            readonly experiments: {
+                manageAccounts?: boolean | undefined;
+                reportErrors?: boolean | undefined;
+            };
+            readonly whatsNewModalVersion: string;
+            readonly enabledChains: {
+                [x: string]: Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]> | undefined;
+            };
+            readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+            readonly customChainSeetings: {
+                mainnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                testnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+            };
+        }) => any, options?: import("vuex").SubscribeOptions | undefined) => () => void;
+        subscribeAction: <P_1 extends import("vuex").ActionPayload>(fn: import("vuex").SubscribeActionOptions<P_1, {
+            readonly version: number;
+            readonly key: string;
+            readonly wallets: import("./types").Wallet[];
+            readonly unlockedAt: number;
+            readonly brokerReady: boolean;
+            readonly encryptedWallets: string;
+            readonly enabledAssets: {
+                mainnet?: Record<string, string[]> | undefined;
+                testnet?: Record<string, string[]> | undefined;
+            };
+            readonly customTokens: {
+                mainnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                testnet?: Record<string, import("./types").CustomToken[]> | undefined;
+            };
+            readonly accounts: {
+                [x: string]: Record<import("./types").Network, import("./types").Account[]> | undefined;
+            };
+            readonly fiatRates: {
+                [x: string]: number;
+            };
+            readonly currenciesInfo: {
+                [x: string]: import("bignumber.js").BigNumber;
+            };
+            readonly fees: {
+                mainnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                testnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+            };
+            readonly history: {
+                mainnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                testnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+            };
+            readonly marketData: {
+                mainnet?: import("./types").MarketData[] | undefined;
+                testnet?: import("./types").MarketData[] | undefined;
+            };
+            readonly activeNetwork: import("./types").Network;
+            readonly activeWalletId: string;
+            readonly keyUpdatedAt: number;
+            readonly keySalt: string;
+            readonly termsAcceptedAt: number;
+            readonly setupAt: number;
+            readonly injectEthereum: boolean;
+            readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+            readonly usbBridgeWindowsId: number;
+            readonly externalConnections: {
+                [x: string]: Record<string, import("./types").Connections>;
+            };
+            readonly rskLegacyDerivation: boolean;
+            readonly analytics: {
+                userId: string;
+                acceptedDate: number;
+                askedDate: number;
+                askedTimes: number;
+                notAskAgain: boolean;
+            };
+            readonly experiments: {
+                manageAccounts?: boolean | undefined;
+                reportErrors?: boolean | undefined;
+            };
+            readonly whatsNewModalVersion: string;
+            readonly enabledChains: {
+                [x: string]: Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]> | undefined;
+            };
+            readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+            readonly customChainSeetings: {
+                mainnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                testnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+            };
+        }>, options?: import("vuex").SubscribeOptions | undefined) => () => void;
+        watch: <T>(getter: (state: {
+            readonly version: number;
+            readonly key: string;
+            readonly wallets: import("./types").Wallet[];
+            readonly unlockedAt: number;
+            readonly brokerReady: boolean;
+            readonly encryptedWallets: string;
+            readonly enabledAssets: {
+                mainnet?: Record<string, string[]> | undefined;
+                testnet?: Record<string, string[]> | undefined;
+            };
+            readonly customTokens: {
+                mainnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                testnet?: Record<string, import("./types").CustomToken[]> | undefined;
+            };
+            readonly accounts: {
+                [x: string]: Record<import("./types").Network, import("./types").Account[]> | undefined;
+            };
+            readonly fiatRates: {
+                [x: string]: number;
+            };
+            readonly currenciesInfo: {
+                [x: string]: import("bignumber.js").BigNumber;
+            };
+            readonly fees: {
+                mainnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                testnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+            };
+            readonly history: {
+                mainnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                testnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+            };
+            readonly marketData: {
+                mainnet?: import("./types").MarketData[] | undefined;
+                testnet?: import("./types").MarketData[] | undefined;
+            };
+            readonly activeNetwork: import("./types").Network;
+            readonly activeWalletId: string;
+            readonly keyUpdatedAt: number;
+            readonly keySalt: string;
+            readonly termsAcceptedAt: number;
+            readonly setupAt: number;
+            readonly injectEthereum: boolean;
+            readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+            readonly usbBridgeWindowsId: number;
+            readonly externalConnections: {
+                [x: string]: Record<string, import("./types").Connections>;
+            };
+            readonly rskLegacyDerivation: boolean;
+            readonly analytics: {
+                userId: string;
+                acceptedDate: number;
+                askedDate: number;
+                askedTimes: number;
+                notAskAgain: boolean;
+            };
+            readonly experiments: {
+                manageAccounts?: boolean | undefined;
+                reportErrors?: boolean | undefined;
+            };
+            readonly whatsNewModalVersion: string;
+            readonly enabledChains: {
+                [x: string]: Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]> | undefined;
+            };
+            readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+            readonly customChainSeetings: {
+                mainnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                testnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+            };
+        }, getters: any) => T, cb: (value: T, oldValue: T) => void, options?: import("vue").WatchOptions | undefined) => () => void;
+        registerModule: {
+            <T_1>(path: string, module: import("vuex").Module<T_1, {
+                readonly version: number;
+                readonly key: string;
+                readonly wallets: import("./types").Wallet[];
+                readonly unlockedAt: number;
+                readonly brokerReady: boolean;
+                readonly encryptedWallets: string;
+                readonly enabledAssets: {
+                    mainnet?: Record<string, string[]> | undefined;
+                    testnet?: Record<string, string[]> | undefined;
+                };
+                readonly customTokens: {
+                    mainnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                    testnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                };
+                readonly accounts: {
+                    [x: string]: Record<import("./types").Network, import("./types").Account[]> | undefined;
+                };
+                readonly fiatRates: {
+                    [x: string]: number;
+                };
+                readonly currenciesInfo: {
+                    [x: string]: import("bignumber.js").BigNumber;
+                };
+                readonly fees: {
+                    mainnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                    testnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                };
+                readonly history: {
+                    mainnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                    testnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                };
+                readonly marketData: {
+                    mainnet?: import("./types").MarketData[] | undefined;
+                    testnet?: import("./types").MarketData[] | undefined;
+                };
+                readonly activeNetwork: import("./types").Network;
+                readonly activeWalletId: string;
+                readonly keyUpdatedAt: number;
+                readonly keySalt: string;
+                readonly termsAcceptedAt: number;
+                readonly setupAt: number;
+                readonly injectEthereum: boolean;
+                readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+                readonly usbBridgeWindowsId: number;
+                readonly externalConnections: {
+                    [x: string]: Record<string, import("./types").Connections>;
+                };
+                readonly rskLegacyDerivation: boolean;
+                readonly analytics: {
+                    userId: string;
+                    acceptedDate: number;
+                    askedDate: number;
+                    askedTimes: number;
+                    notAskAgain: boolean;
+                };
+                readonly experiments: {
+                    manageAccounts?: boolean | undefined;
+                    reportErrors?: boolean | undefined;
+                };
+                readonly whatsNewModalVersion: string;
+                readonly enabledChains: {
+                    [x: string]: Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]> | undefined;
+                };
+                readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+                readonly customChainSeetings: {
+                    mainnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                    testnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                };
+            }>, options?: import("vuex").ModuleOptions | undefined): void;
+            <T_2>(path: string[], module: import("vuex").Module<T_2, {
+                readonly version: number;
+                readonly key: string;
+                readonly wallets: import("./types").Wallet[];
+                readonly unlockedAt: number;
+                readonly brokerReady: boolean;
+                readonly encryptedWallets: string;
+                readonly enabledAssets: {
+                    mainnet?: Record<string, string[]> | undefined;
+                    testnet?: Record<string, string[]> | undefined;
+                };
+                readonly customTokens: {
+                    mainnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                    testnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                };
+                readonly accounts: {
+                    [x: string]: Record<import("./types").Network, import("./types").Account[]> | undefined;
+                };
+                readonly fiatRates: {
+                    [x: string]: number;
+                };
+                readonly currenciesInfo: {
+                    [x: string]: import("bignumber.js").BigNumber;
+                };
+                readonly fees: {
+                    mainnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                    testnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                };
+                readonly history: {
+                    mainnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                    testnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                };
+                readonly marketData: {
+                    mainnet?: import("./types").MarketData[] | undefined;
+                    testnet?: import("./types").MarketData[] | undefined;
+                };
+                readonly activeNetwork: import("./types").Network;
+                readonly activeWalletId: string;
+                readonly keyUpdatedAt: number;
+                readonly keySalt: string;
+                readonly termsAcceptedAt: number;
+                readonly setupAt: number;
+                readonly injectEthereum: boolean;
+                readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+                readonly usbBridgeWindowsId: number;
+                readonly externalConnections: {
+                    [x: string]: Record<string, import("./types").Connections>;
+                };
+                readonly rskLegacyDerivation: boolean;
+                readonly analytics: {
+                    userId: string;
+                    acceptedDate: number;
+                    askedDate: number;
+                    askedTimes: number;
+                    notAskAgain: boolean;
+                };
+                readonly experiments: {
+                    manageAccounts?: boolean | undefined;
+                    reportErrors?: boolean | undefined;
+                };
+                readonly whatsNewModalVersion: string;
+                readonly enabledChains: {
+                    [x: string]: Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]> | undefined;
+                };
+                readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+                readonly customChainSeetings: {
+                    mainnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                    testnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                };
+            }>, options?: import("vuex").ModuleOptions | undefined): void;
+        };
+        unregisterModule: {
+            (path: string): void;
+            (path: string[]): void;
+        };
+        hasModule: {
+            (path: string): boolean;
+            (path: string[]): boolean;
+        };
+        hotUpdate: (options: {
+            actions?: import("vuex").ActionTree<{
+                readonly version: number;
+                readonly key: string;
+                readonly wallets: import("./types").Wallet[];
+                readonly unlockedAt: number;
+                readonly brokerReady: boolean;
+                readonly encryptedWallets: string;
+                readonly enabledAssets: {
+                    mainnet?: Record<string, string[]> | undefined;
+                    testnet?: Record<string, string[]> | undefined;
+                };
+                readonly customTokens: {
+                    mainnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                    testnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                };
+                readonly accounts: {
+                    [x: string]: Record<import("./types").Network, import("./types").Account[]> | undefined;
+                };
+                readonly fiatRates: {
+                    [x: string]: number;
+                };
+                readonly currenciesInfo: {
+                    [x: string]: import("bignumber.js").BigNumber;
+                };
+                readonly fees: {
+                    mainnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                    testnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                };
+                readonly history: {
+                    mainnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                    testnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                };
+                readonly marketData: {
+                    mainnet?: import("./types").MarketData[] | undefined;
+                    testnet?: import("./types").MarketData[] | undefined;
+                };
+                readonly activeNetwork: import("./types").Network;
+                readonly activeWalletId: string;
+                readonly keyUpdatedAt: number;
+                readonly keySalt: string;
+                readonly termsAcceptedAt: number;
+                readonly setupAt: number;
+                readonly injectEthereum: boolean;
+                readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+                readonly usbBridgeWindowsId: number;
+                readonly externalConnections: {
+                    [x: string]: Record<string, import("./types").Connections>;
+                };
+                readonly rskLegacyDerivation: boolean;
+                readonly analytics: {
+                    userId: string;
+                    acceptedDate: number;
+                    askedDate: number;
+                    askedTimes: number;
+                    notAskAgain: boolean;
+                };
+                readonly experiments: {
+                    manageAccounts?: boolean | undefined;
+                    reportErrors?: boolean | undefined;
+                };
+                readonly whatsNewModalVersion: string;
+                readonly enabledChains: {
+                    [x: string]: Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]> | undefined;
+                };
+                readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+                readonly customChainSeetings: {
+                    mainnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                    testnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                };
+            }, {
+                readonly version: number;
+                readonly key: string;
+                readonly wallets: import("./types").Wallet[];
+                readonly unlockedAt: number;
+                readonly brokerReady: boolean;
+                readonly encryptedWallets: string;
+                readonly enabledAssets: {
+                    mainnet?: Record<string, string[]> | undefined;
+                    testnet?: Record<string, string[]> | undefined;
+                };
+                readonly customTokens: {
+                    mainnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                    testnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                };
+                readonly accounts: {
+                    [x: string]: Record<import("./types").Network, import("./types").Account[]> | undefined;
+                };
+                readonly fiatRates: {
+                    [x: string]: number;
+                };
+                readonly currenciesInfo: {
+                    [x: string]: import("bignumber.js").BigNumber;
+                };
+                readonly fees: {
+                    mainnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                    testnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                };
+                readonly history: {
+                    mainnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                    testnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                };
+                readonly marketData: {
+                    mainnet?: import("./types").MarketData[] | undefined;
+                    testnet?: import("./types").MarketData[] | undefined;
+                };
+                readonly activeNetwork: import("./types").Network;
+                readonly activeWalletId: string;
+                readonly keyUpdatedAt: number;
+                readonly keySalt: string;
+                readonly termsAcceptedAt: number;
+                readonly setupAt: number;
+                readonly injectEthereum: boolean;
+                readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+                readonly usbBridgeWindowsId: number;
+                readonly externalConnections: {
+                    [x: string]: Record<string, import("./types").Connections>;
+                };
+                readonly rskLegacyDerivation: boolean;
+                readonly analytics: {
+                    userId: string;
+                    acceptedDate: number;
+                    askedDate: number;
+                    askedTimes: number;
+                    notAskAgain: boolean;
+                };
+                readonly experiments: {
+                    manageAccounts?: boolean | undefined;
+                    reportErrors?: boolean | undefined;
+                };
+                readonly whatsNewModalVersion: string;
+                readonly enabledChains: {
+                    [x: string]: Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]> | undefined;
+                };
+                readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+                readonly customChainSeetings: {
+                    mainnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                    testnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                };
+            }> | undefined;
+            mutations?: import("vuex").MutationTree<{
+                readonly version: number;
+                readonly key: string;
+                readonly wallets: import("./types").Wallet[];
+                readonly unlockedAt: number;
+                readonly brokerReady: boolean;
+                readonly encryptedWallets: string;
+                readonly enabledAssets: {
+                    mainnet?: Record<string, string[]> | undefined;
+                    testnet?: Record<string, string[]> | undefined;
+                };
+                readonly customTokens: {
+                    mainnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                    testnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                };
+                readonly accounts: {
+                    [x: string]: Record<import("./types").Network, import("./types").Account[]> | undefined;
+                };
+                readonly fiatRates: {
+                    [x: string]: number;
+                };
+                readonly currenciesInfo: {
+                    [x: string]: import("bignumber.js").BigNumber;
+                };
+                readonly fees: {
+                    mainnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                    testnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                };
+                readonly history: {
+                    mainnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                    testnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                };
+                readonly marketData: {
+                    mainnet?: import("./types").MarketData[] | undefined;
+                    testnet?: import("./types").MarketData[] | undefined;
+                };
+                readonly activeNetwork: import("./types").Network;
+                readonly activeWalletId: string;
+                readonly keyUpdatedAt: number;
+                readonly keySalt: string;
+                readonly termsAcceptedAt: number;
+                readonly setupAt: number;
+                readonly injectEthereum: boolean;
+                readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+                readonly usbBridgeWindowsId: number;
+                readonly externalConnections: {
+                    [x: string]: Record<string, import("./types").Connections>;
+                };
+                readonly rskLegacyDerivation: boolean;
+                readonly analytics: {
+                    userId: string;
+                    acceptedDate: number;
+                    askedDate: number;
+                    askedTimes: number;
+                    notAskAgain: boolean;
+                };
+                readonly experiments: {
+                    manageAccounts?: boolean | undefined;
+                    reportErrors?: boolean | undefined;
+                };
+                readonly whatsNewModalVersion: string;
+                readonly enabledChains: {
+                    [x: string]: Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]> | undefined;
+                };
+                readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+                readonly customChainSeetings: {
+                    mainnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                    testnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                };
+            }> | undefined;
+            getters?: import("vuex").GetterTree<{
+                readonly version: number;
+                readonly key: string;
+                readonly wallets: import("./types").Wallet[];
+                readonly unlockedAt: number;
+                readonly brokerReady: boolean;
+                readonly encryptedWallets: string;
+                readonly enabledAssets: {
+                    mainnet?: Record<string, string[]> | undefined;
+                    testnet?: Record<string, string[]> | undefined;
+                };
+                readonly customTokens: {
+                    mainnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                    testnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                };
+                readonly accounts: {
+                    [x: string]: Record<import("./types").Network, import("./types").Account[]> | undefined;
+                };
+                readonly fiatRates: {
+                    [x: string]: number;
+                };
+                readonly currenciesInfo: {
+                    [x: string]: import("bignumber.js").BigNumber;
+                };
+                readonly fees: {
+                    mainnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                    testnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                };
+                readonly history: {
+                    mainnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                    testnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                };
+                readonly marketData: {
+                    mainnet?: import("./types").MarketData[] | undefined;
+                    testnet?: import("./types").MarketData[] | undefined;
+                };
+                readonly activeNetwork: import("./types").Network;
+                readonly activeWalletId: string;
+                readonly keyUpdatedAt: number;
+                readonly keySalt: string;
+                readonly termsAcceptedAt: number;
+                readonly setupAt: number;
+                readonly injectEthereum: boolean;
+                readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+                readonly usbBridgeWindowsId: number;
+                readonly externalConnections: {
+                    [x: string]: Record<string, import("./types").Connections>;
+                };
+                readonly rskLegacyDerivation: boolean;
+                readonly analytics: {
+                    userId: string;
+                    acceptedDate: number;
+                    askedDate: number;
+                    askedTimes: number;
+                    notAskAgain: boolean;
+                };
+                readonly experiments: {
+                    manageAccounts?: boolean | undefined;
+                    reportErrors?: boolean | undefined;
+                };
+                readonly whatsNewModalVersion: string;
+                readonly enabledChains: {
+                    [x: string]: Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]> | undefined;
+                };
+                readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+                readonly customChainSeetings: {
+                    mainnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                    testnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                };
+            }, {
+                readonly version: number;
+                readonly key: string;
+                readonly wallets: import("./types").Wallet[];
+                readonly unlockedAt: number;
+                readonly brokerReady: boolean;
+                readonly encryptedWallets: string;
+                readonly enabledAssets: {
+                    mainnet?: Record<string, string[]> | undefined;
+                    testnet?: Record<string, string[]> | undefined;
+                };
+                readonly customTokens: {
+                    mainnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                    testnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                };
+                readonly accounts: {
+                    [x: string]: Record<import("./types").Network, import("./types").Account[]> | undefined;
+                };
+                readonly fiatRates: {
+                    [x: string]: number;
+                };
+                readonly currenciesInfo: {
+                    [x: string]: import("bignumber.js").BigNumber;
+                };
+                readonly fees: {
+                    mainnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                    testnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                };
+                readonly history: {
+                    mainnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                    testnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                };
+                readonly marketData: {
+                    mainnet?: import("./types").MarketData[] | undefined;
+                    testnet?: import("./types").MarketData[] | undefined;
+                };
+                readonly activeNetwork: import("./types").Network;
+                readonly activeWalletId: string;
+                readonly keyUpdatedAt: number;
+                readonly keySalt: string;
+                readonly termsAcceptedAt: number;
+                readonly setupAt: number;
+                readonly injectEthereum: boolean;
+                readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+                readonly usbBridgeWindowsId: number;
+                readonly externalConnections: {
+                    [x: string]: Record<string, import("./types").Connections>;
+                };
+                readonly rskLegacyDerivation: boolean;
+                readonly analytics: {
+                    userId: string;
+                    acceptedDate: number;
+                    askedDate: number;
+                    askedTimes: number;
+                    notAskAgain: boolean;
+                };
+                readonly experiments: {
+                    manageAccounts?: boolean | undefined;
+                    reportErrors?: boolean | undefined;
+                };
+                readonly whatsNewModalVersion: string;
+                readonly enabledChains: {
+                    [x: string]: Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]> | undefined;
+                };
+                readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+                readonly customChainSeetings: {
+                    mainnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                    testnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                };
+            }> | undefined;
+            modules?: import("vuex").ModuleTree<{
+                readonly version: number;
+                readonly key: string;
+                readonly wallets: import("./types").Wallet[];
+                readonly unlockedAt: number;
+                readonly brokerReady: boolean;
+                readonly encryptedWallets: string;
+                readonly enabledAssets: {
+                    mainnet?: Record<string, string[]> | undefined;
+                    testnet?: Record<string, string[]> | undefined;
+                };
+                readonly customTokens: {
+                    mainnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                    testnet?: Record<string, import("./types").CustomToken[]> | undefined;
+                };
+                readonly accounts: {
+                    [x: string]: Record<import("./types").Network, import("./types").Account[]> | undefined;
+                };
+                readonly fiatRates: {
+                    [x: string]: number;
+                };
+                readonly currenciesInfo: {
+                    [x: string]: import("bignumber.js").BigNumber;
+                };
+                readonly fees: {
+                    mainnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                    testnet?: Record<string, Record<string, import("@yaswap/types").FeeDetails>> | undefined;
+                };
+                readonly history: {
+                    mainnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                    testnet?: Record<string, import("./types").HistoryItem[]> | undefined;
+                };
+                readonly marketData: {
+                    mainnet?: import("./types").MarketData[] | undefined;
+                    testnet?: import("./types").MarketData[] | undefined;
+                };
+                readonly activeNetwork: import("./types").Network;
+                readonly activeWalletId: string;
+                readonly keyUpdatedAt: number;
+                readonly keySalt: string;
+                readonly termsAcceptedAt: number;
+                readonly setupAt: number;
+                readonly injectEthereum: boolean;
+                readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+                readonly usbBridgeWindowsId: number;
+                readonly externalConnections: {
+                    [x: string]: Record<string, import("./types").Connections>;
+                };
+                readonly rskLegacyDerivation: boolean;
+                readonly analytics: {
+                    userId: string;
+                    acceptedDate: number;
+                    askedDate: number;
+                    askedTimes: number;
+                    notAskAgain: boolean;
+                };
+                readonly experiments: {
+                    manageAccounts?: boolean | undefined;
+                    reportErrors?: boolean | undefined;
+                };
+                readonly whatsNewModalVersion: string;
+                readonly enabledChains: {
+                    [x: string]: Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]> | undefined;
+                };
+                readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+                readonly customChainSeetings: {
+                    mainnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                    testnet?: Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>> | undefined;
+                };
+            }> | undefined;
+        }) => void;
+        direct: any;
+    };
+}, rootActionContext: (originalContext: _ActionContext<any, any>) => {
+    rootState: {
+        readonly version: number;
+        readonly key: string;
+        readonly wallets: import("./types").Wallet[];
+        readonly unlockedAt: number;
+        readonly brokerReady: boolean;
+        readonly encryptedWallets: string;
+        readonly enabledAssets: Partial<Record<import("./types").Network, Record<string, string[]>>>;
+        readonly customTokens: Partial<Record<import("./types").Network, Record<string, import("./types").CustomToken[]>>>;
+        readonly accounts: Partial<Record<string, Record<import("./types").Network, import("./types").Account[]>>>;
+        readonly fiatRates: import("./types").FiatRates;
+        readonly currenciesInfo: import("./types").CurrenciesInfo;
+        readonly fees: Partial<Record<import("./types").Network, Record<string, Record<string, import("@yaswap/types").FeeDetails>>>>;
+        readonly history: Partial<Record<import("./types").Network, Record<string, import("./types").HistoryItem[]>>>;
+        readonly marketData: Partial<Record<import("./types").Network, import("./types").MarketData[]>>;
+        readonly activeNetwork: import("./types").Network;
+        readonly activeWalletId: string;
+        readonly keyUpdatedAt: number;
+        readonly keySalt: string;
+        readonly termsAcceptedAt: number;
+        readonly setupAt: number;
+        readonly injectEthereum: boolean;
+        readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+        readonly usbBridgeWindowsId: number;
+        readonly externalConnections: import("./types").ExternalConnections;
+        readonly rskLegacyDerivation: boolean;
+        readonly analytics: import("./types").AnalyticsState;
+        readonly experiments: Partial<Record<import("./types").ExperimentType, boolean>>;
+        readonly whatsNewModalVersion: string;
+        readonly enabledChains: Partial<Record<string, Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]>>>;
+        readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+        readonly customChainSeetings: Partial<Record<import("./types").Network, Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>>>>;
+    };
+    rootGetters: {
+        readonly client: ({ network, walletId, chainId, accountId, useCache, accountType, accountIndex, }: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            accountId?: string | undefined;
+            useCache?: boolean | undefined;
+            accountType?: import("./types").AccountType | undefined;
+            accountIndex?: number | undefined;
+        }) => import("@yaswap/client").Client<import("@yaswap/client").Chain<any, import("@yaswap/types").Network>, import("@yaswap/client").Wallet<any, any>, import("@yaswap/client").Swap<any, any, import("@yaswap/client").Wallet<any, any>>, import("@yaswap/client").Nft<any, any>>;
+        readonly historyItemById: (network: import("./types").Network, walletId: string, id: string) => import("./types").HistoryItem | undefined;
+        readonly cryptoassets: Readonly<{
+            [asset: string]: import("@yaswap/cryptoassets").IAsset;
+        }>;
+        readonly networkAccounts: readonly import("./types").Account[];
+        readonly networkAssets: readonly string[];
+        readonly allNetworkAssets: readonly string[];
+        readonly activity: readonly import("./types").HistoryItem[];
+        readonly totalFiatBalance: Readonly<import("bignumber.js").BigNumber>;
+        readonly accountItem: (accountId: string) => import("./types").Account | undefined;
+        readonly suggestedFeePrices: (asset: string) => import("@yaswap/types").FeeDetails | undefined;
+        readonly accountsWithBalance: readonly import("./types").Account[];
+        readonly accountsData: readonly import("./types").Account[];
+        readonly accountFiatBalance: (walletId: string, network: import("./types").Network, accountId: string) => import("bignumber.js").BigNumber;
+        readonly assetFiatBalance: (asset: string, balance: import("bignumber.js").BigNumber) => import("bignumber.js").BigNumber | null;
+        readonly assetMarketCap: (asset: string) => import("@yaswap/types").Nullable<import("bignumber.js").BigNumber>;
+        readonly chainAssets: Readonly<{
+            yacoin?: string[] | undefined;
+            bitcoin?: string[] | undefined;
+            ethereum?: string[] | undefined;
+            rsk?: string[] | undefined;
+            bsc?: string[] | undefined;
+            near?: string[] | undefined;
+            polygon?: string[] | undefined;
+            arbitrum?: string[] | undefined;
+            solana?: string[] | undefined;
+            fuse?: string[] | undefined;
+            terra?: string[] | undefined;
+            avalanche?: string[] | undefined;
+            optimism?: string[] | undefined;
+        }>;
+        readonly analyticsEnabled: Readonly<boolean>;
+        readonly allNftCollections: Readonly<import("./types").NFTCollections<import("./types").NFTWithAccount>>;
+        readonly accountNftCollections: (accountId: string) => import("./types").NFTCollections<import("./types").NFT>;
+        readonly mergedChainSettings: Readonly<Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>>;
+        readonly chainSettings: readonly {
+            chain: string;
+            asset: string;
+            network: import("../types").ChainifyNetwork;
+        }[];
+    };
+    rootCommit: {
+        SET_STATE: (payload: {
+            newState: RootState;
+        }) => void;
+        CREATE_WALLET: (payload: {
+            key: string;
+            keySalt: string;
+            encryptedWallets: string;
+            wallet: import("./types").Wallet;
+        }) => void;
+        ACCEPT_TNC: () => void;
+        CHANGE_ACTIVE_WALLETID: (payload: {
+            walletId: string;
+        }) => void;
+        CHANGE_ACTIVE_NETWORK: (payload: {
+            network: import("./types").Network;
+        }) => void;
+        CHANGE_PASSWORD: (payload: {
+            key: string;
+            keySalt: string;
+            encryptedWallets: string;
+        }) => void;
+        LOCK_WALLET: () => void;
+        UNLOCK_WALLET: (payload: {
+            key: string;
+            wallets: import("./types").Wallet[];
+            unlockedAt: number;
+        }) => void;
+        NEW_SWAP: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            swap: import("./types").SwapHistoryItem;
+        }) => void;
+        NEW_TRASACTION: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            transaction: import("./types").SendHistoryItem;
+        }) => void;
+        NEW_NFT_TRASACTION: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            transaction: import("./types").NFTSendHistoryItem;
+        }) => void;
+        UPDATE_HISTORY: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            id: string;
+            updates: Partial<import("./types").HistoryItem>;
+        }) => void;
+        REMOVE_ORDER: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            id: string;
+        }) => void;
+        UPDATE_BALANCE: (payload: {
+            network: import("./types").Network;
+            accountId: string;
+            walletId: string;
+            asset: string;
+            balance: string;
+        }) => void;
+        UPDATE_MULTIPLE_BALANCES: (payload: {
+            network: import("./types").Network;
+            accountId: string;
+            walletId: string;
+            assets: string[];
+            balances: import("@yaswap/types").Nullable<string>[];
+        }) => void;
+        UPDATE_FEES: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            asset: string;
+            fees: import("@yaswap/types").FeeDetails;
+        }) => void;
+        UPDATE_FIAT_RATES: (payload: {
+            fiatRates: import("./types").FiatRates;
+        }) => void;
+        UPDATE_CURRENCIES_INFO: (payload: {
+            currenciesInfo: import("./types").CurrenciesInfo;
+        }) => void;
+        UPDATE_MARKET_DATA: (payload: {
+            network: import("./types").Network;
+            marketData: import("./types").MarketData[];
+        }) => void;
+        SET_ETHEREUM_INJECTION_CHAIN: (payload: {
+            chain: import("@yaswap/cryptoassets").ChainId;
+        }) => void;
+        ENABLE_ETHEREUM_INJECTION: () => void;
+        DISABLE_ETHEREUM_INJECTION: () => void;
+        ENABLE_ASSETS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+        }) => void;
+        DISABLE_ASSETS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+        }) => void;
+        DISABLE_ACCOUNT_ASSETS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            assets: string[];
+        }) => void;
+        ENABLE_ACCOUNT_ASSETS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            assets: string[];
+        }) => void;
+        ADD_CUSTOM_TOKEN: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            customToken: import("./types").CustomToken;
+        }) => void;
+        REMOVE_CUSTOM_TOKEN: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            symbol: string;
+        }) => void;
+        CREATE_ACCOUNT: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            account: import("./types").Account;
+        }) => void;
+        UPDATE_ACCOUNT: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            account: import("./types").Account;
+        }) => void;
+        REMOVE_ACCOUNT: (payload: {
+            walletId: string;
+            id: string;
+            network: import("./types").Network;
+        }) => void;
+        UPDATE_ACCOUNT_ADDRESSES: (payload: {
+            network: import("./types").Network;
+            accountId: string;
+            walletId: string;
+            addresses: string[];
+        }) => void;
+        SET_USB_BRIDGE_WINDOWS_ID: (payload: {
+            id: number;
+        }) => void;
+        SET_EXTERNAL_CONNECTION_DEFAULT: (payload: {
+            origin: string;
+            activeWalletId: string;
+            accountId: string;
+        }) => void;
+        ADD_EXTERNAL_CONNECTION: (payload: {
+            origin: string;
+            activeWalletId: string;
+            accountId: string;
+            chain: import("@yaswap/cryptoassets").ChainId;
+        }) => void;
+        REMOVE_EXTERNAL_CONNECTIONS: (payload: {
+            activeWalletId: string;
+        }) => void;
+        SET_ANALYTICS_PREFERENCES: (payload: Partial<import("./types").AnalyticsState>) => void;
+        UPDATE_NFTS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            nfts: import("./types").NFT[];
+        }) => void;
+        NFT_TOGGLE_STARRED: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            nft: import("./types").NFT;
+        }) => void;
+        TOGGLE_EXPERIMENT: (payload: {
+            name: import("./types").ExperimentType;
+        }) => void;
+        SET_WHATS_NEW_MODAL_VERSION: (payload: {
+            version: string;
+        }) => void;
+        TOGGLE_BLOCKCHAIN: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            enable: boolean;
+        }) => void;
+        TOGGLE_ACCOUNT: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            enable: boolean;
+        }) => void;
+        LOG_ERROR: (payload: import("@yaswap/error-parser").LiqualityErrorJSON) => void;
+        CLEAR_ERROR_LOG: () => void;
+        SET_CUSTOM_CHAIN_SETTINGS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            chanifyNetwork: import("@yaswap/types").Network;
+        }) => void;
+        REMOVE_CUSTOM_CHAIN_SETTINGS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+        }) => void;
+    };
+    rootDispatch: {
+        readonly acceptTermsAndConditions: (payload: {
+            analyticsAccepted: boolean;
+        }) => Promise<void>;
+        readonly createAccount: (payload: {
+            walletId: string;
+            network: import("./types").Network;
+            account: import("./types").Account;
+        }) => Promise<import("./types").Account>;
+        readonly removeAccount: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            id: string;
+        }) => Promise<string>;
+        readonly toggleAccount: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accounts: string[];
+            enable: boolean;
+        }) => Promise<void>;
+        readonly toggleBlockchain: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            enable: boolean;
+        }) => Promise<void>;
+        readonly updateAccount: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            account: import("./types").Account;
+        }) => Promise<{
+            updatedAt: number;
+            id: string;
+            walletId: string;
+            createdAt: number;
+            enabled: boolean;
+            derivationPath: string;
+            chainCode?: string | undefined;
+            publicKey?: string | undefined;
+            nfts?: import("./types").NFT[] | undefined;
+            type: import("./types").AccountType;
+            name: string;
+            alias?: string | undefined;
+            chain: import("@yaswap/cryptoassets").ChainId;
+            index: number;
+            addresses: string[];
+            assets: string[];
+            balances: Record<string, string>;
+            color: string;
+        }>;
+        readonly addCustomToken: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chain: import("@yaswap/cryptoassets").ChainId;
+            symbol: string;
+            name: string;
+            contractAddress: string;
+            decimals: number;
+        }) => Promise<void>;
+        readonly addExternalConnection: (payload: {
+            origin: string;
+            chain: import("@yaswap/cryptoassets").ChainId;
+            accountId: string;
+            setDefaultEthereum: boolean;
+        }) => Promise<void>;
+        readonly initializeAnalyticsPreferences: (payload: {
+            accepted: boolean;
+        }) => Promise<void>;
+        readonly updateAnalyticsPreferences: (payload: import("./types").AnalyticsState) => Promise<void>;
+        readonly setAnalyticsResponse: (payload: {
+            accepted: boolean;
+        }) => Promise<void>;
+        readonly initializeAnalytics: () => Promise<boolean>;
+        readonly trackAnalytics: (payload: {
+            event: string;
+            properties: actions.AmplitudeProperties;
+        }) => Promise<number> | Promise<undefined>;
+        readonly changeActiveNetwork: (payload: {
+            network: import("./types").Network;
+        }) => Promise<void>;
+        readonly changeActiveWalletId: (payload: {
+            walletId: string;
+        }) => Promise<void>;
+        readonly changePassword: (payload: {
+            key: string;
+        }) => Promise<void>;
+        readonly checkPendingActions: (payload: {
+            walletId: string;
+        }) => Promise<void>;
+        readonly createWallet: (payload: {
+            key: string;
+            mnemonic: string;
+            imported?: boolean | undefined;
+        }) => Promise<import("./types").Wallet>;
+        readonly disableAssets: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+        }) => Promise<void>;
+        readonly disableEthereumInjection: () => Promise<void>;
+        readonly enableAssets: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+        }) => Promise<void>;
+        readonly enableEthereumInjection: () => Promise<void>;
+        readonly exportPrivateKey: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+        }) => Promise<string>;
+        readonly fetchTokenDetails: (payload: actions.FetchTokenDetailsRequest) => Promise<import("@yaswap/types").Nullable<import("@yaswap/types").TokenDetails>>;
+        readonly forgetDappConnections: () => Promise<void>;
+        readonly getLockForAsset: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            asset: string;
+            item: import("./types").BaseHistoryItem;
+        }) => Promise<string>;
+        readonly getQuotes: (payload: import("../swaps/types").GetQuotesRequest) => Promise<actions.GetQuotesResult>;
+        readonly getSlowQuotes: (payload: {
+            requestId: string;
+        }) => Promise<import("../swaps/types").SwapQuote[]>;
+        readonly getUnusedAddresses: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+            accountId: string;
+        }) => Promise<string[]>;
+        readonly getLedgerAccounts: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            asset: string;
+            accountType: import("./types").AccountType;
+            startingIndex: number;
+            numAccounts: number;
+        }) => Promise<{
+            account: string;
+            index: number;
+            exists: boolean;
+        }[]>;
+        readonly initializeAddresses: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+        }) => Promise<void>;
+        readonly lockWallet: () => Promise<void>;
+        readonly newSwap: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            quote: import("../swaps/types").SwapQuote;
+            fee: number;
+            claimFee: number;
+            feeLabel: import("./types").FeeLabel;
+            claimFeeLabel: import("./types").FeeLabel;
+        }) => Promise<import("./types").SwapHistoryItem>;
+        readonly performNextAction: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            id: string;
+        }) => Promise<Partial<import("./types").HistoryItem> | undefined>;
+        readonly proxyMutation: (payload: {
+            type: string;
+            payload: any;
+        }) => Promise<void>;
+        readonly removeCustomToken: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            symbol: string;
+        }) => Promise<void>;
+        readonly retrySwap: (payload: {
+            swap: import("./types").SwapHistoryItem;
+        }) => Promise<Partial<import("./types").SwapHistoryItem> | undefined>;
+        readonly sendNFTTransaction: (payload: import("./types").NFTSendTransactionParams) => Promise<import("@yaswap/types").Transaction<any>>;
+        readonly sendTransaction: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            asset: string;
+            to: string;
+            amount: import("bignumber.js").BigNumber;
+            data: string;
+            fee: number;
+            feeAsset: string;
+            gas: number;
+            feeLabel: import("./types").FeeLabel;
+            fiatRate: number;
+        }) => Promise<import("./types").SendHistoryItem>;
+        readonly setEthereumInjectionChain: (payload: {
+            chain: import("@yaswap/cryptoassets").ChainId;
+        }) => Promise<void>;
+        readonly setWhatsNewModalVersion: (payload: {
+            version: string;
+        }) => Promise<void>;
+        readonly showNotification: (payload: import("../types").Notification) => Promise<void>;
+        readonly toggleExperiment: (payload: {
+            name: import("./types").ExperimentType;
+        }) => Promise<void>;
+        readonly toggleNFTStarred: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            nft: import("./types").NFT;
+        }) => Promise<void>;
+        readonly unlockWallet: (payload: {
+            key: string;
+        }) => Promise<void>;
+        readonly updateAccountBalance: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+        }) => Promise<void>;
+        readonly updateBalances: (payload: {
+            walletId: string;
+            network: import("./types").Network;
+            accountIds?: string[] | undefined;
+        }) => Promise<void>;
+        readonly updateCurrenciesInfo: (payload: {
+            assets: string[];
+        }) => Promise<import("./types").CurrenciesInfo>;
+        readonly updateFees: (payload: {
+            asset: string;
+        }) => Promise<import("@yaswap/types").FeeDetails>;
+        readonly updateFiatRates: (payload: {
+            assets: string[];
+        }) => Promise<import("./types").FiatRates>;
+        readonly updateMarketData: (payload: {
+            network: import("./types").Network;
+        }) => Promise<{
+            network: import("./types").Network;
+            marketData: import("./types").MarketData[];
+        }>;
+        readonly updateNFTs: (payload: {
+            walletId: string;
+            network: import("./types").Network;
+            accountIds: string[];
+        }) => Promise<import("./types").NFT[][]>;
+        readonly updateTransactionFee: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            asset: string;
+            id: string;
+            hash: string;
+            newFee: number;
+        }) => Promise<import("@yaswap/types").Transaction<any>>;
+        readonly logError: (payload: import("@yaswap/error-parser").LiqualityErrorJSON) => Promise<void>;
+        readonly clearErrorLog: () => Promise<void>;
+        readonly saveCustomChainSettings: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            chanifyNetwork: import("@yaswap/types").Network;
+        }) => Promise<void>;
+        readonly removeCustomChainSettings: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+        }) => Promise<void>;
+    };
+    state: {
+        readonly version: number;
+        readonly key: string;
+        readonly wallets: import("./types").Wallet[];
+        readonly unlockedAt: number;
+        readonly brokerReady: boolean;
+        readonly encryptedWallets: string;
+        readonly enabledAssets: Partial<Record<import("./types").Network, Record<string, string[]>>>;
+        readonly customTokens: Partial<Record<import("./types").Network, Record<string, import("./types").CustomToken[]>>>;
+        readonly accounts: Partial<Record<string, Record<import("./types").Network, import("./types").Account[]>>>;
+        readonly fiatRates: import("./types").FiatRates;
+        readonly currenciesInfo: import("./types").CurrenciesInfo;
+        readonly fees: Partial<Record<import("./types").Network, Record<string, Record<string, import("@yaswap/types").FeeDetails>>>>;
+        readonly history: Partial<Record<import("./types").Network, Record<string, import("./types").HistoryItem[]>>>;
+        readonly marketData: Partial<Record<import("./types").Network, import("./types").MarketData[]>>;
+        readonly activeNetwork: import("./types").Network;
+        readonly activeWalletId: string;
+        readonly keyUpdatedAt: number;
+        readonly keySalt: string;
+        readonly termsAcceptedAt: number;
+        readonly setupAt: number;
+        readonly injectEthereum: boolean;
+        readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+        readonly usbBridgeWindowsId: number;
+        readonly externalConnections: import("./types").ExternalConnections;
+        readonly rskLegacyDerivation: boolean;
+        readonly analytics: import("./types").AnalyticsState;
+        readonly experiments: Partial<Record<import("./types").ExperimentType, boolean>>;
+        readonly whatsNewModalVersion: string;
+        readonly enabledChains: Partial<Record<string, Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]>>>;
+        readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+        readonly customChainSeetings: Partial<Record<import("./types").Network, Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>>>>;
+    };
+    getters: {
+        readonly client: ({ network, walletId, chainId, accountId, useCache, accountType, accountIndex, }: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            accountId?: string | undefined;
+            useCache?: boolean | undefined;
+            accountType?: import("./types").AccountType | undefined;
+            accountIndex?: number | undefined;
+        }) => import("@yaswap/client").Client<import("@yaswap/client").Chain<any, import("@yaswap/types").Network>, import("@yaswap/client").Wallet<any, any>, import("@yaswap/client").Swap<any, any, import("@yaswap/client").Wallet<any, any>>, import("@yaswap/client").Nft<any, any>>;
+        readonly historyItemById: (network: import("./types").Network, walletId: string, id: string) => import("./types").HistoryItem | undefined;
+        readonly cryptoassets: Readonly<{
+            [asset: string]: import("@yaswap/cryptoassets").IAsset;
+        }>;
+        readonly networkAccounts: readonly import("./types").Account[];
+        readonly networkAssets: readonly string[];
+        readonly allNetworkAssets: readonly string[];
+        readonly activity: readonly import("./types").HistoryItem[];
+        readonly totalFiatBalance: Readonly<import("bignumber.js").BigNumber>;
+        readonly accountItem: (accountId: string) => import("./types").Account | undefined;
+        readonly suggestedFeePrices: (asset: string) => import("@yaswap/types").FeeDetails | undefined;
+        readonly accountsWithBalance: readonly import("./types").Account[];
+        readonly accountsData: readonly import("./types").Account[];
+        readonly accountFiatBalance: (walletId: string, network: import("./types").Network, accountId: string) => import("bignumber.js").BigNumber;
+        readonly assetFiatBalance: (asset: string, balance: import("bignumber.js").BigNumber) => import("bignumber.js").BigNumber | null;
+        readonly assetMarketCap: (asset: string) => import("@yaswap/types").Nullable<import("bignumber.js").BigNumber>;
+        readonly chainAssets: Readonly<{
+            yacoin?: string[] | undefined;
+            bitcoin?: string[] | undefined;
+            ethereum?: string[] | undefined;
+            rsk?: string[] | undefined;
+            bsc?: string[] | undefined;
+            near?: string[] | undefined;
+            polygon?: string[] | undefined;
+            arbitrum?: string[] | undefined;
+            solana?: string[] | undefined;
+            fuse?: string[] | undefined;
+            terra?: string[] | undefined;
+            avalanche?: string[] | undefined;
+            optimism?: string[] | undefined;
+        }>;
+        readonly analyticsEnabled: Readonly<boolean>;
+        readonly allNftCollections: Readonly<import("./types").NFTCollections<import("./types").NFTWithAccount>>;
+        readonly accountNftCollections: (accountId: string) => import("./types").NFTCollections<import("./types").NFT>;
+        readonly mergedChainSettings: Readonly<Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>>;
+        readonly chainSettings: readonly {
+            chain: string;
+            asset: string;
+            network: import("../types").ChainifyNetwork;
+        }[];
+    };
+    commit: {
+        SET_STATE: (payload: {
+            newState: RootState;
+        }) => void;
+        CREATE_WALLET: (payload: {
+            key: string;
+            keySalt: string;
+            encryptedWallets: string;
+            wallet: import("./types").Wallet;
+        }) => void;
+        ACCEPT_TNC: () => void;
+        CHANGE_ACTIVE_WALLETID: (payload: {
+            walletId: string;
+        }) => void;
+        CHANGE_ACTIVE_NETWORK: (payload: {
+            network: import("./types").Network;
+        }) => void;
+        CHANGE_PASSWORD: (payload: {
+            key: string;
+            keySalt: string;
+            encryptedWallets: string;
+        }) => void;
+        LOCK_WALLET: () => void;
+        UNLOCK_WALLET: (payload: {
+            key: string;
+            wallets: import("./types").Wallet[];
+            unlockedAt: number;
+        }) => void;
+        NEW_SWAP: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            swap: import("./types").SwapHistoryItem;
+        }) => void;
+        NEW_TRASACTION: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            transaction: import("./types").SendHistoryItem;
+        }) => void;
+        NEW_NFT_TRASACTION: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            transaction: import("./types").NFTSendHistoryItem;
+        }) => void;
+        UPDATE_HISTORY: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            id: string;
+            updates: Partial<import("./types").HistoryItem>;
+        }) => void;
+        REMOVE_ORDER: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            id: string;
+        }) => void;
+        UPDATE_BALANCE: (payload: {
+            network: import("./types").Network;
+            accountId: string;
+            walletId: string;
+            asset: string;
+            balance: string;
+        }) => void;
+        UPDATE_MULTIPLE_BALANCES: (payload: {
+            network: import("./types").Network;
+            accountId: string;
+            walletId: string;
+            assets: string[];
+            balances: import("@yaswap/types").Nullable<string>[];
+        }) => void;
+        UPDATE_FEES: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            asset: string;
+            fees: import("@yaswap/types").FeeDetails;
+        }) => void;
+        UPDATE_FIAT_RATES: (payload: {
+            fiatRates: import("./types").FiatRates;
+        }) => void;
+        UPDATE_CURRENCIES_INFO: (payload: {
+            currenciesInfo: import("./types").CurrenciesInfo;
+        }) => void;
+        UPDATE_MARKET_DATA: (payload: {
+            network: import("./types").Network;
+            marketData: import("./types").MarketData[];
+        }) => void;
+        SET_ETHEREUM_INJECTION_CHAIN: (payload: {
+            chain: import("@yaswap/cryptoassets").ChainId;
+        }) => void;
+        ENABLE_ETHEREUM_INJECTION: () => void;
+        DISABLE_ETHEREUM_INJECTION: () => void;
+        ENABLE_ASSETS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+        }) => void;
+        DISABLE_ASSETS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+        }) => void;
+        DISABLE_ACCOUNT_ASSETS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            assets: string[];
+        }) => void;
+        ENABLE_ACCOUNT_ASSETS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            assets: string[];
+        }) => void;
+        ADD_CUSTOM_TOKEN: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            customToken: import("./types").CustomToken;
+        }) => void;
+        REMOVE_CUSTOM_TOKEN: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            symbol: string;
+        }) => void;
+        CREATE_ACCOUNT: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            account: import("./types").Account;
+        }) => void;
+        UPDATE_ACCOUNT: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            account: import("./types").Account;
+        }) => void;
+        REMOVE_ACCOUNT: (payload: {
+            walletId: string;
+            id: string;
+            network: import("./types").Network;
+        }) => void;
+        UPDATE_ACCOUNT_ADDRESSES: (payload: {
+            network: import("./types").Network;
+            accountId: string;
+            walletId: string;
+            addresses: string[];
+        }) => void;
+        SET_USB_BRIDGE_WINDOWS_ID: (payload: {
+            id: number;
+        }) => void;
+        SET_EXTERNAL_CONNECTION_DEFAULT: (payload: {
+            origin: string;
+            activeWalletId: string;
+            accountId: string;
+        }) => void;
+        ADD_EXTERNAL_CONNECTION: (payload: {
+            origin: string;
+            activeWalletId: string;
+            accountId: string;
+            chain: import("@yaswap/cryptoassets").ChainId;
+        }) => void;
+        REMOVE_EXTERNAL_CONNECTIONS: (payload: {
+            activeWalletId: string;
+        }) => void;
+        SET_ANALYTICS_PREFERENCES: (payload: Partial<import("./types").AnalyticsState>) => void;
+        UPDATE_NFTS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            nfts: import("./types").NFT[];
+        }) => void;
+        NFT_TOGGLE_STARRED: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            nft: import("./types").NFT;
+        }) => void;
+        TOGGLE_EXPERIMENT: (payload: {
+            name: import("./types").ExperimentType;
+        }) => void;
+        SET_WHATS_NEW_MODAL_VERSION: (payload: {
+            version: string;
+        }) => void;
+        TOGGLE_BLOCKCHAIN: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            enable: boolean;
+        }) => void;
+        TOGGLE_ACCOUNT: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            enable: boolean;
+        }) => void;
+        LOG_ERROR: (payload: import("@yaswap/error-parser").LiqualityErrorJSON) => void;
+        CLEAR_ERROR_LOG: () => void;
+        SET_CUSTOM_CHAIN_SETTINGS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            chanifyNetwork: import("@yaswap/types").Network;
+        }) => void;
+        REMOVE_CUSTOM_CHAIN_SETTINGS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+        }) => void;
+    };
+    dispatch: {
+        readonly acceptTermsAndConditions: (payload: {
+            analyticsAccepted: boolean;
+        }) => Promise<void>;
+        readonly createAccount: (payload: {
+            walletId: string;
+            network: import("./types").Network;
+            account: import("./types").Account;
+        }) => Promise<import("./types").Account>;
+        readonly removeAccount: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            id: string;
+        }) => Promise<string>;
+        readonly toggleAccount: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accounts: string[];
+            enable: boolean;
+        }) => Promise<void>;
+        readonly toggleBlockchain: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            enable: boolean;
+        }) => Promise<void>;
+        readonly updateAccount: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            account: import("./types").Account;
+        }) => Promise<{
+            updatedAt: number;
+            id: string;
+            walletId: string;
+            createdAt: number;
+            enabled: boolean;
+            derivationPath: string;
+            chainCode?: string | undefined;
+            publicKey?: string | undefined;
+            nfts?: import("./types").NFT[] | undefined;
+            type: import("./types").AccountType;
+            name: string;
+            alias?: string | undefined;
+            chain: import("@yaswap/cryptoassets").ChainId;
+            index: number;
+            addresses: string[];
+            assets: string[];
+            balances: Record<string, string>;
+            color: string;
+        }>;
+        readonly addCustomToken: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chain: import("@yaswap/cryptoassets").ChainId;
+            symbol: string;
+            name: string;
+            contractAddress: string;
+            decimals: number;
+        }) => Promise<void>;
+        readonly addExternalConnection: (payload: {
+            origin: string;
+            chain: import("@yaswap/cryptoassets").ChainId;
+            accountId: string;
+            setDefaultEthereum: boolean;
+        }) => Promise<void>;
+        readonly initializeAnalyticsPreferences: (payload: {
+            accepted: boolean;
+        }) => Promise<void>;
+        readonly updateAnalyticsPreferences: (payload: import("./types").AnalyticsState) => Promise<void>;
+        readonly setAnalyticsResponse: (payload: {
+            accepted: boolean;
+        }) => Promise<void>;
+        readonly initializeAnalytics: () => Promise<boolean>;
+        readonly trackAnalytics: (payload: {
+            event: string;
+            properties: actions.AmplitudeProperties;
+        }) => Promise<number> | Promise<undefined>;
+        readonly changeActiveNetwork: (payload: {
+            network: import("./types").Network;
+        }) => Promise<void>;
+        readonly changeActiveWalletId: (payload: {
+            walletId: string;
+        }) => Promise<void>;
+        readonly changePassword: (payload: {
+            key: string;
+        }) => Promise<void>;
+        readonly checkPendingActions: (payload: {
+            walletId: string;
+        }) => Promise<void>;
+        readonly createWallet: (payload: {
+            key: string;
+            mnemonic: string;
+            imported?: boolean | undefined;
+        }) => Promise<import("./types").Wallet>;
+        readonly disableAssets: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+        }) => Promise<void>;
+        readonly disableEthereumInjection: () => Promise<void>;
+        readonly enableAssets: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+        }) => Promise<void>;
+        readonly enableEthereumInjection: () => Promise<void>;
+        readonly exportPrivateKey: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+        }) => Promise<string>;
+        readonly fetchTokenDetails: (payload: actions.FetchTokenDetailsRequest) => Promise<import("@yaswap/types").Nullable<import("@yaswap/types").TokenDetails>>;
+        readonly forgetDappConnections: () => Promise<void>;
+        readonly getLockForAsset: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            asset: string;
+            item: import("./types").BaseHistoryItem;
+        }) => Promise<string>;
+        readonly getQuotes: (payload: import("../swaps/types").GetQuotesRequest) => Promise<actions.GetQuotesResult>;
+        readonly getSlowQuotes: (payload: {
+            requestId: string;
+        }) => Promise<import("../swaps/types").SwapQuote[]>;
+        readonly getUnusedAddresses: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+            accountId: string;
+        }) => Promise<string[]>;
+        readonly getLedgerAccounts: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            asset: string;
+            accountType: import("./types").AccountType;
+            startingIndex: number;
+            numAccounts: number;
+        }) => Promise<{
+            account: string;
+            index: number;
+            exists: boolean;
+        }[]>;
+        readonly initializeAddresses: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+        }) => Promise<void>;
+        readonly lockWallet: () => Promise<void>;
+        readonly newSwap: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            quote: import("../swaps/types").SwapQuote;
+            fee: number;
+            claimFee: number;
+            feeLabel: import("./types").FeeLabel;
+            claimFeeLabel: import("./types").FeeLabel;
+        }) => Promise<import("./types").SwapHistoryItem>;
+        readonly performNextAction: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            id: string;
+        }) => Promise<Partial<import("./types").HistoryItem> | undefined>;
+        readonly proxyMutation: (payload: {
+            type: string;
+            payload: any;
+        }) => Promise<void>;
+        readonly removeCustomToken: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            symbol: string;
+        }) => Promise<void>;
+        readonly retrySwap: (payload: {
+            swap: import("./types").SwapHistoryItem;
+        }) => Promise<Partial<import("./types").SwapHistoryItem> | undefined>;
+        readonly sendNFTTransaction: (payload: import("./types").NFTSendTransactionParams) => Promise<import("@yaswap/types").Transaction<any>>;
+        readonly sendTransaction: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            asset: string;
+            to: string;
+            amount: import("bignumber.js").BigNumber;
+            data: string;
+            fee: number;
+            feeAsset: string;
+            gas: number;
+            feeLabel: import("./types").FeeLabel;
+            fiatRate: number;
+        }) => Promise<import("./types").SendHistoryItem>;
+        readonly setEthereumInjectionChain: (payload: {
+            chain: import("@yaswap/cryptoassets").ChainId;
+        }) => Promise<void>;
+        readonly setWhatsNewModalVersion: (payload: {
+            version: string;
+        }) => Promise<void>;
+        readonly showNotification: (payload: import("../types").Notification) => Promise<void>;
+        readonly toggleExperiment: (payload: {
+            name: import("./types").ExperimentType;
+        }) => Promise<void>;
+        readonly toggleNFTStarred: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            nft: import("./types").NFT;
+        }) => Promise<void>;
+        readonly unlockWallet: (payload: {
+            key: string;
+        }) => Promise<void>;
+        readonly updateAccountBalance: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+        }) => Promise<void>;
+        readonly updateBalances: (payload: {
+            walletId: string;
+            network: import("./types").Network;
+            accountIds?: string[] | undefined;
+        }) => Promise<void>;
+        readonly updateCurrenciesInfo: (payload: {
+            assets: string[];
+        }) => Promise<import("./types").CurrenciesInfo>;
+        readonly updateFees: (payload: {
+            asset: string;
+        }) => Promise<import("@yaswap/types").FeeDetails>;
+        readonly updateFiatRates: (payload: {
+            assets: string[];
+        }) => Promise<import("./types").FiatRates>;
+        readonly updateMarketData: (payload: {
+            network: import("./types").Network;
+        }) => Promise<{
+            network: import("./types").Network;
+            marketData: import("./types").MarketData[];
+        }>;
+        readonly updateNFTs: (payload: {
+            walletId: string;
+            network: import("./types").Network;
+            accountIds: string[];
+        }) => Promise<import("./types").NFT[][]>;
+        readonly updateTransactionFee: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            asset: string;
+            id: string;
+            hash: string;
+            newFee: number;
+        }) => Promise<import("@yaswap/types").Transaction<any>>;
+        readonly logError: (payload: import("@yaswap/error-parser").LiqualityErrorJSON) => Promise<void>;
+        readonly clearErrorLog: () => Promise<void>;
+        readonly saveCustomChainSettings: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            chanifyNetwork: import("@yaswap/types").Network;
+        }) => Promise<void>;
+        readonly removeCustomChainSettings: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+        }) => Promise<void>;
+    };
+}, rootGetterContext: (args: [any, any]) => {
+    rootState: {
+        readonly version: number;
+        readonly key: string;
+        readonly wallets: import("./types").Wallet[];
+        readonly unlockedAt: number;
+        readonly brokerReady: boolean;
+        readonly encryptedWallets: string;
+        readonly enabledAssets: Partial<Record<import("./types").Network, Record<string, string[]>>>;
+        readonly customTokens: Partial<Record<import("./types").Network, Record<string, import("./types").CustomToken[]>>>;
+        readonly accounts: Partial<Record<string, Record<import("./types").Network, import("./types").Account[]>>>;
+        readonly fiatRates: import("./types").FiatRates;
+        readonly currenciesInfo: import("./types").CurrenciesInfo;
+        readonly fees: Partial<Record<import("./types").Network, Record<string, Record<string, import("@yaswap/types").FeeDetails>>>>;
+        readonly history: Partial<Record<import("./types").Network, Record<string, import("./types").HistoryItem[]>>>;
+        readonly marketData: Partial<Record<import("./types").Network, import("./types").MarketData[]>>;
+        readonly activeNetwork: import("./types").Network;
+        readonly activeWalletId: string;
+        readonly keyUpdatedAt: number;
+        readonly keySalt: string;
+        readonly termsAcceptedAt: number;
+        readonly setupAt: number;
+        readonly injectEthereum: boolean;
+        readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+        readonly usbBridgeWindowsId: number;
+        readonly externalConnections: import("./types").ExternalConnections;
+        readonly rskLegacyDerivation: boolean;
+        readonly analytics: import("./types").AnalyticsState;
+        readonly experiments: Partial<Record<import("./types").ExperimentType, boolean>>;
+        readonly whatsNewModalVersion: string;
+        readonly enabledChains: Partial<Record<string, Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]>>>;
+        readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+        readonly customChainSeetings: Partial<Record<import("./types").Network, Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>>>>;
+    };
+    rootGetters: {
+        readonly client: ({ network, walletId, chainId, accountId, useCache, accountType, accountIndex, }: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            accountId?: string | undefined;
+            useCache?: boolean | undefined;
+            accountType?: import("./types").AccountType | undefined;
+            accountIndex?: number | undefined;
+        }) => import("@yaswap/client").Client<import("@yaswap/client").Chain<any, import("@yaswap/types").Network>, import("@yaswap/client").Wallet<any, any>, import("@yaswap/client").Swap<any, any, import("@yaswap/client").Wallet<any, any>>, import("@yaswap/client").Nft<any, any>>;
+        readonly historyItemById: (network: import("./types").Network, walletId: string, id: string) => import("./types").HistoryItem | undefined;
+        readonly cryptoassets: Readonly<{
+            [asset: string]: import("@yaswap/cryptoassets").IAsset;
+        }>;
+        readonly networkAccounts: readonly import("./types").Account[];
+        readonly networkAssets: readonly string[];
+        readonly allNetworkAssets: readonly string[];
+        readonly activity: readonly import("./types").HistoryItem[];
+        readonly totalFiatBalance: Readonly<import("bignumber.js").BigNumber>;
+        readonly accountItem: (accountId: string) => import("./types").Account | undefined;
+        readonly suggestedFeePrices: (asset: string) => import("@yaswap/types").FeeDetails | undefined;
+        readonly accountsWithBalance: readonly import("./types").Account[];
+        readonly accountsData: readonly import("./types").Account[];
+        readonly accountFiatBalance: (walletId: string, network: import("./types").Network, accountId: string) => import("bignumber.js").BigNumber;
+        readonly assetFiatBalance: (asset: string, balance: import("bignumber.js").BigNumber) => import("bignumber.js").BigNumber | null;
+        readonly assetMarketCap: (asset: string) => import("@yaswap/types").Nullable<import("bignumber.js").BigNumber>;
+        readonly chainAssets: Readonly<{
+            yacoin?: string[] | undefined;
+            bitcoin?: string[] | undefined;
+            ethereum?: string[] | undefined;
+            rsk?: string[] | undefined;
+            bsc?: string[] | undefined;
+            near?: string[] | undefined;
+            polygon?: string[] | undefined;
+            arbitrum?: string[] | undefined;
+            solana?: string[] | undefined;
+            fuse?: string[] | undefined;
+            terra?: string[] | undefined;
+            avalanche?: string[] | undefined;
+            optimism?: string[] | undefined;
+        }>;
+        readonly analyticsEnabled: Readonly<boolean>;
+        readonly allNftCollections: Readonly<import("./types").NFTCollections<import("./types").NFTWithAccount>>;
+        readonly accountNftCollections: (accountId: string) => import("./types").NFTCollections<import("./types").NFT>;
+        readonly mergedChainSettings: Readonly<Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>>;
+        readonly chainSettings: readonly {
+            chain: string;
+            asset: string;
+            network: import("../types").ChainifyNetwork;
+        }[];
+    };
+    state: {
+        readonly version: number;
+        readonly key: string;
+        readonly wallets: import("./types").Wallet[];
+        readonly unlockedAt: number;
+        readonly brokerReady: boolean;
+        readonly encryptedWallets: string;
+        readonly enabledAssets: Partial<Record<import("./types").Network, Record<string, string[]>>>;
+        readonly customTokens: Partial<Record<import("./types").Network, Record<string, import("./types").CustomToken[]>>>;
+        readonly accounts: Partial<Record<string, Record<import("./types").Network, import("./types").Account[]>>>;
+        readonly fiatRates: import("./types").FiatRates;
+        readonly currenciesInfo: import("./types").CurrenciesInfo;
+        readonly fees: Partial<Record<import("./types").Network, Record<string, Record<string, import("@yaswap/types").FeeDetails>>>>;
+        readonly history: Partial<Record<import("./types").Network, Record<string, import("./types").HistoryItem[]>>>;
+        readonly marketData: Partial<Record<import("./types").Network, import("./types").MarketData[]>>;
+        readonly activeNetwork: import("./types").Network;
+        readonly activeWalletId: string;
+        readonly keyUpdatedAt: number;
+        readonly keySalt: string;
+        readonly termsAcceptedAt: number;
+        readonly setupAt: number;
+        readonly injectEthereum: boolean;
+        readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+        readonly usbBridgeWindowsId: number;
+        readonly externalConnections: import("./types").ExternalConnections;
+        readonly rskLegacyDerivation: boolean;
+        readonly analytics: import("./types").AnalyticsState;
+        readonly experiments: Partial<Record<import("./types").ExperimentType, boolean>>;
+        readonly whatsNewModalVersion: string;
+        readonly enabledChains: Partial<Record<string, Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]>>>;
+        readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+        readonly customChainSeetings: Partial<Record<import("./types").Network, Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>>>>;
+    };
+    getters: {
+        readonly client: ({ network, walletId, chainId, accountId, useCache, accountType, accountIndex, }: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            accountId?: string | undefined;
+            useCache?: boolean | undefined;
+            accountType?: import("./types").AccountType | undefined;
+            accountIndex?: number | undefined;
+        }) => import("@yaswap/client").Client<import("@yaswap/client").Chain<any, import("@yaswap/types").Network>, import("@yaswap/client").Wallet<any, any>, import("@yaswap/client").Swap<any, any, import("@yaswap/client").Wallet<any, any>>, import("@yaswap/client").Nft<any, any>>;
+        readonly historyItemById: (network: import("./types").Network, walletId: string, id: string) => import("./types").HistoryItem | undefined;
+        readonly cryptoassets: Readonly<{
+            [asset: string]: import("@yaswap/cryptoassets").IAsset;
+        }>;
+        readonly networkAccounts: readonly import("./types").Account[];
+        readonly networkAssets: readonly string[];
+        readonly allNetworkAssets: readonly string[];
+        readonly activity: readonly import("./types").HistoryItem[];
+        readonly totalFiatBalance: Readonly<import("bignumber.js").BigNumber>;
+        readonly accountItem: (accountId: string) => import("./types").Account | undefined;
+        readonly suggestedFeePrices: (asset: string) => import("@yaswap/types").FeeDetails | undefined;
+        readonly accountsWithBalance: readonly import("./types").Account[];
+        readonly accountsData: readonly import("./types").Account[];
+        readonly accountFiatBalance: (walletId: string, network: import("./types").Network, accountId: string) => import("bignumber.js").BigNumber;
+        readonly assetFiatBalance: (asset: string, balance: import("bignumber.js").BigNumber) => import("bignumber.js").BigNumber | null;
+        readonly assetMarketCap: (asset: string) => import("@yaswap/types").Nullable<import("bignumber.js").BigNumber>;
+        readonly chainAssets: Readonly<{
+            yacoin?: string[] | undefined;
+            bitcoin?: string[] | undefined;
+            ethereum?: string[] | undefined;
+            rsk?: string[] | undefined;
+            bsc?: string[] | undefined;
+            near?: string[] | undefined;
+            polygon?: string[] | undefined;
+            arbitrum?: string[] | undefined;
+            solana?: string[] | undefined;
+            fuse?: string[] | undefined;
+            terra?: string[] | undefined;
+            avalanche?: string[] | undefined;
+            optimism?: string[] | undefined;
+        }>;
+        readonly analyticsEnabled: Readonly<boolean>;
+        readonly allNftCollections: Readonly<import("./types").NFTCollections<import("./types").NFTWithAccount>>;
+        readonly accountNftCollections: (accountId: string) => import("./types").NFTCollections<import("./types").NFT>;
+        readonly mergedChainSettings: Readonly<Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>>;
+        readonly chainSettings: readonly {
+            chain: string;
+            asset: string;
+            network: import("../types").ChainifyNetwork;
+        }[];
+    };
+}, moduleActionContext: <O extends import("direct-vuex").ModuleOptions<any>>(originalContext: _ActionContext<any, any>, module: O) => {
+    rootState: {
+        readonly version: number;
+        readonly key: string;
+        readonly wallets: import("./types").Wallet[];
+        readonly unlockedAt: number;
+        readonly brokerReady: boolean;
+        readonly encryptedWallets: string;
+        readonly enabledAssets: Partial<Record<import("./types").Network, Record<string, string[]>>>;
+        readonly customTokens: Partial<Record<import("./types").Network, Record<string, import("./types").CustomToken[]>>>;
+        readonly accounts: Partial<Record<string, Record<import("./types").Network, import("./types").Account[]>>>;
+        readonly fiatRates: import("./types").FiatRates;
+        readonly currenciesInfo: import("./types").CurrenciesInfo;
+        readonly fees: Partial<Record<import("./types").Network, Record<string, Record<string, import("@yaswap/types").FeeDetails>>>>;
+        readonly history: Partial<Record<import("./types").Network, Record<string, import("./types").HistoryItem[]>>>;
+        readonly marketData: Partial<Record<import("./types").Network, import("./types").MarketData[]>>;
+        readonly activeNetwork: import("./types").Network;
+        readonly activeWalletId: string;
+        readonly keyUpdatedAt: number;
+        readonly keySalt: string;
+        readonly termsAcceptedAt: number;
+        readonly setupAt: number;
+        readonly injectEthereum: boolean;
+        readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+        readonly usbBridgeWindowsId: number;
+        readonly externalConnections: import("./types").ExternalConnections;
+        readonly rskLegacyDerivation: boolean;
+        readonly analytics: import("./types").AnalyticsState;
+        readonly experiments: Partial<Record<import("./types").ExperimentType, boolean>>;
+        readonly whatsNewModalVersion: string;
+        readonly enabledChains: Partial<Record<string, Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]>>>;
+        readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+        readonly customChainSeetings: Partial<Record<import("./types").Network, Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>>>>;
+    };
+    rootGetters: {
+        readonly client: ({ network, walletId, chainId, accountId, useCache, accountType, accountIndex, }: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            accountId?: string | undefined;
+            useCache?: boolean | undefined;
+            accountType?: import("./types").AccountType | undefined;
+            accountIndex?: number | undefined;
+        }) => import("@yaswap/client").Client<import("@yaswap/client").Chain<any, import("@yaswap/types").Network>, import("@yaswap/client").Wallet<any, any>, import("@yaswap/client").Swap<any, any, import("@yaswap/client").Wallet<any, any>>, import("@yaswap/client").Nft<any, any>>;
+        readonly historyItemById: (network: import("./types").Network, walletId: string, id: string) => import("./types").HistoryItem | undefined;
+        readonly cryptoassets: Readonly<{
+            [asset: string]: import("@yaswap/cryptoassets").IAsset;
+        }>;
+        readonly networkAccounts: readonly import("./types").Account[];
+        readonly networkAssets: readonly string[];
+        readonly allNetworkAssets: readonly string[];
+        readonly activity: readonly import("./types").HistoryItem[];
+        readonly totalFiatBalance: Readonly<import("bignumber.js").BigNumber>;
+        readonly accountItem: (accountId: string) => import("./types").Account | undefined;
+        readonly suggestedFeePrices: (asset: string) => import("@yaswap/types").FeeDetails | undefined;
+        readonly accountsWithBalance: readonly import("./types").Account[];
+        readonly accountsData: readonly import("./types").Account[];
+        readonly accountFiatBalance: (walletId: string, network: import("./types").Network, accountId: string) => import("bignumber.js").BigNumber;
+        readonly assetFiatBalance: (asset: string, balance: import("bignumber.js").BigNumber) => import("bignumber.js").BigNumber | null;
+        readonly assetMarketCap: (asset: string) => import("@yaswap/types").Nullable<import("bignumber.js").BigNumber>;
+        readonly chainAssets: Readonly<{
+            yacoin?: string[] | undefined;
+            bitcoin?: string[] | undefined;
+            ethereum?: string[] | undefined;
+            rsk?: string[] | undefined;
+            bsc?: string[] | undefined;
+            near?: string[] | undefined;
+            polygon?: string[] | undefined;
+            arbitrum?: string[] | undefined;
+            solana?: string[] | undefined;
+            fuse?: string[] | undefined;
+            terra?: string[] | undefined;
+            avalanche?: string[] | undefined;
+            optimism?: string[] | undefined;
+        }>;
+        readonly analyticsEnabled: Readonly<boolean>;
+        readonly allNftCollections: Readonly<import("./types").NFTCollections<import("./types").NFTWithAccount>>;
+        readonly accountNftCollections: (accountId: string) => import("./types").NFTCollections<import("./types").NFT>;
+        readonly mergedChainSettings: Readonly<Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>>;
+        readonly chainSettings: readonly {
+            chain: string;
+            asset: string;
+            network: import("../types").ChainifyNetwork;
+        }[];
+    };
+    rootCommit: {
+        SET_STATE: (payload: {
+            newState: RootState;
+        }) => void;
+        CREATE_WALLET: (payload: {
+            key: string;
+            keySalt: string;
+            encryptedWallets: string;
+            wallet: import("./types").Wallet;
+        }) => void;
+        ACCEPT_TNC: () => void;
+        CHANGE_ACTIVE_WALLETID: (payload: {
+            walletId: string;
+        }) => void;
+        CHANGE_ACTIVE_NETWORK: (payload: {
+            network: import("./types").Network;
+        }) => void;
+        CHANGE_PASSWORD: (payload: {
+            key: string;
+            keySalt: string;
+            encryptedWallets: string;
+        }) => void;
+        LOCK_WALLET: () => void;
+        UNLOCK_WALLET: (payload: {
+            key: string;
+            wallets: import("./types").Wallet[];
+            unlockedAt: number;
+        }) => void;
+        NEW_SWAP: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            swap: import("./types").SwapHistoryItem;
+        }) => void;
+        NEW_TRASACTION: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            transaction: import("./types").SendHistoryItem;
+        }) => void;
+        NEW_NFT_TRASACTION: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            transaction: import("./types").NFTSendHistoryItem;
+        }) => void;
+        UPDATE_HISTORY: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            id: string;
+            updates: Partial<import("./types").HistoryItem>;
+        }) => void;
+        REMOVE_ORDER: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            id: string;
+        }) => void;
+        UPDATE_BALANCE: (payload: {
+            network: import("./types").Network;
+            accountId: string;
+            walletId: string;
+            asset: string;
+            balance: string;
+        }) => void;
+        UPDATE_MULTIPLE_BALANCES: (payload: {
+            network: import("./types").Network;
+            accountId: string;
+            walletId: string;
+            assets: string[];
+            balances: import("@yaswap/types").Nullable<string>[];
+        }) => void;
+        UPDATE_FEES: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            asset: string;
+            fees: import("@yaswap/types").FeeDetails;
+        }) => void;
+        UPDATE_FIAT_RATES: (payload: {
+            fiatRates: import("./types").FiatRates;
+        }) => void;
+        UPDATE_CURRENCIES_INFO: (payload: {
+            currenciesInfo: import("./types").CurrenciesInfo;
+        }) => void;
+        UPDATE_MARKET_DATA: (payload: {
+            network: import("./types").Network;
+            marketData: import("./types").MarketData[];
+        }) => void;
+        SET_ETHEREUM_INJECTION_CHAIN: (payload: {
+            chain: import("@yaswap/cryptoassets").ChainId;
+        }) => void;
+        ENABLE_ETHEREUM_INJECTION: () => void;
+        DISABLE_ETHEREUM_INJECTION: () => void;
+        ENABLE_ASSETS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+        }) => void;
+        DISABLE_ASSETS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+        }) => void;
+        DISABLE_ACCOUNT_ASSETS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            assets: string[];
+        }) => void;
+        ENABLE_ACCOUNT_ASSETS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            assets: string[];
+        }) => void;
+        ADD_CUSTOM_TOKEN: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            customToken: import("./types").CustomToken;
+        }) => void;
+        REMOVE_CUSTOM_TOKEN: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            symbol: string;
+        }) => void;
+        CREATE_ACCOUNT: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            account: import("./types").Account;
+        }) => void;
+        UPDATE_ACCOUNT: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            account: import("./types").Account;
+        }) => void;
+        REMOVE_ACCOUNT: (payload: {
+            walletId: string;
+            id: string;
+            network: import("./types").Network;
+        }) => void;
+        UPDATE_ACCOUNT_ADDRESSES: (payload: {
+            network: import("./types").Network;
+            accountId: string;
+            walletId: string;
+            addresses: string[];
+        }) => void;
+        SET_USB_BRIDGE_WINDOWS_ID: (payload: {
+            id: number;
+        }) => void;
+        SET_EXTERNAL_CONNECTION_DEFAULT: (payload: {
+            origin: string;
+            activeWalletId: string;
+            accountId: string;
+        }) => void;
+        ADD_EXTERNAL_CONNECTION: (payload: {
+            origin: string;
+            activeWalletId: string;
+            accountId: string;
+            chain: import("@yaswap/cryptoassets").ChainId;
+        }) => void;
+        REMOVE_EXTERNAL_CONNECTIONS: (payload: {
+            activeWalletId: string;
+        }) => void;
+        SET_ANALYTICS_PREFERENCES: (payload: Partial<import("./types").AnalyticsState>) => void;
+        UPDATE_NFTS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            nfts: import("./types").NFT[];
+        }) => void;
+        NFT_TOGGLE_STARRED: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            nft: import("./types").NFT;
+        }) => void;
+        TOGGLE_EXPERIMENT: (payload: {
+            name: import("./types").ExperimentType;
+        }) => void;
+        SET_WHATS_NEW_MODAL_VERSION: (payload: {
+            version: string;
+        }) => void;
+        TOGGLE_BLOCKCHAIN: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            enable: boolean;
+        }) => void;
+        TOGGLE_ACCOUNT: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            enable: boolean;
+        }) => void;
+        LOG_ERROR: (payload: import("@yaswap/error-parser").LiqualityErrorJSON) => void;
+        CLEAR_ERROR_LOG: () => void;
+        SET_CUSTOM_CHAIN_SETTINGS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            chanifyNetwork: import("@yaswap/types").Network;
+        }) => void;
+        REMOVE_CUSTOM_CHAIN_SETTINGS: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+        }) => void;
+    };
+    rootDispatch: {
+        readonly acceptTermsAndConditions: (payload: {
+            analyticsAccepted: boolean;
+        }) => Promise<void>;
+        readonly createAccount: (payload: {
+            walletId: string;
+            network: import("./types").Network;
+            account: import("./types").Account;
+        }) => Promise<import("./types").Account>;
+        readonly removeAccount: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            id: string;
+        }) => Promise<string>;
+        readonly toggleAccount: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accounts: string[];
+            enable: boolean;
+        }) => Promise<void>;
+        readonly toggleBlockchain: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            enable: boolean;
+        }) => Promise<void>;
+        readonly updateAccount: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            account: import("./types").Account;
+        }) => Promise<{
+            updatedAt: number;
+            id: string;
+            walletId: string;
+            createdAt: number;
+            enabled: boolean;
+            derivationPath: string;
+            chainCode?: string | undefined;
+            publicKey?: string | undefined;
+            nfts?: import("./types").NFT[] | undefined;
+            type: import("./types").AccountType;
+            name: string;
+            alias?: string | undefined;
+            chain: import("@yaswap/cryptoassets").ChainId;
+            index: number;
+            addresses: string[];
+            assets: string[];
+            balances: Record<string, string>;
+            color: string;
+        }>;
+        readonly addCustomToken: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chain: import("@yaswap/cryptoassets").ChainId;
+            symbol: string;
+            name: string;
+            contractAddress: string;
+            decimals: number;
+        }) => Promise<void>;
+        readonly addExternalConnection: (payload: {
+            origin: string;
+            chain: import("@yaswap/cryptoassets").ChainId;
+            accountId: string;
+            setDefaultEthereum: boolean;
+        }) => Promise<void>;
+        readonly initializeAnalyticsPreferences: (payload: {
+            accepted: boolean;
+        }) => Promise<void>;
+        readonly updateAnalyticsPreferences: (payload: import("./types").AnalyticsState) => Promise<void>;
+        readonly setAnalyticsResponse: (payload: {
+            accepted: boolean;
+        }) => Promise<void>;
+        readonly initializeAnalytics: () => Promise<boolean>;
+        readonly trackAnalytics: (payload: {
+            event: string;
+            properties: actions.AmplitudeProperties;
+        }) => Promise<number> | Promise<undefined>;
+        readonly changeActiveNetwork: (payload: {
+            network: import("./types").Network;
+        }) => Promise<void>;
+        readonly changeActiveWalletId: (payload: {
+            walletId: string;
+        }) => Promise<void>;
+        readonly changePassword: (payload: {
+            key: string;
+        }) => Promise<void>;
+        readonly checkPendingActions: (payload: {
+            walletId: string;
+        }) => Promise<void>;
+        readonly createWallet: (payload: {
+            key: string;
+            mnemonic: string;
+            imported?: boolean | undefined;
+        }) => Promise<import("./types").Wallet>;
+        readonly disableAssets: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+        }) => Promise<void>;
+        readonly disableEthereumInjection: () => Promise<void>;
+        readonly enableAssets: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+        }) => Promise<void>;
+        readonly enableEthereumInjection: () => Promise<void>;
+        readonly exportPrivateKey: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+        }) => Promise<string>;
+        readonly fetchTokenDetails: (payload: actions.FetchTokenDetailsRequest) => Promise<import("@yaswap/types").Nullable<import("@yaswap/types").TokenDetails>>;
+        readonly forgetDappConnections: () => Promise<void>;
+        readonly getLockForAsset: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            asset: string;
+            item: import("./types").BaseHistoryItem;
+        }) => Promise<string>;
+        readonly getQuotes: (payload: import("../swaps/types").GetQuotesRequest) => Promise<actions.GetQuotesResult>;
+        readonly getSlowQuotes: (payload: {
+            requestId: string;
+        }) => Promise<import("../swaps/types").SwapQuote[]>;
+        readonly getUnusedAddresses: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            assets: string[];
+            accountId: string;
+        }) => Promise<string[]>;
+        readonly getLedgerAccounts: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            asset: string;
+            accountType: import("./types").AccountType;
+            startingIndex: number;
+            numAccounts: number;
+        }) => Promise<{
+            account: string;
+            index: number;
+            exists: boolean;
+        }[]>;
+        readonly initializeAddresses: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+        }) => Promise<void>;
+        readonly lockWallet: () => Promise<void>;
+        readonly newSwap: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            quote: import("../swaps/types").SwapQuote;
+            fee: number;
+            claimFee: number;
+            feeLabel: import("./types").FeeLabel;
+            claimFeeLabel: import("./types").FeeLabel;
+        }) => Promise<import("./types").SwapHistoryItem>;
+        readonly performNextAction: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            id: string;
+        }) => Promise<Partial<import("./types").HistoryItem> | undefined>;
+        readonly proxyMutation: (payload: {
+            type: string;
+            payload: any;
+        }) => Promise<void>;
+        readonly removeCustomToken: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            symbol: string;
+        }) => Promise<void>;
+        readonly retrySwap: (payload: {
+            swap: import("./types").SwapHistoryItem;
+        }) => Promise<Partial<import("./types").SwapHistoryItem> | undefined>;
+        readonly sendNFTTransaction: (payload: import("./types").NFTSendTransactionParams) => Promise<import("@yaswap/types").Transaction<any>>;
+        readonly sendTransaction: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            asset: string;
+            to: string;
+            amount: import("bignumber.js").BigNumber;
+            data: string;
+            fee: number;
+            feeAsset: string;
+            gas: number;
+            feeLabel: import("./types").FeeLabel;
+            fiatRate: number;
+        }) => Promise<import("./types").SendHistoryItem>;
+        readonly setEthereumInjectionChain: (payload: {
+            chain: import("@yaswap/cryptoassets").ChainId;
+        }) => Promise<void>;
+        readonly setWhatsNewModalVersion: (payload: {
+            version: string;
+        }) => Promise<void>;
+        readonly showNotification: (payload: import("../types").Notification) => Promise<void>;
+        readonly toggleExperiment: (payload: {
+            name: import("./types").ExperimentType;
+        }) => Promise<void>;
+        readonly toggleNFTStarred: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+            nft: import("./types").NFT;
+        }) => Promise<void>;
+        readonly unlockWallet: (payload: {
+            key: string;
+        }) => Promise<void>;
+        readonly updateAccountBalance: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            accountId: string;
+        }) => Promise<void>;
+        readonly updateBalances: (payload: {
+            walletId: string;
+            network: import("./types").Network;
+            accountIds?: string[] | undefined;
+        }) => Promise<void>;
+        readonly updateCurrenciesInfo: (payload: {
+            assets: string[];
+        }) => Promise<import("./types").CurrenciesInfo>;
+        readonly updateFees: (payload: {
+            asset: string;
+        }) => Promise<import("@yaswap/types").FeeDetails>;
+        readonly updateFiatRates: (payload: {
+            assets: string[];
+        }) => Promise<import("./types").FiatRates>;
+        readonly updateMarketData: (payload: {
+            network: import("./types").Network;
+        }) => Promise<{
+            network: import("./types").Network;
+            marketData: import("./types").MarketData[];
+        }>;
+        readonly updateNFTs: (payload: {
+            walletId: string;
+            network: import("./types").Network;
+            accountIds: string[];
+        }) => Promise<import("./types").NFT[][]>;
+        readonly updateTransactionFee: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            asset: string;
+            id: string;
+            hash: string;
+            newFee: number;
+        }) => Promise<import("@yaswap/types").Transaction<any>>;
+        readonly logError: (payload: import("@yaswap/error-parser").LiqualityErrorJSON) => Promise<void>;
+        readonly clearErrorLog: () => Promise<void>;
+        readonly saveCustomChainSettings: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            chanifyNetwork: import("@yaswap/types").Network;
+        }) => Promise<void>;
+        readonly removeCustomChainSettings: (payload: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+        }) => Promise<void>;
+    };
+    state: import("direct-vuex/types/direct-types").ShowContentDepth1<import("direct-vuex/types/direct-types").DirectState<O>>;
+    getters: import("direct-vuex/types/direct-types").ShowContentDepth1<import("direct-vuex/types/direct-types").DirectGetters<O>>;
+    commit: import("direct-vuex/types/direct-types").ShowContentDepth1<import("direct-vuex/types/direct-types").DirectMutations<O>>;
+    dispatch: import("direct-vuex/types/direct-types").ShowContentDepth1<import("direct-vuex/types/direct-types").DirectActions<O>>;
+}, moduleGetterContext: <O extends import("direct-vuex").ModuleOptions<any>>(args: [any, any, any, any], module: O) => {
+    rootState: {
+        readonly version: number;
+        readonly key: string;
+        readonly wallets: import("./types").Wallet[];
+        readonly unlockedAt: number;
+        readonly brokerReady: boolean;
+        readonly encryptedWallets: string;
+        readonly enabledAssets: Partial<Record<import("./types").Network, Record<string, string[]>>>;
+        readonly customTokens: Partial<Record<import("./types").Network, Record<string, import("./types").CustomToken[]>>>;
+        readonly accounts: Partial<Record<string, Record<import("./types").Network, import("./types").Account[]>>>;
+        readonly fiatRates: import("./types").FiatRates;
+        readonly currenciesInfo: import("./types").CurrenciesInfo;
+        readonly fees: Partial<Record<import("./types").Network, Record<string, Record<string, import("@yaswap/types").FeeDetails>>>>;
+        readonly history: Partial<Record<import("./types").Network, Record<string, import("./types").HistoryItem[]>>>;
+        readonly marketData: Partial<Record<import("./types").Network, import("./types").MarketData[]>>;
+        readonly activeNetwork: import("./types").Network;
+        readonly activeWalletId: string;
+        readonly keyUpdatedAt: number;
+        readonly keySalt: string;
+        readonly termsAcceptedAt: number;
+        readonly setupAt: number;
+        readonly injectEthereum: boolean;
+        readonly injectEthereumChain: import("@yaswap/cryptoassets").ChainId;
+        readonly usbBridgeWindowsId: number;
+        readonly externalConnections: import("./types").ExternalConnections;
+        readonly rskLegacyDerivation: boolean;
+        readonly analytics: import("./types").AnalyticsState;
+        readonly experiments: Partial<Record<import("./types").ExperimentType, boolean>>;
+        readonly whatsNewModalVersion: string;
+        readonly enabledChains: Partial<Record<string, Record<import("./types").Network, import("@yaswap/cryptoassets").ChainId[]>>>;
+        readonly errorLog: import("@yaswap/error-parser").LiqualityErrorJSON[];
+        readonly customChainSeetings: Partial<Record<import("./types").Network, Record<string, Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>>>>;
+    };
+    rootGetters: {
+        readonly client: ({ network, walletId, chainId, accountId, useCache, accountType, accountIndex, }: {
+            network: import("./types").Network;
+            walletId: string;
+            chainId: import("@yaswap/cryptoassets").ChainId;
+            accountId?: string | undefined;
+            useCache?: boolean | undefined;
+            accountType?: import("./types").AccountType | undefined;
+            accountIndex?: number | undefined;
+        }) => import("@yaswap/client").Client<import("@yaswap/client").Chain<any, import("@yaswap/types").Network>, import("@yaswap/client").Wallet<any, any>, import("@yaswap/client").Swap<any, any, import("@yaswap/client").Wallet<any, any>>, import("@yaswap/client").Nft<any, any>>;
+        readonly historyItemById: (network: import("./types").Network, walletId: string, id: string) => import("./types").HistoryItem | undefined;
+        readonly cryptoassets: Readonly<{
+            [asset: string]: import("@yaswap/cryptoassets").IAsset;
+        }>;
+        readonly networkAccounts: readonly import("./types").Account[];
+        readonly networkAssets: readonly string[];
+        readonly allNetworkAssets: readonly string[];
+        readonly activity: readonly import("./types").HistoryItem[];
+        readonly totalFiatBalance: Readonly<import("bignumber.js").BigNumber>;
+        readonly accountItem: (accountId: string) => import("./types").Account | undefined;
+        readonly suggestedFeePrices: (asset: string) => import("@yaswap/types").FeeDetails | undefined;
+        readonly accountsWithBalance: readonly import("./types").Account[];
+        readonly accountsData: readonly import("./types").Account[];
+        readonly accountFiatBalance: (walletId: string, network: import("./types").Network, accountId: string) => import("bignumber.js").BigNumber;
+        readonly assetFiatBalance: (asset: string, balance: import("bignumber.js").BigNumber) => import("bignumber.js").BigNumber | null;
+        readonly assetMarketCap: (asset: string) => import("@yaswap/types").Nullable<import("bignumber.js").BigNumber>;
+        readonly chainAssets: Readonly<{
+            yacoin?: string[] | undefined;
+            bitcoin?: string[] | undefined;
+            ethereum?: string[] | undefined;
+            rsk?: string[] | undefined;
+            bsc?: string[] | undefined;
+            near?: string[] | undefined;
+            polygon?: string[] | undefined;
+            arbitrum?: string[] | undefined;
+            solana?: string[] | undefined;
+            fuse?: string[] | undefined;
+            terra?: string[] | undefined;
+            avalanche?: string[] | undefined;
+            optimism?: string[] | undefined;
+        }>;
+        readonly analyticsEnabled: Readonly<boolean>;
+        readonly allNftCollections: Readonly<import("./types").NFTCollections<import("./types").NFTWithAccount>>;
+        readonly accountNftCollections: (accountId: string) => import("./types").NFTCollections<import("./types").NFT>;
+        readonly mergedChainSettings: Readonly<Record<import("@yaswap/cryptoassets").ChainId, import("../types").ChainifyNetwork>>;
+        readonly chainSettings: readonly {
+            chain: string;
+            asset: string;
+            network: import("../types").ChainifyNetwork;
+        }[];
+    };
+    state: import("direct-vuex/types/direct-types").ShowContentDepth1<import("direct-vuex/types/direct-types").DirectState<O>>;
+    getters: import("direct-vuex/types/direct-types").ShowContentDepth1<import("direct-vuex/types/direct-types").DirectGetters<O>>;
+};
+export default store;
+export declare type OriginalStore = typeof store.original;
+export declare type ActionContext = _ActionContext<RootState, RootState>;
+export { rootActionContext, rootGetterContext, moduleActionContext, moduleGetterContext };