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

import type { BTreeSet, Bytes, Option, U256, Vec, bool, u128, u32 } from '@polkadot/types';
import type { AnyNumber, ITuple, Observable } from '@polkadot/types/types';
import type { BlockChain, BtcAddress, BtcTxFeesPerByte, Collateral, ErrorCode, H256Le, IssueRequest, Nominator, Operator, RedeemRequest, RefundRequest, ReplaceRequest, RichBlockHeader, SignedFixedPoint, StatusCode, SystemVault, UnsignedFixedPoint, Vault, Version, Wrapped } from '@interlay/polkabtc/interfaces/default';
import type { AccountData, BalanceLock } from '@polkadot/types/interfaces/balances';
import type { SetId, StoredPendingChange, StoredState } from '@polkadot/types/interfaces/grandpa';
import type { AccountId, Balance, BalanceOf, BlockNumber, H256, Hash, Moment, Releases } from '@polkadot/types/interfaces/runtime';
import type { SessionIndex } from '@polkadot/types/interfaces/session';
import type { AccountInfo, ConsumedWeight, DigestOf, EventIndex, EventRecord, LastRuntimeUpgradeInfo, Phase } from '@polkadot/types/interfaces/system';
import type { Multiplier } from '@polkadot/types/interfaces/txpayment';
import type { ApiTypes } from '@polkadot/api/types';

declare module '@polkadot/api/types/storage' {
  export interface AugmentedQueries<ApiType> {
    btcRelay: {
      /**
       * Store the current blockchain tip
       **/
      bestBlock: AugmentedQuery<ApiType, () => Observable<H256Le>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Store the height of the best block
       **/
      bestBlockHeight: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Store Bitcoin block headers
       **/
      blockHeaders: AugmentedQuery<ApiType, (arg: H256Le | string | Uint8Array) => Observable<RichBlockHeader>, [H256Le]> & QueryableStorageEntry<ApiType, [H256Le]>;
      /**
       * 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<H256Le>, [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<BlockChain>>, [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, []>;
      /**
       * Whether the module should perform OP_RETURN checks.
       **/
      disableOpReturnCheck: 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<BlockNumber>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * BTC height when the relay was initialized
       **/
      startBlockHeight: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    collateral: {
      /**
       * The balance of an account.
       * 
       * NOTE: This is only used in the case that this pallet is used to store balances.
       **/
      account: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<AccountData>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * Any liquidity locks on some account balances.
       * NOTE: Should only be accessed when setting, changing and freeing a lock.
       **/
      locks: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Vec<BalanceLock>>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * Storage version of the pallet.
       * 
       * This is set to v2.0.0 for new networks.
       **/
      storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * The total units issued in the system.
       **/
      totalIssuance: AugmentedQuery<ApiType, () => Observable<Balance>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    collateralCurrency: {
      /**
       * Note that an account's free and reserved balances are handled
       * through the Balances module.
       * 
       * Total locked balance
       **/
      totalLocked: AugmentedQuery<ApiType, () => Observable<BalanceOf>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    collateralRelayerRewards: {
      /**
       * Used to compute the rewards for a participant's stake.
       **/
      rewardPerToken: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Accounts for previous changes in stake size.
       **/
      rewardTally: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<SignedFixedPoint>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * The stake of a participant in this reward pool.
       **/
      stake: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<SignedFixedPoint>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * The total unclaimed rewards distributed to this reward pool.
       * NOTE: this is currently only used for integration tests.
       **/
      totalRewards: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * The total stake deposited to this reward pool.
       **/
      totalStake: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    collateralVaultRewards: {
      /**
       * Used to compute the rewards for a participant's stake.
       **/
      rewardPerToken: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Accounts for previous changes in stake size.
       **/
      rewardTally: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<SignedFixedPoint>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * The stake of a participant in this reward pool.
       **/
      stake: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<SignedFixedPoint>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * The total unclaimed rewards distributed to this reward pool.
       * NOTE: this is currently only used for integration tests.
       **/
      totalRewards: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * The total stake deposited to this reward pool.
       **/
      totalStake: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    exchangeRateOracle: {
      authorizedOracles: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Bytes>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * Current exchange rate (i.e. Planck per Satoshi)
       **/
      exchangeRate: AugmentedQuery<ApiType, () => Observable<UnsignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Last exchange rate time
       **/
      lastExchangeRateTime: AugmentedQuery<ApiType, () => Observable<Moment>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Maximum delay (milliseconds) for the exchange rate to be used
       **/
      maxDelay: AugmentedQuery<ApiType, () => Observable<Moment>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * The estimated inclusion time for a Bitcoin transaction in Satoshis per byte
       **/
      satoshiPerBytes: AugmentedQuery<ApiType, () => Observable<BtcTxFeesPerByte>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Build storage at V1 (requires default 0).
       **/
      storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    fee: {
      /**
       * AccountId of the fee pool.
       **/
      feePoolAccountId: AugmentedQuery<ApiType, () => Observable<AccountId>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * # Issue
       * Fee share that users need to pay to issue tokens.
       **/
      issueFee: AugmentedQuery<ApiType, () => Observable<UnsignedFixedPoint>, []> & 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<UnsignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * AccountId of the parachain maintainer.
       **/
      maintainerAccountId: AugmentedQuery<ApiType, () => Observable<AccountId>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Percentage of fees allocated for development.
       **/
      maintainerRewards: AugmentedQuery<ApiType, () => Observable<UnsignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Percentage of fees generated by nominated collateral that is given to nominators
       **/
      nominationRewards: AugmentedQuery<ApiType, () => Observable<UnsignedFixedPoint>, []> & 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<UnsignedFixedPoint>, []> & 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<UnsignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * # Redeem
       * Fee share that users need to pay to redeem tokens.
       **/
      redeemFee: AugmentedQuery<ApiType, () => Observable<UnsignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * # Refund
       * Fee share that users need to pay to refund overpaid tokens.
       **/
      refundFee: AugmentedQuery<ApiType, () => Observable<UnsignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Percentage of fees allocated to Staked Relayers.
       **/
      relayerRewards: AugmentedQuery<ApiType, () => Observable<UnsignedFixedPoint>, []> & 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<UnsignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Build storage at V1 (requires default 0).
       **/
      storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * # Parachain Fee Pool Distribution
       * Percentage of fees allocated to Vaults.
       **/
      vaultRewards: AugmentedQuery<ApiType, () => Observable<UnsignedFixedPoint>, []> & 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<SetId>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * next block number where we can force a change.
       **/
      nextForced: AugmentedQuery<ApiType, () => Observable<Option<BlockNumber>>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Pending change: (signaled at, scheduled change).
       **/
      pendingChange: AugmentedQuery<ApiType, () => Observable<Option<StoredPendingChange>>, []> & 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: SetId | AnyNumber | Uint8Array) => Observable<Option<SessionIndex>>, [SetId]> & QueryableStorageEntry<ApiType, [SetId]>;
      /**
       * `true` if we are currently stalled.
       **/
      stalled: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[BlockNumber, BlockNumber]>>>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * State of the current authority set.
       **/
      state: AugmentedQuery<ApiType, () => Observable<StoredState>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    issue: {
      /**
       * 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<BlockNumber>, []> & 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<IssueRequest>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
      /**
       * Build storage at V1 (requires default 0).
       **/
      storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    nomination: {
      /**
       * ## Storage
       * Flag indicating whether this feature is enabled
       **/
      nominationEnabled: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Map of Nominators
       **/
      nominators: AugmentedQuery<ApiType, (arg: ITuple<[AccountId, AccountId]> | [AccountId | string | Uint8Array, AccountId | string | Uint8Array]) => Observable<Nominator>, [ITuple<[AccountId, AccountId]>]> & QueryableStorageEntry<ApiType, [ITuple<[AccountId, AccountId]>]>;
      /**
       * Base unbonding period by which collateral withdrawal requests from Vault Nominators
       * are delayed
       **/
      nominatorUnbondingPeriod: AugmentedQuery<ApiType, () => Observable<BlockNumber>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Map of Vault Operators
       **/
      operators: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Operator>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * Base unbonding period by which collateral withdrawal requests from Vault Operators
       * are delayed
       **/
      operatorUnbondingPeriod: AugmentedQuery<ApiType, () => Observable<BlockNumber>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    randomnessCollectiveFlip: {
      /**
       * Series of block headers from the last 81 blocks that acts as random seed material. This
       * is arranged as a ring buffer with `block_number % 81` being the index into the `Vec` of
       * the oldest hash.
       **/
      randomMaterial: AugmentedQuery<ApiType, () => Observable<Vec<Hash>>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * 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<Wrapped>, []> & 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<BlockNumber>, []> & 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<RedeemRequest>, [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<Version>, []> & 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<Wrapped>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * This mapping provides access from a unique hash refundId to a Refund struct.
       **/
      refundRequests: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<RefundRequest>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
      /**
       * 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<Wrapped>, []> & 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<BlockNumber>, []> & 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<ReplaceRequest>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
      /**
       * Build storage at V1 (requires default 0).
       **/
      storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * 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<BlockNumber>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Set of ErrorCodes, indicating the reason for an "Error" ParachainStatus.
       **/
      errors: AugmentedQuery<ApiType, () => Observable<BTreeSet<ErrorCode>>, []> & 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<StatusCode>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    sla: {
      averageDeposit: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      averageDepositCount: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      averageWithdraw: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      averageWithdrawCount: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      lifetimeIssued: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
      relayerSla: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<SignedFixedPoint>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      relayerStoreBlock: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      relayerTargetSla: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      relayerTheftReport: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      totalIssueCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
      vaultDepositMaxSlaChange: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      vaultExecuteIssueMaxSlaChange: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      vaultRedeemFailure: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      vaultRefund: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Mapping from accounts of vaults/relayers to their sla score
       **/
      vaultSla: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<SignedFixedPoint>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      vaultSubmitIssueProof: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      vaultTargetSla: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      vaultWithdrawMaxSlaChange: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    stakedRelayers: {
      /**
       * Mapping of Bitcoin transaction identifiers (SHA256 hashes) to account
       * identifiers of Vaults accused of theft.
       **/
      theftReports: AugmentedQuery<ApiType, (arg: H256Le | string | Uint8Array) => Observable<BTreeSet<AccountId>>, [H256Le]> & QueryableStorageEntry<ApiType, [H256Le]>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    sudo: {
      /**
       * The `AccountId` of the sudo key.
       **/
      key: AugmentedQuery<ApiType, () => Observable<AccountId>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    system: {
      /**
       * The full account information for a particular account ID.
       **/
      account: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<AccountInfo>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * 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: BlockNumber | AnyNumber | Uint8Array) => Observable<Hash>, [BlockNumber]> & QueryableStorageEntry<ApiType, [BlockNumber]>;
      /**
       * The current weight for the block.
       **/
      blockWeight: AugmentedQuery<ApiType, () => Observable<ConsumedWeight>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Digest of the current block, also part of the block header.
       **/
      digest: AugmentedQuery<ApiType, () => Observable<DigestOf>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * The number of events in the `Events<T>` list.
       **/
      eventCount: AugmentedQuery<ApiType, () => Observable<EventIndex>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Events deposited for the current block.
       **/
      events: AugmentedQuery<ApiType, () => Observable<Vec<EventRecord>>, []> & 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: Hash | string | Uint8Array) => Observable<Vec<ITuple<[BlockNumber, EventIndex]>>>, [Hash]> & QueryableStorageEntry<ApiType, [Hash]>;
      /**
       * The execution phase of the block.
       **/
      executionPhase: AugmentedQuery<ApiType, () => Observable<Option<Phase>>, []> & 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<LastRuntimeUpgradeInfo>>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * The current block number being processed. Set by `execute_block`.
       **/
      number: AugmentedQuery<ApiType, () => Observable<BlockNumber>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Hash of the previous block.
       **/
      parentHash: AugmentedQuery<ApiType, () => Observable<Hash>, []> & 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>;
    };
    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<Moment>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    transactionPayment: {
      nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<Multiplier>, []> & QueryableStorageEntry<ApiType, []>;
      storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * 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, () => Observable<UnsignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      liquidationVault: AugmentedQuery<ApiType, () => Observable<SystemVault>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Account identifier of an artificial Vault maintained by the VaultRegistry to handle issued balances
       * and collateral of liquidated Vaults. That is, when a Vault is liquidated, its balances are
       * transferred to LiquidationVault and claims are later handled via the LiquidationVault.
       **/
      liquidationVaultAccountId: AugmentedQuery<ApiType, () => Observable<AccountId>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * The minimum collateral (e.g. DOT/KSM) a Vault needs to provide to register.
       **/
      minimumCollateralVault: AugmentedQuery<ApiType, () => Observable<Collateral>, []> & 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, () => Observable<UnsignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * 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<BlockNumber>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Mapping of reserved BTC addresses to the registered account
       **/
      reservedAddresses: AugmentedQuery<ApiType, (arg: BtcAddress | { P2PKH: any } | { P2SH: any } | { P2WPKHv0: any } | { P2WSHv0: any } | string | Uint8Array) => Observable<AccountId>, [BtcAddress]> & QueryableStorageEntry<ApiType, [BtcAddress]>;
      /**
       * 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, () => Observable<UnsignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Build storage at V1 (requires default 0).
       **/
      storageVersion: AugmentedQuery<ApiType, () => Observable<Version>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Total collateral used for collateral tokens issued by active vaults, excluding the liquidation vault
       **/
      totalUserVaultCollateralCollateral: AugmentedQuery<ApiType, () => Observable<Collateral>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Mapping of Vaults, using the respective Vault account identifier as key.
       **/
      vaults: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Vault>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    wrapped: {
      /**
       * The balance of an account.
       * 
       * NOTE: This is only used in the case that this pallet is used to store balances.
       **/
      account: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<AccountData>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * Any liquidity locks on some account balances.
       * NOTE: Should only be accessed when setting, changing and freeing a lock.
       **/
      locks: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Vec<BalanceLock>>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * Storage version of the pallet.
       * 
       * This is set to v2.0.0 for new networks.
       **/
      storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * The total units issued in the system.
       **/
      totalIssuance: AugmentedQuery<ApiType, () => Observable<Balance>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    wrappedCurrency: {
      /**
       * Note that an account's free and reserved balances are handled
       * through the Balances module.
       * 
       * Total locked balance
       **/
      totalLocked: AugmentedQuery<ApiType, () => Observable<BalanceOf>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    wrappedRelayerRewards: {
      /**
       * Used to compute the rewards for a participant's stake.
       **/
      rewardPerToken: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Accounts for previous changes in stake size.
       **/
      rewardTally: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<SignedFixedPoint>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * The stake of a participant in this reward pool.
       **/
      stake: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<SignedFixedPoint>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * The total unclaimed rewards distributed to this reward pool.
       * NOTE: this is currently only used for integration tests.
       **/
      totalRewards: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * The total stake deposited to this reward pool.
       **/
      totalStake: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
    wrappedVaultRewards: {
      /**
       * Used to compute the rewards for a participant's stake.
       **/
      rewardPerToken: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Accounts for previous changes in stake size.
       **/
      rewardTally: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<SignedFixedPoint>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * The stake of a participant in this reward pool.
       **/
      stake: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<SignedFixedPoint>, [AccountId]> & QueryableStorageEntry<ApiType, [AccountId]>;
      /**
       * The total unclaimed rewards distributed to this reward pool.
       * NOTE: this is currently only used for integration tests.
       **/
      totalRewards: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * The total stake deposited to this reward pool.
       **/
      totalStake: AugmentedQuery<ApiType, () => Observable<SignedFixedPoint>, []> & QueryableStorageEntry<ApiType, []>;
      /**
       * Generic query
       **/
      [key: string]: QueryableStorageEntry<ApiType>;
    };
  }

  export interface QueryableStorage<ApiType extends ApiTypes> extends AugmentedQueries<ApiType> {
    [key: string]: QueryableModuleStorage<ApiType>;
  }
}