/// <reference types="bn.js" />
import { _AssetRef, _AssetType, _ChainAsset, _ChainInfo, _MultiChainAsset } from '@soul-wallet/chain-list/types';
import { TransactionError } from '@soul-wallet/extension-base/background/errors/TransactionError';
import { AuthUrls, Resolver } from '@soul-wallet/extension-base/background/handlers/State';
import { AccountAuthType, AccountJson, AddressJson, AuthorizeRequest, ConfirmationRequestBase, RequestAccountList, RequestAccountSubscribe, RequestAccountUnsubscribe, RequestAuthorizeCancel, RequestAuthorizeReject, RequestAuthorizeSubscribe, RequestAuthorizeTab, RequestCurrentAccountAddress, ResponseAuthorizeList, ResponseJsonGetAccountInfo, SeedLengths } from '@soul-wallet/extension-base/background/types';
import { _CHAIN_VALIDATION_ERROR } from '@soul-wallet/extension-base/services/chain-service/handler/types';
import { _ChainState, _EvmApi, _NetworkUpsertParams, _SubstrateApi, _ValidateCustomAssetRequest, _ValidateCustomAssetResponse, EnableChainParams, EnableMultiChainParams } from '@soul-wallet/extension-base/services/chain-service/types';
import { SWTransactionResponse, SWTransactionResult } from '@soul-wallet/extension-base/services/transaction-service/types';
import { WalletConnectNotSupportRequest, WalletConnectSessionRequest } from '../services/wallet-connect-service/types';
import { InjectedAccount, InjectedAccountWithMeta, MetadataDefBase } from '@soul-wallet/extension-inject/types';
import { KeyringPair$Json, KeyringPair$Meta } from '@subwallet/keyring/types';
import { KeyringOptions } from '@subwallet/ui-keyring/options/types';
import { KeyringAddress, KeyringPairs$Json } from '@subwallet/ui-keyring/types';
import { SessionTypes } from '@walletconnect/types/dist/types/sign-client/session';
import Web3 from 'web3';
import { RequestArguments, TransactionConfig } from 'web3-core';
import { JsonRpcPayload, JsonRpcResponse } from 'web3-core-helpers';
import { SignerResult } from '@polkadot/types/types/extrinsic';
import { BN } from '@polkadot/util';
import { HexString } from '@polkadot/util/types';
import { KeypairType } from '@polkadot/util-crypto/types';
import { TransactionWarning } from './warnings/TransactionWarning';
export declare enum RuntimeEnvironment {
    Web = "Web",
    Node = "Node",
    ExtensionChrome = "Extension (Chrome)",
    ExtensionFirefox = "Extension (Firefox)",
    WebWorker = "Web Worker",
    ServiceWorker = "Service Worker",
    Unknown = "Unknown"
}
export interface RuntimeEnvironmentInfo {
    environment: RuntimeEnvironment;
    version: string;
    host?: string;
    protocol?: string;
}
export declare type TargetEnvironment = 'extension' | 'webapp' | 'web-runner';
export interface EnvironmentSupport {
    MANTA_ZK: boolean;
}
export interface ServiceInfo {
    chainInfoMap: Record<string, _ChainInfo>;
    chainStateMap: Record<string, _ChainState>;
    chainApiMap: ApiMap;
    currentAccountInfo: CurrentAccountInfo;
    assetRegistry: Record<string, _ChainAsset>;
}
export interface AssetSetting {
    visible: boolean;
}
export interface AuthRequestV2 extends Resolver<ResultResolver> {
    id: string;
    idStr: string;
    request: RequestAuthorizeTab;
    url: string;
    accountAuthType: AccountAuthType;
}
export interface RequestAuthorizeApproveV2 {
    id: string;
    accounts: string[];
}
export interface RequestAuthorizationAll {
    connectValue: boolean;
}
export interface RequestAuthorization extends RequestAuthorizationAll {
    url: string;
}
export interface RequestAuthorizationPerAccount extends RequestAuthorization {
    address: string;
}
export interface RequestAuthorizationPerSite {
    id: string;
    values: Record<string, boolean>;
}
export interface RequestAuthorizationBlock {
    id: string;
    connectedValue: boolean;
}
export interface RequestForgetSite {
    url: string;
}
export interface ResultResolver {
    result: boolean;
    accounts: string[];
}
export interface RejectResolver {
    error: Error;
    accounts: string[];
}
export declare enum StakingType {
    NOMINATED = "nominated",
    POOLED = "pooled"
}
export interface StakingRewardItem {
    state: APIItemState;
    name: string;
    chain: string;
    address: string;
    type: StakingType;
    latestReward?: string;
    totalReward?: string;
    totalSlash?: string;
    unclaimedReward?: string;
}
export interface UnlockingStakeInfo {
    chain: string;
    address: string;
    type: StakingType;
    nextWithdrawal: number;
    redeemable: number;
    nextWithdrawalAmount: number;
    nextWithdrawalAction?: string;
    validatorAddress?: string;
}
export interface StakingItem {
    name: string;
    chain: string;
    address: string;
    type: StakingType;
    balance?: string;
    activeBalance?: string;
    unlockingBalance?: string;
    nativeToken: string;
    unit?: string;
    state: APIItemState;
}
export interface StakingJson {
    reset?: boolean;
    ready?: boolean;
    details: StakingItem[];
}
export interface StakingRewardJson {
    ready: boolean;
    data: Record<string, StakingRewardItem>;
}
export interface PriceJson {
    ready?: boolean;
    currency: string;
    priceMap: Record<string, number>;
    price24hMap: Record<string, number>;
}
export declare enum APIItemState {
    PENDING = "pending",
    READY = "ready",
    CACHED = "cached",
    ERROR = "error",
    NOT_SUPPORT = "not_support"
}
export declare enum RMRK_VER {
    VER_1 = "1.0.0",
    VER_2 = "2.0.0"
}
export declare enum CrowdloanParaState {
    ONGOING = "ongoing",
    COMPLETED = "completed",
    FAILED = "failed"
}
export interface NftItem {
    id: string;
    chain: string;
    collectionId: string;
    owner: string;
    originAsset?: string;
    name?: string;
    image?: string;
    externalUrl?: string;
    rarity?: string;
    description?: string;
    properties?: Record<any, any> | null;
    type?: _AssetType.ERC721 | _AssetType.PSP34 | RMRK_VER;
    rmrk_ver?: RMRK_VER;
    onChainOption?: any;
}
export interface NftCollection {
    collectionId: string;
    chain: string;
    originAsset?: string;
    collectionName?: string;
    image?: string;
    itemCount?: number;
    externalUrl?: string;
}
export interface NftJson {
    total: number;
    nftList: Array<NftItem>;
}
export interface NftCollectionJson {
    ready: boolean;
    nftCollectionList: Array<NftCollection>;
}
export interface MetadataItem {
    genesisHash: string;
    specVersion: string;
    hexValue: HexString;
}
export interface TokenBalanceRaw {
    reserved: BN;
    frozen: BN;
    free: BN;
}
export interface SubstrateBalance {
    reserved?: string;
    miscFrozen?: string;
    feeFrozen?: string;
}
export interface BalanceItem {
    tokenSlug: string;
    state: APIItemState;
    timestamp?: number;
    free: string;
    locked: string;
    substrateInfo?: SubstrateBalance;
}
export interface BalanceJson {
    reset?: boolean;
    details: Record<string, BalanceItem>;
}
export interface CrowdloanItem {
    state: APIItemState;
    paraState?: CrowdloanParaState;
    contribute: string;
}
export interface CrowdloanJson {
    reset?: boolean;
    details: Record<string, CrowdloanItem>;
}
export declare type NetWorkGroup = 'RELAY_CHAIN' | 'POLKADOT_PARACHAIN' | 'KUSAMA_PARACHAIN' | 'MAIN_NET' | 'TEST_NET' | 'UNKNOWN';
export declare enum ContractType {
    wasm = "wasm",
    evm = "evm"
}
export interface NetworkJson {
    key: string;
    chain: string;
    icon?: string;
    active: boolean;
    providers: Record<string, string>;
    currentProvider: string | null;
    currentProviderMode: 'http' | 'ws';
    customProviders?: Record<string, string>;
    nftProvider?: string;
    genesisHash: string;
    groups: NetWorkGroup[];
    ss58Format: number;
    paraId?: number;
    chainType?: 'substrate' | 'ethereum';
    crowdloanUrl?: string;
    isEthereum?: boolean;
    evmChainId?: number;
    isHybrid?: boolean;
    nativeToken?: string;
    decimals?: number;
    coinGeckoKey?: string;
    blockExplorer?: string;
    abiExplorer?: string;
    dependencies?: string[];
    getStakingOnChain?: boolean;
    supportBonding?: boolean;
    supportSmartContract?: ContractType[];
    apiStatus?: NETWORK_STATUS;
    requestId?: string;
}
export interface DonateInfo {
    key: string;
    name: string;
    value: string;
    icon: string;
    link: string;
}
export interface DropdownTransformOptionType {
    label: string;
    value: string;
}
export interface NetWorkMetadataDef extends MetadataDefBase {
    networkKey: string;
    groups: NetWorkGroup[];
    isEthereum: boolean;
    paraId?: number;
    isAvailable: boolean;
    active: boolean;
    apiStatus: NETWORK_STATUS;
}
export declare type CurrentNetworkInfo = {
    networkKey: string;
    networkPrefix: number;
    icon: string;
    genesisHash: string;
    isEthereum: boolean;
    isReady?: boolean;
};
export interface AccountsWithCurrentAddress {
    accounts: AccountJson[];
    currentAddress?: string;
    currentGenesisHash?: string | null;
    isShowBalance?: boolean;
    allAccountLogo?: string;
}
export interface OptionInputAddress {
    options: KeyringOptions;
}
export interface CurrentAccountInfo {
    address: string;
    currentGenesisHash: string | null;
    allGenesisHash?: string;
}
export declare type LanguageType = 'en' | 'zh' | 'fr' | 'tr' | 'pl' | 'th' | 'ur' | 'vi' | 'ja' | 'ru';
export declare type LanguageOptionType = {
    text: string;
    value: LanguageType;
};
export declare type BrowserConfirmationType = 'extension' | 'popup' | 'window';
export declare enum WalletUnlockType {
    ALWAYS_REQUIRED = "always_required",
    WHEN_NEEDED = "when_needed"
}
export interface UiSettings {
    language: LanguageType;
    browserConfirmationType: BrowserConfirmationType;
    isShowZeroBalance: boolean;
    isShowBalance: boolean;
    accountAllLogo: string;
    theme: ThemeNames;
    camera: boolean;
    timeAutoLock: number;
    unlockType: WalletUnlockType;
    enableChainPatrol: boolean;
    walletReference: string;
}
export declare type RequestSettingsType = UiSettings;
export declare type RequestCameraSettings = {
    camera: boolean;
};
export declare type RequestChangeTimeAutoLock = {
    autoLockTime: number;
};
export declare type RequestUnlockType = {
    unlockType: WalletUnlockType;
};
export declare type RequestChangeEnableChainPatrol = {
    enable: boolean;
};
export declare type RequestChangeShowZeroBalance = {
    show: boolean;
};
export declare type RequestChangeLanguage = {
    language: LanguageType;
};
export declare type RequestChangeShowBalance = {
    enable: boolean;
};
export interface RandomTestRequest {
    start: number;
    end: number;
}
export declare enum TransactionDirection {
    SEND = "send",
    RECEIVED = "received"
}
export declare enum ChainType {
    EVM = "evm",
    SUBSTRATE = "substrate"
}
export declare enum ExtrinsicType {
    TRANSFER_BALANCE = "transfer.balance",
    TRANSFER_TOKEN = "transfer.token",
    TRANSFER_XCM = "transfer.xcm",
    SEND_NFT = "send_nft",
    CROWDLOAN = "crowdloan",
    STAKING_JOIN_POOL = "staking.join_pool",
    STAKING_LEAVE_POOL = "staking.leave_pool",
    STAKING_POOL_WITHDRAW = "staking.pool_withdraw",
    STAKING_BOND = "staking.bond",
    STAKING_UNBOND = "staking.unbond",
    STAKING_CLAIM_REWARD = "staking.claim_reward",
    STAKING_WITHDRAW = "staking.withdraw",
    STAKING_COMPOUNDING = "staking.compounding",
    STAKING_CANCEL_COMPOUNDING = "staking.cancel_compounding",
    STAKING_CANCEL_UNSTAKE = "staking.cancel_unstake",
    EVM_EXECUTE = "evm.execute",
    UNKNOWN = "unknown"
}
export interface ExtrinsicDataTypeMap {
    [ExtrinsicType.TRANSFER_BALANCE]: RequestTransfer;
    [ExtrinsicType.TRANSFER_TOKEN]: RequestTransfer;
    [ExtrinsicType.TRANSFER_XCM]: RequestCrossChainTransfer;
    [ExtrinsicType.SEND_NFT]: NftTransactionRequest;
    [ExtrinsicType.CROWDLOAN]: any;
    [ExtrinsicType.STAKING_JOIN_POOL]: RequestStakePoolingBonding;
    [ExtrinsicType.STAKING_LEAVE_POOL]: RequestStakePoolingUnbonding;
    [ExtrinsicType.STAKING_BOND]: RequestStakePoolingBonding;
    [ExtrinsicType.STAKING_UNBOND]: RequestUnbondingSubmit;
    [ExtrinsicType.STAKING_CLAIM_REWARD]: RequestStakeClaimReward;
    [ExtrinsicType.STAKING_WITHDRAW]: RequestStakeWithdrawal;
    [ExtrinsicType.STAKING_COMPOUNDING]: RequestTuringStakeCompound;
    [ExtrinsicType.STAKING_CANCEL_COMPOUNDING]: RequestTuringCancelStakeCompound;
    [ExtrinsicType.STAKING_CANCEL_UNSTAKE]: RequestStakeCancelWithdrawal;
    [ExtrinsicType.STAKING_POOL_WITHDRAW]: any;
    [ExtrinsicType.EVM_EXECUTE]: TransactionConfig;
    [ExtrinsicType.UNKNOWN]: any;
}
export declare enum ExtrinsicStatus {
    QUEUED = "queued",
    SUBMITTING = "submitting",
    PROCESSING = "processing",
    SUCCESS = "success",
    FAIL = "fail",
    CANCELLED = "cancelled",
    UNKNOWN = "unknown"
}
export interface TxHistoryItem {
    time: number | string;
    networkKey: string;
    isSuccess: boolean;
    action: TransactionDirection;
    extrinsicHash: string;
    change?: string;
    changeSymbol?: string;
    fee?: string;
    feeSymbol?: string;
    origin?: 'app' | 'network';
}
export interface TransactionHistoryItemJson {
    items: TxHistoryItem[];
    total: number;
}
export interface BasicTokenInfo {
    decimals: number;
    symbol: string;
}
export interface AmountData extends BasicTokenInfo {
    value: string;
}
export interface XCMTransactionAdditionalInfo {
    destinationChain: string;
    originalChain: string;
    fee?: AmountData;
}
export interface NFTTransactionAdditionalInfo {
    collectionName: string;
}
export declare type TransactionAdditionalInfo<T extends ExtrinsicType> = T extends ExtrinsicType.TRANSFER_XCM ? XCMTransactionAdditionalInfo : T extends ExtrinsicType.SEND_NFT ? NFTTransactionAdditionalInfo : undefined;
export interface TransactionHistoryItem<ET extends ExtrinsicType = ExtrinsicType.TRANSFER_BALANCE> {
    origin?: 'app' | 'migration' | 'subsquid';
    callhash?: string;
    signature?: string;
    chain: string;
    chainType?: ChainType;
    chainName?: string;
    direction: TransactionDirection;
    type: ExtrinsicType;
    from: string;
    fromName?: string;
    to: string;
    toName?: string;
    address: string;
    status: ExtrinsicStatus;
    transactionId?: string;
    extrinsicHash: string;
    time: number;
    data?: string;
    blockNumber: number;
    blockHash: string;
    amount?: AmountData;
    tip?: AmountData;
    fee?: AmountData;
    explorerUrl?: string;
    additionalInfo?: TransactionAdditionalInfo<ET>;
    startBlock?: number;
    nonce?: number;
}
export interface SWError extends Error {
    code?: number;
    errorType: string;
    data?: unknown;
}
export interface SWWarning {
    errorType: string;
    code?: number;
    message: string;
    data?: unknown;
}
export declare enum BasicTxErrorType {
    NOT_ENOUGH_BALANCE = "NOT_ENOUGH_BALANCE",
    CHAIN_DISCONNECTED = "CHAIN_DISCONNECTED",
    INVALID_PARAMS = "INVALID_PARAMS",
    DUPLICATE_TRANSACTION = "DUPLICATE_TRANSACTION",
    UNABLE_TO_SIGN = "UNABLE_TO_SIGN",
    USER_REJECT_REQUEST = "USER_REJECT_REQUEST",
    UNABLE_TO_SEND = "UNABLE_TO_SEND",
    SEND_TRANSACTION_FAILED = "SEND_TRANSACTION_FAILED",
    INTERNAL_ERROR = "INTERNAL_ERROR",
    UNSUPPORTED = "UNSUPPORTED",
    TIMEOUT = "TIMEOUT",
    NOT_ENOUGH_EXISTENTIAL_DEPOSIT = "NOT_ENOUGH_EXISTENTIAL_DEPOSIT"
}
export declare enum StakingTxErrorType {
    NOT_ENOUGH_MIN_STAKE = "NOT_ENOUGH_MIN_STAKE",
    EXCEED_MAX_NOMINATIONS = "EXCEED_MAX_NOMINATIONS",
    EXIST_UNSTAKING_REQUEST = "EXIST_UNSTAKING_REQUEST",
    INVALID_ACTIVE_STAKE = "INVALID_ACTIVE_STAKE",
    EXCEED_MAX_UNSTAKING = "EXCEED_MAX_UNSTAKING",
    INACTIVE_NOMINATION_POOL = "INACTIVE_NOMINATION_POOL"
}
export declare enum TransferTxErrorType {
    NOT_ENOUGH_VALUE = "NOT_ENOUGH_VALUE",
    NOT_ENOUGH_FEE = "NOT_ENOUGH_FEE",
    INVALID_TOKEN = "INVALID_TOKEN",
    TRANSFER_ERROR = "TRANSFER_ERROR",
    RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT = "RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT"
}
export declare type TransactionErrorType = BasicTxErrorType | TransferTxErrorType | StakingTxErrorType;
export declare enum BasicTxWarningCode {
    NOT_ENOUGH_EXISTENTIAL_DEPOSIT = "notEnoughExistentialDeposit"
}
export declare type BasicTxError = {
    errorType: TxErrorCode;
    data?: object;
    message: string;
};
export declare type BasicTxWarning = {
    warningType: TransactionWarningType;
    data?: object;
    message: string;
};
export interface TransactionResponse {
    extrinsicHash?: string;
    txError?: boolean;
    errors?: TransactionError[];
    status?: boolean;
    txResult?: TxResultType;
    passwordError?: string | null;
}
export interface NftTransactionResponse extends SWTransactionResponse {
    isSendingSelf: boolean;
}
export declare type HandleBasicTx = (data: TransactionResponse) => void;
export declare type TxErrorCode = TransferTxErrorType | TransactionErrorType;
export declare enum BalanceErrorType {
    NETWORK_ERROR = "NETWORK_ERROR",
    TOKEN_ERROR = "TOKEN_ERROR",
    TIMEOUT = "TIMEOUT",
    GET_BALANCE_ERROR = "GET_BALANCE_ERROR"
}
export declare type TransactionWarningType = BasicTxWarningCode;
export declare enum ProviderErrorType {
    CHAIN_DISCONNECTED = "CHAIN_DISCONNECTED",
    INVALID_PARAMS = "INVALID_PARAMS",
    INTERNAL_ERROR = "INTERNAL_ERROR",
    USER_REJECT = "USER_REJECT"
}
export interface RequestAccountExportPrivateKey {
    address: string;
    password: string;
}
export interface ResponseAccountExportPrivateKey {
    privateKey: string;
    publicKey: string;
}
export interface RequestCheckPublicAndSecretKey {
    secretKey: string;
    publicKey: string;
}
export interface ResponseCheckPublicAndSecretKey {
    address: string;
    isValid: boolean;
    isEthereum: boolean;
}
export interface RequestSeedCreateV2 {
    length?: SeedLengths;
    seed?: string;
    types?: Array<KeypairType>;
}
export interface ResponseSeedCreateV2 {
    seed: string;
    addressMap: Record<KeypairType, string>;
}
export interface RequestSeedValidateV2 {
    suri: string;
    types?: Array<KeypairType>;
}
export declare type ResponseSeedValidateV2 = ResponseSeedCreateV2;
export interface RequestAccountCreateSuriV2 {
    name: string;
    genesisHash?: string | null;
    password?: string;
    suri: string;
    types?: Array<KeypairType>;
    isAllowed: boolean;
}
export declare type ResponseAccountCreateSuriV2 = Record<KeypairType, string>;
export interface RequestDeriveCreateV2 {
    name: string;
    genesisHash?: string | null;
    suri: string;
    parentAddress: string;
    isAllowed: boolean;
}
export interface CreateDeriveAccountInfo {
    name: string;
    suri: string;
}
export interface RequestDeriveCreateV3 {
    address: string;
}
export interface RequestDeriveCreateMultiple {
    parentAddress: string;
    isAllowed: boolean;
    items: CreateDeriveAccountInfo[];
}
export interface DeriveAccountInfo {
    address: string;
    suri: string;
}
export interface RequestDeriveValidateV2 {
    suri: string;
    parentAddress: string;
}
export declare type ResponseDeriveValidateV2 = DeriveAccountInfo;
export interface RequestGetDeriveAccounts {
    page: number;
    limit: number;
    parentAddress: string;
}
export interface ResponseGetDeriveAccounts {
    result: DeriveAccountInfo[];
}
export interface RequestJsonRestoreV2 {
    file: KeyringPair$Json;
    password: string;
    address: string;
    isAllowed: boolean;
    withMasterPassword: boolean;
}
export interface RequestBatchRestoreV2 {
    file: KeyringPairs$Json;
    password: string;
    accountsInfo: ResponseJsonGetAccountInfo[];
    isAllowed: boolean;
}
export interface ResponsePrivateKeyValidateV2 {
    addressMap: Record<KeypairType, string>;
    autoAddPrefix: boolean;
}
export declare enum AccountExternalErrorCode {
    INVALID_ADDRESS = "invalidToAccount",
    KEYRING_ERROR = "keyringError",
    UNKNOWN_ERROR = "unknownError"
}
export interface AccountExternalError {
    code: AccountExternalErrorCode;
    message: string;
}
export interface RequestAccountCreateExternalV2 {
    address: string;
    genesisHash?: string | null;
    name: string;
    isEthereum: boolean;
    isAllowed: boolean;
    isReadOnly: boolean;
}
export interface RequestAccountCreateHardwareV2 {
    accountIndex: number;
    address: string;
    addressOffset: number;
    genesisHash: string;
    hardwareType: string;
    name: string;
    isAllowed?: boolean;
}
export interface CreateHardwareAccountItem {
    accountIndex: number;
    address: string;
    addressOffset: number;
    genesisHash: string;
    hardwareType: string;
    name: string;
    isEthereum: boolean;
}
export interface RequestAccountCreateHardwareMultiple {
    accounts: CreateHardwareAccountItem[];
}
export interface RequestAccountCreateWithSecretKey {
    publicKey: string;
    secretKey: string;
    name: string;
    isAllow: boolean;
    isEthereum: boolean;
}
export interface ResponseAccountCreateWithSecretKey {
    errors: AccountExternalError[];
    success: boolean;
}
export interface AddressBookInfo {
    addresses: AddressJson[];
}
export interface RequestEditContactAccount {
    address: string;
    meta: KeyringPair$Meta;
}
export interface RequestDeleteContactAccount {
    address: string;
}
export interface RequestAddInjectedAccounts {
    accounts: InjectedAccountWithMeta[];
}
export interface RequestRemoveInjectedAccounts {
    addresses: string[];
}
export declare enum ExternalRequestPromiseStatus {
    PENDING = 0,
    REJECTED = 1,
    FAILED = 2,
    COMPLETED = 3
}
export interface ExternalRequestPromise {
    resolve?: (result: SignerResult | PromiseLike<SignerResult>) => void;
    reject?: (error?: Error) => void;
    status: ExternalRequestPromiseStatus;
    message?: string;
    createdAt: number;
}
export interface PrepareExternalRequest {
    id: string;
    setState: (promise: ExternalRequestPromise) => void;
    updateState: (promise: Partial<ExternalRequestPromise>) => void;
}
export interface RequestRejectExternalRequest {
    id: string;
    message?: string;
    throwError?: boolean;
}
export declare type ResponseRejectExternalRequest = void;
export interface RequestResolveExternalRequest {
    id: string;
    data: SignerResult;
}
export declare type ResponseResolveExternalRequest = void;
export declare type AccountRef = Array<string>;
export declare type AccountRefMap = Record<string, AccountRef>;
export declare type RequestPrice = null;
export declare type RequestSubscribePrice = null;
export declare type RequestBalance = null;
export declare type RequestSubscribeBalance = null;
export declare type RequestSubscribeBalancesVisibility = null;
export declare type RequestCrowdloan = null;
export declare type RequestSubscribeCrowdloan = null;
export declare type RequestSubscribeNft = null;
export declare type RequestSubscribeStaking = null;
export declare type RequestSubscribeStakingReward = null;
export declare enum ThemeNames {
    LIGHT = "light",
    DARK = "dark",
    SUBSPACE = "subspace"
}
export declare enum NETWORK_ERROR {
    INVALID_INFO_TYPE = "invalidInfoType",
    INJECT_SCRIPT_DETECTED = "injectScriptDetected",
    EXISTED_NETWORK = "existedNetwork",
    EXISTED_PROVIDER = "existedProvider",
    INVALID_PROVIDER = "invalidProvider",
    NONE = "none",
    CONNECTION_FAILURE = "connectionFailure",
    PROVIDER_NOT_SAME_NETWORK = "providerNotSameNetwork"
}
export declare enum NETWORK_STATUS {
    CONNECTED = "connected",
    CONNECTING = "connecting",
    DISCONNECTED = "disconnected",
    PENDING = "pending"
}
export declare type BaseRequestSign = {
    ignoreWarnings?: boolean;
};
export declare type InternalRequestSign<T extends BaseRequestSign> = Omit<T, 'password'>;
export declare type TxResultType = {
    change: string;
    changeSymbol?: string;
    fee?: string;
    feeSymbol?: string;
};
export interface NftTransactionRequest {
    networkKey: string;
    senderAddress: string;
    recipientAddress: string;
    nftItemName?: string;
    params: Record<string, any>;
    nftItem: NftItem;
}
export interface EvmNftTransaction extends ValidateTransactionResponse {
    tx: Record<string, any> | null;
}
export interface EvmNftSubmitTransaction extends BaseRequestSign {
    senderAddress: string;
    recipientAddress: string;
    networkKey: string;
    estimateGas: string;
    rawTransaction: Record<string, any>;
}
export interface ValidateNetworkResponse {
    success: boolean;
    error?: _CHAIN_VALIDATION_ERROR;
    conflictChain?: string;
    conflictKey?: string;
    genesisHash: string;
    addressPrefix: string;
    name: string;
    paraId: number | null;
    evmChainId: number | null;
    symbol: string;
    decimals: number;
    existentialDeposit: string;
}
export interface ValidateNetworkRequest {
    provider: string;
    existedChainSlug?: string;
}
export interface ApiMap {
    substrate: Record<string, _SubstrateApi>;
    evm: Record<string, _EvmApi>;
}
export interface SupportTransferResponse {
    supportTransfer: boolean;
    supportTransferAll: boolean;
}
export interface RequestFreeBalance {
    address: string;
    networkKey: string;
    token?: string;
}
export interface RequestMaxTransferable {
    address: string;
    networkKey: string;
    token?: string;
    isXcmTransfer?: boolean;
    destChain: string;
}
export interface RequestTransferCheckReferenceCount {
    address: string;
    networkKey: string;
}
export interface RequestTransferCheckSupporting {
    networkKey: string;
    tokenSlug: string;
}
export interface RequestTransferExistentialDeposit {
    tokenSlug: string;
}
export interface RequestSaveRecentAccount {
    accountId: string;
}
export interface SubstrateNftTransaction {
    error: boolean;
    estimatedFee?: string;
    balanceError: boolean;
}
export interface SubstrateNftSubmitTransaction extends BaseRequestSign {
    params: Record<string, any> | null;
    senderAddress: string;
    nftItemName?: string;
    recipientAddress: string;
}
export declare type RequestSubstrateNftSubmitTransaction = InternalRequestSign<SubstrateNftSubmitTransaction>;
export declare type RequestEvmNftSubmitTransaction = InternalRequestSign<EvmNftSubmitTransaction>;
export interface RequestAccountMeta {
    address: string | Uint8Array;
}
export interface ResponseAccountMeta {
    meta: KeyringPair$Meta;
}
export declare type RequestEvmEvents = null;
export declare type EvmEventType = 'connect' | 'disconnect' | 'accountsChanged' | 'chainChanged' | 'message' | 'data' | 'reconnect' | 'error';
export declare type EvmAccountsChangedPayload = string[];
export declare type EvmChainChangedPayload = string;
export declare type EvmConnectPayload = {
    chainId: EvmChainChangedPayload;
};
export declare type EvmDisconnectPayload = unknown;
export interface EvmEvent {
    type: EvmEventType;
    payload: EvmAccountsChangedPayload | EvmChainChangedPayload | EvmConnectPayload | EvmDisconnectPayload;
}
export interface EvmAppState {
    networkKey?: string;
    chainId?: string;
    isConnected?: boolean;
    web3?: Web3;
    listenEvents?: string[];
}
export declare type RequestEvmProviderSend = JsonRpcPayload;
export interface ResponseEvmProviderSend {
    error: (Error | null);
    result?: JsonRpcResponse;
}
export declare enum EvmProviderErrorType {
    USER_REJECTED_REQUEST = "USER_REJECTED_REQUEST",
    UNAUTHORIZED = "UNAUTHORIZED",
    UNSUPPORTED_METHOD = "UNSUPPORTED_METHOD",
    DISCONNECTED = "DISCONNECTED",
    CHAIN_DISCONNECTED = "CHAIN_DISCONNECTED",
    INVALID_PARAMS = "INVALID_PARAMS",
    INTERNAL_ERROR = "INTERNAL_ERROR"
}
export interface EvmSendTransactionParams {
    from: string;
    to?: string;
    value?: string | number;
    gasLimit?: string | number;
    maxPriorityFeePerGas?: string | number;
    maxFeePerGas?: string | number;
    gasPrice?: string | number;
    data?: string;
}
export interface SwitchNetworkRequest {
    networkKey: string;
    address?: string;
}
export interface EvmSignRequest {
    account: AccountJson;
    hashPayload: string;
    canSign: boolean;
}
export interface EvmSignatureRequest extends EvmSignRequest {
    id: string;
    type: string;
    payload: unknown;
}
export interface EvmSendTransactionRequest extends TransactionConfig, EvmSignRequest {
    estimateGas: string;
    parseData: EvmTransactionData;
    isToContract: boolean;
}
export declare type EvmWatchTransactionRequest = EvmSendTransactionRequest;
export interface ConfirmationsQueueItemOptions {
    requiredPassword?: boolean;
    address?: string;
    networkKey?: string;
}
export interface ConfirmationsQueueItem<T> extends ConfirmationsQueueItemOptions, ConfirmationRequestBase {
    payload: T;
    payloadJson: string;
}
export interface ConfirmationResult<T> extends ConfirmationRequestBase {
    isApproved: boolean;
    payload?: T;
}
export interface EvmRequestExternal {
    hashPayload: string;
    canSign: boolean;
}
export interface EvmSendTransactionRequestExternal extends EvmSendTransactionRequest, EvmRequestExternal {
}
export interface EvmSignatureRequestExternal extends EvmSignatureRequest, EvmRequestExternal {
}
export interface AddNetworkRequestExternal {
    chainId: string;
    rpcUrls: string[];
    chainName: string;
    blockExplorerUrls?: string[];
    requestId?: string;
    nativeCurrency: {
        name: string;
        symbol: string;
        decimals: number;
    };
}
export interface AddNetworkExternalRequest {
    chainId: string;
    rpcUrl: string;
    chainName: string;
    blockExplorerUrl: string;
    requestId: string;
}
export interface AddTokenRequestExternal {
    slug?: string;
    contractAddress: string;
    originChain: string;
    type: _AssetType;
    name: string;
    symbol: string;
    decimals: number;
    validated: boolean;
    contractError: boolean;
}
export interface ConfirmationDefinitions {
    addNetworkRequest: [ConfirmationsQueueItem<_NetworkUpsertParams>, ConfirmationResult<null>];
    addTokenRequest: [ConfirmationsQueueItem<AddTokenRequestExternal>, ConfirmationResult<boolean>];
    switchNetworkRequest: [ConfirmationsQueueItem<SwitchNetworkRequest>, ConfirmationResult<boolean>];
    evmSignatureRequest: [ConfirmationsQueueItem<EvmSignatureRequest>, ConfirmationResult<string>];
    evmSendTransactionRequest: [ConfirmationsQueueItem<EvmSendTransactionRequest>, ConfirmationResult<string>];
    evmWatchTransactionRequest: [ConfirmationsQueueItem<EvmWatchTransactionRequest>, ConfirmationResult<string>];
}
export declare type ConfirmationType = keyof ConfirmationDefinitions;
export declare type ConfirmationsQueue = {
    [CT in ConfirmationType]: Record<string, ConfirmationDefinitions[CT][0]>;
};
export declare type RequestConfirmationsSubscribe = null;
export declare type RequestConfirmationComplete = {
    [CT in ConfirmationType]?: ConfirmationDefinitions[CT][1];
};
export interface BasicTxInfo {
    fee: string;
    balanceError: boolean;
    rawFee?: number;
}
export interface BondingOptionParams {
    chain: string;
    type: StakingType;
}
export interface SingleModeJson {
    networkKeys: string[];
    theme: ThemeNames;
    autoTriggerDomain: string;
}
export declare type NestedArray<T> = T | NestedArray<T>[];
export interface EvmTransactionArg {
    name: string;
    type: string;
    value: string;
    children?: EvmTransactionArg[];
}
export interface ParseEvmTransactionData {
    method: string;
    methodName: string;
    args: EvmTransactionArg[];
}
export interface RequestParseEvmContractInput {
    data: string;
    contract: string;
    chainId: number;
}
export declare type EvmTransactionData = ParseEvmTransactionData | string;
export interface ResponseParseEvmContractInput {
    result: EvmTransactionData;
}
export interface LedgerNetwork {
    genesisHash: string;
    networkName: string;
    accountName: string;
    appName: string;
    network: string;
    slug: string;
    icon: 'substrate' | 'ethereum';
    isDevMode: boolean;
    isEthereum: boolean;
}
export interface TransakNetwork {
    networks: string[];
    tokens?: string[];
}
export interface FormattedMethod {
    args?: ArgInfo[];
    methodName: string;
}
export interface ArgInfo {
    argName: string;
    argValue: string | string[];
}
export interface EraInfo {
    period: number;
    phase: number;
}
export interface ResponseParseTransactionSubstrate {
    era: EraInfo | string;
    nonce: number;
    method: string | FormattedMethod[];
    tip: number;
    specVersion: number;
    message: string;
}
export interface RequestParseTransactionSubstrate {
    data: string;
    networkKey: string;
}
export interface RequestQrParseRLP {
    data: string;
}
export interface ResponseQrParseRLP {
    data: EvmTransactionData;
    input: string;
    nonce: number;
    to: string;
    gas: number;
    gasPrice: number;
    value: number;
}
export interface RequestAccountIsLocked {
    address: string;
}
export interface ResponseAccountIsLocked {
    isLocked: boolean;
    remainingTime: number;
}
export declare type SignerDataType = 'transaction' | 'message';
export interface RequestQrSignSubstrate {
    address: string;
    data: string;
    networkKey: string;
}
export interface ResponseQrSignSubstrate {
    signature: string;
}
export interface RequestQrSignEvm {
    address: string;
    message: string;
    type: 'message' | 'transaction';
    chainId?: number;
}
export interface ResponseQrSignEvm {
    signature: string;
}
export interface RequestCheckTransfer extends BaseRequestSign {
    networkKey: string;
    from: string;
    to: string;
    value?: string;
    transferAll?: boolean;
    tokenSlug: string;
}
export interface ValidateTransactionResponse {
    errors: TransactionError[];
    warnings: TransactionWarning[];
    transferNativeAmount?: string;
}
export declare type RequestTransfer = InternalRequestSign<RequestCheckTransfer>;
export interface RequestCheckCrossChainTransfer extends BaseRequestSign {
    originNetworkKey: string;
    destinationNetworkKey: string;
    from: string;
    to: string;
    transferAll?: boolean;
    value: string;
    tokenSlug: string;
}
export declare type RequestCrossChainTransfer = InternalRequestSign<RequestCheckCrossChainTransfer>;
export interface ChainStakingMetadata {
    chain: string;
    type: StakingType;
    era: number;
    minJoinNominationPool?: string;
    minStake: string;
    maxValidatorPerNominator: number;
    maxWithdrawalRequestPerValidator: number;
    allowCancelUnstaking: boolean;
    unstakingPeriod: number;
    expectedReturn?: number;
    inflation?: number;
    nominatorCount?: number;
}
export interface NominationInfo {
    chain: string;
    validatorAddress: string;
    validatorIdentity?: string;
    activeStake: string;
    hasUnstaking?: boolean;
    validatorMinStake?: string;
    status: StakingStatus;
}
export interface PalletNominationPoolsBondedPoolInner {
    points: number;
    state: 'Open' | 'Destroying' | 'Locked';
    memberCounter: number;
    roles: {
        depositor: string;
        root: string;
        nominator: string;
        bouncer: string;
    };
}
export interface NominationPoolInfo extends Pick<PalletNominationPoolsBondedPoolInner, 'roles' | 'memberCounter' | 'state'> {
    id: number;
    address: string;
    name?: string;
    bondedAmount: string;
}
export declare enum UnstakingStatus {
    CLAIMABLE = "CLAIMABLE",
    UNLOCKING = "UNLOCKING"
}
export interface UnstakingInfo {
    chain: string;
    status: UnstakingStatus;
    claimable: string;
    waitingTime: number;
    validatorAddress?: string;
}
export declare enum StakingStatus {
    EARNING_REWARD = "EARNING_REWARD",
    PARTIALLY_EARNING = "PARTIALLY_EARNING",
    NOT_EARNING = "NOT_EARNING",
    WAITING = "WAITING",
    NOT_STAKING = "NOT_STAKING"
}
export interface NominatorMetadata {
    chain: string;
    type: StakingType;
    status: StakingStatus;
    address: string;
    activeStake: string;
    nominations: NominationInfo[];
    unstakings: UnstakingInfo[];
    isBondedBefore?: boolean;
}
export interface ValidatorInfo {
    address: string;
    chain: string;
    totalStake: string;
    ownStake: string;
    otherStake: string;
    minBond: string;
    nominatorCount: number;
    commission: number;
    expectedReturn?: number;
    blocked: boolean;
    identity?: string;
    isVerified: boolean;
    icon?: string;
    isCrowded: boolean;
}
export interface BondingSubmitParams extends BaseRequestSign {
    chain: string;
    type: StakingType;
    nominatorMetadata?: NominatorMetadata;
    amount: string;
    address: string;
    selectedValidators: ValidatorInfo[];
    lockPeriod?: number;
}
export declare type RequestBondingSubmit = InternalRequestSign<BondingSubmitParams>;
export interface UnbondingSubmitParams extends BaseRequestSign {
    amount: string;
    chain: string;
    nominatorMetadata: NominatorMetadata;
    validatorAddress?: string;
}
export declare type RequestUnbondingSubmit = InternalRequestSign<UnbondingSubmitParams>;
export interface StakeWithdrawalParams extends BaseRequestSign {
    nominatorMetadata: NominatorMetadata;
    unstakingInfo: UnstakingInfo;
    chain: string;
    validatorAddress?: string;
}
export declare type RequestStakeWithdrawal = InternalRequestSign<StakeWithdrawalParams>;
export interface StakeClaimRewardParams extends BaseRequestSign {
    address: string;
    chain: string;
    stakingType: StakingType;
    unclaimedReward?: string;
    bondReward?: boolean;
}
export declare type RequestStakeClaimReward = InternalRequestSign<StakeClaimRewardParams>;
export interface StakeCancelWithdrawalParams extends BaseRequestSign {
    address: string;
    chain: string;
    selectedUnstaking: UnstakingInfo;
}
export declare type RequestStakeCancelWithdrawal = InternalRequestSign<StakeCancelWithdrawalParams>;
export interface StakePoolingBondingParams extends BaseRequestSign {
    nominatorMetadata?: NominatorMetadata;
    chain: string;
    selectedPool: NominationPoolInfo;
    amount: string;
    address: string;
}
export declare type RequestStakePoolingBonding = InternalRequestSign<StakePoolingBondingParams>;
export interface StakePoolingUnbondingParams extends BaseRequestSign {
    nominatorMetadata: NominatorMetadata;
    chain: string;
    amount: string;
}
export declare type RequestStakePoolingUnbonding = InternalRequestSign<StakePoolingUnbondingParams>;
export interface DelegationItem {
    owner: string;
    amount: string;
    identity?: string;
    minBond: string;
    hasScheduledRequest: boolean;
    icon?: string;
}
export interface StakeDelegationRequest {
    address: string;
    networkKey: string;
}
export interface CheckExistingTuringCompoundParams {
    address: string;
    collatorAddress: string;
    networkKey: string;
}
export interface ExistingTuringCompoundTask {
    exist: boolean;
    taskId: string;
    accountMinimum: number;
    frequency: number;
}
export interface TuringStakeCompoundResp {
    txInfo: BasicTxInfo;
    optimalFrequency: string;
    initTime: number;
    compoundFee: string;
    rawCompoundFee?: number;
}
export interface TuringStakeCompoundParams extends BaseRequestSign {
    address: string;
    collatorAddress: string;
    networkKey: string;
    accountMinimum: string;
    bondedAmount: string;
}
export declare type RequestTuringStakeCompound = InternalRequestSign<TuringStakeCompoundParams>;
export interface TuringCancelStakeCompoundParams extends BaseRequestSign {
    taskId: string;
    networkKey: string;
    address: string;
}
export declare type RequestTuringCancelStakeCompound = InternalRequestSign<TuringCancelStakeCompoundParams>;
export declare type RequestTransferExternal = InternalRequestSign<RequestCheckTransfer>;
export declare type RequestCrossChainTransferExternal = InternalRequestSign<RequestCheckCrossChainTransfer>;
export declare type RequestNftTransferExternalSubstrate = InternalRequestSign<SubstrateNftSubmitTransaction>;
export declare type RequestNftTransferExternalEvm = InternalRequestSign<EvmNftSubmitTransaction>;
export declare type RequestStakeExternal = InternalRequestSign<BondingSubmitParams>;
export declare type RequestUnStakeExternal = InternalRequestSign<UnbondingSubmitParams>;
export declare type RequestWithdrawStakeExternal = InternalRequestSign<StakeWithdrawalParams>;
export declare type RequestClaimRewardExternal = InternalRequestSign<StakeClaimRewardParams>;
export declare type RequestCreateCompoundStakeExternal = InternalRequestSign<TuringStakeCompoundParams>;
export declare type RequestCancelCompoundStakeExternal = InternalRequestSign<TuringCancelStakeCompoundParams>;
export declare enum ChainEditStandard {
    EVM = "EVM",
    SUBSTRATE = "SUBSTRATE",
    UNKNOWN = "UNKNOWN",
    MIXED = "MIXED"
}
export declare type ChainEditInfo = {
    slug: string;
    currentProvider: string;
    providers: Record<string, string>;
    name: string;
    chainType: ChainEditStandard;
    blockExplorer?: string;
    crowdloanUrl?: string;
    priceId?: string;
    symbol: string;
};
export interface ChainSpecInfo {
    addressPrefix: number;
    genesisHash: string;
    paraId: number | null;
    evmChainId: number | null;
    existentialDeposit: string;
    decimals: number;
}
export interface KeyringState {
    isReady: boolean;
    hasMasterPassword: boolean;
    isLocked: boolean;
}
export interface UIViewState {
    isUILocked: boolean;
}
export interface AddressBookState {
    contacts: AddressJson[];
    recent: AddressJson[];
}
export interface RequestChangeMasterPassword {
    oldPassword?: string;
    newPassword: string;
    createNew: boolean;
}
export interface ResponseChangeMasterPassword {
    status: boolean;
    errors: string[];
}
export interface RequestMigratePassword {
    address: string;
    password: string;
}
export interface ResponseMigratePassword {
    status: boolean;
    errors: string[];
}
export interface RequestUnlockKeyring {
    password: string;
}
export interface ResponseUnlockKeyring {
    status: boolean;
    errors: string[];
}
export interface RequestKeyringExportMnemonic {
    address: string;
    password: string;
}
export interface ResponseKeyringExportMnemonic {
    result: string;
}
export interface RequestResetWallet {
    resetAll: boolean;
}
export interface ResponseResetWallet {
    status: boolean;
    errors: string[];
}
export interface RequestSigningApprovePasswordV2 {
    id: string;
}
export interface AssetSettingUpdateReq {
    tokenSlug: string;
    assetSetting: AssetSetting;
    autoEnableNativeToken?: boolean;
}
export interface RequestGetTransaction {
    id: string;
}
export declare type SubscriptionServiceType = 'chainRegistry' | 'balance' | 'crowdloan' | 'staking';
export declare type CronServiceType = 'price' | 'nft' | 'staking' | 'history' | 'recoverApi' | 'checkApiStatus';
export declare type CronType = 'recoverApiMap' | 'checkApiMapStatus' | 'refreshHistory' | 'refreshNft' | 'refreshPrice' | 'refreshStakeUnlockingInfo' | 'refreshStakingReward' | 'refreshPoolingStakingReward';
export interface RequestInitCronAndSubscription {
    subscription: {
        activeServices: SubscriptionServiceType[];
    };
    cron: {
        intervalMap: Partial<Record<CronType, number>>;
        activeServices: CronServiceType[];
    };
}
export interface RequestCronAndSubscriptionAction {
    subscriptionServices: SubscriptionServiceType[];
    cronServices: CronServiceType[];
}
export interface ActiveCronAndSubscriptionMap {
    subscription: Record<SubscriptionServiceType, boolean>;
    cron: Record<CronServiceType, boolean>;
}
export declare enum NotificationType {
    INFO = "info",
    SUCCESS = "success",
    WARNING = "warning",
    ERROR = "error"
}
export interface Notification {
    id: number;
    type: NotificationType;
    title: string;
    message: string;
    notifyViaBrowser?: boolean;
    action?: {
        url?: string;
    };
}
export declare type NotificationParams = Omit<Notification, 'id'>;
export interface CronReloadRequest {
    data: 'nft' | 'staking';
}
export interface AllLogoMap {
    chainLogoMap: Record<string, string>;
    assetLogoMap: Record<string, string>;
}
export interface PassPhishing {
    pass: boolean;
}
export interface RequestPassPhishingPage {
    url: string;
}
export interface RequestAddPspToken {
    genesisHash: string;
    tokenInfo: {
        type: string;
        address: string;
        symbol: string;
        name: string;
        decimals?: number;
        logo?: string;
    };
}
export interface RequestConnectWalletConnect {
    uri: string;
}
export interface RequestRejectConnectWalletSession {
    id: string;
}
export interface RequestApproveConnectWalletSession {
    id: string;
    accounts: string[];
}
export interface RequestReconnectConnectWalletSession {
    id: string;
}
export interface RequestDisconnectWalletConnectSession {
    topic: string;
}
export interface RequestRejectWalletConnectNotSupport {
    id: string;
}
export interface RequestApproveWalletConnectNotSupport {
    id: string;
}
export interface MantaPayConfig {
    address: string;
    zkAddress: string;
    enabled: boolean;
    chain: string;
    isInitialSync: boolean;
}
export interface MantaAuthorizationContext {
    address: string;
    chain: string;
    data: unknown;
}
export interface MantaPaySyncState {
    isSyncing: boolean;
    progress: number;
    needManualSync?: boolean;
}
export interface MantaPayEnableParams {
    password: string;
    address: string;
}
export declare enum MantaPayEnableMessage {
    WRONG_PASSWORD = "WRONG_PASSWORD",
    CHAIN_DISCONNECTED = "CHAIN_DISCONNECTED",
    UNKNOWN_ERROR = "UNKNOWN_ERROR",
    SUCCESS = "SUCCESS"
}
export interface MantaPayEnableResponse {
    success: boolean;
    message: MantaPayEnableMessage;
}
export interface RequestFindRawMetadata {
    genesisHash: string;
}
export interface ResponseFindRawMetadata {
    rawMetadata: string;
    specVersion: number;
}
export interface ResolveDomainRequest {
    chain: string;
    domain: string;
}
export interface ResolveAddressToDomainRequest {
    chain: string;
    address: string;
}
export interface KoniRequestSignatures {
    'pri(staking.submitTuringCancelCompound)': [RequestTuringCancelStakeCompound, SWTransactionResponse];
    'pri(staking.submitTuringCompound)': [RequestTuringStakeCompound, SWTransactionResponse];
    'pri(staking.submitClaimReward)': [RequestStakeClaimReward, SWTransactionResponse];
    'pri(staking.submitCancelWithdrawal)': [RequestStakeCancelWithdrawal, SWTransactionResponse];
    'pri(unbonding.submitWithdrawal)': [RequestStakeWithdrawal, SWTransactionResponse];
    'pri(unbonding.submitTransaction)': [RequestUnbondingSubmit, SWTransactionResponse];
    'pri(bonding.submitBondingTransaction)': [RequestBondingSubmit, SWTransactionResponse];
    'pri(bonding.subscribeChainStakingMetadata)': [null, ChainStakingMetadata[], ChainStakingMetadata[]];
    'pri(bonding.subscribeNominatorMetadata)': [null, NominatorMetadata[], NominatorMetadata[]];
    'pri(bonding.getBondingOptions)': [BondingOptionParams, ValidatorInfo[]];
    'pri(bonding.getNominationPoolOptions)': [string, NominationPoolInfo[]];
    'pri(bonding.nominationPool.submitBonding)': [RequestStakePoolingBonding, SWTransactionResponse];
    'pri(bonding.nominationPool.submitUnbonding)': [RequestStakePoolingUnbonding, SWTransactionResponse];
    'pri(chainService.subscribeChainInfoMap)': [null, Record<string, any>, Record<string, any>];
    'pri(chainService.subscribeChainStateMap)': [null, Record<string, any>, Record<string, any>];
    'pri(chainService.subscribeAssetRegistry)': [null, Record<string, any>, Record<string, any>];
    'pri(chainService.subscribeMultiChainAssetMap)': [null, Record<string, _MultiChainAsset>, Record<string, _MultiChainAsset>];
    'pri(chainService.subscribeXcmRefMap)': [null, Record<string, _AssetRef>, Record<string, _AssetRef>];
    'pri(chainService.upsertChain)': [_NetworkUpsertParams, boolean];
    'pri(chainService.enableChains)': [EnableMultiChainParams, boolean];
    'pri(chainService.enableChain)': [EnableChainParams, boolean];
    'pri(chainService.reconnectChain)': [string, boolean];
    'pri(chainService.disableChains)': [string[], boolean];
    'pri(chainService.disableChain)': [string, boolean];
    'pri(chainService.removeChain)': [string, boolean];
    'pri(chainService.deleteCustomAsset)': [string, boolean];
    'pri(chainService.upsertCustomAsset)': [Record<string, any>, boolean];
    'pri(chainService.validateCustomAsset)': [_ValidateCustomAssetRequest, _ValidateCustomAssetResponse];
    'pri(chainService.resetDefaultChains)': [null, boolean];
    'pri(chainService.getSupportedContractTypes)': [null, string[]];
    'pri(chainService.validateCustomChain)': [ValidateNetworkRequest, ValidateNetworkResponse];
    'pri(chainService.recoverSubstrateApi)': [string, boolean];
    'pri(chainService.disableAllChains)': [null, boolean];
    'pri(assetSetting.getSubscription)': [null, Record<string, AssetSetting>, Record<string, AssetSetting>];
    'pri(assetSetting.update)': [AssetSettingUpdateReq, boolean];
    'pri(evmNft.submitTransaction)': [NftTransactionRequest, SWTransactionResponse];
    'pri(evmNft.getTransaction)': [NftTransactionRequest, EvmNftTransaction];
    'pri(substrateNft.submitTransaction)': [NftTransactionRequest, SWTransactionResponse];
    'pri(substrateNft.getTransaction)': [NftTransactionRequest, SubstrateNftTransaction];
    'pri(nft.getNft)': [null, NftJson];
    'pri(nft.getSubscription)': [RequestSubscribeNft, NftJson, NftJson];
    'pri(nftCollection.getNftCollection)': [null, NftCollectionJson];
    'pri(nftCollection.getSubscription)': [null, NftCollection[], NftCollection[]];
    'pri(staking.getStaking)': [null, StakingJson];
    'pri(staking.getSubscription)': [RequestSubscribeStaking, StakingJson, StakingJson];
    'pri(stakingReward.getStakingReward)': [null, StakingRewardJson];
    'pri(stakingReward.getSubscription)': [RequestSubscribeStakingReward, StakingRewardJson, StakingRewardJson];
    'pri(price.getPrice)': [RequestPrice, PriceJson];
    'pri(price.getSubscription)': [RequestSubscribePrice, PriceJson, PriceJson];
    'pri(balance.getBalance)': [RequestBalance, BalanceJson];
    'pri(balance.getSubscription)': [RequestSubscribeBalance, BalanceJson, BalanceJson];
    'pri(crowdloan.getCrowdloan)': [RequestCrowdloan, CrowdloanJson];
    'pri(crowdloan.getSubscription)': [RequestSubscribeCrowdloan, CrowdloanJson, CrowdloanJson];
    'pri(phishing.pass)': [RequestPassPhishingPage, boolean];
    'pri(mantaPay.enable)': [MantaPayEnableParams, MantaPayEnableResponse];
    'pri(mantaPay.disable)': [string, boolean];
    'pri(mantaPay.getZkBalance)': [null, null];
    'pri(mantaPay.subscribeConfig)': [null, MantaPayConfig[], MantaPayConfig[]];
    'pri(mantaPay.subscribeSyncingState)': [null, MantaPaySyncState, MantaPaySyncState];
    'pri(mantaPay.initSyncMantaPay)': [string, null];
    'pri(authorize.listV2)': [null, ResponseAuthorizeList];
    'pri(authorize.requestsV2)': [RequestAuthorizeSubscribe, AuthorizeRequest[], AuthorizeRequest[]];
    'pri(authorize.approveV2)': [RequestAuthorizeApproveV2, boolean];
    'pri(authorize.changeSiteAll)': [RequestAuthorizationAll, boolean, AuthUrls];
    'pri(authorize.changeSite)': [RequestAuthorization, boolean, AuthUrls];
    'pri(authorize.changeSitePerAccount)': [RequestAuthorizationPerAccount, boolean, AuthUrls];
    'pri(authorize.changeSitePerSite)': [RequestAuthorizationPerSite, boolean];
    'pri(authorize.changeSiteBlock)': [RequestAuthorizationBlock, boolean];
    'pri(authorize.forgetSite)': [RequestForgetSite, boolean, AuthUrls];
    'pri(authorize.forgetAllSite)': [null, boolean, AuthUrls];
    'pri(authorize.rejectV2)': [RequestAuthorizeReject, boolean];
    'pri(authorize.cancelV2)': [RequestAuthorizeCancel, boolean];
    'pri(seed.validateV2)': [RequestSeedValidateV2, ResponseSeedValidateV2];
    'pri(privateKey.validateV2)': [RequestSeedValidateV2, ResponsePrivateKeyValidateV2];
    'pri(accounts.checkPublicAndSecretKey)': [RequestCheckPublicAndSecretKey, ResponseCheckPublicAndSecretKey];
    'pri(seed.createV2)': [RequestSeedCreateV2, ResponseSeedCreateV2];
    'pri(accounts.create.suriV2)': [RequestAccountCreateSuriV2, ResponseAccountCreateSuriV2];
    'pri(accounts.create.externalV2)': [RequestAccountCreateExternalV2, AccountExternalError[]];
    'pri(accounts.create.hardwareV2)': [RequestAccountCreateHardwareV2, boolean];
    'pri(accounts.create.hardwareMultiple)': [RequestAccountCreateHardwareMultiple, boolean];
    'pri(accounts.create.withSecret)': [RequestAccountCreateWithSecretKey, ResponseAccountCreateWithSecretKey];
    'pri(accounts.inject.add)': [RequestAddInjectedAccounts, boolean];
    'pri(accounts.inject.remove)': [RequestRemoveInjectedAccounts, boolean];
    'pri(derivation.createV2)': [RequestDeriveCreateV2, boolean];
    'pri(json.restoreV2)': [RequestJsonRestoreV2, void];
    'pri(json.batchRestoreV2)': [RequestBatchRestoreV2, void];
    'pri(accounts.exportPrivateKey)': [RequestAccountExportPrivateKey, ResponseAccountExportPrivateKey];
    'pri(accounts.subscribeWithCurrentAddress)': [RequestAccountSubscribe, AccountsWithCurrentAddress, AccountsWithCurrentAddress];
    'pri(accounts.updateCurrentAddress)': [string, boolean];
    'pri(currentAccount.saveAddress)': [RequestCurrentAccountAddress, CurrentAccountInfo];
    'pri(accounts.get.meta)': [RequestAccountMeta, ResponseAccountMeta];
    'pri(accounts.saveRecent)': [RequestSaveRecentAccount, KeyringAddress];
    'pri(accounts.subscribeAddresses)': [null, AddressBookInfo, AddressBookInfo];
    'pri(accounts.editContact)': [RequestEditContactAccount, boolean];
    'pri(accounts.deleteContact)': [RequestDeleteContactAccount, boolean];
    'pri(accounts.resolveDomainToAddress)': [ResolveDomainRequest, string | undefined];
    'pri(accounts.resolveAddressToDomain)': [ResolveAddressToDomainRequest, string | undefined];
    'pri(accounts.subscribeAccountsInputAddress)': [RequestAccountSubscribe, string, OptionInputAddress];
    'pri(settings.changeBalancesVisibility)': [null, boolean];
    'pri(settings.subscribe)': [null, UiSettings, UiSettings];
    'pri(settings.getLogoMaps)': [null, AllLogoMap];
    'pri(settings.saveAccountAllLogo)': [string, boolean, UiSettings];
    'pri(settings.saveTheme)': [ThemeNames, boolean];
    'pri(settings.saveBrowserConfirmationType)': [BrowserConfirmationType, boolean];
    'pri(settings.saveCamera)': [RequestCameraSettings, boolean];
    'pri(settings.saveAutoLockTime)': [RequestChangeTimeAutoLock, boolean];
    'pri(settings.saveUnlockType)': [RequestUnlockType, boolean];
    'pri(settings.saveEnableChainPatrol)': [RequestChangeEnableChainPatrol, boolean];
    'pri(settings.saveLanguage)': [RequestChangeLanguage, boolean];
    'pri(settings.saveShowZeroBalance)': [RequestChangeShowZeroBalance, boolean];
    'pri(settings.saveShowBalance)': [RequestChangeShowBalance, boolean];
    'pri(transaction.history.getSubscription)': [null, TransactionHistoryItem[], TransactionHistoryItem[]];
    'pri(transfer.checkReferenceCount)': [RequestTransferCheckReferenceCount, boolean];
    'pri(transfer.checkSupporting)': [RequestTransferCheckSupporting, SupportTransferResponse];
    'pri(transfer.getExistentialDeposit)': [RequestTransferExistentialDeposit, string];
    'pri(transfer.getMaxTransferable)': [RequestMaxTransferable, AmountData];
    'pri(subscription.cancel)': [string, boolean];
    'pri(freeBalance.get)': [RequestFreeBalance, AmountData];
    'pri(freeBalance.subscribe)': [RequestFreeBalance, AmountData, AmountData];
    'pri(accounts.checkTransfer)': [RequestCheckTransfer, ValidateTransactionResponse];
    'pri(accounts.transfer)': [RequestTransfer, SWTransactionResponse];
    'pri(accounts.checkCrossChainTransfer)': [RequestCheckCrossChainTransfer, ValidateTransactionResponse];
    'pri(accounts.crossChainTransfer)': [RequestCrossChainTransfer, SWTransactionResponse];
    'pri(confirmations.subscribe)': [RequestConfirmationsSubscribe, ConfirmationsQueue, ConfirmationsQueue];
    'pri(confirmations.complete)': [RequestConfirmationComplete, boolean];
    'pub(utils.getRandom)': [RandomTestRequest, number];
    'pub(accounts.listV2)': [RequestAccountList, InjectedAccount[]];
    'pub(accounts.subscribeV2)': [RequestAccountSubscribe, string, InjectedAccount[]];
    'pub(accounts.unsubscribe)': [RequestAccountUnsubscribe, boolean];
    'pri(account.isLocked)': [RequestAccountIsLocked, ResponseAccountIsLocked];
    'pri(qr.transaction.parse.substrate)': [RequestParseTransactionSubstrate, ResponseParseTransactionSubstrate];
    'pri(qr.transaction.parse.evm)': [RequestQrParseRLP, ResponseQrParseRLP];
    'pri(qr.sign.substrate)': [RequestQrSignSubstrate, ResponseQrSignSubstrate];
    'pri(qr.sign.evm)': [RequestQrSignEvm, ResponseQrSignEvm];
    'pri(account.external.reject)': [RequestRejectExternalRequest, ResponseRejectExternalRequest];
    'pri(account.external.resolve)': [RequestResolveExternalRequest, ResponseResolveExternalRequest];
    'evm(events.subscribe)': [RequestEvmEvents, boolean, EvmEvent];
    'evm(request)': [RequestArguments, unknown];
    'evm(provider.send)': [RequestEvmProviderSend, string | number, ResponseEvmProviderSend];
    'pri(evm.transaction.parse.input)': [RequestParseEvmContractInput, ResponseParseEvmContractInput];
    'pri(authorize.subscribe)': [null, AuthUrls, AuthUrls];
    'pri(keyring.subscribe)': [null, KeyringState, KeyringState];
    'pri(keyring.change)': [RequestChangeMasterPassword, ResponseChangeMasterPassword];
    'pri(keyring.migrate)': [RequestMigratePassword, ResponseMigratePassword];
    'pri(keyring.unlock)': [RequestUnlockKeyring, ResponseUnlockKeyring];
    'pri(keyring.lock)': [null, void];
    'pri(keyring.export.mnemonic)': [RequestKeyringExportMnemonic, ResponseKeyringExportMnemonic];
    'pri(keyring.reset)': [RequestResetWallet, ResponseResetWallet];
    'pri(signing.approve.passwordV2)': [RequestSigningApprovePasswordV2, boolean];
    'pri(derivation.validateV2)': [RequestDeriveValidateV2, ResponseDeriveValidateV2];
    'pri(derivation.getList)': [RequestGetDeriveAccounts, ResponseGetDeriveAccounts];
    'pri(derivation.create.multiple)': [RequestDeriveCreateMultiple, boolean];
    'pri(derivation.createV3)': [RequestDeriveCreateV3, boolean];
    'pri(transactions.getOne)': [RequestGetTransaction, SWTransactionResult];
    'pri(transactions.subscribe)': [null, Record<string, SWTransactionResult>, Record<string, SWTransactionResult>];
    'pri(notifications.subscribe)': [null, Notification[], Notification[]];
    'pri(cron.reload)': [CronReloadRequest, boolean];
    'mobile(ping)': [null, string];
    'mobile(cronAndSubscription.init)': [RequestInitCronAndSubscription, ActiveCronAndSubscriptionMap];
    'mobile(cronAndSubscription.activeService.subscribe)': [null, ActiveCronAndSubscriptionMap, ActiveCronAndSubscriptionMap];
    'mobile(cronAndSubscription.start)': [RequestCronAndSubscriptionAction, void];
    'mobile(cronAndSubscription.stop)': [RequestCronAndSubscriptionAction, void];
    'mobile(cronAndSubscription.restart)': [RequestCronAndSubscriptionAction, void];
    'mobile(cron.start)': [CronServiceType[], void];
    'mobile(cron.stop)': [CronServiceType[], void];
    'mobile(cron.restart)': [CronServiceType[], void];
    'mobile(subscription.start)': [SubscriptionServiceType[], void];
    'mobile(subscription.stop)': [SubscriptionServiceType[], void];
    'mobile(subscription.restart)': [SubscriptionServiceType[], void];
    'pub(token.add)': [RequestAddPspToken, boolean];
    'pri(walletConnect.connect)': [RequestConnectWalletConnect, boolean];
    'pri(walletConnect.requests.connect.subscribe)': [null, WalletConnectSessionRequest[], WalletConnectSessionRequest[]];
    'pri(walletConnect.session.approve)': [RequestApproveConnectWalletSession, boolean];
    'pri(walletConnect.session.reject)': [RequestRejectConnectWalletSession, boolean];
    'pri(walletConnect.session.reconnect)': [RequestReconnectConnectWalletSession, boolean];
    'pri(walletConnect.session.subscribe)': [null, SessionTypes.Struct[], SessionTypes.Struct[]];
    'pri(walletConnect.session.disconnect)': [RequestDisconnectWalletConnectSession, boolean];
    'pri(walletConnect.requests.notSupport.subscribe)': [null, WalletConnectNotSupportRequest[], WalletConnectNotSupportRequest[]];
    'pri(walletConnect.notSupport.approve)': [RequestApproveWalletConnectNotSupport, boolean];
    'pri(walletConnect.notSupport.reject)': [RequestRejectWalletConnectNotSupport, boolean];
    'pri(metadata.find)': [RequestFindRawMetadata, ResponseFindRawMetadata];
}
export interface ApplicationMetadataType {
    version: string;
}
export declare type OSType = 'Mac OS' | 'iOS' | 'Windows' | 'Android' | 'Linux' | 'Unknown';
export declare const MobileOS: OSType[];