@polkadot/api-augment 7.0.3-1 → 7.0.3-13

package/kusama/query.d.ts

@@ -0,0 +1,1925 @@
+import type { ApiTypes } from '@polkadot/api-base/types';
+import type { Data } from '@polkadot/types';
+import type { BTreeMap, Bytes, Null, Option, U8aFixed, Vec, WrapperOpaque, bool, u128, u32, u64 } from '@polkadot/types-codec';
+import type { AnyNumber, ITuple } from '@polkadot/types-codec/types';
+import type { EthereumAddress } from '@polkadot/types/interfaces/eth';
+import type { AccountId32, Call, H256, Perbill, Percent } from '@polkadot/types/interfaces/runtime';
+import type { FrameSupportWeightsPerDispatchClassU64, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, KusamaRuntimeSessionKeys, PalletAuthorshipUncleEntryItem, PalletBagsListListBag, PalletBagsListListNode, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReleases, PalletBalancesReserveData, PalletBountiesBounty, PalletCollectiveVotes, PalletDemocracyPreimageStatus, PalletDemocracyReferendumInfo, PalletDemocracyReleases, PalletDemocracyVoteThreshold, PalletDemocracyVoteVoting, PalletElectionProviderMultiPhasePhase, PalletElectionProviderMultiPhaseReadySolution, PalletElectionProviderMultiPhaseRoundSnapshot, PalletElectionProviderMultiPhaseSignedSignedSubmission, PalletElectionProviderMultiPhaseSolutionOrSnapshotSize, PalletElectionsPhragmenSeatHolder, PalletElectionsPhragmenVoter, PalletGiltActiveGilt, PalletGiltActiveGiltsTotal, PalletGiltGiltBid, PalletGrandpaStoredPendingChange, PalletGrandpaStoredState, PalletIdentityRegistrarInfo, PalletIdentityRegistration, PalletImOnlineBoundedOpaqueNetworkState, PalletImOnlineSr25519AppSr25519Public, PalletMultisigMultisig, PalletPreimageRequestStatus, PalletProxyAnnouncement, PalletProxyProxyDefinition, PalletRecoveryActiveRecovery, PalletRecoveryRecoveryConfig, PalletSchedulerReleases, PalletSchedulerScheduledV3, PalletSocietyBid, PalletSocietyBidKind, PalletSocietyVote, PalletSocietyVouchingStatus, PalletStakingActiveEraInfo, PalletStakingEraRewardPoints, PalletStakingExposure, PalletStakingForcing, PalletStakingNominations, PalletStakingReleases, PalletStakingRewardDestination, PalletStakingSlashingSlashingSpans, PalletStakingSlashingSpanRecord, PalletStakingStakingLedger, PalletStakingUnappliedSlash, PalletStakingValidatorPrefs, PalletTipsOpenTip, PalletTransactionPaymentReleases, PalletTreasuryProposal, PalletVestingReleases, PalletVestingVestingInfo, PalletXcmQueryStatus, PalletXcmVersionMigrationStage, PolkadotCorePrimitivesInboundDownwardMessage, PolkadotCorePrimitivesInboundHrmpMessage, PolkadotParachainPrimitivesHrmpChannelId, PolkadotPrimitivesV0ValidatorAppPublic, PolkadotPrimitivesV1AssignmentAppPublic, PolkadotPrimitivesV1CandidateCommitments, PolkadotPrimitivesV1CoreOccupied, PolkadotPrimitivesV1DisputeState, PolkadotPrimitivesV1ScrapedOnChainVotes, PolkadotPrimitivesV1SessionInfo, PolkadotPrimitivesV1UpgradeGoAhead, PolkadotPrimitivesV1UpgradeRestriction, PolkadotRuntimeCommonClaimsStatementKind, PolkadotRuntimeCommonCrowdloanFundInfo, PolkadotRuntimeCommonParasRegistrarParaInfo, PolkadotRuntimeParachainsConfigurationHostConfiguration, PolkadotRuntimeParachainsConfigurationMigrationV1HostConfiguration, PolkadotRuntimeParachainsHrmpHrmpChannel, PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest, PolkadotRuntimeParachainsInclusionAvailabilityBitfieldRecord, PolkadotRuntimeParachainsInclusionCandidatePendingAvailability, PolkadotRuntimeParachainsInitializerBufferedSessionChange, PolkadotRuntimeParachainsParasParaGenesisArgs, PolkadotRuntimeParachainsParasParaLifecycle, PolkadotRuntimeParachainsParasParaPastCodeMeta, PolkadotRuntimeParachainsParasPvfCheckActiveVoteState, PolkadotRuntimeParachainsSchedulerCoreAssignment, PolkadotRuntimeParachainsSchedulerParathreadClaimQueue, SpConsensusBabeAppPublic, SpConsensusBabeBabeEpochConfiguration, SpConsensusBabeDigestsNextConfigDescriptor, SpCoreCryptoKeyTypeId, SpRuntimeDigest, SpStakingOffenceOffenceDetails, XcmVersionedMultiLocation } from '@polkadot/types/lookup';
+import type { Observable } from '@polkadot/types/types';
+declare module '@polkadot/api-base/types/storage' {
+    interface AugmentedQueries<ApiType extends ApiTypes> {
+        auctions: {
+            /**
+             * Number of auctions started so far.
+             **/
+            auctionCounter: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Information relating to the current auction, if there is one.
+             *
+             * The first item in the tuple is the lease period index that the first of the four
+             * contiguous lease periods on auction is for. The second is the block number when the
+             * auction will "begin to end", i.e. the first block of the Ending Period of the auction.
+             **/
+            auctionInfo: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Amounts currently reserved in the accounts of the bidders currently winning
+             * (sub-)ranges.
+             **/
+            reservedAmounts: AugmentedQuery<ApiType, (arg: ITuple<[AccountId32, u32]> | [AccountId32 | string | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<Option<u128>>, [ITuple<[AccountId32, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[AccountId32, u32]>]>;
+            /**
+             * The winning bids for each of the 10 ranges at each sample in the final Ending Period of
+             * the current auction. The map's key is the 0-based index into the Sample Size. The
+             * first sample of the ending period is 0; the last is `Sample Size - 1`.
+             **/
+            winning: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Vec<Option<ITuple<[AccountId32, u32, u128]>>>>>, [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>;
+        };
+        babe: {
+            /**
+             * Current epoch authorities.
+             **/
+            authorities: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[SpConsensusBabeAppPublic, u64]>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * This field should always be populated during block processing unless
+             * secondary plain slots are enabled (which don't contain a VRF output).
+             *
+             * It is set in `on_initialize`, before it will contain the value from the last block.
+             **/
+            authorVrfRandomness: AugmentedQuery<ApiType, () => Observable<Option<U8aFixed>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Current slot number.
+             **/
+            currentSlot: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The configuration for the current epoch. Should never be `None` as it is initialized in
+             * genesis.
+             **/
+            epochConfig: AugmentedQuery<ApiType, () => Observable<Option<SpConsensusBabeBabeEpochConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Current epoch index.
+             **/
+            epochIndex: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The block numbers when the last and current epoch have started, respectively `N-1` and
+             * `N`.
+             * NOTE: We track this is in order to annotate the block number when a given pool of
+             * entropy was fixed (i.e. it was known to chain observers). Since epochs are defined in
+             * slots, which may be skipped, the block numbers may not line up with the slot numbers.
+             **/
+            epochStart: AugmentedQuery<ApiType, () => Observable<ITuple<[u32, u32]>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The slot at which the first epoch actually started. This is 0
+             * until the first block of the chain.
+             **/
+            genesisSlot: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Temporary value (cleared at block finalization) which is `Some`
+             * if per-block initialization has already been called for current block.
+             **/
+            initialized: AugmentedQuery<ApiType, () => Observable<Option<Option<U8aFixed>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * How late the current block is compared to its parent.
+             *
+             * This entry is populated as part of block execution and is cleaned up
+             * on block finalization. Querying this storage entry outside of block
+             * execution context should always yield zero.
+             **/
+            lateness: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Next epoch authorities.
+             **/
+            nextAuthorities: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[SpConsensusBabeAppPublic, u64]>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The configuration for the next epoch, `None` if the config will not change
+             * (you can fallback to `EpochConfig` instead in that case).
+             **/
+            nextEpochConfig: AugmentedQuery<ApiType, () => Observable<Option<SpConsensusBabeBabeEpochConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Next epoch randomness.
+             **/
+            nextRandomness: AugmentedQuery<ApiType, () => Observable<U8aFixed>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Pending epoch configuration change that will be applied when the next epoch is enacted.
+             **/
+            pendingEpochConfigChange: AugmentedQuery<ApiType, () => Observable<Option<SpConsensusBabeDigestsNextConfigDescriptor>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The epoch randomness for the *current* epoch.
+             *
+             * # Security
+             *
+             * This MUST NOT be used for gambling, as it can be influenced by a
+             * malicious validator in the short term. It MAY be used in many
+             * cryptographic protocols, however, so long as one remembers that this
+             * (like everything else on-chain) it is public. For example, it can be
+             * used where a number is needed that cannot have been chosen by an
+             * adversary, for purposes such as public-coin zero-knowledge proofs.
+             **/
+            randomness: AugmentedQuery<ApiType, () => Observable<U8aFixed>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Randomness under construction.
+             *
+             * We make a trade-off between storage accesses and list length.
+             * We store the under-construction randomness in segments of up to
+             * `UNDER_CONSTRUCTION_SEGMENT_LENGTH`.
+             *
+             * Once a segment reaches this length, we begin the next one.
+             * We reset all segments and return to `0` at the beginning of every
+             * epoch.
+             **/
+            segmentIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * TWOX-NOTE: `SegmentIndex` is an increasing integer, so this is okay.
+             **/
+            underConstruction: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<U8aFixed>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        bagsList: {
+            /**
+             * Counter for the related counted storage map
+             **/
+            counterForListNodes: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * A bag stored in storage.
+             *
+             * Stores a `Bag` struct, which stores head and tail pointers to itself.
+             **/
+            listBags: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<PalletBagsListListBag>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
+            /**
+             * A single node, within some bag.
+             *
+             * Nodes store links forward and back within their respective bags.
+             **/
+            listNodes: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletBagsListListNode>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        balances: {
+            /**
+             * 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: AccountId32 | string | Uint8Array) => Observable<PalletBalancesAccountData>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Any liquidity locks on some account balances.
+             * NOTE: Should only be accessed when setting, changing and freeing a lock.
+             **/
+            locks: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesBalanceLock>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Named reserves on some account balances.
+             **/
+            reserves: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesReserveData>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Storage version of the pallet.
+             *
+             * This is set to v2.0.0 for new networks.
+             **/
+            storageVersion: AugmentedQuery<ApiType, () => Observable<PalletBalancesReleases>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The total units issued in the system.
+             **/
+            totalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        bounties: {
+            /**
+             * Bounties that have been made.
+             **/
+            bounties: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletBountiesBounty>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Bounty indices that have been approved but not yet funded.
+             **/
+            bountyApprovals: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Number of bounty proposals that have been made.
+             **/
+            bountyCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The description of each bounty.
+             **/
+            bountyDescriptions: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        claims: {
+            claims: AugmentedQuery<ApiType, (arg: EthereumAddress | string | Uint8Array) => Observable<Option<u128>>, [EthereumAddress]> & QueryableStorageEntry<ApiType, [EthereumAddress]>;
+            /**
+             * Pre-claimed Ethereum accounts, by the Account ID that they are claimed to.
+             **/
+            preclaims: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<EthereumAddress>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * The statement kind that must be signed, if any.
+             **/
+            signing: AugmentedQuery<ApiType, (arg: EthereumAddress | string | Uint8Array) => Observable<Option<PolkadotRuntimeCommonClaimsStatementKind>>, [EthereumAddress]> & QueryableStorageEntry<ApiType, [EthereumAddress]>;
+            total: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Vesting schedule for a claim.
+             * First balance is the total amount that should be held for vesting.
+             * Second balance is how much should be unlocked per block.
+             * The block number is when the vesting should start.
+             **/
+            vesting: AugmentedQuery<ApiType, (arg: EthereumAddress | string | Uint8Array) => Observable<Option<ITuple<[u128, u128, u32]>>>, [EthereumAddress]> & QueryableStorageEntry<ApiType, [EthereumAddress]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        configuration: {
+            /**
+             * The active configuration for the current session.
+             **/
+            activeConfig: AugmentedQuery<ApiType, () => Observable<PolkadotRuntimeParachainsConfigurationHostConfiguration>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Pending configuration (if any) for the next session.
+             *
+             * DEPRECATED: This is no longer used, and will be removed in the future.
+             **/
+            pendingConfig: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PolkadotRuntimeParachainsConfigurationMigrationV1HostConfiguration>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Pending configuration changes.
+             *
+             * This is a list of configuration changes, each with a session index at which it should
+             * be applied.
+             *
+             * The list is sorted ascending by session index. Also, this list can only contain at most
+             * 2 items: for the next session and for the `scheduled_session`.
+             **/
+            pendingConfigs: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, PolkadotRuntimeParachainsConfigurationHostConfiguration]>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        council: {
+            /**
+             * 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>;
+        };
+        crowdloan: {
+            /**
+             * The number of auctions that have entered into their ending period so far.
+             **/
+            endingsCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Info on all of the funds.
+             **/
+            funds: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PolkadotRuntimeCommonCrowdloanFundInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The funds that have had additional contributions during the last block. This is used
+             * in order to determine which funds should submit new or updated bids.
+             **/
+            newRaise: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Tracker for the next available trie index
+             **/
+            nextTrieIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        democracy: {
+            /**
+             * A record of who vetoed what. Maps proposal hash to a possible existent block number
+             * (until when it may not be resubmitted) and who vetoed it.
+             **/
+            blacklist: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<ITuple<[u32, Vec<AccountId32>]>>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
+            /**
+             * Record of all proposals that have been subject to emergency cancellation.
+             **/
+            cancellations: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<bool>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
+            /**
+             * 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]>;
+            /**
+             * True if the last referendum tabled was submitted externally. False if it was a public
+             * proposal.
+             **/
+            lastTabledWasExternal: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Accounts for which there are locks in action which may be removed at some point in the
+             * future. The value is the block number at which the lock expires and may be removed.
+             *
+             * TWOX-NOTE: OK ― `AccountId` is a secure hash.
+             **/
+            locks: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * 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, []>;
+            /**
+             * The referendum to be tabled whenever it would be valid to table an external proposal.
+             * This happens when a referendum needs to be tabled and one of two conditions are met:
+             * - `LastTabledWasExternal` is `false`; or
+             * - `PublicProps` is empty.
+             **/
+            nextExternal: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[H256, PalletDemocracyVoteThreshold]>>>, []> & 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<PalletDemocracyPreimageStatus>>, [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<PalletDemocracyReferendumInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Storage version of the pallet.
+             *
+             * New networks start with last version.
+             **/
+            storageVersion: AugmentedQuery<ApiType, () => Observable<Option<PalletDemocracyReleases>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * All votes for a particular voter. We store the balance for the number of votes that we
+             * have recorded. The second item is the total amount of delegations, that will be added.
+             *
+             * TWOX-NOTE: SAFE as `AccountId`s are crypto hashes anyway.
+             **/
+            votingOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletDemocracyVoteVoting>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        dmp: {
+            /**
+             * A mapping that stores the downward message queue MQC head for each para.
+             *
+             * Each link in this chain has a form:
+             * `(prev_head, B, H(M))`, where
+             * - `prev_head`: is the previous head hash or zero if none.
+             * - `B`: is the relay-chain block number in which a message was appended.
+             * - `H(M)`: is the hash of the message being appended.
+             **/
+            downwardMessageQueueHeads: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<H256>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The downward messages addressed for a certain para.
+             **/
+            downwardMessageQueues: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<PolkadotCorePrimitivesInboundDownwardMessage>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        electionProviderMultiPhase: {
+            /**
+             * Current phase.
+             **/
+            currentPhase: AugmentedQuery<ApiType, () => Observable<PalletElectionProviderMultiPhasePhase>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Desired number of targets to elect for this round.
+             *
+             * Only exists when [`Snapshot`] is present.
+             **/
+            desiredTargets: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The minimum score that each 'untrusted' solution must attain in order to be considered
+             * feasible.
+             *
+             * Can be set via `set_minimum_untrusted_score`.
+             **/
+            minimumUntrustedScore: AugmentedQuery<ApiType, () => Observable<Option<Vec<u128>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Current best solution, signed or unsigned, queued to be returned upon `elect`.
+             **/
+            queuedSolution: AugmentedQuery<ApiType, () => Observable<Option<PalletElectionProviderMultiPhaseReadySolution>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Internal counter for the number of rounds.
+             *
+             * This is useful for de-duplication of transactions submitted to the pool, and general
+             * diagnostics of the pallet.
+             *
+             * This is merely incremented once per every time that an upstream `elect` is called.
+             **/
+            round: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * A sorted, bounded set of `(score, index)`, where each `index` points to a value in
+             * `SignedSubmissions`.
+             *
+             * We never need to process more than a single signed submission at a time. Signed submissions
+             * can be quite large, so we're willing to pay the cost of multiple database accesses to access
+             * them one at a time instead of reading and decoding all of them at once.
+             **/
+            signedSubmissionIndices: AugmentedQuery<ApiType, () => Observable<BTreeMap<Vec<u128>, u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The next index to be assigned to an incoming signed submission.
+             *
+             * Every accepted submission is assigned a unique index; that index is bound to that particular
+             * submission for the duration of the election. On election finalization, the next index is
+             * reset to 0.
+             *
+             * We can't just use `SignedSubmissionIndices.len()`, because that's a bounded set; past its
+             * capacity, it will simply saturate. We can't just iterate over `SignedSubmissionsMap`,
+             * because iteration is slow. Instead, we store the value here.
+             **/
+            signedSubmissionNextIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Unchecked, signed solutions.
+             *
+             * Together with `SubmissionIndices`, this stores a bounded set of `SignedSubmissions` while
+             * allowing us to keep only a single one in memory at a time.
+             *
+             * Twox note: the key of the map is an auto-incrementing index which users cannot inspect or
+             * affect; we shouldn't need a cryptographically secure hasher.
+             **/
+            signedSubmissionsMap: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletElectionProviderMultiPhaseSignedSignedSubmission>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Snapshot data of the round.
+             *
+             * This is created at the beginning of the signed phase and cleared upon calling `elect`.
+             **/
+            snapshot: AugmentedQuery<ApiType, () => Observable<Option<PalletElectionProviderMultiPhaseRoundSnapshot>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The metadata of the [`RoundSnapshot`]
+             *
+             * Only exists when [`Snapshot`] is present.
+             **/
+            snapshotMetadata: AugmentedQuery<ApiType, () => Observable<Option<PalletElectionProviderMultiPhaseSolutionOrSnapshotSize>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        gilt: {
+            /**
+             * The currently active gilts, indexed according to the order of creation.
+             **/
+            active: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletGiltActiveGilt>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Information relating to the gilts currently active.
+             **/
+            activeTotal: AugmentedQuery<ApiType, () => Observable<PalletGiltActiveGiltsTotal>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The queues of bids ready to become gilts. Indexed by duration (in `Period`s).
+             **/
+            queues: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<PalletGiltGiltBid>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The totals of items and balances within each queue. Saves a lot of storage reads in the
+             * case of sparsely packed queues.
+             *
+             * The vector is indexed by duration in `Period`s, offset by one, so information on the queue
+             * whose duration is one `Period` would be storage `0`.
+             **/
+            queueTotals: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, u128]>>>, []> & 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>;
+        };
+        hrmp: {
+            /**
+             * This mapping tracks how many open channel requests were accepted by a given recipient para.
+             * Invariant: `HrmpOpenChannelRequests` should contain the same number of items `(_, X)` with
+             * `confirmed` set to true, as the number of `HrmpAcceptedChannelRequestCount` for `X`.
+             **/
+            hrmpAcceptedChannelRequestCount: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Storage for the messages for each channel.
+             * Invariant: cannot be non-empty if the corresponding channel in `HrmpChannels` is `None`.
+             **/
+            hrmpChannelContents: AugmentedQuery<ApiType, (arg: PolkadotParachainPrimitivesHrmpChannelId | {
+                sender?: any;
+                recipient?: any;
+            } | string | Uint8Array) => Observable<Vec<PolkadotCorePrimitivesInboundHrmpMessage>>, [PolkadotParachainPrimitivesHrmpChannelId]> & QueryableStorageEntry<ApiType, [PolkadotParachainPrimitivesHrmpChannelId]>;
+            /**
+             * Maintains a mapping that can be used to answer the question:
+             * What paras sent a message at the given block number for a given receiver.
+             * Invariants:
+             * - The inner `Vec<ParaId>` is never empty.
+             * - The inner `Vec<ParaId>` cannot store two same `ParaId`.
+             * - The outer vector is sorted ascending by block number and cannot store two items with the same
+             * block number.
+             **/
+            hrmpChannelDigests: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, Vec<u32>]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * HRMP channel data associated with each para.
+             * Invariant:
+             * - each participant in the channel should satisfy `Paras::is_valid_para(P)` within a session.
+             **/
+            hrmpChannels: AugmentedQuery<ApiType, (arg: PolkadotParachainPrimitivesHrmpChannelId | {
+                sender?: any;
+                recipient?: any;
+            } | string | Uint8Array) => Observable<Option<PolkadotRuntimeParachainsHrmpHrmpChannel>>, [PolkadotParachainPrimitivesHrmpChannelId]> & QueryableStorageEntry<ApiType, [PolkadotParachainPrimitivesHrmpChannelId]>;
+            /**
+             * A set of pending HRMP close channel requests that are going to be closed during the session change.
+             * Used for checking if a given channel is registered for closure.
+             *
+             * The set is accompanied by a list for iteration.
+             *
+             * Invariant:
+             * - There are no channels that exists in list but not in the set and vice versa.
+             **/
+            hrmpCloseChannelRequests: AugmentedQuery<ApiType, (arg: PolkadotParachainPrimitivesHrmpChannelId | {
+                sender?: any;
+                recipient?: any;
+            } | string | Uint8Array) => Observable<Option<Null>>, [PolkadotParachainPrimitivesHrmpChannelId]> & QueryableStorageEntry<ApiType, [PolkadotParachainPrimitivesHrmpChannelId]>;
+            hrmpCloseChannelRequestsList: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotParachainPrimitivesHrmpChannelId>>, []> & QueryableStorageEntry<ApiType, []>;
+            hrmpEgressChannelsIndex: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Ingress/egress indexes allow to find all the senders and receivers given the opposite
+             * side. I.e.
+             *
+             * (a) ingress index allows to find all the senders for a given recipient.
+             * (b) egress index allows to find all the recipients for a given sender.
+             *
+             * Invariants:
+             * - for each ingress index entry for `P` each item `I` in the index should present in `HrmpChannels`
+             * as `(I, P)`.
+             * - for each egress index entry for `P` each item `E` in the index should present in `HrmpChannels`
+             * as `(P, E)`.
+             * - there should be no other dangling channels in `HrmpChannels`.
+             * - the vectors are sorted.
+             **/
+            hrmpIngressChannelsIndex: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * This mapping tracks how many open channel requests are initiated by a given sender para.
+             * Invariant: `HrmpOpenChannelRequests` should contain the same number of items that has `(X, _)`
+             * as the number of `HrmpOpenChannelRequestCount` for `X`.
+             **/
+            hrmpOpenChannelRequestCount: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The set of pending HRMP open channel requests.
+             *
+             * The set is accompanied by a list for iteration.
+             *
+             * Invariant:
+             * - There are no channels that exists in list but not in the set and vice versa.
+             **/
+            hrmpOpenChannelRequests: AugmentedQuery<ApiType, (arg: PolkadotParachainPrimitivesHrmpChannelId | {
+                sender?: any;
+                recipient?: any;
+            } | string | Uint8Array) => Observable<Option<PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest>>, [PolkadotParachainPrimitivesHrmpChannelId]> & QueryableStorageEntry<ApiType, [PolkadotParachainPrimitivesHrmpChannelId]>;
+            hrmpOpenChannelRequestsList: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotParachainPrimitivesHrmpChannelId>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The HRMP watermark associated with each para.
+             * Invariant:
+             * - each para `P` used here as a key should satisfy `Paras::is_valid_para(P)` within a session.
+             **/
+            hrmpWatermarks: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * 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>;
+        };
+        imOnline: {
+            /**
+             * For each session index, we keep a mapping of `ValidatorId<T>` to the
+             * number of blocks authored by the given authority.
+             **/
+            authoredBlocks: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<u32>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
+            /**
+             * The block number after which it's ok to send heartbeats in the current
+             * session.
+             *
+             * At the beginning of each session we set this to a value that should fall
+             * roughly in the middle of the session duration. The idea is to first wait for
+             * the validators to produce a block in the current session, so that the
+             * heartbeat later on will not be necessary.
+             *
+             * This value will only be used as a fallback if we fail to get a proper session
+             * progress estimate from `NextSessionRotation`, as those estimates should be
+             * more accurate then the value we calculate for `HeartbeatAfter`.
+             **/
+            heartbeatAfter: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The current set of keys that may issue a heartbeat.
+             **/
+            keys: AugmentedQuery<ApiType, () => Observable<Vec<PalletImOnlineSr25519AppSr25519Public>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * For each session index, we keep a mapping of `SessionIndex` and `AuthIndex` to
+             * `WrapperOpaque<BoundedOpaqueNetworkState>`.
+             **/
+            receivedHeartbeats: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<WrapperOpaque<PalletImOnlineBoundedOpaqueNetworkState>>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        indices: {
+            /**
+             * The lookup from index to account.
+             **/
+            accounts: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[AccountId32, u128, bool]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        initializer: {
+            /**
+             * Buffered session changes along with the block number at which they should be applied.
+             *
+             * Typically this will be empty or one element long. Apart from that this item never hits
+             * the storage.
+             *
+             * However this is a `Vec` regardless to handle various edge cases that may occur at runtime
+             * upgrade boundaries or if governance intervenes.
+             **/
+            bufferedSessionChanges: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotRuntimeParachainsInitializerBufferedSessionChange>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Whether the parachains modules have been initialized within this block.
+             *
+             * Semantically a `bool`, but this guarantees it should never hit the trie,
+             * as this is cleared in `on_finalize` and Frame optimizes `None` values to be empty values.
+             *
+             * As a `bool`, `set(false)` and `remove()` both lead to the next `get()` being false, but one of
+             * them writes to the trie and one does not. This confusion makes `Option<()>` more suitable for
+             * the semantics of this variable.
+             **/
+            hasInitialized: AugmentedQuery<ApiType, () => Observable<Option<Null>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        multisig: {
+            calls: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Option<ITuple<[Bytes, 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>;
+        };
+        offences: {
+            /**
+             * A vector of reports of the same kind that happened at the same time slot.
+             **/
+            concurrentReportsIndex: AugmentedQuery<ApiType, (arg1: U8aFixed | string | Uint8Array, arg2: Bytes | string | Uint8Array) => Observable<Vec<H256>>, [U8aFixed, Bytes]> & QueryableStorageEntry<ApiType, [U8aFixed, Bytes]>;
+            /**
+             * The primary structure that holds all offence records keyed by report identifiers.
+             **/
+            reports: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<SpStakingOffenceOffenceDetails>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
+            /**
+             * Enumerates all reports of a kind along with the time they happened.
+             *
+             * All reports are sorted by the time of offence.
+             *
+             * Note that the actual type of this mapping is `Vec<u8>`, this is because values of
+             * different types are not supported at the moment so we are doing the manual serialization.
+             **/
+            reportsByKindIndex: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Bytes>, [U8aFixed]> & QueryableStorageEntry<ApiType, [U8aFixed]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        paraInclusion: {
+            /**
+             * The latest bitfield for each validator, referred to by their index in the validator set.
+             **/
+            availabilityBitfields: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PolkadotRuntimeParachainsInclusionAvailabilityBitfieldRecord>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Candidates pending availability by `ParaId`.
+             **/
+            pendingAvailability: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PolkadotRuntimeParachainsInclusionCandidatePendingAvailability>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The commitments of candidates pending availability, by `ParaId`.
+             **/
+            pendingAvailabilityCommitments: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PolkadotPrimitivesV1CandidateCommitments>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        paraInherent: {
+            /**
+             * Whether the paras inherent was included within this block.
+             *
+             * The `Option<()>` is effectively a `bool`, but it never hits storage in the `None` variant
+             * due to the guarantees of FRAME's storage APIs.
+             *
+             * If this is `None` at the end of the block, we panic and render the block invalid.
+             **/
+            included: AugmentedQuery<ApiType, () => Observable<Option<Null>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Scraped on chain data for extracting resolved disputes as well as backing votes.
+             **/
+            onChainVotes: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV1ScrapedOnChainVotes>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        paras: {
+            /**
+             * The actions to perform during the start of a specific session index.
+             **/
+            actionsQueue: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Validation code stored by its hash.
+             *
+             * This storage is consistent with [`FutureCodeHash`], [`CurrentCodeHash`] and
+             * [`PastCodeHash`].
+             **/
+            codeByHash: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<Bytes>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
+            /**
+             * The number of reference on the validation code in [`CodeByHash`] storage.
+             **/
+            codeByHashRefs: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<u32>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
+            /**
+             * The validation code hash of every live para.
+             *
+             * Corresponding code can be retrieved with [`CodeByHash`].
+             **/
+            currentCodeHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<H256>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The actual future code hash of a para.
+             *
+             * Corresponding code can be retrieved with [`CodeByHash`].
+             **/
+            futureCodeHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<H256>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The block number at which the planned code change is expected for a para.
+             * The change will be applied after the first parablock for this ID included which executes
+             * in the context of a relay chain block with a number >= `expected_at`.
+             **/
+            futureCodeUpgrades: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The head-data of every registered para.
+             **/
+            heads: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * All parachains. Ordered ascending by `ParaId`. Parathreads are not included.
+             **/
+            parachains: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The current lifecycle of a all known Para IDs.
+             **/
+            paraLifecycles: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PolkadotRuntimeParachainsParasParaLifecycle>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Actual past code hash, indicated by the para id as well as the block number at which it
+             * became outdated.
+             *
+             * Corresponding code can be retrieved with [`CodeByHash`].
+             **/
+            pastCodeHash: AugmentedQuery<ApiType, (arg: ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<Option<H256>>, [ITuple<[u32, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[u32, u32]>]>;
+            /**
+             * Past code of parachains. The parachains themselves may not be registered anymore,
+             * but we also keep their code on-chain for the same amount of time as outdated code
+             * to keep it available for secondary checkers.
+             **/
+            pastCodeMeta: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<PolkadotRuntimeParachainsParasParaPastCodeMeta>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Which paras have past code that needs pruning and the relay-chain block at which the code was replaced.
+             * Note that this is the actual height of the included block, not the expected height at which the
+             * code upgrade would be applied, although they may be equal.
+             * This is to ensure the entire acceptance period is covered, not an offset acceptance period starting
+             * from the time at which the parachain perceives a code upgrade as having occurred.
+             * Multiple entries for a single para are permitted. Ordered ascending by block number.
+             **/
+            pastCodePruning: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The list of all currently active PVF votes. Auxiliary to `PvfActiveVoteMap`.
+             **/
+            pvfActiveVoteList: AugmentedQuery<ApiType, () => Observable<Vec<H256>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * All currently active PVF pre-checking votes.
+             *
+             * Invariant:
+             * - There are no PVF pre-checking votes that exists in list but not in the set and vice versa.
+             **/
+            pvfActiveVoteMap: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PolkadotRuntimeParachainsParasPvfCheckActiveVoteState>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
+            /**
+             * Upcoming paras instantiation arguments.
+             *
+             * NOTE that after PVF pre-checking is enabled the para genesis arg will have it's code set
+             * to empty. Instead, the code will be saved into the storage right away via `CodeByHash`.
+             **/
+            upcomingParasGenesis: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PolkadotRuntimeParachainsParasParaGenesisArgs>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The list of upcoming code upgrades. Each item is a pair of which para performs a code
+             * upgrade and at which relay-chain block it is expected at.
+             *
+             * Ordered ascending by block number.
+             **/
+            upcomingUpgrades: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The list of parachains that are awaiting for their upgrade restriction to cooldown.
+             *
+             * Ordered ascending by block number.
+             **/
+            upgradeCooldowns: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * This is used by the relay-chain to communicate to a parachain a go-ahead with in the upgrade procedure.
+             *
+             * This value is absent when there are no upgrades scheduled or during the time the relay chain
+             * performs the checks. It is set at the first relay-chain block when the corresponding parachain
+             * can switch its upgrade function. As soon as the parachain's block is included, the value
+             * gets reset to `None`.
+             *
+             * NOTE that this field is used by parachains via merkle storage proofs, therefore changing
+             * the format will require migration of parachains.
+             **/
+            upgradeGoAheadSignal: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PolkadotPrimitivesV1UpgradeGoAhead>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * This is used by the relay-chain to communicate that there are restrictions for performing
+             * an upgrade for this parachain.
+             *
+             * This may be a because the parachain waits for the upgrade cooldown to expire. Another
+             * potential use case is when we want to perform some maintenance (such as storage migration)
+             * we could restrict upgrades to make the process simpler.
+             *
+             * NOTE that this field is used by parachains via merkle storage proofs, therefore changing
+             * the format will require migration of parachains.
+             **/
+            upgradeRestrictionSignal: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PolkadotPrimitivesV1UpgradeRestriction>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        paraScheduler: {
+            /**
+             * One entry for each availability core. Entries are `None` if the core is not currently occupied. Can be
+             * temporarily `Some` if scheduled but not occupied.
+             * The i'th parachain belongs to the i'th core, with the remaining cores all being
+             * parathread-multiplexers.
+             *
+             * Bounded by the maximum of either of these two values:
+             * * The number of parachains and parathread multiplexers
+             * * The number of validators divided by `configuration.max_validators_per_core`.
+             **/
+            availabilityCores: AugmentedQuery<ApiType, () => Observable<Vec<Option<PolkadotPrimitivesV1CoreOccupied>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * An index used to ensure that only one claim on a parathread exists in the queue or is
+             * currently being handled by an occupied core.
+             *
+             * Bounded by the number of parathread cores and scheduling lookahead. Reasonably, 10 * 50 = 500.
+             **/
+            parathreadClaimIndex: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * A queue of upcoming claims and which core they should be mapped onto.
+             *
+             * The number of queued claims is bounded at the `scheduling_lookahead`
+             * multiplied by the number of parathread multiplexer cores. Reasonably, 10 * 50 = 500.
+             **/
+            parathreadQueue: AugmentedQuery<ApiType, () => Observable<PolkadotRuntimeParachainsSchedulerParathreadClaimQueue>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Currently scheduled cores - free but up to be occupied.
+             *
+             * Bounded by the number of cores: one for each parachain and parathread multiplexer.
+             *
+             * The value contained here will not be valid after the end of a block. Runtime APIs should be used to determine scheduled cores/
+             * for the upcoming block.
+             **/
+            scheduled: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotRuntimeParachainsSchedulerCoreAssignment>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The block number where the session start occurred. Used to track how many group rotations have occurred.
+             *
+             * Note that in the context of parachains modules the session change is signaled during
+             * the block and enacted at the end of the block (at the finalization stage, to be exact).
+             * Thus for all intents and purposes the effect of the session change is observed at the
+             * block following the session change, block number of which we save in this storage value.
+             **/
+            sessionStartBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * All the validator groups. One for each core. Indices are into `ActiveValidators` - not the
+             * broader set of Polkadot validators, but instead just the subset used for parachains during
+             * this session.
+             *
+             * Bound: The number of cores is the sum of the numbers of parachains and parathread multiplexers.
+             * Reasonably, 100-1000. The dominant factor is the number of validators: safe upper bound at 10k.
+             **/
+            validatorGroups: AugmentedQuery<ApiType, () => Observable<Vec<Vec<u32>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        parasDisputes: {
+            /**
+             * All ongoing or concluded disputes for the last several sessions.
+             **/
+            disputes: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: H256 | string | Uint8Array) => Observable<Option<PolkadotPrimitivesV1DisputeState>>, [u32, H256]> & QueryableStorageEntry<ApiType, [u32, H256]>;
+            /**
+             * Whether the chain is frozen. Starts as `None`. When this is `Some`,
+             * the chain will not accept any new parachain blocks for backing or inclusion,
+             * and its value indicates the last valid block number in the chain.
+             * It can only be set back to `None` by governance intervention.
+             **/
+            frozen: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * All included blocks on the chain, as well as the block number in this chain that
+             * should be reverted back to if the candidate is disputed and determined to be invalid.
+             **/
+            included: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: H256 | string | Uint8Array) => Observable<Option<u32>>, [u32, H256]> & QueryableStorageEntry<ApiType, [u32, H256]>;
+            /**
+             * The last pruned session, if any. All data stored by this module
+             * references sessions.
+             **/
+            lastPrunedSession: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Maps session indices to a vector indicating the number of potentially-spam disputes
+             * each validator is participating in. Potentially-spam disputes are remote disputes which have
+             * fewer than `byzantine_threshold + 1` validators.
+             *
+             * The i'th entry of the vector corresponds to the i'th validator in the session.
+             **/
+            spamSlots: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Vec<u32>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        paraSessionInfo: {
+            /**
+             * Assignment keys for the current session.
+             * Note that this API is private due to it being prone to 'off-by-one' at session boundaries.
+             * When in doubt, use `Sessions` API instead.
+             **/
+            assignmentKeysUnsafe: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotPrimitivesV1AssignmentAppPublic>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The earliest session for which previous session info is stored.
+             **/
+            earliestStoredSession: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Session information in a rolling window.
+             * Should have an entry in range `EarliestStoredSession..=CurrentSessionIndex`.
+             * Does not have any entries before the session index in the first session change notification.
+             **/
+            sessions: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PolkadotPrimitivesV1SessionInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        parasShared: {
+            /**
+             * All the validators actively participating in parachain consensus.
+             * Indices are into the broader validator set.
+             **/
+            activeValidatorIndices: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The parachain attestation keys of the validators actively participating in parachain consensus.
+             * This should be the same length as `ActiveValidatorIndices`.
+             **/
+            activeValidatorKeys: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotPrimitivesV0ValidatorAppPublic>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The current session index.
+             **/
+            currentSessionIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        phragmenElection: {
+            /**
+             * The present candidate list. A current member or runner-up can never enter this vector
+             * and is always implicitly assumed to be a candidate.
+             *
+             * Second element is the deposit.
+             *
+             * Invariant: Always sorted based on account id.
+             **/
+            candidates: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[AccountId32, u128]>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The total number of vote rounds that have happened, excluding the upcoming one.
+             **/
+            electionRounds: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The current elected members.
+             *
+             * Invariant: Always sorted based on account id.
+             **/
+            members: AugmentedQuery<ApiType, () => Observable<Vec<PalletElectionsPhragmenSeatHolder>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The current reserved runners-up.
+             *
+             * Invariant: Always sorted based on rank (worse to best). Upon removal of a member, the
+             * last (i.e. _best_) runner-up will be replaced.
+             **/
+            runnersUp: AugmentedQuery<ApiType, () => Observable<Vec<PalletElectionsPhragmenSeatHolder>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Votes and locked stake of a particular voter.
+             *
+             * TWOX-NOTE: SAFE as `AccountId` is a crypto hash.
+             **/
+            voting: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletElectionsPhragmenVoter>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * 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>;
+        };
+        proxy: {
+            /**
+             * The announcements made by the proxy (key).
+             **/
+            announcements: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[Vec<PalletProxyAnnouncement>, u128]>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * The set of account proxies. Maps the account which has delegated to the accounts
+             * which are being delegated to, together with the amount held on deposit.
+             **/
+            proxies: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[Vec<PalletProxyProxyDefinition>, u128]>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        recovery: {
+            /**
+             * Active recovery attempts.
+             *
+             * First account is the account to be recovered, and the second account
+             * is the user trying to recover the account.
+             **/
+            activeRecoveries: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<PalletRecoveryActiveRecovery>>, [AccountId32, AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32, AccountId32]>;
+            /**
+             * The list of allowed proxy accounts.
+             *
+             * Map from the user who can access it to the recovered account.
+             **/
+            proxy: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<AccountId32>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * The set of recoverable accounts and their recovery configuration.
+             **/
+            recoverable: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletRecoveryRecoveryConfig>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        registrar: {
+            /**
+             * The next free `ParaId`.
+             **/
+            nextFreeParaId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Amount held on deposit for each para and the original depositor.
+             *
+             * The given account ID is responsible for registering the code and initial head data, but may only do
+             * so if it isn't yet registered. (After that, it's up to governance to do so.)
+             **/
+            paras: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PolkadotRuntimeCommonParasRegistrarParaInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Pending swap operations.
+             **/
+            pendingSwap: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * 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]>;
+            /**
+             * Storage version of the pallet.
+             *
+             * New networks start with last version.
+             **/
+            storageVersion: AugmentedQuery<ApiType, () => Observable<PalletSchedulerReleases>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        session: {
+            /**
+             * Current index of the session.
+             **/
+            currentIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Indices of disabled validators.
+             *
+             * The vec is always kept sorted so that we can find whether a given validator is
+             * disabled using binary search. It gets cleared when `on_session_ending` returns
+             * a new set of identities.
+             **/
+            disabledValidators: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The owner of a key. The key is the `KeyTypeId` + the encoded key.
+             **/
+            keyOwner: AugmentedQuery<ApiType, (arg: ITuple<[SpCoreCryptoKeyTypeId, Bytes]> | [SpCoreCryptoKeyTypeId | string | Uint8Array, Bytes | string | Uint8Array]) => Observable<Option<AccountId32>>, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]> & QueryableStorageEntry<ApiType, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]>;
+            /**
+             * The next session keys for a validator.
+             **/
+            nextKeys: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<KusamaRuntimeSessionKeys>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * True if the underlying economic identities or weighting behind the validators
+             * has changed in the queued validator set.
+             **/
+            queuedChanged: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The queued keys for the next session. When the next session begins, these keys
+             * will be used to determine the validator's session keys.
+             **/
+            queuedKeys: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[AccountId32, KusamaRuntimeSessionKeys]>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The current set of validators.
+             **/
+            validators: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        slots: {
+            /**
+             * Amounts held on deposit for each (possibly future) leased parachain.
+             *
+             * The actual amount locked on its behalf by any account at any time is the maximum of the second values
+             * of the items in this list whose first value is the account.
+             *
+             * The first item in the list is the amount locked for the current Lease Period. Following
+             * items are for the subsequent lease periods.
+             *
+             * The default value (an empty list) implies that the parachain no longer exists (or never
+             * existed) as far as this pallet is concerned.
+             *
+             * If a parachain doesn't exist *yet* but is scheduled to exist in the future, then it
+             * will be left-padded with one or more `None`s to denote the fact that nothing is held on
+             * deposit for the non-existent chain currently, but is held at some point in the future.
+             *
+             * It is illegal for a `None` value to trail in the list.
+             **/
+            leases: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<Option<ITuple<[AccountId32, u128]>>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        society: {
+            /**
+             * The current bids, stored ordered by the value of the bid.
+             **/
+            bids: AugmentedQuery<ApiType, () => Observable<Vec<PalletSocietyBid>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The current set of candidates; bidders that are attempting to become members.
+             **/
+            candidates: AugmentedQuery<ApiType, () => Observable<Vec<PalletSocietyBid>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The defending member currently being challenged.
+             **/
+            defender: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Votes for the defender.
+             **/
+            defenderVotes: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletSocietyVote>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * The first member.
+             **/
+            founder: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The most primary from the most recently approved members.
+             **/
+            head: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The max number of members for the society at one time.
+             **/
+            maxMembers: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The current set of members, ordered.
+             **/
+            members: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Pending payouts; ordered by block number, with the amount that should be paid out.
+             **/
+            payouts: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<ITuple<[u32, u128]>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Amount of our account balance that is specifically for the next round's bid(s).
+             **/
+            pot: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * A hash of the rules of this society concerning membership. Can only be set once and
+             * only by the founder.
+             **/
+            rules: AugmentedQuery<ApiType, () => Observable<Option<H256>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The ongoing number of losing votes cast by the member.
+             **/
+            strikes: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u32>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * The set of suspended candidates.
+             **/
+            suspendedCandidates: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<ITuple<[u128, PalletSocietyBidKind]>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * The set of suspended members.
+             **/
+            suspendedMembers: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<bool>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Double map from Candidate -> Voter -> (Maybe) Vote.
+             **/
+            votes: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<PalletSocietyVote>>, [AccountId32, AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32, AccountId32]>;
+            /**
+             * Members currently vouching or banned from vouching again
+             **/
+            vouching: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletSocietyVouchingStatus>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        staking: {
+            /**
+             * The active era information, it holds index and start.
+             *
+             * The active era is the era being currently rewarded. Validator set of this era must be
+             * equal to [`SessionInterface::validators`].
+             **/
+            activeEra: AugmentedQuery<ApiType, () => Observable<Option<PalletStakingActiveEraInfo>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Map from all locked "stash" accounts to the controller account.
+             **/
+            bonded: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<AccountId32>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * A mapping from still-bonded eras to the first session index of that era.
+             *
+             * Must contains information for eras for the range:
+             * `[active_era - bounding_duration; active_era]`
+             **/
+            bondedEras: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The amount of currency given to reporters of a slash event which was
+             * canceled by extraordinary circumstances (e.g. governance).
+             **/
+            canceledSlashPayout: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The threshold for when users can start calling `chill_other` for other validators /
+             * nominators. The threshold is compared to the actual number of validators / nominators
+             * (`CountFor*`) in the system compared to the configured max (`Max*Count`).
+             **/
+            chillThreshold: AugmentedQuery<ApiType, () => Observable<Option<Percent>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Counter for the related counted storage map
+             **/
+            counterForNominators: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Counter for the related counted storage map
+             **/
+            counterForValidators: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The current era index.
+             *
+             * This is the latest planned era, depending on how the Session pallet queues the validator
+             * set, it might be active or not.
+             **/
+            currentEra: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The last planned session scheduled by the session pallet.
+             *
+             * This is basically in sync with the call to [`pallet_session::SessionManager::new_session`].
+             **/
+            currentPlannedSession: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The earliest era for which we have a pending, unapplied slash.
+             **/
+            earliestUnappliedSlash: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Rewards for the last `HISTORY_DEPTH` eras.
+             * If reward hasn't been set or has been removed then 0 reward is returned.
+             **/
+            erasRewardPoints: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<PalletStakingEraRewardPoints>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Exposure of validator at era.
+             *
+             * This is keyed first by the era index to allow bulk deletion and then the stash account.
+             *
+             * Is it removed after `HISTORY_DEPTH` eras.
+             * If stakers hasn't been set or has been removed then empty exposure is returned.
+             **/
+            erasStakers: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<PalletStakingExposure>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
+            /**
+             * Clipped Exposure of validator at era.
+             *
+             * This is similar to [`ErasStakers`] but number of nominators exposed is reduced to the
+             * `T::MaxNominatorRewardedPerValidator` biggest stakers.
+             * (Note: the field `total` and `own` of the exposure remains unchanged).
+             * This is used to limit the i/o cost for the nominator payout.
+             *
+             * This is keyed fist by the era index to allow bulk deletion and then the stash account.
+             *
+             * Is it removed after `HISTORY_DEPTH` eras.
+             * If stakers hasn't been set or has been removed then empty exposure is returned.
+             **/
+            erasStakersClipped: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<PalletStakingExposure>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
+            /**
+             * The session index at which the era start for the last `HISTORY_DEPTH` eras.
+             *
+             * Note: This tracks the starting session (i.e. session index when era start being active)
+             * for the eras in `[CurrentEra - HISTORY_DEPTH, CurrentEra]`.
+             **/
+            erasStartSessionIndex: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The total amount staked for the last `HISTORY_DEPTH` eras.
+             * If total hasn't been set or has been removed then 0 stake is returned.
+             **/
+            erasTotalStake: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Similar to `ErasStakers`, this holds the preferences of validators.
+             *
+             * This is keyed first by the era index to allow bulk deletion and then the stash account.
+             *
+             * Is it removed after `HISTORY_DEPTH` eras.
+             **/
+            erasValidatorPrefs: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<PalletStakingValidatorPrefs>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
+            /**
+             * The total validator era payout for the last `HISTORY_DEPTH` eras.
+             *
+             * Eras that haven't finished yet or has been removed doesn't have reward.
+             **/
+            erasValidatorReward: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u128>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Mode of era forcing.
+             **/
+            forceEra: AugmentedQuery<ApiType, () => Observable<PalletStakingForcing>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Number of eras to keep in history.
+             *
+             * Information is kept for eras in `[current_era - history_depth; current_era]`.
+             *
+             * Must be more than the number of eras delayed by session otherwise. I.e. active era must
+             * always be in history. I.e. `active_era > current_era - history_depth` must be
+             * guaranteed.
+             **/
+            historyDepth: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Any validators that may never be slashed or forcibly kicked. It's a Vec since they're
+             * easy to initialize and the performance hit is minimal (we expect no more than four
+             * invulnerables) and restricted to testnets.
+             **/
+            invulnerables: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Map from all (unlocked) "controller" accounts to the info regarding the staking.
+             **/
+            ledger: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletStakingStakingLedger>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * The maximum nominator count before we stop allowing new validators to join.
+             *
+             * When this value is not set, no limits are enforced.
+             **/
+            maxNominatorsCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The maximum validator count before we stop allowing new validators to join.
+             *
+             * When this value is not set, no limits are enforced.
+             **/
+            maxValidatorsCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The minimum amount of commission that validators can set.
+             *
+             * If set to `0`, no limit exists.
+             **/
+            minCommission: AugmentedQuery<ApiType, () => Observable<Perbill>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Minimum number of staking participants before emergency conditions are imposed.
+             **/
+            minimumValidatorCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The minimum active bond to become and maintain the role of a nominator.
+             **/
+            minNominatorBond: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The minimum active bond to become and maintain the role of a validator.
+             **/
+            minValidatorBond: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The map from nominator stash key to the set of stash keys of all validators to nominate.
+             **/
+            nominators: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletStakingNominations>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * All slashing events on nominators, mapped by era to the highest slash value of the era.
+             **/
+            nominatorSlashInEra: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u128>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
+            /**
+             * Indices of validators that have offended in the active era and whether they are currently
+             * disabled.
+             *
+             * This value should be a superset of disabled validators since not all offences lead to the
+             * validator being disabled (if there was no slash). This is needed to track the percentage of
+             * validators that have offended in the current era, ensuring a new era is forced if
+             * `OffendingValidatorsThreshold` is reached. The vec is always kept sorted so that we can find
+             * whether a given validator has previously offended using binary search. It gets cleared when
+             * the era ends.
+             **/
+            offendingValidators: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, bool]>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Where the reward payment should be made. Keyed by stash.
+             **/
+            payee: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletStakingRewardDestination>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Slashing spans for stash accounts.
+             **/
+            slashingSpans: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletStakingSlashingSlashingSpans>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * The percentage of the slash that is distributed to reporters.
+             *
+             * The rest of the slashed value is handled by the `Slash`.
+             **/
+            slashRewardFraction: AugmentedQuery<ApiType, () => Observable<Perbill>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Records information about the maximum slash of a stash within a slashing span,
+             * as well as how much reward has been paid out.
+             **/
+            spanSlash: AugmentedQuery<ApiType, (arg: ITuple<[AccountId32, u32]> | [AccountId32 | string | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<PalletStakingSlashingSpanRecord>, [ITuple<[AccountId32, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[AccountId32, u32]>]>;
+            /**
+             * True if network has been upgraded to this version.
+             * Storage version of the pallet.
+             *
+             * This is set to v7.0.0 for new networks.
+             **/
+            storageVersion: AugmentedQuery<ApiType, () => Observable<PalletStakingReleases>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * All unapplied slashes that are queued for later.
+             **/
+            unappliedSlashes: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<PalletStakingUnappliedSlash>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The ideal number of staking participants.
+             **/
+            validatorCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The map from (wannabe) validator stash key to the preferences of that validator.
+             **/
+            validators: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletStakingValidatorPrefs>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * All slashing events on validators, mapped by era to the highest slash proportion
+             * and slash value of the era.
+             **/
+            validatorSlashInEra: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<ITuple<[Perbill, u128]>>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
+            /**
+             * 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: This storage item is explicitly unbounded since it is never intended to be read
+             * 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>;
+        };
+        tips: {
+            /**
+             * Simple preimage lookup from the reason's hash to the original data. Again, has an
+             * insecure enumerable hash since the key is guaranteed to be the result of a secure hash.
+             **/
+            reasons: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<Bytes>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
+            /**
+             * TipsMap that are not yet completed. Keyed by the hash of `(reason, who)` from the value.
+             * This has the insecure enumerable hash function since the key itself is already
+             * guaranteed to be a secure hash.
+             **/
+            tips: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletTipsOpenTip>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
+            /**
+             * 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>;
+        };
+        ump: {
+            /**
+             * The ordered list of `ParaId`s that have a `RelayDispatchQueue` entry.
+             *
+             * Invariant:
+             * - The set of items from this vector should be exactly the set of the keys in
+             * `RelayDispatchQueues` and `RelayDispatchQueueSize`.
+             **/
+            needsDispatch: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * This is the para that gets will get dispatched first during the next upward dispatchable queue
+             * execution round.
+             *
+             * Invariant:
+             * - If `Some(para)`, then `para` must be present in `NeedsDispatch`.
+             **/
+            nextDispatchRoundStartWith: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The messages that exceeded max individual message weight budget.
+             *
+             * These messages stay there until manually dispatched.
+             **/
+            overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
+            /**
+             * The number of overweight messages ever recorded in `Overweight` (and thus the lowest free
+             * index).
+             **/
+            overweightCount: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The messages waiting to be handled by the relay-chain originating from a certain parachain.
+             *
+             * Note that some upward messages might have been already processed by the inclusion logic. E.g.
+             * channel management messages.
+             *
+             * The messages are processed in FIFO order.
+             **/
+            relayDispatchQueues: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<Bytes>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Size of the dispatch queues. Caches sizes of the queues in `RelayDispatchQueue`.
+             *
+             * First item in the tuple is the count of messages and second
+             * is the total length (in bytes) of the message payloads.
+             *
+             * Note that this is an auxiliary mapping: it's possible to tell the byte size and the number of
+             * messages only looking at `RelayDispatchQueues`. This mapping is separate to avoid the cost of
+             * loading the whole message queue if only the total size and count are required.
+             *
+             * Invariant:
+             * - The set of keys should exactly match the set of keys of `RelayDispatchQueues`.
+             **/
+            relayDispatchQueueSize: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<ITuple<[u32, u32]>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        vesting: {
+            /**
+             * Storage version of the pallet.
+             *
+             * New networks start with latest version, as determined by the genesis build.
+             **/
+            storageVersion: AugmentedQuery<ApiType, () => Observable<PalletVestingReleases>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Information regarding the vesting of a given account.
+             **/
+            vesting: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<Vec<PalletVestingVestingInfo>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        xcmPallet: {
+            /**
+             * The existing asset traps.
+             *
+             * Key is the blake2 256 hash of (origin, versioned `MultiAssets`) pair. Value is the number of
+             * times this pair has been trapped (usually just 1 if it exists at all).
+             **/
+            assetTraps: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<u32>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
+            /**
+             * The current migration's stage, if any.
+             **/
+            currentMigration: AugmentedQuery<ApiType, () => Observable<Option<PalletXcmVersionMigrationStage>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The ongoing queries.
+             **/
+            queries: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<PalletXcmQueryStatus>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
+            /**
+             * The latest available query index.
+             **/
+            queryCounter: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Default version to encode XCM when latest version of destination is unknown. If `None`,
+             * then the destinations whose XCM version is unknown are considered unreachable.
+             **/
+            safeXcmVersion: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The Latest versions that we know various locations support.
+             **/
+            supportedVersion: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | {
+                V0: any;
+            } | {
+                V1: any;
+            } | string | Uint8Array) => Observable<Option<u32>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedMultiLocation]>;
+            /**
+             * Destinations whose latest XCM version we would like to know. Duplicates not allowed, and
+             * the `u32` counter is the number of times that a send to the destination has been attempted,
+             * which is used as a prioritization.
+             **/
+            versionDiscoveryQueue: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[XcmVersionedMultiLocation, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * All locations that we have requested version notifications from.
+             **/
+            versionNotifiers: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | {
+                V0: any;
+            } | {
+                V1: any;
+            } | string | Uint8Array) => Observable<Option<u64>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedMultiLocation]>;
+            /**
+             * The target locations that are subscribed to our version changes, as well as the most recent
+             * of our versions we informed them of.
+             **/
+            versionNotifyTargets: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | {
+                V0: any;
+            } | {
+                V1: any;
+            } | string | Uint8Array) => Observable<Option<ITuple<[u64, u64, u32]>>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedMultiLocation]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+    }
+}