// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
/* eslint-disable */

// import type lookup before we augment - in some environments
// this is required to allow for ambient/previous definitions
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, H256, Permill } from '@polkadot/types/interfaces/runtime';
import type { BitcoinAddress, BitcoinAddressPublicKey, BitcoinBlockChain, BitcoinH256Le, BtcRelayRichBlockHeader, ClientsInfoClientRelease, CollatorSelectionCandidateInfo, CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, DemocracyPreimageStatus, DemocracyReferendumInfo, DemocracyReleases, DemocracyVoting, EscrowLockedBalance, EscrowPoint, FeeVersion, FrameSupportDispatchPerDispatchClassWeight, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, InterbtcPrimitivesCurrencyId, InterbtcPrimitivesIssueIssueRequest, InterbtcPrimitivesOracleKey, InterbtcPrimitivesRedeemRedeemRequest, InterbtcPrimitivesReplaceReplaceRequest, InterbtcPrimitivesVaultCurrencyPair, InterbtcPrimitivesVaultId, IssueVersion, LoansBorrowSnapshot, LoansEarnedSnapshot, LoansMarket, LoansRewardMarketState, LoansVersions, OracleTimestampedValue, OracleVersion, OrmlTokensAccountData, OrmlTokensBalanceLock, OrmlTokensReserveData, OrmlTraitsAssetRegistryAssetMetadata, OrmlVestingVestingSchedule, PalletAuthorshipUncleEntryItem, PalletCollectiveVotes, PalletIdentityRegistrarInfo, PalletIdentityRegistration, PalletMultisigMultisig, PalletPreimageRequestStatus, PalletSchedulerScheduled, PalletTransactionPaymentReleases, PalletTreasuryProposal, PalletXcmQueryStatus, PalletXcmVersionMigrationStage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, RedeemVersion, ReplaceVersion, SecurityErrorCode, SecurityStatusCode, SpConsensusAuraSr25519AppSr25519Public, SpCoreCryptoKeyTypeId, SpRuntimeDigest, SpTrieStorageProof, SpWeightsWeightV2Weight, TestnetKintsugiRuntimeParachainSessionKeys, VaultRegistrySystemVault, VaultRegistryVault, VaultRegistryVersion, XcmV1MultiLocation, XcmVersionedMultiLocation, ZenlinkProtocolPrimitivesPairStatus, ZenlinkStableAmmPrimitivesPool } 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: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array) => Observable<Option<u32>>, [XcmV1MultiLocation]> & QueryableStorageEntry<ApiType, [XcmV1MultiLocation]>;
      /**
       * 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, []>;
      /**
       * Whether uncles were already set in this block.
       **/
      didSetUncles: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Uncles
       **/
      uncles: AugmentedQuery<ApiType, () => Observable<Vec<PalletAuthorshipUncleEntryItem>>, []> & 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, []>;
      /**
       * Map of hashes to the proposal preimage, along with who registered it and their deposit.
       * The block number is the block at which it was deposited.
       **/
      preimages: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<DemocracyPreimageStatus>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
      /**
       * 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's hash.
       **/
      publicProps: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, H256, 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]>;
      /**
       * Storage version of the pallet.
       * 
       * New networks start with last version.
       **/
      storageVersion: AugmentedQuery<ApiType, () => Observable<Option<DemocracyReleases>>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * 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>;
    };
    dmpQueue: {
      /**
       * The configuration.
       **/
      configuration: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueueConfigData>, []> & 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: {
      /**
       * 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>;
    };
    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 deposit details
       * CollateralType -> Owner -> Deposits
       **/
      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]>;
      /**
       * Mapping of account addresses to total deposit interest accrual
       * CurrencyId -> Owner -> EarnedSnapshot
       **/
      accountEarned: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | { Token: any } | { ForeignAsset: any } | { LendToken: any } | { LpToken: any } | { StableLpToken: any } | string | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<LoansEarnedSnapshot>, [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 exchange rate from the underlying to the internal collateral
       **/
      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 asset 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.
       **/
      minExchangeRate: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * The reward accrued but not yet transferred to each user.
       **/
      rewardAccrued: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u128>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
      /**
       * The 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 token 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 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 token 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 asset 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>;
    };
    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<H256>>, []> & 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<PolkadotPrimitivesV2AbridgedHostConfiguration>>, []> & 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<PolkadotPrimitivesV2UpgradeRestriction>>, []> & 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<PolkadotPrimitivesV2PersistedValidationData>>, []> & 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, []>;
      /**
       * 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, []>;
      /**
       * 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 | { V0: any } | { V1: 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 | { V0: any } | { V1: 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 | { V0: any } | { V1: any } | string | Uint8Array) => Observable<Option<ITuple<[u64, u64, u32]>>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedMultiLocation]>;
      /**
       * 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>;
    };
    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, []>;
      /**
       * Set of ErrorCodes, indicating the reason for an "Error" ParachainStatus.
       **/
      errors: AugmentedQuery<ApiType, () => Observable<BTreeSet<SecurityErrorCode>>, []> & 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, []>;
      /**
       * Integer/Enum defining the current state of the BTC-Parachain.
       **/
      parachainStatus: AugmentedQuery<ApiType, () => Observable<SecurityStatusCode>, []> & 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<TestnetKintsugiRuntimeParachainSessionKeys>>, [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, TestnetKintsugiRuntimeParachainSessionKeys]>>>, []> & 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>;
    };
    treasury: {
      /**
       * Proposal indices that have been approved but not yet awarded.
       **/
      approvals: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Number of proposals that have been made.
       **/
      proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Proposals that have been made.
       **/
      proposals: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletTreasuryProposal>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
      /**
       * 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: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, arg2: Bytes | string | Uint8Array) => Observable<u128>, [XcmV1MultiLocation, Bytes]> & QueryableStorageEntry<ApiType, [XcmV1MultiLocation, Bytes]>;
      /**
       * Concrete fungible balances under a given location and a concrete
       * fungible id.
       * 
       * double_map: who, asset_id => u128
       **/
      concreteFungibleBalances: AugmentedQuery<ApiType, (arg1: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array, arg2: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array) => Observable<u128>, [XcmV1MultiLocation, XcmV1MultiLocation]> & QueryableStorageEntry<ApiType, [XcmV1MultiLocation, XcmV1MultiLocation]>;
      /**
       * 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: {
      /**
       * 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<U8aFixed>>, [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: {
      /**
       * 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: {
      /**
       * 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>;
    };
    zenlinkProtocol: {
      /**
       * 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<ZenlinkProtocolPrimitivesPairStatus>, [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]>]>;
      /**
       * (Option<fee_receiver>, fee_point)
       **/
      feeMeta: AugmentedQuery<ApiType, () => Observable<ITuple<[Option<AccountId32>, u8]>>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Foreign foreign storage
       * The number of units of assets held by any given account.
       **/
      foreignLedger: AugmentedQuery<ApiType, (arg: ITuple<[InterbtcPrimitivesCurrencyId, AccountId32]> | [InterbtcPrimitivesCurrencyId | { Token: any } | { ForeignAsset: any } | { LendToken: any } | { LpToken: any } | { StableLpToken: any } | string | Uint8Array, AccountId32 | string | Uint8Array]) => Observable<u128>, [ITuple<[InterbtcPrimitivesCurrencyId, AccountId32]>]> & QueryableStorageEntry<ApiType, [ITuple<[InterbtcPrimitivesCurrencyId, AccountId32]>]>;
      foreignList: AugmentedQuery<ApiType, () => Observable<Vec<InterbtcPrimitivesCurrencyId>>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * TWOX-NOTE: `AssetId` is trusted, so this is safe.
       **/
      foreignMeta: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesCurrencyId | { Token: any } | { ForeignAsset: any } | { LendToken: any } | { LpToken: any } | { StableLpToken: any } | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
      /**
       * 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<ZenlinkProtocolPrimitivesPairStatus>, [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>]> & QueryableStorageEntry<ApiType, [ITuple<[InterbtcPrimitivesCurrencyId, InterbtcPrimitivesCurrencyId]>]>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    zenlinkStableAmm: {
      /**
       * 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<ZenlinkStableAmmPrimitivesPool>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
  } // AugmentedQueries
} // declare module
