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

import type { ApiTypes } from '@polkadot/api-base/types';
import type { Data } from '@polkadot/types';
import type { BTreeSet, Bytes, Option, U256, U8aFixed, Vec, WrapperKeepOpaque, bool, i128, u128, u32, u64 } from '@polkadot/types-codec';
import type { AnyNumber, ITuple } from '@polkadot/types-codec/types';
import type { AccountId32, Call, H256 } from '@polkadot/types/interfaces/runtime';
import type { BitcoinAddress, BitcoinAddressPublicKey, BitcoinBlockChain, BitcoinH256Le, BtcRelayRichBlockHeader, DemocracyPreimageStatus, DemocracyReferendumInfo, DemocracyReleases, DemocracyVoting, EscrowLockedBalance, EscrowPoint, FeeVersion, FrameSupportWeightsPerDispatchClassU64, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, InterbtcPrimitivesCurrencyId, InterbtcPrimitivesIssueIssueRequest, InterbtcPrimitivesOracleKey, InterbtcPrimitivesRedeemRedeemRequest, InterbtcPrimitivesRefundRefundRequest, InterbtcPrimitivesReplaceReplaceRequest, InterbtcPrimitivesVaultCurrencyPair, InterbtcPrimitivesVaultId, IssueVersion, OracleTimestampedValue, OracleVersion, OrmlTokensAccountData, OrmlTokensBalanceLock, OrmlTokensReserveData, OrmlTraitsAssetRegistryAssetMetadata, OrmlVestingVestingSchedule, PalletAuthorshipUncleEntryItem, PalletCollectiveVotes, PalletGrandpaStoredPendingChange, PalletGrandpaStoredState, PalletIdentityRegistrarInfo, PalletIdentityRegistration, PalletMultisigMultisig, PalletPreimageRequestStatus, PalletSchedulerScheduledV3, PalletTransactionPaymentReleases, PalletTreasuryProposal, RedeemVersion, ReplaceVersion, SecurityErrorCode, SecurityStatusCode, SpRuntimeDigest, VaultRegistryClientRelease, VaultRegistrySystemVault, VaultRegistryVault, VaultRegistryVersion, XcmV1MultiLocation } from '@polkadot/types/lookup';
import type { Observable } from '@polkadot/types/types';

declare module '@polkadot/api-base/types/storage' {
  export 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>;
    };
    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>;
    };
    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, []>;
      /**
       * 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>;
    };
    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, (arg: InterbtcPrimitivesCurrencyId | { Token: any } | { ForeignAsset: any } | string | Uint8Array) => Observable<i128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
      /**
       * Accounts for previous changes in stake size.
       **/
      rewardTally: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | { Token: any } | { ForeignAsset: any } | string | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<i128>, [InterbtcPrimitivesCurrencyId, AccountId32]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, AccountId32]>;
      /**
       * The stake of a participant in this reward pool.
       **/
      stake: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<i128>, [AccountId32]> & QueryableStorageEntry<ApiType, [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 } | string | Uint8Array) => Observable<i128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
      /**
       * The total stake deposited to this reward pool.
       **/
      totalStake: AugmentedQuery<ApiType, () => Observable<i128>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    fee: {
      /**
       * # 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, []>;
      /**
       * # Refund
       * Fee share that users need to pay to refund overpaid tokens.
       **/
      refundFee: 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>;
    };
    grandpa: {
      /**
       * The number of changes (both in terms of keys and underlying economic responsibilities)
       * in the "set" of Grandpa validators from genesis.
       **/
      currentSetId: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * next block number where we can force a change.
       **/
      nextForced: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Pending change: (signaled at, scheduled change).
       **/
      pendingChange: AugmentedQuery<ApiType, () => Observable<Option<PalletGrandpaStoredPendingChange>>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * A mapping from grandpa set ID to the index of the *most recent* session for which its
       * members were responsible.
       * 
       * TWOX-NOTE: `SetId` is not under user control.
       **/
      setIdSession: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
      /**
       * `true` if we are currently stalled.
       **/
      stalled: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * State of the current authority set.
       **/
      state: AugmentedQuery<ApiType, () => Observable<PalletGrandpaStoredState>, []> & 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>;
    };
    multisig: {
      calls: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Option<ITuple<[WrapperKeepOpaque<Call>, AccountId32, u128]>>>, [U8aFixed]> & QueryableStorageEntry<ApiType, [U8aFixed]>;
      /**
       * 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, []>;
      /**
       * 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>;
    };
    preimage: {
      /**
       * The preimages stored by this pallet.
       **/
      preimageFor: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<Bytes>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
      /**
       * 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>;
    };
    refund: {
      /**
       * The minimum amount of btc that is accepted for refund requests (NOTE: too low
       * values could result in the bitcoin client rejecting the payment)
       **/
      refundBtcDustValue: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * This mapping provides access from a unique hash refundId to a Refund struct.
       **/
      refundRequests: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<InterbtcPrimitivesRefundRefundRequest>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
      /**
       * the expected size in bytes of the redeem bitcoin transfer
       **/
      refundTransactionSize: AugmentedQuery<ApiType, () => Observable<u32>, []> & 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<PalletSchedulerScheduledV3>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
      /**
       * Lookup from identity to the block number and index of the task.
       **/
      lookup: AugmentedQuery<ApiType, (arg: Bytes | string | Uint8Array) => Observable<Option<ITuple<[u32, u32]>>>, [Bytes]> & QueryableStorageEntry<ApiType, [Bytes]>;
      /**
       * 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>;
    };
    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<FrameSupportWeightsPerDispatchClassU64>, []> & 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 } | 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 } | 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 } | 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 } | 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>;
    };
    vaultAnnuity: {
      rewardPerBlock: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
      rewardPerWrapped: AugmentedQuery<ApiType, () => Observable<Option<u128>>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    vaultRegistry: {
      /**
       * Tuple of (release_uri, code_hash) indicating the current vault client release.
       **/
      currentClientRelease: AugmentedQuery<ApiType, () => Observable<VaultRegistryClientRelease>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * 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 } | string | Uint8Array) => Observable<u128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
      /**
       * Tuple of (release_uri, code_hash) indicating the pending vault client release.
       **/
      pendingClientRelease: AugmentedQuery<ApiType, () => Observable<Option<VaultRegistryClientRelease>>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * 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]>;
      /**
       * Build storage at V1 (requires default 0).
       **/
      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, (arg: InterbtcPrimitivesCurrencyId | { Token: any } | { ForeignAsset: any } | string | Uint8Array) => Observable<i128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
      /**
       * Accounts for previous changes in stake size.
       **/
      rewardTally: AugmentedQuery<ApiType, (arg1: InterbtcPrimitivesCurrencyId | { Token: any } | { ForeignAsset: any } | string | Uint8Array, arg2: InterbtcPrimitivesVaultId | { accountId?: any; currencies?: any } | string | Uint8Array) => Observable<i128>, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesVaultId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId, InterbtcPrimitivesVaultId]>;
      /**
       * The stake of a participant in this reward pool.
       **/
      stake: AugmentedQuery<ApiType, (arg: InterbtcPrimitivesVaultId | { accountId?: any; currencies?: any } | string | Uint8Array) => Observable<i128>, [InterbtcPrimitivesVaultId]> & QueryableStorageEntry<ApiType, [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 } | string | Uint8Array) => Observable<i128>, [InterbtcPrimitivesCurrencyId]> & QueryableStorageEntry<ApiType, [InterbtcPrimitivesCurrencyId]>;
      /**
       * The total stake deposited to this reward pool.
       **/
      totalStake: AugmentedQuery<ApiType, () => Observable<i128>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * 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 } | 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 } | 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 } | 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>;
    };
  } // AugmentedQueries
} // declare module
