import '@polkadot/api-base/types/storage';
import type { ApiTypes, AugmentedQuery, QueryableStorageEntry } from '@polkadot/api-base/types';
import type { Data } from '@polkadot/types';
import type { BTreeMap, BTreeSet, Bytes, Null, Option, U256, U8aFixed, Vec, bool, i128, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
import type { AnyNumber, ITuple } from '@polkadot/types-codec/types';
import type { AccountId32, Call, H160, H256, Permill } from '@polkadot/types/interfaces/runtime';
import type { BitcoinAddress, BitcoinAddressPublicKey, BitcoinBlockChain, BitcoinH256Le, BtcRelayRichBlockHeader, ClientsInfoClientRelease, CollatorSelectionCandidateInfo, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCodeUpgradeAuthorization, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, DemocracyReferendumInfo, DemocracyVoting, DexGeneralPrimitivesPairStatus, DexStablePrimitivesPool, EscrowLockedBalance, EscrowPoint, EthereumBlock, EthereumReceiptReceiptV3, EthereumTransactionTransactionV2, FarmingRewardSchedule, FeeVersion, FpRpcTransactionStatus, FrameSupportDispatchPerDispatchClassWeight, FrameSupportPreimagesBounded, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, InterbtcPrimitivesCurrencyId, InterbtcPrimitivesIssueIssueRequest, InterbtcPrimitivesOracleKey, InterbtcPrimitivesRedeemRedeemRequest, InterbtcPrimitivesReplaceReplaceRequest, InterbtcPrimitivesVaultCurrencyPair, InterbtcPrimitivesVaultId, InterlayRuntimeParachainSessionKeys, IssueVersion, LoansBorrowSnapshot, LoansMarket, LoansRewardMarketState, LoansVersions, OracleTimestampedValue, OracleVersion, OrmlTokensAccountData, OrmlTokensBalanceLock, OrmlTokensReserveData, OrmlTraitsAssetRegistryAssetMetadata, OrmlVestingVestingSchedule, PalletCollectiveVotes, PalletEvmCodeMetadata, PalletIdentityRegistrarInfo, PalletIdentityRegistration, PalletMultisigMultisig, PalletPreimageRequestStatus, PalletProxyAnnouncement, PalletProxyProxyDefinition, PalletSchedulerScheduled, PalletTransactionPaymentReleases, PalletXcmQueryStatus, PalletXcmRemoteLockedFungibleRecord, PalletXcmVersionMigrationStage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV4AbridgedHostConfiguration, PolkadotPrimitivesV4PersistedValidationData, PolkadotPrimitivesV4UpgradeRestriction, RedeemVersion, ReplaceVersion, SpConsensusAuraSr25519AppSr25519Public, SpCoreCryptoKeyTypeId, SpRuntimeDigest, SpTrieStorageProof, SpWeightsWeightV2Weight, VaultRegistrySystemVault, VaultRegistryVault, VaultRegistryVersion, XcmV3MultiLocation, XcmVersionedAssetId, XcmVersionedMultiLocation } from '@polkadot/types/lookup';
import type { Observable } from '@polkadot/types/types';
export type __AugmentedQuery<ApiType extends ApiTypes> = AugmentedQuery<ApiType, () => unknown>;
export type __QueryableStorageEntry<ApiType extends ApiTypes> = QueryableStorageEntry<ApiType>;
declare module '@polkadot/api-base/types/storage' {
    interface AugmentedQueries<ApiType extends ApiTypes> {
        assetRegistry: {
            /**
             * The last processed asset id - used when assigning a sequential id.
             **/
            lastAssetId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Maps a multilocation to an asset id - useful when processing xcm
             * messages.
             **/
            locationToAssetId: AugmentedQuery<ApiType, (arg: XcmV3MultiLocation | {
                parents?: any;
                interior?: any;
            } | string | Uint8Array) => Observable<Option<u32>>, [XcmV3MultiLocation]> & QueryableStorageEntry<ApiType, [XcmV3MultiLocation]>;
            /**
             * The metadata of an asset, indexed by asset id.
             **/
            metadata: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<OrmlTraitsAssetRegistryAssetMetadata>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        aura: {
            /**
             * The current authority set.
             **/
            authorities: AugmentedQuery<ApiType, () => Observable<Vec<SpConsensusAuraSr25519AppSr25519Public>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The current slot of this block.
             *
             * This will be set in `on_initialize`.
             **/
            currentSlot: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        auraExt: {
            /**
             * Serves as cache for the authorities.
             *
             * The authorities in AuRa are overwritten in `on_initialize` when we switch to a new session,
             * but we require the old authorities to verify the seal when validating a PoV. This will always
             * be updated to the latest AuRa authorities in `on_finalize`.
             **/
            authorities: AugmentedQuery<ApiType, () => Observable<Vec<SpConsensusAuraSr25519AppSr25519Public>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        authorship: {
            /**
             * Author of current block.
             **/
            author: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        baseFee: {
            baseFeePerGas: AugmentedQuery<ApiType, () => Observable<U256>, []> & QueryableStorageEntry<ApiType, []>;
            elasticity: AugmentedQuery<ApiType, () => Observable<Permill>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        btcRelay: {
            /**
             * Store the current blockchain tip
             **/
            bestBlock: AugmentedQuery<ApiType, () => Observable<BitcoinH256Le>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Store the height of the best block
             **/
            bestBlockHeight: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Store Bitcoin block headers
             **/
            blockHeaders: AugmentedQuery<ApiType, (arg: BitcoinH256Le | {
                content?: any;
            } | string | Uint8Array) => Observable<BtcRelayRichBlockHeader>, [BitcoinH256Le]> & QueryableStorageEntry<ApiType, [BitcoinH256Le]>;
            /**
             * Increment-only counter used to track new BlockChain entries
             **/
            chainCounter: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Priority queue of BlockChain elements, ordered by the maximum height (descending).
             * The first index into this mapping (0) is considered to be the longest chain. The value
             * of the entry is the index into `ChainsIndex` to retrieve the `BlockChain`.
             **/
            chains: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Stores a mapping from (chain_index, block_height) to block hash
             **/
            chainsHashes: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<BitcoinH256Le>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
            /**
             * Auxiliary mapping of chains ids to `BlockChain` entries. The first index into this
             * mapping (0) is considered to be the Bitcoin main chain.
             **/
            chainsIndex: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<BitcoinBlockChain>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Whether the module should perform difficulty checks.
             **/
            disableDifficultyCheck: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Whether the module should perform inclusion checks.
             **/
            disableInclusionCheck: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Global security parameter k for stable Bitcoin transactions
             **/
            stableBitcoinConfirmations: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Global security parameter k for stable Parachain transactions
             **/
            stableParachainConfirmations: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * BTC height when the relay was initialized
             **/
            startBlockHeight: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        clientsInfo: {
            /**
             * Mapping of client name (string literal represented as bytes) to its release details.
             **/
            currentClientReleases: AugmentedQuery<ApiType, (arg: Bytes | string | Uint8Array) => Observable<Option<ClientsInfoClientRelease>>, [Bytes]> & QueryableStorageEntry<ApiType, [Bytes]>;
            /**
             * Mapping of client name (string literal represented as bytes) to its pending release details.
             **/
            pendingClientReleases: AugmentedQuery<ApiType, (arg: Bytes | string | Uint8Array) => Observable<Option<ClientsInfoClientRelease>>, [Bytes]> & QueryableStorageEntry<ApiType, [Bytes]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        collatorSelection: {
            /**
             * Fixed amount to deposit to become a collator.
             *
             * When a collator calls `leave_intent` they immediately receive the deposit back.
             **/
            candidacyBond: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The (community, limited) collation candidates.
             **/
            candidates: AugmentedQuery<ApiType, () => Observable<Vec<CollatorSelectionCandidateInfo>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Desired number of candidates.
             *
             * This should ideally always be less than [`Config::MaxCandidates`] for weights to be correct.
             **/
            desiredCandidates: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The invulnerable, fixed collators.
             **/
            invulnerables: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Last block authored by collator.
             **/
            lastAuthoredBlock: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u32>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        democracy: {
            /**
             * Those who have locked a deposit.
             *
             * TWOX-NOTE: Safe, as increasing integer keys are safe.
             **/
            depositOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[Vec<AccountId32>, u128]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * The lowest referendum index representing an unbaked referendum. Equal to
             * `ReferendumCount` if there isn't a unbaked referendum.
             **/
            lowestUnbaked: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            nextLaunchTimestamp: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The number of (public) proposals that have been made so far.
             **/
            publicPropCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The public proposals. Unsorted. The second item is the proposal.
             **/
            publicProps: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, FrameSupportPreimagesBounded, AccountId32]>>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The next free referendum index, aka the number of referenda started so far.
             **/
            referendumCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Information concerning any given referendum.
             *
             * TWOX-NOTE: SAFE as indexes are not under an attacker’s control.
             **/
            referendumInfoOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<DemocracyReferendumInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * All votes for a particular voter. We store the balance for the number of votes that we
             * have recorded.
             *
             * TWOX-NOTE: SAFE as `AccountId`s are crypto hashes anyway.
             **/
            votingOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<DemocracyVoting>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        dexGeneral: {
            /**
             * End status of bootstrap
             *
             * BootstrapEndStatus: map bootstrap pair => pairStatus
             **/
            bootstrapEndStatus: AugmentedQuery<ApiType, (arg: ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]> | [InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array]) => Observable<DexGeneralPrimitivesPairStatus>, [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>]> & QueryableStorageEntry<ApiType, [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>]>;
            bootstrapLimits: AugmentedQuery<ApiType, (arg: ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]> | [InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array]) => Observable<BTreeMap<InterbtcPrimitivesCurrencyId, u128>>, [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>]> & QueryableStorageEntry<ApiType, [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>]>;
            bootstrapPersonalSupply: AugmentedQuery<ApiType, (arg: ITuple<[ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>, AccountId32]> | [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]> | [InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array], AccountId32 | string | Uint8Array]) => Observable<ITuple<[u128, u128]>>, [ITuple<[ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>, AccountId32]>]> & QueryableStorageEntry<ApiType, [ITuple<[ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>, AccountId32]>]>;
            bootstrapRewards: AugmentedQuery<ApiType, (arg: ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]> | [InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array]) => Observable<BTreeMap<InterbtcPrimitivesCurrencyId, u128>>, [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>]> & QueryableStorageEntry<ApiType, [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>]>;
            feeMeta: AugmentedQuery<ApiType, () => Observable<ITuple<[Option<AccountId32>, u8]>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Refer: https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2Pair.sol#L88
             * Last unliquidated protocol fee;
             **/
            kLast: AugmentedQuery<ApiType, (arg: ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]> | [InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array]) => Observable<U256>, [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>]> & QueryableStorageEntry<ApiType, [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>]>;
            liquidityPairs: AugmentedQuery<ApiType, (arg: ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]> | [InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array]) => Observable<Option<InterbtcPrimitivesCurrencyId>>, [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>]> & QueryableStorageEntry<ApiType, [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>]>;
            /**
             * (T::AssetId, T::AssetId) -> PairStatus
             **/
            pairStatuses: AugmentedQuery<ApiType, (arg: ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]> | [InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array]) => Observable<DexGeneralPrimitivesPairStatus>, [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>]> & QueryableStorageEntry<ApiType, [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        dexStable: {
            /**
             * The pool id corresponding to lp currency
             **/
            lpCurrencies: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<Option<u32>>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * The id of next pool
             **/
            nextPoolId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Info of a pool.
             **/
            pools: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<DexStablePrimitivesPool>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        dmpQueue: {
            /**
             * The configuration.
             **/
            configuration: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Counter for the related counted storage map
             **/
            counterForOverweight: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The overweight messages.
             **/
            overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
            /**
             * The page index.
             **/
            pageIndex: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueuePageIndexData>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The queue pages.
             **/
            pages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, Bytes]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        escrow: {
            blocks: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<bool>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            epoch: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            limits: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<ITuple<[u32, u32]>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            locked: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<EscrowLockedBalance>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            pointHistory: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<EscrowPoint>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            reserved: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u128>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            slopeChanges: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            userPointEpoch: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u32>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            userPointHistory: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<EscrowPoint>, [AccountId32, u32]> & QueryableStorageEntry<ApiType, [AccountId32, u32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        escrowAnnuity: {
            rewardPerBlock: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            rewardPerWrapped: AugmentedQuery<ApiType, () => Observable<Option<u128>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        escrowRewards: {
            /**
             * Track the currencies used for rewards.
             **/
            rewardCurrencies: AugmentedQuery<ApiType, (arg: Null | null) => Observable<BTreeSet<InterbtcPrimitivesCurrencyId>>, [Null]> & QueryableStorageEntry<ApiType, [Null]>;
            /**
             * Used to compute the rewards for a participant's stake.
             **/
            rewardPerToken: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: Null | null) => Observable<i128>, [InterbtcPrimitivesCurrencyId, Null]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, Null]>;
            /**
             * Accounts for previous changes in stake size.
             **/
            rewardTally: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: ITuple<[Null, AccountId32]> | [Null | null, AccountId32 | string | Uint8Array]) => Observable<i128>, [InterbtcPrimitivesCurrencyId, ITuple<[Null, AccountId32]>]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, ITuple<[Null, AccountId32]>]>;
            /**
             * The stake of a participant in this reward pool.
             **/
            stake: AugmentedQuery<ApiType, (arg: ITuple<[Null, AccountId32]> | [Null | null, AccountId32 | string | Uint8Array]) => Observable<i128>, [ITuple<[Null, AccountId32]>]> & QueryableStorageEntry<ApiType, [ITuple<[Null, AccountId32]>]>;
            /**
             * The total unclaimed rewards distributed to this reward pool.
             * NOTE: this is currently only used for integration tests.
             **/
            totalRewards: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<i128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * The total stake deposited to this reward pool.
             **/
            totalStake: AugmentedQuery<ApiType, (arg: Null | null) => Observable<i128>, [Null]> & QueryableStorageEntry<ApiType, [Null]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        ethereum: {
            blockHash: AugmentedQuery<ApiType, (arg: U256 | AnyNumber | Uint8Array) => Observable<H256>, [U256]> & QueryableStorageEntry<ApiType, [U256]>;
            /**
             * The current Ethereum block.
             **/
            currentBlock: AugmentedQuery<ApiType, () => Observable<Option<EthereumBlock>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The current Ethereum receipts.
             **/
            currentReceipts: AugmentedQuery<ApiType, () => Observable<Option<Vec<EthereumReceiptReceiptV3>>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The current transaction statuses.
             **/
            currentTransactionStatuses: AugmentedQuery<ApiType, () => Observable<Option<Vec<FpRpcTransactionStatus>>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Current building block's transactions and receipts.
             **/
            pending: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[EthereumTransactionTransactionV2, FpRpcTransactionStatus, EthereumReceiptReceiptV3]>>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        evm: {
            accountCodes: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Bytes>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;
            accountCodesMetadata: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<PalletEvmCodeMetadata>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;
            accountStorages: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H256 | string | Uint8Array) => Observable<H256>, [H160, H256]> & QueryableStorageEntry<ApiType, [H160, H256]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        evmChainId: {
            /**
             * The EVM chain ID.
             **/
            chainId: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        farming: {
            rewardSchedules: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<FarmingRewardSchedule>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        farmingRewards: {
            /**
             * Track the currencies used for rewards.
             **/
            rewardCurrencies: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<BTreeSet<InterbtcPrimitivesCurrencyId>>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Used to compute the rewards for a participant's stake.
             **/
            rewardPerToken: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<i128>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>;
            /**
             * Accounts for previous changes in stake size.
             **/
            rewardTally: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: ITuple<[InterbtcPrimitivesCurrencyId, AccountId32]> | [InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, AccountId32 | string | Uint8Array]) => Observable<i128>, [InterbtcPrimitivesCurrencyId, ITuple<[InterbtcPrimitivesCurrencyId, AccountId32]>]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, ITuple<[InterbtcPrimitivesCurrencyId, AccountId32]>]>;
            /**
             * The stake of a participant in this reward pool.
             **/
            stake: AugmentedQuery<ApiType, (arg: ITuple<[InterbtcPrimitivesCurrencyId, AccountId32]> | [InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, AccountId32 | string | Uint8Array]) => Observable<i128>, [ITuple<[InterbtcPrimitivesCurrencyId, AccountId32]>]> & QueryableStorageEntry<ApiType, [ITuple<[InterbtcPrimitivesCurrencyId, AccountId32]>]>;
            /**
             * The total unclaimed rewards distributed to this reward pool.
             * NOTE: this is currently only used for integration tests.
             **/
            totalRewards: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<i128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * The total stake deposited to this reward pool.
             **/
            totalStake: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<i128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        fee: {
            /**
             * The fraction up rewards going straight to the vault operator. The rest goes to the vault's pool.
             **/
            commission: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array) => Observable<Option<u128>>, [InterbtcPrimitivesVaultId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesVaultId]>;
            /**
             * # Issue
             * Fee share that users need to pay to issue tokens.
             **/
            issueFee: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Default griefing collateral (e.g. DOT/KSM) as a percentage of the locked
             * collateral of a Vault a user has to lock to issue tokens.
             **/
            issueGriefingCollateral: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * # Vault Registry
             * If users execute a redeem with a Vault flagged for premium redeem,
             * they can earn a collateral premium, slashed from the Vault.
             **/
            premiumRedeemFee: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Fee that a Vault has to pay if it fails to execute redeem or replace requests
             * (for redeem, on top of the slashed value of the request). The fee is
             * paid in collateral based on the token amount at the current exchange rate.
             **/
            punishmentFee: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * # Redeem
             * Fee share that users need to pay to redeem tokens.
             **/
            redeemFee: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * # Replace
             * Default griefing collateral (e.g. DOT/KSM) as a percentage of the to-be-locked collateral
             * of the new Vault. This collateral will be slashed and allocated to the replacing Vault
             * if the to-be-replaced Vault does not transfer BTC on time.
             **/
            replaceGriefingCollateral: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Build storage at V1 (requires default 0).
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<FeeVersion>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        identity: {
            /**
             * Information that is pertinent to identify the entity behind an account.
             *
             * TWOX-NOTE: OK ― `AccountId` is a secure hash.
             **/
            identityOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletIdentityRegistration>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * The set of registrars. Not expected to get very big as can only be added through a
             * special origin (likely a council motion).
             *
             * The index into this can be cast to `RegistrarIndex` to get a valid value.
             **/
            registrars: AugmentedQuery<ApiType, () => Observable<Vec<Option<PalletIdentityRegistrarInfo>>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Alternative "sub" identities of this account.
             *
             * The first item is the deposit, the second is a vector of the accounts.
             *
             * TWOX-NOTE: OK ― `AccountId` is a secure hash.
             **/
            subsOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[u128, Vec<AccountId32>]>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * The super-identity of an alternative "sub" identity together with its name, within that
             * context. If the account is not some other account's sub-identity, then just `None`.
             **/
            superOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<ITuple<[AccountId32, Data]>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        issue: {
            /**
             * The minimum amount of btc that is required for issue requests; lower values would
             * risk the rejection of payment on Bitcoin.
             **/
            issueBtcDustValue: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The time difference in number of blocks between an issue request is created
             * and required completion time by a user. The issue period has an upper limit
             * to prevent griefing of vault collateral.
             **/
            issuePeriod: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Users create issue requests to issue tokens. This mapping provides access
             * from a unique hash `IssueId` to an `IssueRequest` struct.
             **/
            issueRequests: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<InterbtcPrimitivesIssueIssueRequest>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
            /**
             * Build storage at V1 (requires default 0).
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<IssueVersion>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        loans: {
            /**
             * Mapping of account addresses to outstanding borrow balances
             * CurrencyId -> Owner -> BorrowSnapshot
             **/
            accountBorrows: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<LoansBorrowSnapshot>, [InterbtcPrimitivesCurrencyId, AccountId32]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, AccountId32]>;
            /**
             * Mapping of account addresses to collateral deposit details
             * CollateralType -> Owner -> Collateral Deposits
             *
             * # Remarks
             *
             * Differently from Parallel Finance's implementation of lending, `AccountDeposits` only
             * represents Lend Tokens locked as collateral rather than the entire Lend Token balance of an account.
             * If an account minted without also locking their balance as collateral, their corresponding entry
             * in this map will be zero.
             **/
            accountDeposits: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesCurrencyId, AccountId32]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, AccountId32]>;
            /**
             * Accumulator of the total earned interest rate since the opening of the market
             * CurrencyId -> u128
             **/
            borrowIndex: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Mapping of borrow rate to currency type
             **/
            borrowRate: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * The internal exchange rate from the associated lend token to the underlying currency.
             **/
            exchangeRate: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * The timestamp of the last calculation of accrued interest
             **/
            lastAccruedInterestTime: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<u64>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Mapping of underlying currency id to its market
             **/
            markets: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<Option<LoansMarket>>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * The maximum allowed exchange rate for a market.
             **/
            maxExchangeRate: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The minimum allowed exchange rate for a market. This is the starting rate when a market is first set up.
             **/
            minExchangeRate: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The incentive reward accrued but not yet transferred to each user.
             **/
            rewardAccrued: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u128>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * The incentive reward index for each market for each borrower as of the last time they accrued Reward
             **/
            rewardBorrowerIndex: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesCurrencyId, AccountId32]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, AccountId32]>;
            /**
             * Mapping of underlying currency id to borrow reward speed
             **/
            rewardBorrowSpeed: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * The Reward market borrow state for each market
             **/
            rewardBorrowState: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<LoansRewardMarketState>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * The incentive reward index for each market for each supplier as of the last time they accrued Reward
             **/
            rewardSupplierIndex: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesCurrencyId, AccountId32]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, AccountId32]>;
            /**
             * Mapping of underlying currency id to supply reward speed
             **/
            rewardSupplySpeed: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * The Reward market supply state for each market
             **/
            rewardSupplyState: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<LoansRewardMarketState>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Storage version of the pallet.
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<LoansVersions>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Mapping of supply rate to currency type
             **/
            supplyRate: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Total amount of outstanding borrows of the underlying in this market
             * CurrencyId -> Balance
             **/
            totalBorrows: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Total amount of reserves of the underlying held in this market
             * CurrencyId -> Balance
             **/
            totalReserves: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Mapping of lend_token id to underlying currency id
             * `lend_token id`: voucher token id
             * `asset id`: underlying token id
             **/
            underlyingAssetId: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<Option<InterbtcPrimitivesCurrencyId>>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Borrow utilization ratio
             **/
            utilizationRatio: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<Permill>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        multisig: {
            /**
             * The set of open multisig operations.
             **/
            multisigs: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: U8aFixed | string | Uint8Array) => Observable<Option<PalletMultisigMultisig>>, [AccountId32, U8aFixed]> & QueryableStorageEntry<ApiType, [AccountId32, U8aFixed]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        multiTransactionPayment: {
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        nomination: {
            /**
             * Flag indicating whether this feature is enabled
             **/
            nominationEnabled: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The maximum amount of collateral to be nominated for a given vault.
             **/
            nominationLimit: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesVaultId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesVaultId]>;
            /**
             * Map of Vaults who have enabled nomination
             **/
            vaults: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array) => Observable<bool>, [InterbtcPrimitivesVaultId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesVaultId]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        oracle: {
            /**
             * Current medianized value for the given key
             **/
            aggregate: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesOracleKey | {
                ExchangeRate: any;
            } | {
                FeeEstimation: any;
            } | string | Uint8Array) => Observable<Option<u128>>, [InterbtcPrimitivesOracleKey]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesOracleKey]>;
            authorizedOracles: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Bytes>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Maximum delay (milliseconds) for a reported value to be used
             **/
            maxDelay: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
            rawValues: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesOracleKey | {
                ExchangeRate: any;
            } | {
                FeeEstimation: any;
            } | string | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<OracleTimestampedValue>>, [InterbtcPrimitivesOracleKey, AccountId32]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesOracleKey, AccountId32]>;
            /**
             * if a key is present, it means the values have been updated
             **/
            rawValuesUpdated: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesOracleKey | {
                ExchangeRate: any;
            } | {
                FeeEstimation: any;
            } | string | Uint8Array) => Observable<Option<bool>>, [InterbtcPrimitivesOracleKey]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesOracleKey]>;
            /**
             * Build storage at V1 (requires default 0).
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<OracleVersion>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Time until which the aggregate is valid
             **/
            validUntil: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesOracleKey | {
                ExchangeRate: any;
            } | {
                FeeEstimation: any;
            } | string | Uint8Array) => Observable<Option<u64>>, [InterbtcPrimitivesOracleKey]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesOracleKey]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        parachainInfo: {
            parachainId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        parachainSystem: {
            /**
             * The number of HRMP messages we observed in `on_initialize` and thus used that number for
             * announcing the weight of `on_initialize` and `on_finalize`.
             **/
            announcedHrmpMessagesPerCandidate: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The next authorized upgrade, if there is one.
             **/
            authorizedUpgrade: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemCodeUpgradeAuthorization>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * A custom head data that should be returned as result of `validate_block`.
             *
             * See [`Pallet::set_custom_validation_head_data`] for more information.
             **/
            customValidationHeadData: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Were the validation data set to notify the relay chain?
             **/
            didSetValidationCode: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The parachain host configuration that was obtained from the relay parent.
             *
             * This field is meant to be updated each block with the validation data inherent. Therefore,
             * before processing of the inherent, e.g. in `on_initialize` this data may be stale.
             *
             * This data is also absent from the genesis.
             **/
            hostConfiguration: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV4AbridgedHostConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * HRMP messages that were sent in a block.
             *
             * This will be cleared in `on_initialize` of each new block.
             **/
            hrmpOutboundMessages: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotCorePrimitivesOutboundHrmpMessage>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * HRMP watermark that was set in a block.
             *
             * This will be cleared in `on_initialize` of each new block.
             **/
            hrmpWatermark: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The last downward message queue chain head we have observed.
             *
             * This value is loaded before and saved after processing inbound downward messages carried
             * by the system inherent.
             **/
            lastDmqMqcHead: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The message queue chain heads we have observed per each channel incoming channel.
             *
             * This value is loaded before and saved after processing inbound downward messages carried
             * by the system inherent.
             **/
            lastHrmpMqcHeads: AugmentedQuery<ApiType, () => Observable<BTreeMap<u32, H256>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The relay chain block number associated with the last parachain block.
             **/
            lastRelayChainBlockNumber: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Validation code that is set by the parachain and is to be communicated to collator and
             * consequently the relay-chain.
             *
             * This will be cleared in `on_initialize` of each new block if no other pallet already set
             * the value.
             **/
            newValidationCode: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Upward messages that are still pending and not yet send to the relay chain.
             **/
            pendingUpwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * In case of a scheduled upgrade, this storage field contains the validation code to be applied.
             *
             * As soon as the relay chain gives us the go-ahead signal, we will overwrite the [`:code`][well_known_keys::CODE]
             * which will result the next block process with the new validation code. This concludes the upgrade process.
             *
             * [well_known_keys::CODE]: sp_core::storage::well_known_keys::CODE
             **/
            pendingValidationCode: AugmentedQuery<ApiType, () => Observable<Bytes>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Number of downward messages processed in a block.
             *
             * This will be cleared in `on_initialize` of each new block.
             **/
            processedDownwardMessages: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The state proof for the last relay parent block.
             *
             * This field is meant to be updated each block with the validation data inherent. Therefore,
             * before processing of the inherent, e.g. in `on_initialize` this data may be stale.
             *
             * This data is also absent from the genesis.
             **/
            relayStateProof: AugmentedQuery<ApiType, () => Observable<Option<SpTrieStorageProof>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The snapshot of some state related to messaging relevant to the current parachain as per
             * the relay parent.
             *
             * This field is meant to be updated each block with the validation data inherent. Therefore,
             * before processing of the inherent, e.g. in `on_initialize` this data may be stale.
             *
             * This data is also absent from the genesis.
             **/
            relevantMessagingState: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The weight we reserve at the beginning of the block for processing DMP messages. This
             * overrides the amount set in the Config trait.
             **/
            reservedDmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The weight we reserve at the beginning of the block for processing XCMP messages. This
             * overrides the amount set in the Config trait.
             **/
            reservedXcmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * An option which indicates if the relay-chain restricts signalling a validation code upgrade.
             * In other words, if this is `Some` and [`NewValidationCode`] is `Some` then the produced
             * candidate will be invalid.
             *
             * This storage item is a mirror of the corresponding value for the current parachain from the
             * relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is
             * set after the inherent.
             **/
            upgradeRestrictionSignal: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV4UpgradeRestriction>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Upward messages that were sent in a block.
             *
             * This will be cleared in `on_initialize` of each new block.
             **/
            upwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The [`PersistedValidationData`] set for this block.
             * This value is expected to be set only once per block and it's never stored
             * in the trie.
             **/
            validationData: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV4PersistedValidationData>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        polkadotXcm: {
            /**
             * The existing asset traps.
             *
             * Key is the blake2 256 hash of (origin, versioned `MultiAssets`) pair. Value is the number of
             * times this pair has been trapped (usually just 1 if it exists at all).
             **/
            assetTraps: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<u32>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
            /**
             * The current migration's stage, if any.
             **/
            currentMigration: AugmentedQuery<ApiType, () => Observable<Option<PalletXcmVersionMigrationStage>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Fungible assets which we know are locked on this chain.
             **/
            lockedFungibles: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<Vec<ITuple<[u128, XcmVersionedMultiLocation]>>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * The ongoing queries.
             **/
            queries: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<PalletXcmQueryStatus>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
            /**
             * The latest available query index.
             **/
            queryCounter: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Fungible assets which we know are locked on a remote chain.
             **/
            remoteLockedFungibles: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array, arg3: XcmVersionedAssetId | {
                V3: any;
            } | string | Uint8Array) => Observable<Option<PalletXcmRemoteLockedFungibleRecord>>, [u32, AccountId32, XcmVersionedAssetId]> & QueryableStorageEntry<ApiType, [u32, AccountId32, XcmVersionedAssetId]>;
            /**
             * Default version to encode XCM when latest version of destination is unknown. If `None`,
             * then the destinations whose XCM version is unknown are considered unreachable.
             **/
            safeXcmVersion: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The Latest versions that we know various locations support.
             **/
            supportedVersion: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array) => Observable<Option<u32>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedMultiLocation]>;
            /**
             * Destinations whose latest XCM version we would like to know. Duplicates not allowed, and
             * the `u32` counter is the number of times that a send to the destination has been attempted,
             * which is used as a prioritization.
             **/
            versionDiscoveryQueue: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[XcmVersionedMultiLocation, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * All locations that we have requested version notifications from.
             **/
            versionNotifiers: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array) => Observable<Option<u64>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedMultiLocation]>;
            /**
             * The target locations that are subscribed to our version changes, as well as the most recent
             * of our versions we informed them of.
             **/
            versionNotifyTargets: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | {
                V2: any;
            } | {
                V3: any;
            } | string | Uint8Array) => Observable<Option<ITuple<[u64, SpWeightsWeightV2Weight, u32]>>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedMultiLocation]>;
            /**
             * Global suspension state of the XCM executor.
             **/
            xcmExecutionSuspended: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        preimage: {
            preimageFor: AugmentedQuery<ApiType, (arg: ITuple<[H256, u32]> | [H256 | string | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<Option<Bytes>>, [ITuple<[H256, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[H256, u32]>]>;
            /**
             * The request status of a given hash.
             **/
            statusFor: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletPreimageRequestStatus>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        proxy: {
            /**
             * The announcements made by the proxy (key).
             **/
            announcements: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[Vec<PalletProxyAnnouncement>, u128]>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * The set of account proxies. Maps the account which has delegated to the accounts
             * which are being delegated to, together with the amount held on deposit.
             **/
            proxies: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[Vec<PalletProxyProxyDefinition>, u128]>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        redeem: {
            /**
             * The minimum amount of btc that is accepted for redeem requests; any lower values would
             * risk the bitcoin client to reject the payment
             **/
            redeemBtcDustValue: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The time difference in number of blocks between a redeem request is created and required completion time by a
             * vault. The redeem period has an upper limit to ensure the user gets their BTC in time and to potentially
             * punish a vault for inactivity or stealing BTC.
             **/
            redeemPeriod: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Users create redeem requests to receive BTC in return for their previously issued tokens.
             * This mapping provides access from a unique hash redeemId to a Redeem struct.
             **/
            redeemRequests: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<InterbtcPrimitivesRedeemRedeemRequest>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
            /**
             * the expected size in bytes of the redeem bitcoin transfer
             **/
            redeemTransactionSize: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Build storage at V1 (requires default 0).
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<RedeemVersion>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        replace: {
            /**
             * The minimum amount of btc that is accepted for replace requests; any lower values would
             * risk the bitcoin client to reject the payment
             **/
            replaceBtcDustValue: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The time difference in number of blocks between when a replace request is created
             * and required completion time by a vault. The replace period has an upper limit
             * to prevent griefing of vault collateral.
             **/
            replacePeriod: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Vaults create replace requests to transfer locked collateral.
             * This mapping provides access from a unique hash to a `ReplaceRequest`.
             **/
            replaceRequests: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<InterbtcPrimitivesReplaceReplaceRequest>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
            /**
             * Build storage at V1 (requires default 0).
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<ReplaceVersion>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        scheduler: {
            /**
             * Items to be executed, indexed by the block number that they should be executed on.
             **/
            agenda: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<Option<PalletSchedulerScheduled>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            incompleteSince: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Lookup from a name to the block number and index of the task.
             *
             * For v3 -> v4 the previously unbounded identities are Blake2-256 hashed to form the v4
             * identities.
             **/
            lookup: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Option<ITuple<[u32, u32]>>>, [U8aFixed]> & QueryableStorageEntry<ApiType, [U8aFixed]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        security: {
            /**
             * Like frame_system::block_number, but this one only increments if the parachain status is RUNNING.
             * This variable is used to keep track of durations, such as the issue/redeem/replace expiry. If the
             * parachain is not RUNNING, no payment proofs can be submitted, and it wouldn't be fair to punish
             * the user/vault. By using this variable we ensure that they have sufficient time to submit their
             * proof.
             **/
            activeBlockCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            isDeactivated: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Integer increment-only counter, used to prevent collisions when generating identifiers
             * for e.g. issue, redeem or replace requests (for OP_RETURN field in Bitcoin).
             **/
            nonce: AugmentedQuery<ApiType, () => Observable<U256>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        session: {
            /**
             * Current index of the session.
             **/
            currentIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Indices of disabled validators.
             *
             * The vec is always kept sorted so that we can find whether a given validator is
             * disabled using binary search. It gets cleared when `on_session_ending` returns
             * a new set of identities.
             **/
            disabledValidators: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The owner of a key. The key is the `KeyTypeId` + the encoded key.
             **/
            keyOwner: AugmentedQuery<ApiType, (arg: ITuple<[SpCoreCryptoKeyTypeId, Bytes]> | [SpCoreCryptoKeyTypeId | string | Uint8Array, Bytes | string | Uint8Array]) => Observable<Option<AccountId32>>, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]> & QueryableStorageEntry<ApiType, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]>;
            /**
             * The next session keys for a validator.
             **/
            nextKeys: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<InterlayRuntimeParachainSessionKeys>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * True if the underlying economic identities or weighting behind the validators
             * has changed in the queued validator set.
             **/
            queuedChanged: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The queued keys for the next session. When the next session begins, these keys
             * will be used to determine the validator's session keys.
             **/
            queuedKeys: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[AccountId32, InterlayRuntimeParachainSessionKeys]>>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The current set of validators.
             **/
            validators: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        sudo: {
            /**
             * The `AccountId` of the sudo key.
             **/
            key: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        supply: {
            inflation: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            lastEmission: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            startHeight: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        system: {
            /**
             * The full account information for a particular account ID.
             **/
            account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<FrameSystemAccountInfo>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Total length (in bytes) for all extrinsics put together, for the current block.
             **/
            allExtrinsicsLen: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Map of block numbers to block hashes.
             **/
            blockHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<H256>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * The current weight for the block.
             **/
            blockWeight: AugmentedQuery<ApiType, () => Observable<FrameSupportDispatchPerDispatchClassWeight>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Digest of the current block, also part of the block header.
             **/
            digest: AugmentedQuery<ApiType, () => Observable<SpRuntimeDigest>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The number of events in the `Events<T>` list.
             **/
            eventCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Events deposited for the current block.
             *
             * NOTE: The item is unbound and should therefore never be read on chain.
             * It could otherwise inflate the PoV size of a block.
             *
             * Events have a large in-memory size. Box the events to not go out-of-memory
             * just in case someone still reads them from within the runtime.
             **/
            events: AugmentedQuery<ApiType, () => Observable<Vec<FrameSystemEventRecord>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Mapping between a topic (represented by T::Hash) and a vector of indexes
             * of events in the `<Events<T>>` list.
             *
             * All topic vectors have deterministic storage locations depending on the topic. This
             * allows light-clients to leverage the changes trie storage tracking mechanism and
             * in case of changes fetch the list of events of interest.
             *
             * The value has the type `(T::BlockNumber, EventIndex)` because if we used only just
             * the `EventIndex` then in case if the topic has the same contents on the next block
             * no notification will be triggered thus the event might be lost.
             **/
            eventTopics: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Vec<ITuple<[u32, u32]>>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
            /**
             * The execution phase of the block.
             **/
            executionPhase: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemPhase>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Total extrinsics count for the current block.
             **/
            extrinsicCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Extrinsics data for the current block (maps an extrinsic's index to its data).
             **/
            extrinsicData: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.
             **/
            lastRuntimeUpgrade: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemLastRuntimeUpgradeInfo>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The current block number being processed. Set by `execute_block`.
             **/
            number: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Hash of the previous block.
             **/
            parentHash: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False
             * (default) if not.
             **/
            upgradedToTripleRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.
             **/
            upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        technicalCommittee: {
            /**
             * The current members of the collective. This is stored sorted (just by value).
             **/
            members: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The prime member that helps determine the default vote behavior in case of absentations.
             **/
            prime: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Proposals so far.
             **/
            proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Actual proposal for a given hash, if it's current.
             **/
            proposalOf: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<Call>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
            /**
             * The hashes of the active proposals.
             **/
            proposals: AugmentedQuery<ApiType, () => Observable<Vec<H256>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Votes on a given proposal, if it is ongoing.
             **/
            voting: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletCollectiveVotes>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        technicalMembership: {
            /**
             * The current membership, stored as an ordered Vec.
             **/
            members: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The current prime member, if one exists.
             **/
            prime: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        timestamp: {
            /**
             * Did the timestamp get updated in this block?
             **/
            didUpdate: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Current time for the current block.
             **/
            now: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        tokens: {
            /**
             * The balance of a token type under an account.
             *
             * NOTE: If the total is ever zero, decrease account ref account.
             *
             * NOTE: This is only used in the case that this module is used to store
             * balances.
             **/
            accounts: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<OrmlTokensAccountData>, [AccountId32, InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [AccountId32, InterbtcPrimitivesCurrencyId]>;
            /**
             * Any liquidity locks of a token type under an account.
             * NOTE: Should only be accessed when setting, changing and freeing a lock.
             **/
            locks: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<Vec<OrmlTokensBalanceLock>>, [AccountId32, InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [AccountId32, InterbtcPrimitivesCurrencyId]>;
            /**
             * Named reserves on some account balances.
             **/
            reserves: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<Vec<OrmlTokensReserveData>>, [AccountId32, InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [AccountId32, InterbtcPrimitivesCurrencyId]>;
            /**
             * The total issuance of a token type.
             **/
            totalIssuance: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        transactionPayment: {
            nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            storageVersion: AugmentedQuery<ApiType, () => Observable<PalletTransactionPaymentReleases>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        txPause: {
            /**
             * The set of calls that are explicitly paused.
             **/
            pausedCalls: AugmentedQuery<ApiType, (arg: ITuple<[Bytes, Option<Bytes>]> | [Bytes | string | Uint8Array, Option<Bytes> | null | Uint8Array | Bytes | string]) => Observable<Option<Null>>, [ITuple<[Bytes, Option<Bytes>]>]> & QueryableStorageEntry<ApiType, [ITuple<[Bytes, Option<Bytes>]>]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        unknownTokens: {
            /**
             * Abstract fungible balances under a given location and a abstract
             * fungible id.
             *
             * double_map: who, asset_id => u128
             **/
            abstractFungibleBalances: AugmentedQuery<ApiType, (arg1: XcmV3MultiLocation | {
                parents?: any;
                interior?: any;
            } | string | Uint8Array, arg2: Bytes | string | Uint8Array) => Observable<u128>, [XcmV3MultiLocation, Bytes]> & QueryableStorageEntry<ApiType, [XcmV3MultiLocation, Bytes]>;
            /**
             * Concrete fungible balances under a given location and a concrete
             * fungible id.
             *
             * double_map: who, asset_id => u128
             **/
            concreteFungibleBalances: AugmentedQuery<ApiType, (arg1: XcmV3MultiLocation | {
                parents?: any;
                interior?: any;
            } | string | Uint8Array, arg2: XcmV3MultiLocation | {
                parents?: any;
                interior?: any;
            } | string | Uint8Array) => Observable<u128>, [XcmV3MultiLocation, XcmV3MultiLocation]> & QueryableStorageEntry<ApiType, [XcmV3MultiLocation, XcmV3MultiLocation]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        vaultAnnuity: {
            rewardPerBlock: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            rewardPerWrapped: AugmentedQuery<ApiType, () => Observable<Option<u128>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        vaultCapacity: {
            /**
             * Track the currencies used for rewards.
             **/
            rewardCurrencies: AugmentedQuery<ApiType, (arg: Null | null) => Observable<BTreeSet<InterbtcPrimitivesCurrencyId>>, [Null]> & QueryableStorageEntry<ApiType, [Null]>;
            /**
             * Used to compute the rewards for a participant's stake.
             **/
            rewardPerToken: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: Null | null) => Observable<i128>, [InterbtcPrimitivesCurrencyId, Null]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, Null]>;
            /**
             * Accounts for previous changes in stake size.
             **/
            rewardTally: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: ITuple<[Null, InterbtcPrimitivesCurrencyId]> | [Null | null, InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array]) => Observable<i128>, [InterbtcPrimitivesCurrencyId, ITuple<[Null, InterbtcPrimitivesCurrencyId]>]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, ITuple<[Null, InterbtcPrimitivesCurrencyId]>]>;
            /**
             * The stake of a participant in this reward pool.
             **/
            stake: AugmentedQuery<ApiType, (arg: ITuple<[Null, InterbtcPrimitivesCurrencyId]> | [Null | null, InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array]) => Observable<i128>, [ITuple<[Null, InterbtcPrimitivesCurrencyId]>]> & QueryableStorageEntry<ApiType, [ITuple<[Null, InterbtcPrimitivesCurrencyId]>]>;
            /**
             * The total unclaimed rewards distributed to this reward pool.
             * NOTE: this is currently only used for integration tests.
             **/
            totalRewards: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<i128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * The total stake deposited to this reward pool.
             **/
            totalStake: AugmentedQuery<ApiType, (arg: Null | null) => Observable<i128>, [Null]> & QueryableStorageEntry<ApiType, [Null]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        vaultRegistry: {
            /**
             * Determines the lower bound for the collateral rate in issued tokens. If a Vault’s
             * collateral rate drops below this, automatic liquidation (forced Redeem) is triggered.
             **/
            liquidationCollateralThreshold: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array) => Observable<Option<u128>>, [InterbtcPrimitivesVaultCurrencyPair]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesVaultCurrencyPair]>;
            liquidationVault: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array) => Observable<Option<VaultRegistrySystemVault>>, [InterbtcPrimitivesVaultCurrencyPair]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesVaultCurrencyPair]>;
            /**
             * The minimum collateral (e.g. DOT/KSM) a Vault needs to provide to register.
             **/
            minimumCollateralVault: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Determines the rate for the collateral rate of Vaults, at which users receive a premium,
             * allocated from the Vault's collateral, when performing a redeem with this Vault. This
             * threshold should be greater than the LiquidationCollateralThreshold.
             **/
            premiumRedeemThreshold: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array) => Observable<Option<u128>>, [InterbtcPrimitivesVaultCurrencyPair]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesVaultCurrencyPair]>;
            /**
             * If a Vault fails to execute a correct redeem or replace, it is temporarily banned
             * from further issue, redeem or replace requests. This value configures the duration
             * of this ban (in number of blocks) .
             **/
            punishmentDelay: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Mapping of reserved BTC addresses to the registered account
             **/
            reservedAddresses: AugmentedQuery<ApiType, (arg: BitcoinAddress | {
                P2PKH: any;
            } | {
                P2SH: any;
            } | {
                P2WPKHv0: any;
            } | {
                P2WSHv0: any;
            } | string | Uint8Array) => Observable<Option<InterbtcPrimitivesVaultId>>, [BitcoinAddress]> & QueryableStorageEntry<ApiType, [BitcoinAddress]>;
            /**
             * Determines the over-collateralization rate for collateral locked by Vaults, necessary for
             * wrapped tokens. This threshold should be greater than the LiquidationCollateralThreshold.
             **/
            secureCollateralThreshold: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array) => Observable<Option<u128>>, [InterbtcPrimitivesVaultCurrencyPair]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesVaultCurrencyPair]>;
            /**
             * Pallet storage version
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<VaultRegistryVersion>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Determines the over-collateralization rate for collateral locked by Vaults, necessary for
             * wrapped tokens. This threshold should be greater than the LiquidationCollateralThreshold.
             **/
            systemCollateralCeiling: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array) => Observable<Option<u128>>, [InterbtcPrimitivesVaultCurrencyPair]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesVaultCurrencyPair]>;
            /**
             * Total collateral used for collateral tokens issued by active vaults, excluding the liquidation vault
             **/
            totalUserVaultCollateral: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesVaultCurrencyPair | {
                collateral?: any;
                wrapped?: any;
            } | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesVaultCurrencyPair]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesVaultCurrencyPair]>;
            /**
             * Mapping of Vaults, using the respective Vault account identifier as key.
             **/
            vaultBitcoinPublicKey: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<BitcoinAddressPublicKey>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Mapping of Vaults, using the respective Vault account identifier as key.
             **/
            vaults: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array) => Observable<Option<VaultRegistryVault>>, [InterbtcPrimitivesVaultId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesVaultId]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        vaultRewards: {
            /**
             * Track the currencies used for rewards.
             **/
            rewardCurrencies: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<BTreeSet<InterbtcPrimitivesCurrencyId>>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Used to compute the rewards for a participant's stake.
             **/
            rewardPerToken: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<i128>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>;
            /**
             * Accounts for previous changes in stake size.
             **/
            rewardTally: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesVaultId]> | [InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array]) => Observable<i128>, [InterbtcPrimitivesCurrencyId, ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesVaultId]>]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesVaultId]>]>;
            /**
             * The stake of a participant in this reward pool.
             **/
            stake: AugmentedQuery<ApiType, (arg: ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesVaultId]> | [InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array]) => Observable<i128>, [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesVaultId]>]> & QueryableStorageEntry<ApiType, [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesVaultId]>]>;
            /**
             * The total unclaimed rewards distributed to this reward pool.
             * NOTE: this is currently only used for integration tests.
             **/
            totalRewards: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<i128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * The total stake deposited to this reward pool.
             **/
            totalStake: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array) => Observable<i128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        vaultStaking: {
            /**
             * The nonce of the current staking pool, used in force refunds.
             * This is a strictly increasing value.
             **/
            nonce: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array) => Observable<u32>, [InterbtcPrimitivesVaultId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesVaultId]>;
            /**
             * Used to compute the rewards for a participant's stake.
             **/
            rewardPerToken: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: ITuple<[u32, InterbtcPrimitivesVaultId]> | [u32 | AnyNumber | Uint8Array, InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array]) => Observable<i128>, [InterbtcPrimitivesCurrencyId, ITuple<[u32, InterbtcPrimitivesVaultId]>]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, ITuple<[u32, InterbtcPrimitivesVaultId]>]>;
            /**
             * Accounts for previous changes in stake size.
             **/
            rewardTally: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: ITuple<[u32, InterbtcPrimitivesVaultId, AccountId32]> | [u32 | AnyNumber | Uint8Array, InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array, AccountId32 | string | Uint8Array]) => Observable<i128>, [InterbtcPrimitivesCurrencyId, ITuple<[u32, InterbtcPrimitivesVaultId, AccountId32]>]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, ITuple<[u32, InterbtcPrimitivesVaultId, AccountId32]>]>;
            /**
             * Used to compute the amount to slash from a participant's stake.
             **/
            slashPerToken: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array) => Observable<i128>, [u32, InterbtcPrimitivesVaultId]> & QueryableStorageEntry<ApiType, [u32, InterbtcPrimitivesVaultId]>;
            /**
             * Accounts for previous changes in stake size.
             **/
            slashTally: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: ITuple<[InterbtcPrimitivesVaultId, AccountId32]> | [InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array, AccountId32 | string | Uint8Array]) => Observable<i128>, [u32, ITuple<[InterbtcPrimitivesVaultId, AccountId32]>]> & QueryableStorageEntry<ApiType, [u32, ITuple<[InterbtcPrimitivesVaultId, AccountId32]>]>;
            /**
             * The stake of a participant in this reward pool.
             **/
            stake: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: ITuple<[InterbtcPrimitivesVaultId, AccountId32]> | [InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array, AccountId32 | string | Uint8Array]) => Observable<i128>, [u32, ITuple<[InterbtcPrimitivesVaultId, AccountId32]>]> & QueryableStorageEntry<ApiType, [u32, ITuple<[InterbtcPrimitivesVaultId, AccountId32]>]>;
            /**
             * The total stake - this will increase on deposit and decrease on withdrawal or slashing.
             **/
            totalCurrentStake: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array) => Observable<i128>, [u32, InterbtcPrimitivesVaultId]> & QueryableStorageEntry<ApiType, [u32, InterbtcPrimitivesVaultId]>;
            /**
             * The total unclaimed rewards distributed to this reward pool.
             * NOTE: this is currently only used for integration tests.
             **/
            totalRewards: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | {
                Token: any;
            } | {
                ForeignAsset: any;
            } | {
                LendToken: any;
            } | {
                LpToken: any;
            } | {
                StableLpToken: any;
            } | string | Uint8Array, arg2: ITuple<[u32, InterbtcPrimitivesVaultId]> | [u32 | AnyNumber | Uint8Array, InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array]) => Observable<i128>, [InterbtcPrimitivesCurrencyId, ITuple<[u32, InterbtcPrimitivesVaultId]>]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, ITuple<[u32, InterbtcPrimitivesVaultId]>]>;
            /**
             * The total stake - this will increase on deposit and decrease on withdrawal.
             **/
            totalStake: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: InterbtcPrimitivesVaultId | {
                accountId?: any;
                currencies?: any;
            } | string | Uint8Array) => Observable<i128>, [u32, InterbtcPrimitivesVaultId]> & QueryableStorageEntry<ApiType, [u32, InterbtcPrimitivesVaultId]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        vesting: {
            /**
             * Vesting schedules of an account.
             *
             * VestingSchedules: map AccountId => Vec<VestingSchedule>
             **/
            vestingSchedules: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<OrmlVestingVestingSchedule>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        xcmpQueue: {
            /**
             * Counter for the related counted storage map
             **/
            counterForOverweight: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Inbound aggregate XCMP messages. It can only be one per ParaId/block.
             **/
            inboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
            /**
             * Status of the inbound XCMP channels.
             **/
            inboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueInboundChannelDetails>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The messages outbound in a given XCMP channel.
             **/
            outboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u16 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u16]> & QueryableStorageEntry<ApiType, [u32, u16]>;
            /**
             * The non-empty XCMP channels in order of becoming non-empty, and the index of the first
             * and last outbound message. If the two indices are equal, then it indicates an empty
             * queue and there must be a non-`Ok` `OutboundStatus`. We assume queues grow no greater
             * than 65535 items. Queue indices for normal messages begin at one; zero is reserved in
             * case of the need to send a high-priority signal message this block.
             * The bool is true if there is a signal message waiting to be sent.
             **/
            outboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueOutboundChannelDetails>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The messages that exceeded max individual message weight budget.
             *
             * These message stay in this storage map until they are manually dispatched via
             * `service_overweight`.
             **/
            overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
            /**
             * The number of overweight messages ever recorded in `Overweight`. Also doubles as the next
             * available free overweight index.
             **/
            overweightCount: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The configuration which controls the dynamics of the outbound queue.
             **/
            queueConfig: AugmentedQuery<ApiType, () => Observable<CumulusPalletXcmpQueueQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Whether or not the XCMP queue is suspended from executing incoming XCMs or not.
             **/
            queueSuspended: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Any signal messages waiting to be sent.
             **/
            signalMessages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        xTokens: {
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
    }
}