@dedot/chaintypes 0.0.1-next.f5bf4fc2.1 → 0.1.0

package/westend/query.d.ts

@@ -0,0 +1,3855 @@
+// Generated by dedot cli
+
+import type { GenericChainStorage, GenericStorageQuery, Callback, RpcVersion } from 'dedot/types';
+import type {
+  AccountId32,
+  AccountId32Like,
+  H256,
+  Bytes,
+  Digest,
+  Phase,
+  FixedBytes,
+  FixedU128,
+  Perbill,
+  Percent,
+  BytesLike,
+  Data,
+  FixedArray,
+} from 'dedot/codecs';
+import type {
+  FrameSystemAccountInfo,
+  FrameSupportDispatchPerDispatchClass,
+  FrameSystemEventRecord,
+  FrameSystemLastRuntimeUpgradeInfo,
+  FrameSystemCodeUpgradeAuthorization,
+  SpConsensusBabeAppPublic,
+  SpConsensusSlotsSlot,
+  SpConsensusBabeDigestsNextConfigDescriptor,
+  SpConsensusBabeDigestsPreDigest,
+  SpConsensusBabeBabeEpochConfiguration,
+  PalletBalancesAccountData,
+  PalletBalancesBalanceLock,
+  PalletBalancesReserveData,
+  FrameSupportTokensMiscIdAmount,
+  FrameSupportTokensMiscIdAmountRuntimeFreezeReason,
+  PalletTransactionPaymentReleases,
+  PalletStakingStakingLedger,
+  PalletStakingRewardDestination,
+  PalletStakingValidatorPrefs,
+  PalletStakingNominations,
+  PalletStakingActiveEraInfo,
+  SpStakingExposure,
+  SpStakingPagedExposureMetadata,
+  SpStakingExposurePage,
+  PalletStakingEraRewardPoints,
+  PalletStakingForcing,
+  PalletStakingUnappliedSlash,
+  PalletStakingSlashingSlashingSpans,
+  PalletStakingSlashingSpanRecord,
+  SpStakingOffenceOffenceDetails,
+  WestendRuntimeSessionKeys,
+  SpCoreCryptoKeyTypeId,
+  PalletGrandpaStoredState,
+  PalletGrandpaStoredPendingChange,
+  SpConsensusGrandpaAppPublic,
+  SpAuthorityDiscoveryAppPublic,
+  PalletIdentityRegistration,
+  PalletIdentityRegistrarInfo,
+  PalletIdentityAuthorityProperties,
+  PalletRecoveryRecoveryConfig,
+  PalletRecoveryActiveRecovery,
+  PalletVestingVestingInfo,
+  PalletVestingReleases,
+  PalletSchedulerScheduled,
+  PalletSchedulerRetryConfig,
+  PalletPreimageOldRequestStatus,
+  PalletPreimageRequestStatus,
+  PalletProxyProxyDefinition,
+  PalletProxyAnnouncement,
+  PalletMultisigMultisig,
+  PalletElectionProviderMultiPhasePhase,
+  PalletElectionProviderMultiPhaseReadySolution,
+  PalletElectionProviderMultiPhaseRoundSnapshot,
+  PalletElectionProviderMultiPhaseSolutionOrSnapshotSize,
+  SpNposElectionsElectionScore,
+  PalletElectionProviderMultiPhaseSignedSignedSubmission,
+  PalletBagsListListNode,
+  PalletBagsListListBag,
+  PalletNominationPoolsPoolMember,
+  PalletNominationPoolsBondedPoolInner,
+  PalletNominationPoolsRewardPool,
+  PalletNominationPoolsSubPools,
+  PalletNominationPoolsClaimPermission,
+  PalletFastUnstakeUnstakeRequest,
+  PalletConvictionVotingVoteVoting,
+  PalletReferendaReferendumInfo,
+  PalletTreasuryProposal,
+  PalletTreasurySpendStatus,
+  PalletDelegatedStakingDelegation,
+  PalletDelegatedStakingAgentLedger,
+  PolkadotRuntimeParachainsConfigurationHostConfiguration,
+  PolkadotPrimitivesV7ValidatorIndex,
+  PolkadotPrimitivesV7ValidatorAppPublic,
+  PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker,
+  PolkadotRuntimeParachainsInclusionCandidatePendingAvailability,
+  PolkadotParachainPrimitivesPrimitivesId,
+  PolkadotPrimitivesV7ScrapedOnChainVotes,
+  PolkadotRuntimeParachainsSchedulerPalletCoreOccupied,
+  PolkadotPrimitivesV7CoreIndex,
+  PolkadotRuntimeParachainsSchedulerPalletParasEntry,
+  PolkadotRuntimeParachainsParasPvfCheckActiveVoteState,
+  PolkadotParachainPrimitivesPrimitivesValidationCodeHash,
+  PolkadotRuntimeParachainsParasParaLifecycle,
+  PolkadotParachainPrimitivesPrimitivesHeadData,
+  PolkadotRuntimeParachainsParasParaPastCodeMeta,
+  PolkadotPrimitivesV7UpgradeGoAhead,
+  PolkadotPrimitivesV7UpgradeRestriction,
+  PolkadotRuntimeParachainsParasParaGenesisArgs,
+  PolkadotParachainPrimitivesPrimitivesValidationCode,
+  PolkadotRuntimeParachainsInitializerBufferedSessionChange,
+  PolkadotCorePrimitivesInboundDownwardMessage,
+  PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest,
+  PolkadotParachainPrimitivesPrimitivesHrmpChannelId,
+  PolkadotRuntimeParachainsHrmpHrmpChannel,
+  PolkadotCorePrimitivesInboundHrmpMessage,
+  PolkadotPrimitivesV7AssignmentAppPublic,
+  PolkadotPrimitivesV7SessionInfo,
+  PolkadotPrimitivesV7ExecutorParams,
+  PolkadotPrimitivesV7DisputeState,
+  PolkadotCorePrimitivesCandidateHash,
+  PolkadotPrimitivesV7SlashingPendingSlashes,
+  PolkadotRuntimeParachainsAssignerOnDemandTypesCoreAffinityCount,
+  PolkadotRuntimeParachainsAssignerOnDemandTypesQueueStatusType,
+  BinaryHeapEnqueuedOrder,
+  PolkadotRuntimeParachainsAssignerCoretimeSchedule,
+  PolkadotRuntimeParachainsAssignerCoretimeCoreDescriptor,
+  PolkadotRuntimeCommonParasRegistrarParaInfo,
+  PolkadotRuntimeCommonCrowdloanFundInfo,
+  PolkadotRuntimeCommonAssignedSlotsParachainTemporarySlot,
+  PalletXcmQueryStatus,
+  XcmVersionedLocation,
+  SpWeightsWeightV2Weight,
+  PalletXcmVersionMigrationStage,
+  PalletXcmRemoteLockedFungibleRecord,
+  XcmVersionedAssetId,
+  StagingXcmV4Xcm,
+  PalletMessageQueueBookState,
+  PolkadotRuntimeParachainsInclusionAggregateMessageOrigin,
+  PalletMessageQueuePage,
+  PolkadotRuntimeCommonImplsVersionedLocatableAsset,
+  SpConsensusBeefyEcdsaCryptoPublic,
+  SpConsensusBeefyMmrBeefyAuthoritySet,
+} from './types';
+
+export interface ChainStorage<Rv extends RpcVersion> extends GenericChainStorage<Rv> {
+  /**
+   * Pallet `System`'s storage queries
+   **/
+  system: {
+    /**
+     * The full account information for a particular account ID.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<FrameSystemAccountInfo> =} callback
+     **/
+    account: GenericStorageQuery<Rv, (arg: AccountId32Like) => FrameSystemAccountInfo, AccountId32>;
+
+    /**
+     * Total extrinsics count for the current block.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    extrinsicCount: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * Whether all inherents have been applied.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    inherentsApplied: GenericStorageQuery<Rv, () => boolean>;
+
+    /**
+     * The current weight for the block.
+     *
+     * @param {Callback<FrameSupportDispatchPerDispatchClass> =} callback
+     **/
+    blockWeight: GenericStorageQuery<Rv, () => FrameSupportDispatchPerDispatchClass>;
+
+    /**
+     * Total length (in bytes) for all extrinsics put together, for the current block.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    allExtrinsicsLen: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * Map of block numbers to block hashes.
+     *
+     * @param {number} arg
+     * @param {Callback<H256> =} callback
+     **/
+    blockHash: GenericStorageQuery<Rv, (arg: number) => H256, number>;
+
+    /**
+     * Extrinsics data for the current block (maps an extrinsic's index to its data).
+     *
+     * @param {number} arg
+     * @param {Callback<Bytes> =} callback
+     **/
+    extrinsicData: GenericStorageQuery<Rv, (arg: number) => Bytes, number>;
+
+    /**
+     * The current block number being processed. Set by `execute_block`.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    number: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Hash of the previous block.
+     *
+     * @param {Callback<H256> =} callback
+     **/
+    parentHash: GenericStorageQuery<Rv, () => H256>;
+
+    /**
+     * Digest of the current block, also part of the block header.
+     *
+     * @param {Callback<Digest> =} callback
+     **/
+    digest: GenericStorageQuery<Rv, () => Digest>;
+
+    /**
+     * Events deposited for the current block.
+     *
+     * NOTE: The item is unbound and should therefore never be read on chain.
+     * It could otherwise inflate the PoV size of a block.
+     *
+     * Events have a large in-memory size. Box the events to not go out-of-memory
+     * just in case someone still reads them from within the runtime.
+     *
+     * @param {Callback<Array<FrameSystemEventRecord>> =} callback
+     **/
+    events: GenericStorageQuery<Rv, () => Array<FrameSystemEventRecord>>;
+
+    /**
+     * The number of events in the `Events<T>` list.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    eventCount: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * 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 `(BlockNumberFor<T>, 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.
+     *
+     * @param {H256} arg
+     * @param {Callback<Array<[number, number]>> =} callback
+     **/
+    eventTopics: GenericStorageQuery<Rv, (arg: H256) => Array<[number, number]>, H256>;
+
+    /**
+     * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.
+     *
+     * @param {Callback<FrameSystemLastRuntimeUpgradeInfo | undefined> =} callback
+     **/
+    lastRuntimeUpgrade: GenericStorageQuery<Rv, () => FrameSystemLastRuntimeUpgradeInfo | undefined>;
+
+    /**
+     * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    upgradedToU32RefCount: GenericStorageQuery<Rv, () => boolean>;
+
+    /**
+     * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False
+     * (default) if not.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    upgradedToTripleRefCount: GenericStorageQuery<Rv, () => boolean>;
+
+    /**
+     * The execution phase of the block.
+     *
+     * @param {Callback<Phase | undefined> =} callback
+     **/
+    executionPhase: GenericStorageQuery<Rv, () => Phase | undefined>;
+
+    /**
+     * `Some` if a code upgrade has been authorized.
+     *
+     * @param {Callback<FrameSystemCodeUpgradeAuthorization | undefined> =} callback
+     **/
+    authorizedUpgrade: GenericStorageQuery<Rv, () => FrameSystemCodeUpgradeAuthorization | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Babe`'s storage queries
+   **/
+  babe: {
+    /**
+     * Current epoch index.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    epochIndex: GenericStorageQuery<Rv, () => bigint>;
+
+    /**
+     * Current epoch authorities.
+     *
+     * @param {Callback<Array<[SpConsensusBabeAppPublic, bigint]>> =} callback
+     **/
+    authorities: GenericStorageQuery<Rv, () => Array<[SpConsensusBabeAppPublic, bigint]>>;
+
+    /**
+     * The slot at which the first epoch actually started. This is 0
+     * until the first block of the chain.
+     *
+     * @param {Callback<SpConsensusSlotsSlot> =} callback
+     **/
+    genesisSlot: GenericStorageQuery<Rv, () => SpConsensusSlotsSlot>;
+
+    /**
+     * Current slot number.
+     *
+     * @param {Callback<SpConsensusSlotsSlot> =} callback
+     **/
+    currentSlot: GenericStorageQuery<Rv, () => SpConsensusSlotsSlot>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<FixedBytes<32>> =} callback
+     **/
+    randomness: GenericStorageQuery<Rv, () => FixedBytes<32>>;
+
+    /**
+     * Pending epoch configuration change that will be applied when the next epoch is enacted.
+     *
+     * @param {Callback<SpConsensusBabeDigestsNextConfigDescriptor | undefined> =} callback
+     **/
+    pendingEpochConfigChange: GenericStorageQuery<Rv, () => SpConsensusBabeDigestsNextConfigDescriptor | undefined>;
+
+    /**
+     * Next epoch randomness.
+     *
+     * @param {Callback<FixedBytes<32>> =} callback
+     **/
+    nextRandomness: GenericStorageQuery<Rv, () => FixedBytes<32>>;
+
+    /**
+     * Next epoch authorities.
+     *
+     * @param {Callback<Array<[SpConsensusBabeAppPublic, bigint]>> =} callback
+     **/
+    nextAuthorities: GenericStorageQuery<Rv, () => Array<[SpConsensusBabeAppPublic, bigint]>>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    segmentIndex: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * TWOX-NOTE: `SegmentIndex` is an increasing integer, so this is okay.
+     *
+     * @param {number} arg
+     * @param {Callback<Array<FixedBytes<32>>> =} callback
+     **/
+    underConstruction: GenericStorageQuery<Rv, (arg: number) => Array<FixedBytes<32>>, number>;
+
+    /**
+     * Temporary value (cleared at block finalization) which is `Some`
+     * if per-block initialization has already been called for current block.
+     *
+     * @param {Callback<SpConsensusBabeDigestsPreDigest | undefined | undefined> =} callback
+     **/
+    initialized: GenericStorageQuery<Rv, () => SpConsensusBabeDigestsPreDigest | undefined | undefined>;
+
+    /**
+     * 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_finalize`, before it will contain the value from the last block.
+     *
+     * @param {Callback<FixedBytes<32> | undefined> =} callback
+     **/
+    authorVrfRandomness: GenericStorageQuery<Rv, () => FixedBytes<32> | undefined>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<[number, number]> =} callback
+     **/
+    epochStart: GenericStorageQuery<Rv, () => [number, number]>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    lateness: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * The configuration for the current epoch. Should never be `None` as it is initialized in
+     * genesis.
+     *
+     * @param {Callback<SpConsensusBabeBabeEpochConfiguration | undefined> =} callback
+     **/
+    epochConfig: GenericStorageQuery<Rv, () => SpConsensusBabeBabeEpochConfiguration | undefined>;
+
+    /**
+     * The configuration for the next epoch, `None` if the config will not change
+     * (you can fallback to `EpochConfig` instead in that case).
+     *
+     * @param {Callback<SpConsensusBabeBabeEpochConfiguration | undefined> =} callback
+     **/
+    nextEpochConfig: GenericStorageQuery<Rv, () => SpConsensusBabeBabeEpochConfiguration | undefined>;
+
+    /**
+     * A list of the last 100 skipped epochs and the corresponding session index
+     * when the epoch was skipped.
+     *
+     * This is only used for validating equivocation proofs. An equivocation proof
+     * must contains a key-ownership proof for a given session, therefore we need a
+     * way to tie together sessions and epoch indices, i.e. we need to validate that
+     * a validator was the owner of a given key on a given session, and what the
+     * active epoch index was during that session.
+     *
+     * @param {Callback<Array<[bigint, number]>> =} callback
+     **/
+    skippedEpochs: GenericStorageQuery<Rv, () => Array<[bigint, number]>>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Timestamp`'s storage queries
+   **/
+  timestamp: {
+    /**
+     * The current time for the current block.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    now: GenericStorageQuery<Rv, () => bigint>;
+
+    /**
+     * Whether the timestamp has been updated in this block.
+     *
+     * This value is updated to `true` upon successful submission of a timestamp by a node.
+     * It is then checked at the end of each block execution in the `on_finalize` hook.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    didUpdate: GenericStorageQuery<Rv, () => boolean>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Indices`'s storage queries
+   **/
+  indices: {
+    /**
+     * The lookup from index to account.
+     *
+     * @param {number} arg
+     * @param {Callback<[AccountId32, bigint, boolean] | undefined> =} callback
+     **/
+    accounts: GenericStorageQuery<Rv, (arg: number) => [AccountId32, bigint, boolean] | undefined, number>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Balances`'s storage queries
+   **/
+  balances: {
+    /**
+     * The total units issued in the system.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    totalIssuance: GenericStorageQuery<Rv, () => bigint>;
+
+    /**
+     * The total units of outstanding deactivated balance in the system.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    inactiveIssuance: GenericStorageQuery<Rv, () => bigint>;
+
+    /**
+     * The Balances pallet example of storing the balance of an account.
+     *
+     * # Example
+     *
+     * ```nocompile
+     * impl pallet_balances::Config for Runtime {
+     * type AccountStore = StorageMapShim<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>
+     * }
+     * ```
+     *
+     * You can also store the balance of an account in the `System` pallet.
+     *
+     * # Example
+     *
+     * ```nocompile
+     * impl pallet_balances::Config for Runtime {
+     * type AccountStore = System
+     * }
+     * ```
+     *
+     * But this comes with tradeoffs, storing account balances in the system pallet stores
+     * `frame_system` data alongside the account data contrary to storing account balances in the
+     * `Balances` pallet, which uses a `StorageMap` to store balances data only.
+     * NOTE: This is only used in the case that this pallet is used to store balances.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletBalancesAccountData> =} callback
+     **/
+    account: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletBalancesAccountData, AccountId32>;
+
+    /**
+     * Any liquidity locks on some account balances.
+     * NOTE: Should only be accessed when setting, changing and freeing a lock.
+     *
+     * Use of locks is deprecated in favour of freezes. See `https://github.com/paritytech/substrate/pull/12951/`
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<Array<PalletBalancesBalanceLock>> =} callback
+     **/
+    locks: GenericStorageQuery<Rv, (arg: AccountId32Like) => Array<PalletBalancesBalanceLock>, AccountId32>;
+
+    /**
+     * Named reserves on some account balances.
+     *
+     * Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/`
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<Array<PalletBalancesReserveData>> =} callback
+     **/
+    reserves: GenericStorageQuery<Rv, (arg: AccountId32Like) => Array<PalletBalancesReserveData>, AccountId32>;
+
+    /**
+     * Holds on account balances.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<Array<FrameSupportTokensMiscIdAmount>> =} callback
+     **/
+    holds: GenericStorageQuery<Rv, (arg: AccountId32Like) => Array<FrameSupportTokensMiscIdAmount>, AccountId32>;
+
+    /**
+     * Freeze locks on account balances.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<Array<FrameSupportTokensMiscIdAmountRuntimeFreezeReason>> =} callback
+     **/
+    freezes: GenericStorageQuery<
+      Rv,
+      (arg: AccountId32Like) => Array<FrameSupportTokensMiscIdAmountRuntimeFreezeReason>,
+      AccountId32
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `TransactionPayment`'s storage queries
+   **/
+  transactionPayment: {
+    /**
+     *
+     * @param {Callback<FixedU128> =} callback
+     **/
+    nextFeeMultiplier: GenericStorageQuery<Rv, () => FixedU128>;
+
+    /**
+     *
+     * @param {Callback<PalletTransactionPaymentReleases> =} callback
+     **/
+    storageVersion: GenericStorageQuery<Rv, () => PalletTransactionPaymentReleases>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Authorship`'s storage queries
+   **/
+  authorship: {
+    /**
+     * Author of current block.
+     *
+     * @param {Callback<AccountId32 | undefined> =} callback
+     **/
+    author: GenericStorageQuery<Rv, () => AccountId32 | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Staking`'s storage queries
+   **/
+  staking: {
+    /**
+     * The ideal number of active validators.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    validatorCount: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Minimum number of staking participants before emergency conditions are imposed.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    minimumValidatorCount: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<Array<AccountId32>> =} callback
+     **/
+    invulnerables: GenericStorageQuery<Rv, () => Array<AccountId32>>;
+
+    /**
+     * Map from all locked "stash" accounts to the controller account.
+     *
+     * TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<AccountId32 | undefined> =} callback
+     **/
+    bonded: GenericStorageQuery<Rv, (arg: AccountId32Like) => AccountId32 | undefined, AccountId32>;
+
+    /**
+     * The minimum active bond to become and maintain the role of a nominator.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    minNominatorBond: GenericStorageQuery<Rv, () => bigint>;
+
+    /**
+     * The minimum active bond to become and maintain the role of a validator.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    minValidatorBond: GenericStorageQuery<Rv, () => bigint>;
+
+    /**
+     * The minimum active nominator stake of the last successful election.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    minimumActiveStake: GenericStorageQuery<Rv, () => bigint>;
+
+    /**
+     * The minimum amount of commission that validators can set.
+     *
+     * If set to `0`, no limit exists.
+     *
+     * @param {Callback<Perbill> =} callback
+     **/
+    minCommission: GenericStorageQuery<Rv, () => Perbill>;
+
+    /**
+     * Map from all (unlocked) "controller" accounts to the info regarding the staking.
+     *
+     * Note: All the reads and mutations to this storage *MUST* be done through the methods exposed
+     * by [`StakingLedger`] to ensure data and lock consistency.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletStakingStakingLedger | undefined> =} callback
+     **/
+    ledger: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletStakingStakingLedger | undefined, AccountId32>;
+
+    /**
+     * Where the reward payment should be made. Keyed by stash.
+     *
+     * TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletStakingRewardDestination | undefined> =} callback
+     **/
+    payee: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletStakingRewardDestination | undefined, AccountId32>;
+
+    /**
+     * The map from (wannabe) validator stash key to the preferences of that validator.
+     *
+     * TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletStakingValidatorPrefs> =} callback
+     **/
+    validators: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletStakingValidatorPrefs, AccountId32>;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForValidators: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * The maximum validator count before we stop allowing new validators to join.
+     *
+     * When this value is not set, no limits are enforced.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    maxValidatorsCount: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * The map from nominator stash key to their nomination preferences, namely the validators that
+     * they wish to support.
+     *
+     * Note that the keys of this storage map might become non-decodable in case the
+     * account's [`NominationsQuota::MaxNominations`] configuration is decreased.
+     * In this rare case, these nominators
+     * are still existent in storage, their key is correct and retrievable (i.e. `contains_key`
+     * indicates that they exist), but their value cannot be decoded. Therefore, the non-decodable
+     * nominators will effectively not-exist, until they re-submit their preferences such that it
+     * is within the bounds of the newly set `Config::MaxNominations`.
+     *
+     * This implies that `::iter_keys().count()` and `::iter().count()` might return different
+     * values for this map. Moreover, the main `::count()` is aligned with the former, namely the
+     * number of keys that exist.
+     *
+     * Lastly, if any of the nominators become non-decodable, they can be chilled immediately via
+     * [`Call::chill_other`] dispatchable by anyone.
+     *
+     * TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletStakingNominations | undefined> =} callback
+     **/
+    nominators: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletStakingNominations | undefined, AccountId32>;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForNominators: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Stakers whose funds are managed by other pallets.
+     *
+     * This pallet does not apply any locks on them, therefore they are only virtually bonded. They
+     * are expected to be keyless accounts and hence should not be allowed to mutate their ledger
+     * directly via this pallet. Instead, these accounts are managed by other pallets and accessed
+     * via low level apis. We keep track of them to do minimal integrity checks.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<[] | undefined> =} callback
+     **/
+    virtualStakers: GenericStorageQuery<Rv, (arg: AccountId32Like) => [] | undefined, AccountId32>;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForVirtualStakers: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * The maximum nominator count before we stop allowing new validators to join.
+     *
+     * When this value is not set, no limits are enforced.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    maxNominatorsCount: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    currentEra: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * 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`].
+     *
+     * @param {Callback<PalletStakingActiveEraInfo | undefined> =} callback
+     **/
+    activeEra: GenericStorageQuery<Rv, () => PalletStakingActiveEraInfo | undefined>;
+
+    /**
+     * The session index at which the era start for the last [`Config::HistoryDepth`] eras.
+     *
+     * Note: This tracks the starting session (i.e. session index when era start being active)
+     * for the eras in `[CurrentEra - HISTORY_DEPTH, CurrentEra]`.
+     *
+     * @param {number} arg
+     * @param {Callback<number | undefined> =} callback
+     **/
+    erasStartSessionIndex: GenericStorageQuery<Rv, (arg: number) => number | undefined, number>;
+
+    /**
+     * 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 [`Config::HistoryDepth`] eras.
+     * If stakers hasn't been set or has been removed then empty exposure is returned.
+     *
+     * Note: Deprecated since v14. Use `EraInfo` instead to work with exposures.
+     *
+     * @param {[number, AccountId32Like]} arg
+     * @param {Callback<SpStakingExposure> =} callback
+     **/
+    erasStakers: GenericStorageQuery<Rv, (arg: [number, AccountId32Like]) => SpStakingExposure, [number, AccountId32]>;
+
+    /**
+     * Summary of validator exposure at a given era.
+     *
+     * This contains the total stake in support of the validator and their own stake. In addition,
+     * it can also be used to get the number of nominators backing this validator and the number of
+     * exposure pages they are divided into. The page count is useful to determine the number of
+     * pages of rewards that needs to be claimed.
+     *
+     * This is keyed first by the era index to allow bulk deletion and then the stash account.
+     * Should only be accessed through `EraInfo`.
+     *
+     * Is it removed after [`Config::HistoryDepth`] eras.
+     * If stakers hasn't been set or has been removed then empty overview is returned.
+     *
+     * @param {[number, AccountId32Like]} arg
+     * @param {Callback<SpStakingPagedExposureMetadata | undefined> =} callback
+     **/
+    erasStakersOverview: GenericStorageQuery<
+      Rv,
+      (arg: [number, AccountId32Like]) => SpStakingPagedExposureMetadata | undefined,
+      [number, AccountId32]
+    >;
+
+    /**
+     * Clipped Exposure of validator at era.
+     *
+     * Note: This is deprecated, should be used as read-only and will be removed in the future.
+     * New `Exposure`s are stored in a paged manner in `ErasStakersPaged` instead.
+     *
+     * This is similar to [`ErasStakers`] but number of nominators exposed is reduced to the
+     * `T::MaxExposurePageSize` 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.
+     *
+     * It is removed after [`Config::HistoryDepth`] eras.
+     * If stakers hasn't been set or has been removed then empty exposure is returned.
+     *
+     * Note: Deprecated since v14. Use `EraInfo` instead to work with exposures.
+     *
+     * @param {[number, AccountId32Like]} arg
+     * @param {Callback<SpStakingExposure> =} callback
+     **/
+    erasStakersClipped: GenericStorageQuery<
+      Rv,
+      (arg: [number, AccountId32Like]) => SpStakingExposure,
+      [number, AccountId32]
+    >;
+
+    /**
+     * Paginated exposure of a validator at given era.
+     *
+     * This is keyed first by the era index to allow bulk deletion, then stash account and finally
+     * the page. Should only be accessed through `EraInfo`.
+     *
+     * This is cleared after [`Config::HistoryDepth`] eras.
+     *
+     * @param {[number, AccountId32Like, number]} arg
+     * @param {Callback<SpStakingExposurePage | undefined> =} callback
+     **/
+    erasStakersPaged: GenericStorageQuery<
+      Rv,
+      (arg: [number, AccountId32Like, number]) => SpStakingExposurePage | undefined,
+      [number, AccountId32, number]
+    >;
+
+    /**
+     * History of claimed paged rewards by era and validator.
+     *
+     * This is keyed by era and validator stash which maps to the set of page indexes which have
+     * been claimed.
+     *
+     * It is removed after [`Config::HistoryDepth`] eras.
+     *
+     * @param {[number, AccountId32Like]} arg
+     * @param {Callback<Array<number>> =} callback
+     **/
+    claimedRewards: GenericStorageQuery<Rv, (arg: [number, AccountId32Like]) => Array<number>, [number, AccountId32]>;
+
+    /**
+     * 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 [`Config::HistoryDepth`] eras.
+     *
+     * @param {[number, AccountId32Like]} arg
+     * @param {Callback<PalletStakingValidatorPrefs> =} callback
+     **/
+    erasValidatorPrefs: GenericStorageQuery<
+      Rv,
+      (arg: [number, AccountId32Like]) => PalletStakingValidatorPrefs,
+      [number, AccountId32]
+    >;
+
+    /**
+     * The total validator era payout for the last [`Config::HistoryDepth`] eras.
+     *
+     * Eras that haven't finished yet or has been removed doesn't have reward.
+     *
+     * @param {number} arg
+     * @param {Callback<bigint | undefined> =} callback
+     **/
+    erasValidatorReward: GenericStorageQuery<Rv, (arg: number) => bigint | undefined, number>;
+
+    /**
+     * Rewards for the last [`Config::HistoryDepth`] eras.
+     * If reward hasn't been set or has been removed then 0 reward is returned.
+     *
+     * @param {number} arg
+     * @param {Callback<PalletStakingEraRewardPoints> =} callback
+     **/
+    erasRewardPoints: GenericStorageQuery<Rv, (arg: number) => PalletStakingEraRewardPoints, number>;
+
+    /**
+     * The total amount staked for the last [`Config::HistoryDepth`] eras.
+     * If total hasn't been set or has been removed then 0 stake is returned.
+     *
+     * @param {number} arg
+     * @param {Callback<bigint> =} callback
+     **/
+    erasTotalStake: GenericStorageQuery<Rv, (arg: number) => bigint, number>;
+
+    /**
+     * Mode of era forcing.
+     *
+     * @param {Callback<PalletStakingForcing> =} callback
+     **/
+    forceEra: GenericStorageQuery<Rv, () => PalletStakingForcing>;
+
+    /**
+     * Maximum staked rewards, i.e. the percentage of the era inflation that
+     * is used for stake rewards.
+     * See [Era payout](./index.html#era-payout).
+     *
+     * @param {Callback<Percent | undefined> =} callback
+     **/
+    maxStakedRewards: GenericStorageQuery<Rv, () => Percent | undefined>;
+
+    /**
+     * The percentage of the slash that is distributed to reporters.
+     *
+     * The rest of the slashed value is handled by the `Slash`.
+     *
+     * @param {Callback<Perbill> =} callback
+     **/
+    slashRewardFraction: GenericStorageQuery<Rv, () => Perbill>;
+
+    /**
+     * The amount of currency given to reporters of a slash event which was
+     * canceled by extraordinary circumstances (e.g. governance).
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    canceledSlashPayout: GenericStorageQuery<Rv, () => bigint>;
+
+    /**
+     * All unapplied slashes that are queued for later.
+     *
+     * @param {number} arg
+     * @param {Callback<Array<PalletStakingUnappliedSlash>> =} callback
+     **/
+    unappliedSlashes: GenericStorageQuery<Rv, (arg: number) => Array<PalletStakingUnappliedSlash>, number>;
+
+    /**
+     * 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]`
+     *
+     * @param {Callback<Array<[number, number]>> =} callback
+     **/
+    bondedEras: GenericStorageQuery<Rv, () => Array<[number, number]>>;
+
+    /**
+     * All slashing events on validators, mapped by era to the highest slash proportion
+     * and slash value of the era.
+     *
+     * @param {[number, AccountId32Like]} arg
+     * @param {Callback<[Perbill, bigint] | undefined> =} callback
+     **/
+    validatorSlashInEra: GenericStorageQuery<
+      Rv,
+      (arg: [number, AccountId32Like]) => [Perbill, bigint] | undefined,
+      [number, AccountId32]
+    >;
+
+    /**
+     * All slashing events on nominators, mapped by era to the highest slash value of the era.
+     *
+     * @param {[number, AccountId32Like]} arg
+     * @param {Callback<bigint | undefined> =} callback
+     **/
+    nominatorSlashInEra: GenericStorageQuery<
+      Rv,
+      (arg: [number, AccountId32Like]) => bigint | undefined,
+      [number, AccountId32]
+    >;
+
+    /**
+     * Slashing spans for stash accounts.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletStakingSlashingSlashingSpans | undefined> =} callback
+     **/
+    slashingSpans: GenericStorageQuery<
+      Rv,
+      (arg: AccountId32Like) => PalletStakingSlashingSlashingSpans | undefined,
+      AccountId32
+    >;
+
+    /**
+     * Records information about the maximum slash of a stash within a slashing span,
+     * as well as how much reward has been paid out.
+     *
+     * @param {[AccountId32Like, number]} arg
+     * @param {Callback<PalletStakingSlashingSpanRecord> =} callback
+     **/
+    spanSlash: GenericStorageQuery<
+      Rv,
+      (arg: [AccountId32Like, number]) => PalletStakingSlashingSpanRecord,
+      [AccountId32, number]
+    >;
+
+    /**
+     * The last planned session scheduled by the session pallet.
+     *
+     * This is basically in sync with the call to [`pallet_session::SessionManager::new_session`].
+     *
+     * @param {Callback<number> =} callback
+     **/
+    currentPlannedSession: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Indices of validators that have offended in the active era. The offenders are disabled for a
+     * whole era. For this reason they are kept here - only staking pallet knows about eras. The
+     * implementor of [`DisablingStrategy`] defines if a validator should be disabled which
+     * implicitly means that the implementor also controls the max number of disabled validators.
+     *
+     * The vec is always kept sorted so that we can find whether a given validator has previously
+     * offended using binary search.
+     *
+     * @param {Callback<Array<number>> =} callback
+     **/
+    disabledValidators: GenericStorageQuery<Rv, () => Array<number>>;
+
+    /**
+     * 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`).
+     *
+     * @param {Callback<Percent | undefined> =} callback
+     **/
+    chillThreshold: GenericStorageQuery<Rv, () => Percent | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Offences`'s storage queries
+   **/
+  offences: {
+    /**
+     * The primary structure that holds all offence records keyed by report identifiers.
+     *
+     * @param {H256} arg
+     * @param {Callback<SpStakingOffenceOffenceDetails | undefined> =} callback
+     **/
+    reports: GenericStorageQuery<Rv, (arg: H256) => SpStakingOffenceOffenceDetails | undefined, H256>;
+
+    /**
+     * A vector of reports of the same kind that happened at the same time slot.
+     *
+     * @param {[FixedBytes<16>, BytesLike]} arg
+     * @param {Callback<Array<H256>> =} callback
+     **/
+    concurrentReportsIndex: GenericStorageQuery<
+      Rv,
+      (arg: [FixedBytes<16>, BytesLike]) => Array<H256>,
+      [FixedBytes<16>, Bytes]
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Historical`'s storage queries
+   **/
+  historical: {
+    /**
+     * Mapping from historical session indices to session-data root hash and validator count.
+     *
+     * @param {number} arg
+     * @param {Callback<[H256, number] | undefined> =} callback
+     **/
+    historicalSessions: GenericStorageQuery<Rv, (arg: number) => [H256, number] | undefined, number>;
+
+    /**
+     * The range of historical sessions we store. [first, last)
+     *
+     * @param {Callback<[number, number] | undefined> =} callback
+     **/
+    storedRange: GenericStorageQuery<Rv, () => [number, number] | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Session`'s storage queries
+   **/
+  session: {
+    /**
+     * The current set of validators.
+     *
+     * @param {Callback<Array<AccountId32>> =} callback
+     **/
+    validators: GenericStorageQuery<Rv, () => Array<AccountId32>>;
+
+    /**
+     * Current index of the session.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    currentIndex: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * True if the underlying economic identities or weighting behind the validators
+     * has changed in the queued validator set.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    queuedChanged: GenericStorageQuery<Rv, () => boolean>;
+
+    /**
+     * The queued keys for the next session. When the next session begins, these keys
+     * will be used to determine the validator's session keys.
+     *
+     * @param {Callback<Array<[AccountId32, WestendRuntimeSessionKeys]>> =} callback
+     **/
+    queuedKeys: GenericStorageQuery<Rv, () => Array<[AccountId32, WestendRuntimeSessionKeys]>>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<Array<number>> =} callback
+     **/
+    disabledValidators: GenericStorageQuery<Rv, () => Array<number>>;
+
+    /**
+     * The next session keys for a validator.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<WestendRuntimeSessionKeys | undefined> =} callback
+     **/
+    nextKeys: GenericStorageQuery<Rv, (arg: AccountId32Like) => WestendRuntimeSessionKeys | undefined, AccountId32>;
+
+    /**
+     * The owner of a key. The key is the `KeyTypeId` + the encoded key.
+     *
+     * @param {[SpCoreCryptoKeyTypeId, BytesLike]} arg
+     * @param {Callback<AccountId32 | undefined> =} callback
+     **/
+    keyOwner: GenericStorageQuery<
+      Rv,
+      (arg: [SpCoreCryptoKeyTypeId, BytesLike]) => AccountId32 | undefined,
+      [SpCoreCryptoKeyTypeId, Bytes]
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Grandpa`'s storage queries
+   **/
+  grandpa: {
+    /**
+     * State of the current authority set.
+     *
+     * @param {Callback<PalletGrandpaStoredState> =} callback
+     **/
+    state: GenericStorageQuery<Rv, () => PalletGrandpaStoredState>;
+
+    /**
+     * Pending change: (signaled at, scheduled change).
+     *
+     * @param {Callback<PalletGrandpaStoredPendingChange | undefined> =} callback
+     **/
+    pendingChange: GenericStorageQuery<Rv, () => PalletGrandpaStoredPendingChange | undefined>;
+
+    /**
+     * next block number where we can force a change.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    nextForced: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * `true` if we are currently stalled.
+     *
+     * @param {Callback<[number, number] | undefined> =} callback
+     **/
+    stalled: GenericStorageQuery<Rv, () => [number, number] | undefined>;
+
+    /**
+     * The number of changes (both in terms of keys and underlying economic responsibilities)
+     * in the "set" of Grandpa validators from genesis.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    currentSetId: GenericStorageQuery<Rv, () => bigint>;
+
+    /**
+     * A mapping from grandpa set ID to the index of the *most recent* session for which its
+     * members were responsible.
+     *
+     * This is only used for validating equivocation proofs. An equivocation proof must
+     * contains a key-ownership proof for a given session, therefore we need a way to tie
+     * together sessions and GRANDPA set ids, i.e. we need to validate that a validator
+     * was the owner of a given key on a given session, and what the active set ID was
+     * during that session.
+     *
+     * TWOX-NOTE: `SetId` is not under user control.
+     *
+     * @param {bigint} arg
+     * @param {Callback<number | undefined> =} callback
+     **/
+    setIdSession: GenericStorageQuery<Rv, (arg: bigint) => number | undefined, bigint>;
+
+    /**
+     * The current list of authorities.
+     *
+     * @param {Callback<Array<[SpConsensusGrandpaAppPublic, bigint]>> =} callback
+     **/
+    authorities: GenericStorageQuery<Rv, () => Array<[SpConsensusGrandpaAppPublic, bigint]>>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `AuthorityDiscovery`'s storage queries
+   **/
+  authorityDiscovery: {
+    /**
+     * Keys of the current authority set.
+     *
+     * @param {Callback<Array<SpAuthorityDiscoveryAppPublic>> =} callback
+     **/
+    keys: GenericStorageQuery<Rv, () => Array<SpAuthorityDiscoveryAppPublic>>;
+
+    /**
+     * Keys of the next authority set.
+     *
+     * @param {Callback<Array<SpAuthorityDiscoveryAppPublic>> =} callback
+     **/
+    nextKeys: GenericStorageQuery<Rv, () => Array<SpAuthorityDiscoveryAppPublic>>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Identity`'s storage queries
+   **/
+  identity: {
+    /**
+     * Information that is pertinent to identify the entity behind an account. First item is the
+     * registration, second is the account's primary username.
+     *
+     * TWOX-NOTE: OK ― `AccountId` is a secure hash.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<[PalletIdentityRegistration, Bytes | undefined] | undefined> =} callback
+     **/
+    identityOf: GenericStorageQuery<
+      Rv,
+      (arg: AccountId32Like) => [PalletIdentityRegistration, Bytes | undefined] | undefined,
+      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`.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<[AccountId32, Data] | undefined> =} callback
+     **/
+    superOf: GenericStorageQuery<Rv, (arg: AccountId32Like) => [AccountId32, Data] | undefined, AccountId32>;
+
+    /**
+     * 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.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<[bigint, Array<AccountId32>]> =} callback
+     **/
+    subsOf: GenericStorageQuery<Rv, (arg: AccountId32Like) => [bigint, Array<AccountId32>], 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.
+     *
+     * @param {Callback<Array<PalletIdentityRegistrarInfo | undefined>> =} callback
+     **/
+    registrars: GenericStorageQuery<Rv, () => Array<PalletIdentityRegistrarInfo | undefined>>;
+
+    /**
+     * A map of the accounts who are authorized to grant usernames.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletIdentityAuthorityProperties | undefined> =} callback
+     **/
+    usernameAuthorities: GenericStorageQuery<
+      Rv,
+      (arg: AccountId32Like) => PalletIdentityAuthorityProperties | undefined,
+      AccountId32
+    >;
+
+    /**
+     * Reverse lookup from `username` to the `AccountId` that has registered it. The value should
+     * be a key in the `IdentityOf` map, but it may not if the user has cleared their identity.
+     *
+     * Multiple usernames may map to the same `AccountId`, but `IdentityOf` will only map to one
+     * primary username.
+     *
+     * @param {BytesLike} arg
+     * @param {Callback<AccountId32 | undefined> =} callback
+     **/
+    accountOfUsername: GenericStorageQuery<Rv, (arg: BytesLike) => AccountId32 | undefined, Bytes>;
+
+    /**
+     * Usernames that an authority has granted, but that the account controller has not confirmed
+     * that they want it. Used primarily in cases where the `AccountId` cannot provide a signature
+     * because they are a pure proxy, multisig, etc. In order to confirm it, they should call
+     * [`Call::accept_username`].
+     *
+     * First tuple item is the account and second is the acceptance deadline.
+     *
+     * @param {BytesLike} arg
+     * @param {Callback<[AccountId32, number] | undefined> =} callback
+     **/
+    pendingUsernames: GenericStorageQuery<Rv, (arg: BytesLike) => [AccountId32, number] | undefined, Bytes>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Recovery`'s storage queries
+   **/
+  recovery: {
+    /**
+     * The set of recoverable accounts and their recovery configuration.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletRecoveryRecoveryConfig | undefined> =} callback
+     **/
+    recoverable: GenericStorageQuery<
+      Rv,
+      (arg: AccountId32Like) => PalletRecoveryRecoveryConfig | undefined,
+      AccountId32
+    >;
+
+    /**
+     * Active recovery attempts.
+     *
+     * First account is the account to be recovered, and the second account
+     * is the user trying to recover the account.
+     *
+     * @param {[AccountId32Like, AccountId32Like]} arg
+     * @param {Callback<PalletRecoveryActiveRecovery | undefined> =} callback
+     **/
+    activeRecoveries: GenericStorageQuery<
+      Rv,
+      (arg: [AccountId32Like, AccountId32Like]) => PalletRecoveryActiveRecovery | undefined,
+      [AccountId32, AccountId32]
+    >;
+
+    /**
+     * The list of allowed proxy accounts.
+     *
+     * Map from the user who can access it to the recovered account.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<AccountId32 | undefined> =} callback
+     **/
+    proxy: GenericStorageQuery<Rv, (arg: AccountId32Like) => AccountId32 | undefined, AccountId32>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Vesting`'s storage queries
+   **/
+  vesting: {
+    /**
+     * Information regarding the vesting of a given account.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<Array<PalletVestingVestingInfo> | undefined> =} callback
+     **/
+    vesting: GenericStorageQuery<
+      Rv,
+      (arg: AccountId32Like) => Array<PalletVestingVestingInfo> | undefined,
+      AccountId32
+    >;
+
+    /**
+     * Storage version of the pallet.
+     *
+     * New networks start with latest version, as determined by the genesis build.
+     *
+     * @param {Callback<PalletVestingReleases> =} callback
+     **/
+    storageVersion: GenericStorageQuery<Rv, () => PalletVestingReleases>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Scheduler`'s storage queries
+   **/
+  scheduler: {
+    /**
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    incompleteSince: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * Items to be executed, indexed by the block number that they should be executed on.
+     *
+     * @param {number} arg
+     * @param {Callback<Array<PalletSchedulerScheduled | undefined>> =} callback
+     **/
+    agenda: GenericStorageQuery<Rv, (arg: number) => Array<PalletSchedulerScheduled | undefined>, number>;
+
+    /**
+     * Retry configurations for items to be executed, indexed by task address.
+     *
+     * @param {[number, number]} arg
+     * @param {Callback<PalletSchedulerRetryConfig | undefined> =} callback
+     **/
+    retries: GenericStorageQuery<
+      Rv,
+      (arg: [number, number]) => PalletSchedulerRetryConfig | undefined,
+      [number, number]
+    >;
+
+    /**
+     * Lookup from a name to the block number and index of the task.
+     *
+     * For v3 -> v4 the previously unbounded identities are Blake2-256 hashed to form the v4
+     * identities.
+     *
+     * @param {FixedBytes<32>} arg
+     * @param {Callback<[number, number] | undefined> =} callback
+     **/
+    lookup: GenericStorageQuery<Rv, (arg: FixedBytes<32>) => [number, number] | undefined, FixedBytes<32>>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Preimage`'s storage queries
+   **/
+  preimage: {
+    /**
+     * The request status of a given hash.
+     *
+     * @param {H256} arg
+     * @param {Callback<PalletPreimageOldRequestStatus | undefined> =} callback
+     **/
+    statusFor: GenericStorageQuery<Rv, (arg: H256) => PalletPreimageOldRequestStatus | undefined, H256>;
+
+    /**
+     * The request status of a given hash.
+     *
+     * @param {H256} arg
+     * @param {Callback<PalletPreimageRequestStatus | undefined> =} callback
+     **/
+    requestStatusFor: GenericStorageQuery<Rv, (arg: H256) => PalletPreimageRequestStatus | undefined, H256>;
+
+    /**
+     *
+     * @param {[H256, number]} arg
+     * @param {Callback<Bytes | undefined> =} callback
+     **/
+    preimageFor: GenericStorageQuery<Rv, (arg: [H256, number]) => Bytes | undefined, [H256, number]>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Sudo`'s storage queries
+   **/
+  sudo: {
+    /**
+     * The `AccountId` of the sudo key.
+     *
+     * @param {Callback<AccountId32 | undefined> =} callback
+     **/
+    key: GenericStorageQuery<Rv, () => AccountId32 | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Proxy`'s storage queries
+   **/
+  proxy: {
+    /**
+     * 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.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<[Array<PalletProxyProxyDefinition>, bigint]> =} callback
+     **/
+    proxies: GenericStorageQuery<
+      Rv,
+      (arg: AccountId32Like) => [Array<PalletProxyProxyDefinition>, bigint],
+      AccountId32
+    >;
+
+    /**
+     * The announcements made by the proxy (key).
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<[Array<PalletProxyAnnouncement>, bigint]> =} callback
+     **/
+    announcements: GenericStorageQuery<
+      Rv,
+      (arg: AccountId32Like) => [Array<PalletProxyAnnouncement>, bigint],
+      AccountId32
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Multisig`'s storage queries
+   **/
+  multisig: {
+    /**
+     * The set of open multisig operations.
+     *
+     * @param {[AccountId32Like, FixedBytes<32>]} arg
+     * @param {Callback<PalletMultisigMultisig | undefined> =} callback
+     **/
+    multisigs: GenericStorageQuery<
+      Rv,
+      (arg: [AccountId32Like, FixedBytes<32>]) => PalletMultisigMultisig | undefined,
+      [AccountId32, FixedBytes<32>]
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `ElectionProviderMultiPhase`'s storage queries
+   **/
+  electionProviderMultiPhase: {
+    /**
+     * 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.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    round: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Current phase.
+     *
+     * @param {Callback<PalletElectionProviderMultiPhasePhase> =} callback
+     **/
+    currentPhase: GenericStorageQuery<Rv, () => PalletElectionProviderMultiPhasePhase>;
+
+    /**
+     * Current best solution, signed or unsigned, queued to be returned upon `elect`.
+     *
+     * Always sorted by score.
+     *
+     * @param {Callback<PalletElectionProviderMultiPhaseReadySolution | undefined> =} callback
+     **/
+    queuedSolution: GenericStorageQuery<Rv, () => PalletElectionProviderMultiPhaseReadySolution | undefined>;
+
+    /**
+     * Snapshot data of the round.
+     *
+     * This is created at the beginning of the signed phase and cleared upon calling `elect`.
+     * Note: This storage type must only be mutated through [`SnapshotWrapper`].
+     *
+     * @param {Callback<PalletElectionProviderMultiPhaseRoundSnapshot | undefined> =} callback
+     **/
+    snapshot: GenericStorageQuery<Rv, () => PalletElectionProviderMultiPhaseRoundSnapshot | undefined>;
+
+    /**
+     * Desired number of targets to elect for this round.
+     *
+     * Only exists when [`Snapshot`] is present.
+     * Note: This storage type must only be mutated through [`SnapshotWrapper`].
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    desiredTargets: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * The metadata of the [`RoundSnapshot`]
+     *
+     * Only exists when [`Snapshot`] is present.
+     * Note: This storage type must only be mutated through [`SnapshotWrapper`].
+     *
+     * @param {Callback<PalletElectionProviderMultiPhaseSolutionOrSnapshotSize | undefined> =} callback
+     **/
+    snapshotMetadata: GenericStorageQuery<Rv, () => PalletElectionProviderMultiPhaseSolutionOrSnapshotSize | undefined>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    signedSubmissionNextIndex: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * A sorted, bounded vector of `(score, block_number, 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.
+     *
+     * @param {Callback<Array<[SpNposElectionsElectionScore, number, number]>> =} callback
+     **/
+    signedSubmissionIndices: GenericStorageQuery<Rv, () => Array<[SpNposElectionsElectionScore, number, number]>>;
+
+    /**
+     * 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.
+     *
+     * @param {number} arg
+     * @param {Callback<PalletElectionProviderMultiPhaseSignedSignedSubmission | undefined> =} callback
+     **/
+    signedSubmissionsMap: GenericStorageQuery<
+      Rv,
+      (arg: number) => PalletElectionProviderMultiPhaseSignedSignedSubmission | undefined,
+      number
+    >;
+
+    /**
+     * The minimum score that each 'untrusted' solution must attain in order to be considered
+     * feasible.
+     *
+     * Can be set via `set_minimum_untrusted_score`.
+     *
+     * @param {Callback<SpNposElectionsElectionScore | undefined> =} callback
+     **/
+    minimumUntrustedScore: GenericStorageQuery<Rv, () => SpNposElectionsElectionScore | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `VoterList`'s storage queries
+   **/
+  voterList: {
+    /**
+     * A single node, within some bag.
+     *
+     * Nodes store links forward and back within their respective bags.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletBagsListListNode | undefined> =} callback
+     **/
+    listNodes: GenericStorageQuery<Rv, (arg: AccountId32Like) => PalletBagsListListNode | undefined, AccountId32>;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForListNodes: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * A bag stored in storage.
+     *
+     * Stores a `Bag` struct, which stores head and tail pointers to itself.
+     *
+     * @param {bigint} arg
+     * @param {Callback<PalletBagsListListBag | undefined> =} callback
+     **/
+    listBags: GenericStorageQuery<Rv, (arg: bigint) => PalletBagsListListBag | undefined, bigint>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `NominationPools`'s storage queries
+   **/
+  nominationPools: {
+    /**
+     * The sum of funds across all pools.
+     *
+     * This might be lower but never higher than the sum of `total_balance` of all [`PoolMembers`]
+     * because calling `pool_withdraw_unbonded` might decrease the total stake of the pool's
+     * `bonded_account` without adjusting the pallet-internal `UnbondingPool`'s.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    totalValueLocked: GenericStorageQuery<Rv, () => bigint>;
+
+    /**
+     * Minimum amount to bond to join a pool.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    minJoinBond: GenericStorageQuery<Rv, () => bigint>;
+
+    /**
+     * Minimum bond required to create a pool.
+     *
+     * This is the amount that the depositor must put as their initial stake in the pool, as an
+     * indication of "skin in the game".
+     *
+     * This is the value that will always exist in the staking ledger of the pool bonded account
+     * while all other accounts leave.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    minCreateBond: GenericStorageQuery<Rv, () => bigint>;
+
+    /**
+     * Maximum number of nomination pools that can exist. If `None`, then an unbounded number of
+     * pools can exist.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    maxPools: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * Maximum number of members that can exist in the system. If `None`, then the count
+     * members are not bound on a system wide basis.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    maxPoolMembers: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * Maximum number of members that may belong to pool. If `None`, then the count of
+     * members is not bound on a per pool basis.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    maxPoolMembersPerPool: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * The maximum commission that can be charged by a pool. Used on commission payouts to bound
+     * pool commissions that are > `GlobalMaxCommission`, necessary if a future
+     * `GlobalMaxCommission` is lower than some current pool commissions.
+     *
+     * @param {Callback<Perbill | undefined> =} callback
+     **/
+    globalMaxCommission: GenericStorageQuery<Rv, () => Perbill | undefined>;
+
+    /**
+     * Active members.
+     *
+     * TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletNominationPoolsPoolMember | undefined> =} callback
+     **/
+    poolMembers: GenericStorageQuery<
+      Rv,
+      (arg: AccountId32Like) => PalletNominationPoolsPoolMember | undefined,
+      AccountId32
+    >;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForPoolMembers: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Storage for bonded pools.
+     *
+     * @param {number} arg
+     * @param {Callback<PalletNominationPoolsBondedPoolInner | undefined> =} callback
+     **/
+    bondedPools: GenericStorageQuery<Rv, (arg: number) => PalletNominationPoolsBondedPoolInner | undefined, number>;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForBondedPools: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Reward pools. This is where there rewards for each pool accumulate. When a members payout is
+     * claimed, the balance comes out of the reward pool. Keyed by the bonded pools account.
+     *
+     * @param {number} arg
+     * @param {Callback<PalletNominationPoolsRewardPool | undefined> =} callback
+     **/
+    rewardPools: GenericStorageQuery<Rv, (arg: number) => PalletNominationPoolsRewardPool | undefined, number>;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForRewardPools: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Groups of unbonding pools. Each group of unbonding pools belongs to a
+     * bonded pool, hence the name sub-pools. Keyed by the bonded pools account.
+     *
+     * @param {number} arg
+     * @param {Callback<PalletNominationPoolsSubPools | undefined> =} callback
+     **/
+    subPoolsStorage: GenericStorageQuery<Rv, (arg: number) => PalletNominationPoolsSubPools | undefined, number>;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForSubPoolsStorage: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Metadata for the pool.
+     *
+     * @param {number} arg
+     * @param {Callback<Bytes> =} callback
+     **/
+    metadata: GenericStorageQuery<Rv, (arg: number) => Bytes, number>;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForMetadata: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Ever increasing number of all pools created so far.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    lastPoolId: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * A reverse lookup from the pool's account id to its id.
+     *
+     * This is only used for slashing and on automatic withdraw update. In all other instances, the
+     * pool id is used, and the accounts are deterministically derived from it.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<number | undefined> =} callback
+     **/
+    reversePoolIdLookup: GenericStorageQuery<Rv, (arg: AccountId32Like) => number | undefined, AccountId32>;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForReversePoolIdLookup: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Map from a pool member account to their opted claim permission.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletNominationPoolsClaimPermission> =} callback
+     **/
+    claimPermissions: GenericStorageQuery<
+      Rv,
+      (arg: AccountId32Like) => PalletNominationPoolsClaimPermission,
+      AccountId32
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `FastUnstake`'s storage queries
+   **/
+  fastUnstake: {
+    /**
+     * The current "head of the queue" being unstaked.
+     *
+     * The head in itself can be a batch of up to [`Config::BatchSize`] stakers.
+     *
+     * @param {Callback<PalletFastUnstakeUnstakeRequest | undefined> =} callback
+     **/
+    head: GenericStorageQuery<Rv, () => PalletFastUnstakeUnstakeRequest | undefined>;
+
+    /**
+     * The map of all accounts wishing to be unstaked.
+     *
+     * Keeps track of `AccountId` wishing to unstake and it's corresponding deposit.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<bigint | undefined> =} callback
+     **/
+    queue: GenericStorageQuery<Rv, (arg: AccountId32Like) => bigint | undefined, AccountId32>;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForQueue: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Number of eras to check per block.
+     *
+     * If set to 0, this pallet does absolutely nothing. Cannot be set to more than
+     * [`Config::MaxErasToCheckPerBlock`].
+     *
+     * Based on the amount of weight available at [`Pallet::on_idle`], up to this many eras are
+     * checked. The checking is represented by updating [`UnstakeRequest::checked`], which is
+     * stored in [`Head`].
+     *
+     * @param {Callback<number> =} callback
+     **/
+    erasToCheckPerBlock: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `ConvictionVoting`'s storage queries
+   **/
+  convictionVoting: {
+    /**
+     * All voting for a particular voter in a particular voting class. We store the balance for the
+     * number of votes that we have recorded.
+     *
+     * @param {[AccountId32Like, number]} arg
+     * @param {Callback<PalletConvictionVotingVoteVoting> =} callback
+     **/
+    votingFor: GenericStorageQuery<
+      Rv,
+      (arg: [AccountId32Like, number]) => PalletConvictionVotingVoteVoting,
+      [AccountId32, number]
+    >;
+
+    /**
+     * The voting classes which have a non-zero lock requirement and the lock amounts which they
+     * require. The actual amount locked on behalf of this pallet should always be the maximum of
+     * this list.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<Array<[number, bigint]>> =} callback
+     **/
+    classLocksFor: GenericStorageQuery<Rv, (arg: AccountId32Like) => Array<[number, bigint]>, AccountId32>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Referenda`'s storage queries
+   **/
+  referenda: {
+    /**
+     * The next free referendum index, aka the number of referenda started so far.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    referendumCount: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Information concerning any given referendum.
+     *
+     * @param {number} arg
+     * @param {Callback<PalletReferendaReferendumInfo | undefined> =} callback
+     **/
+    referendumInfoFor: GenericStorageQuery<Rv, (arg: number) => PalletReferendaReferendumInfo | undefined, number>;
+
+    /**
+     * The sorted list of referenda ready to be decided but not yet being decided, ordered by
+     * conviction-weighted approvals.
+     *
+     * This should be empty if `DecidingCount` is less than `TrackInfo::max_deciding`.
+     *
+     * @param {number} arg
+     * @param {Callback<Array<[number, bigint]>> =} callback
+     **/
+    trackQueue: GenericStorageQuery<Rv, (arg: number) => Array<[number, bigint]>, number>;
+
+    /**
+     * The number of referenda being decided currently.
+     *
+     * @param {number} arg
+     * @param {Callback<number> =} callback
+     **/
+    decidingCount: GenericStorageQuery<Rv, (arg: number) => number, number>;
+
+    /**
+     * The metadata is a general information concerning the referendum.
+     * The `Hash` refers to the preimage of the `Preimages` provider which can be a JSON
+     * dump or IPFS hash of a JSON file.
+     *
+     * Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)
+     * large preimages.
+     *
+     * @param {number} arg
+     * @param {Callback<H256 | undefined> =} callback
+     **/
+    metadataOf: GenericStorageQuery<Rv, (arg: number) => H256 | undefined, number>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Whitelist`'s storage queries
+   **/
+  whitelist: {
+    /**
+     *
+     * @param {H256} arg
+     * @param {Callback<[] | undefined> =} callback
+     **/
+    whitelistedCall: GenericStorageQuery<Rv, (arg: H256) => [] | undefined, H256>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Treasury`'s storage queries
+   **/
+  treasury: {
+    /**
+     * Number of proposals that have been made.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    proposalCount: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Proposals that have been made.
+     *
+     * @param {number} arg
+     * @param {Callback<PalletTreasuryProposal | undefined> =} callback
+     **/
+    proposals: GenericStorageQuery<Rv, (arg: number) => PalletTreasuryProposal | undefined, number>;
+
+    /**
+     * The amount which has been reported as inactive to Currency.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    deactivated: GenericStorageQuery<Rv, () => bigint>;
+
+    /**
+     * Proposal indices that have been approved but not yet awarded.
+     *
+     * @param {Callback<Array<number>> =} callback
+     **/
+    approvals: GenericStorageQuery<Rv, () => Array<number>>;
+
+    /**
+     * The count of spends that have been made.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    spendCount: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Spends that have been approved and being processed.
+     *
+     * @param {number} arg
+     * @param {Callback<PalletTreasurySpendStatus | undefined> =} callback
+     **/
+    spends: GenericStorageQuery<Rv, (arg: number) => PalletTreasurySpendStatus | undefined, number>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `DelegatedStaking`'s storage queries
+   **/
+  delegatedStaking: {
+    /**
+     * Map of Delegators to their `Delegation`.
+     *
+     * Implementation note: We are not using a double map with `delegator` and `agent` account
+     * as keys since we want to restrict delegators to delegate only to one account at a time.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletDelegatedStakingDelegation | undefined> =} callback
+     **/
+    delegators: GenericStorageQuery<
+      Rv,
+      (arg: AccountId32Like) => PalletDelegatedStakingDelegation | undefined,
+      AccountId32
+    >;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForDelegators: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Map of `Agent` to their `Ledger`.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<PalletDelegatedStakingAgentLedger | undefined> =} callback
+     **/
+    agents: GenericStorageQuery<
+      Rv,
+      (arg: AccountId32Like) => PalletDelegatedStakingAgentLedger | undefined,
+      AccountId32
+    >;
+
+    /**
+     * Counter for the related counted storage map
+     *
+     * @param {Callback<number> =} callback
+     **/
+    counterForAgents: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Configuration`'s storage queries
+   **/
+  configuration: {
+    /**
+     * The active configuration for the current session.
+     *
+     * @param {Callback<PolkadotRuntimeParachainsConfigurationHostConfiguration> =} callback
+     **/
+    activeConfig: GenericStorageQuery<Rv, () => PolkadotRuntimeParachainsConfigurationHostConfiguration>;
+
+    /**
+     * 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`.
+     *
+     * @param {Callback<Array<[number, PolkadotRuntimeParachainsConfigurationHostConfiguration]>> =} callback
+     **/
+    pendingConfigs: GenericStorageQuery<
+      Rv,
+      () => Array<[number, PolkadotRuntimeParachainsConfigurationHostConfiguration]>
+    >;
+
+    /**
+     * If this is set, then the configuration setters will bypass the consistency checks. This
+     * is meant to be used only as the last resort.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    bypassConsistencyCheck: GenericStorageQuery<Rv, () => boolean>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `ParasShared`'s storage queries
+   **/
+  parasShared: {
+    /**
+     * The current session index.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    currentSessionIndex: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * All the validators actively participating in parachain consensus.
+     * Indices are into the broader validator set.
+     *
+     * @param {Callback<Array<PolkadotPrimitivesV7ValidatorIndex>> =} callback
+     **/
+    activeValidatorIndices: GenericStorageQuery<Rv, () => Array<PolkadotPrimitivesV7ValidatorIndex>>;
+
+    /**
+     * The parachain attestation keys of the validators actively participating in parachain
+     * consensus. This should be the same length as `ActiveValidatorIndices`.
+     *
+     * @param {Callback<Array<PolkadotPrimitivesV7ValidatorAppPublic>> =} callback
+     **/
+    activeValidatorKeys: GenericStorageQuery<Rv, () => Array<PolkadotPrimitivesV7ValidatorAppPublic>>;
+
+    /**
+     * All allowed relay-parents.
+     *
+     * @param {Callback<PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker> =} callback
+     **/
+    allowedRelayParents: GenericStorageQuery<Rv, () => PolkadotRuntimeParachainsSharedAllowedRelayParentsTracker>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `ParaInclusion`'s storage queries
+   **/
+  paraInclusion: {
+    /**
+     * Candidates pending availability by `ParaId`. They form a chain starting from the latest
+     * included head of the para.
+     * Use a different prefix post-migration to v1, since the v0 `PendingAvailability` storage
+     * would otherwise have the exact same prefix which could cause undefined behaviour when doing
+     * the migration.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<Array<PolkadotRuntimeParachainsInclusionCandidatePendingAvailability> | undefined> =} callback
+     **/
+    v1: GenericStorageQuery<
+      Rv,
+      (
+        arg: PolkadotParachainPrimitivesPrimitivesId,
+      ) => Array<PolkadotRuntimeParachainsInclusionCandidatePendingAvailability> | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `ParaInherent`'s storage queries
+   **/
+  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.
+     *
+     * @param {Callback<[] | undefined> =} callback
+     **/
+    included: GenericStorageQuery<Rv, () => [] | undefined>;
+
+    /**
+     * Scraped on chain data for extracting resolved disputes as well as backing votes.
+     *
+     * @param {Callback<PolkadotPrimitivesV7ScrapedOnChainVotes | undefined> =} callback
+     **/
+    onChainVotes: GenericStorageQuery<Rv, () => PolkadotPrimitivesV7ScrapedOnChainVotes | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `ParaScheduler`'s storage queries
+   **/
+  paraScheduler: {
+    /**
+     * 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.
+     *
+     * @param {Callback<Array<Array<PolkadotPrimitivesV7ValidatorIndex>>> =} callback
+     **/
+    validatorGroups: GenericStorageQuery<Rv, () => Array<Array<PolkadotPrimitivesV7ValidatorIndex>>>;
+
+    /**
+     * One entry for each availability core. The i'th parachain belongs to the i'th core, with the
+     * remaining cores all being on demand parachain 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`.
+     *
+     * @param {Callback<Array<PolkadotRuntimeParachainsSchedulerPalletCoreOccupied>> =} callback
+     **/
+    availabilityCores: GenericStorageQuery<Rv, () => Array<PolkadotRuntimeParachainsSchedulerPalletCoreOccupied>>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    sessionStartBlock: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * One entry for each availability core. The `VecDeque` represents the assignments to be
+     * scheduled on that core. 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.
+     *
+     * @param {Callback<Array<[PolkadotPrimitivesV7CoreIndex, Array<PolkadotRuntimeParachainsSchedulerPalletParasEntry>]>> =} callback
+     **/
+    claimQueue: GenericStorageQuery<
+      Rv,
+      () => Array<[PolkadotPrimitivesV7CoreIndex, Array<PolkadotRuntimeParachainsSchedulerPalletParasEntry>]>
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Paras`'s storage queries
+   **/
+  paras: {
+    /**
+     * 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.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesValidationCodeHash} arg
+     * @param {Callback<PolkadotRuntimeParachainsParasPvfCheckActiveVoteState | undefined> =} callback
+     **/
+    pvfActiveVoteMap: GenericStorageQuery<
+      Rv,
+      (
+        arg: PolkadotParachainPrimitivesPrimitivesValidationCodeHash,
+      ) => PolkadotRuntimeParachainsParasPvfCheckActiveVoteState | undefined,
+      PolkadotParachainPrimitivesPrimitivesValidationCodeHash
+    >;
+
+    /**
+     * The list of all currently active PVF votes. Auxiliary to `PvfActiveVoteMap`.
+     *
+     * @param {Callback<Array<PolkadotParachainPrimitivesPrimitivesValidationCodeHash>> =} callback
+     **/
+    pvfActiveVoteList: GenericStorageQuery<Rv, () => Array<PolkadotParachainPrimitivesPrimitivesValidationCodeHash>>;
+
+    /**
+     * All lease holding parachains. Ordered ascending by `ParaId`. On demand parachains are not
+     * included.
+     *
+     * Consider using the [`ParachainsCache`] type of modifying.
+     *
+     * @param {Callback<Array<PolkadotParachainPrimitivesPrimitivesId>> =} callback
+     **/
+    parachains: GenericStorageQuery<Rv, () => Array<PolkadotParachainPrimitivesPrimitivesId>>;
+
+    /**
+     * The current lifecycle of a all known Para IDs.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<PolkadotRuntimeParachainsParasParaLifecycle | undefined> =} callback
+     **/
+    paraLifecycles: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => PolkadotRuntimeParachainsParasParaLifecycle | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * The head-data of every registered para.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<PolkadotParachainPrimitivesPrimitivesHeadData | undefined> =} callback
+     **/
+    heads: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => PolkadotParachainPrimitivesPrimitivesHeadData | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * The context (relay-chain block number) of the most recent parachain head.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<number | undefined> =} callback
+     **/
+    mostRecentContext: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => number | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * The validation code hash of every live para.
+     *
+     * Corresponding code can be retrieved with [`CodeByHash`].
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<PolkadotParachainPrimitivesPrimitivesValidationCodeHash | undefined> =} callback
+     **/
+    currentCodeHash: GenericStorageQuery<
+      Rv,
+      (
+        arg: PolkadotParachainPrimitivesPrimitivesId,
+      ) => PolkadotParachainPrimitivesPrimitivesValidationCodeHash | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * 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`].
+     *
+     * @param {[PolkadotParachainPrimitivesPrimitivesId, number]} arg
+     * @param {Callback<PolkadotParachainPrimitivesPrimitivesValidationCodeHash | undefined> =} callback
+     **/
+    pastCodeHash: GenericStorageQuery<
+      Rv,
+      (
+        arg: [PolkadotParachainPrimitivesPrimitivesId, number],
+      ) => PolkadotParachainPrimitivesPrimitivesValidationCodeHash | undefined,
+      [PolkadotParachainPrimitivesPrimitivesId, number]
+    >;
+
+    /**
+     * 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 approval checkers.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<PolkadotRuntimeParachainsParasParaPastCodeMeta> =} callback
+     **/
+    pastCodeMeta: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => PolkadotRuntimeParachainsParasParaPastCodeMeta,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<Array<[PolkadotParachainPrimitivesPrimitivesId, number]>> =} callback
+     **/
+    pastCodePruning: GenericStorageQuery<Rv, () => Array<[PolkadotParachainPrimitivesPrimitivesId, number]>>;
+
+    /**
+     * The block number at which the planned code change is expected for a parachain.
+     *
+     * 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`.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<number | undefined> =} callback
+     **/
+    futureCodeUpgrades: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => number | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * The list of upcoming future code upgrades.
+     *
+     * Each item is a pair of the parachain and the expected block at which the upgrade should be
+     * applied. The upgrade will be applied at the given relay chain block. In contrast to
+     * [`FutureCodeUpgrades`] this code upgrade will be applied regardless the parachain making any
+     * progress or not.
+     *
+     * Ordered ascending by block number.
+     *
+     * @param {Callback<Array<[PolkadotParachainPrimitivesPrimitivesId, number]>> =} callback
+     **/
+    futureCodeUpgradesAt: GenericStorageQuery<Rv, () => Array<[PolkadotParachainPrimitivesPrimitivesId, number]>>;
+
+    /**
+     * The actual future code hash of a para.
+     *
+     * Corresponding code can be retrieved with [`CodeByHash`].
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<PolkadotParachainPrimitivesPrimitivesValidationCodeHash | undefined> =} callback
+     **/
+    futureCodeHash: GenericStorageQuery<
+      Rv,
+      (
+        arg: PolkadotParachainPrimitivesPrimitivesId,
+      ) => PolkadotParachainPrimitivesPrimitivesValidationCodeHash | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * 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.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<PolkadotPrimitivesV7UpgradeGoAhead | undefined> =} callback
+     **/
+    upgradeGoAheadSignal: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => PolkadotPrimitivesV7UpgradeGoAhead | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * 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.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<PolkadotPrimitivesV7UpgradeRestriction | undefined> =} callback
+     **/
+    upgradeRestrictionSignal: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => PolkadotPrimitivesV7UpgradeRestriction | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * The list of parachains that are awaiting for their upgrade restriction to cooldown.
+     *
+     * Ordered ascending by block number.
+     *
+     * @param {Callback<Array<[PolkadotParachainPrimitivesPrimitivesId, number]>> =} callback
+     **/
+    upgradeCooldowns: GenericStorageQuery<Rv, () => Array<[PolkadotParachainPrimitivesPrimitivesId, number]>>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<Array<[PolkadotParachainPrimitivesPrimitivesId, number]>> =} callback
+     **/
+    upcomingUpgrades: GenericStorageQuery<Rv, () => Array<[PolkadotParachainPrimitivesPrimitivesId, number]>>;
+
+    /**
+     * The actions to perform during the start of a specific session index.
+     *
+     * @param {number} arg
+     * @param {Callback<Array<PolkadotParachainPrimitivesPrimitivesId>> =} callback
+     **/
+    actionsQueue: GenericStorageQuery<Rv, (arg: number) => Array<PolkadotParachainPrimitivesPrimitivesId>, number>;
+
+    /**
+     * 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`.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<PolkadotRuntimeParachainsParasParaGenesisArgs | undefined> =} callback
+     **/
+    upcomingParasGenesis: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => PolkadotRuntimeParachainsParasParaGenesisArgs | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * The number of reference on the validation code in [`CodeByHash`] storage.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesValidationCodeHash} arg
+     * @param {Callback<number> =} callback
+     **/
+    codeByHashRefs: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesValidationCodeHash) => number,
+      PolkadotParachainPrimitivesPrimitivesValidationCodeHash
+    >;
+
+    /**
+     * Validation code stored by its hash.
+     *
+     * This storage is consistent with [`FutureCodeHash`], [`CurrentCodeHash`] and
+     * [`PastCodeHash`].
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesValidationCodeHash} arg
+     * @param {Callback<PolkadotParachainPrimitivesPrimitivesValidationCode | undefined> =} callback
+     **/
+    codeByHash: GenericStorageQuery<
+      Rv,
+      (
+        arg: PolkadotParachainPrimitivesPrimitivesValidationCodeHash,
+      ) => PolkadotParachainPrimitivesPrimitivesValidationCode | undefined,
+      PolkadotParachainPrimitivesPrimitivesValidationCodeHash
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Initializer`'s storage queries
+   **/
+  initializer: {
+    /**
+     * 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.
+     *
+     * @param {Callback<[] | undefined> =} callback
+     **/
+    hasInitialized: GenericStorageQuery<Rv, () => [] | undefined>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<Array<PolkadotRuntimeParachainsInitializerBufferedSessionChange>> =} callback
+     **/
+    bufferedSessionChanges: GenericStorageQuery<
+      Rv,
+      () => Array<PolkadotRuntimeParachainsInitializerBufferedSessionChange>
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Dmp`'s storage queries
+   **/
+  dmp: {
+    /**
+     * The downward messages addressed for a certain para.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<Array<PolkadotCorePrimitivesInboundDownwardMessage>> =} callback
+     **/
+    downwardMessageQueues: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => Array<PolkadotCorePrimitivesInboundDownwardMessage>,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * 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.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<H256> =} callback
+     **/
+    downwardMessageQueueHeads: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => H256,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * The factor to multiply the base delivery fee by.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<FixedU128> =} callback
+     **/
+    deliveryFeeFactor: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => FixedU128,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Hrmp`'s storage queries
+   **/
+  hrmp: {
+    /**
+     * 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.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesHrmpChannelId} arg
+     * @param {Callback<PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest | undefined> =} callback
+     **/
+    hrmpOpenChannelRequests: GenericStorageQuery<
+      Rv,
+      (
+        arg: PolkadotParachainPrimitivesPrimitivesHrmpChannelId,
+      ) => PolkadotRuntimeParachainsHrmpHrmpOpenChannelRequest | undefined,
+      PolkadotParachainPrimitivesPrimitivesHrmpChannelId
+    >;
+
+    /**
+     *
+     * @param {Callback<Array<PolkadotParachainPrimitivesPrimitivesHrmpChannelId>> =} callback
+     **/
+    hrmpOpenChannelRequestsList: GenericStorageQuery<
+      Rv,
+      () => Array<PolkadotParachainPrimitivesPrimitivesHrmpChannelId>
+    >;
+
+    /**
+     * 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`.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<number> =} callback
+     **/
+    hrmpOpenChannelRequestCount: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => number,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * 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`.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<number> =} callback
+     **/
+    hrmpAcceptedChannelRequestCount: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => number,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * 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.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesHrmpChannelId} arg
+     * @param {Callback<[] | undefined> =} callback
+     **/
+    hrmpCloseChannelRequests: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesHrmpChannelId) => [] | undefined,
+      PolkadotParachainPrimitivesPrimitivesHrmpChannelId
+    >;
+
+    /**
+     *
+     * @param {Callback<Array<PolkadotParachainPrimitivesPrimitivesHrmpChannelId>> =} callback
+     **/
+    hrmpCloseChannelRequestsList: GenericStorageQuery<
+      Rv,
+      () => Array<PolkadotParachainPrimitivesPrimitivesHrmpChannelId>
+    >;
+
+    /**
+     * 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.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<number | undefined> =} callback
+     **/
+    hrmpWatermarks: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => number | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * HRMP channel data associated with each para.
+     * Invariant:
+     * - each participant in the channel should satisfy `Paras::is_valid_para(P)` within a session.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesHrmpChannelId} arg
+     * @param {Callback<PolkadotRuntimeParachainsHrmpHrmpChannel | undefined> =} callback
+     **/
+    hrmpChannels: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesHrmpChannelId) => PolkadotRuntimeParachainsHrmpHrmpChannel | undefined,
+      PolkadotParachainPrimitivesPrimitivesHrmpChannelId
+    >;
+
+    /**
+     * 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.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<Array<PolkadotParachainPrimitivesPrimitivesId>> =} callback
+     **/
+    hrmpIngressChannelsIndex: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => Array<PolkadotParachainPrimitivesPrimitivesId>,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<Array<PolkadotParachainPrimitivesPrimitivesId>> =} callback
+     **/
+    hrmpEgressChannelsIndex: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => Array<PolkadotParachainPrimitivesPrimitivesId>,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * Storage for the messages for each channel.
+     * Invariant: cannot be non-empty if the corresponding channel in `HrmpChannels` is `None`.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesHrmpChannelId} arg
+     * @param {Callback<Array<PolkadotCorePrimitivesInboundHrmpMessage>> =} callback
+     **/
+    hrmpChannelContents: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesHrmpChannelId) => Array<PolkadotCorePrimitivesInboundHrmpMessage>,
+      PolkadotParachainPrimitivesPrimitivesHrmpChannelId
+    >;
+
+    /**
+     * 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.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<Array<[number, Array<PolkadotParachainPrimitivesPrimitivesId>]>> =} callback
+     **/
+    hrmpChannelDigests: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => Array<[number, Array<PolkadotParachainPrimitivesPrimitivesId>]>,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `ParaSessionInfo`'s storage queries
+   **/
+  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.
+     *
+     * @param {Callback<Array<PolkadotPrimitivesV7AssignmentAppPublic>> =} callback
+     **/
+    assignmentKeysUnsafe: GenericStorageQuery<Rv, () => Array<PolkadotPrimitivesV7AssignmentAppPublic>>;
+
+    /**
+     * The earliest session for which previous session info is stored.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    earliestStoredSession: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * 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.
+     *
+     * @param {number} arg
+     * @param {Callback<PolkadotPrimitivesV7SessionInfo | undefined> =} callback
+     **/
+    sessions: GenericStorageQuery<Rv, (arg: number) => PolkadotPrimitivesV7SessionInfo | undefined, number>;
+
+    /**
+     * The validator account keys of the validators actively participating in parachain consensus.
+     *
+     * @param {number} arg
+     * @param {Callback<Array<AccountId32> | undefined> =} callback
+     **/
+    accountKeys: GenericStorageQuery<Rv, (arg: number) => Array<AccountId32> | undefined, number>;
+
+    /**
+     * Executor parameter set for a given session index
+     *
+     * @param {number} arg
+     * @param {Callback<PolkadotPrimitivesV7ExecutorParams | undefined> =} callback
+     **/
+    sessionExecutorParams: GenericStorageQuery<
+      Rv,
+      (arg: number) => PolkadotPrimitivesV7ExecutorParams | undefined,
+      number
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `ParasDisputes`'s storage queries
+   **/
+  parasDisputes: {
+    /**
+     * The last pruned session, if any. All data stored by this module
+     * references sessions.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    lastPrunedSession: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * All ongoing or concluded disputes for the last several sessions.
+     *
+     * @param {[number, PolkadotCorePrimitivesCandidateHash]} arg
+     * @param {Callback<PolkadotPrimitivesV7DisputeState | undefined> =} callback
+     **/
+    disputes: GenericStorageQuery<
+      Rv,
+      (arg: [number, PolkadotCorePrimitivesCandidateHash]) => PolkadotPrimitivesV7DisputeState | undefined,
+      [number, PolkadotCorePrimitivesCandidateHash]
+    >;
+
+    /**
+     * Backing votes stored for each dispute.
+     * This storage is used for slashing.
+     *
+     * @param {[number, PolkadotCorePrimitivesCandidateHash]} arg
+     * @param {Callback<Array<PolkadotPrimitivesV7ValidatorIndex> | undefined> =} callback
+     **/
+    backersOnDisputes: GenericStorageQuery<
+      Rv,
+      (arg: [number, PolkadotCorePrimitivesCandidateHash]) => Array<PolkadotPrimitivesV7ValidatorIndex> | undefined,
+      [number, PolkadotCorePrimitivesCandidateHash]
+    >;
+
+    /**
+     * 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.
+     *
+     * @param {[number, PolkadotCorePrimitivesCandidateHash]} arg
+     * @param {Callback<number | undefined> =} callback
+     **/
+    included: GenericStorageQuery<
+      Rv,
+      (arg: [number, PolkadotCorePrimitivesCandidateHash]) => number | undefined,
+      [number, PolkadotCorePrimitivesCandidateHash]
+    >;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    frozen: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `ParasSlashing`'s storage queries
+   **/
+  parasSlashing: {
+    /**
+     * Validators pending dispute slashes.
+     *
+     * @param {[number, PolkadotCorePrimitivesCandidateHash]} arg
+     * @param {Callback<PolkadotPrimitivesV7SlashingPendingSlashes | undefined> =} callback
+     **/
+    unappliedSlashes: GenericStorageQuery<
+      Rv,
+      (arg: [number, PolkadotCorePrimitivesCandidateHash]) => PolkadotPrimitivesV7SlashingPendingSlashes | undefined,
+      [number, PolkadotCorePrimitivesCandidateHash]
+    >;
+
+    /**
+     * `ValidatorSetCount` per session.
+     *
+     * @param {number} arg
+     * @param {Callback<number | undefined> =} callback
+     **/
+    validatorSetCounts: GenericStorageQuery<Rv, (arg: number) => number | undefined, number>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `OnDemandAssignmentProvider`'s storage queries
+   **/
+  onDemandAssignmentProvider: {
+    /**
+     * Maps a `ParaId` to `CoreIndex` and keeps track of how many assignments the scheduler has in
+     * it's lookahead. Keeping track of this affinity prevents parallel execution of the same
+     * `ParaId` on two or more `CoreIndex`es.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<PolkadotRuntimeParachainsAssignerOnDemandTypesCoreAffinityCount | undefined> =} callback
+     **/
+    paraIdAffinity: GenericStorageQuery<
+      Rv,
+      (
+        arg: PolkadotParachainPrimitivesPrimitivesId,
+      ) => PolkadotRuntimeParachainsAssignerOnDemandTypesCoreAffinityCount | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * Overall status of queue (both free + affinity entries)
+     *
+     * @param {Callback<PolkadotRuntimeParachainsAssignerOnDemandTypesQueueStatusType> =} callback
+     **/
+    queueStatus: GenericStorageQuery<Rv, () => PolkadotRuntimeParachainsAssignerOnDemandTypesQueueStatusType>;
+
+    /**
+     * Priority queue for all orders which don't yet (or not any more) have any core affinity.
+     *
+     * @param {Callback<BinaryHeapEnqueuedOrder> =} callback
+     **/
+    freeEntries: GenericStorageQuery<Rv, () => BinaryHeapEnqueuedOrder>;
+
+    /**
+     * Queue entries that are currently bound to a particular core due to core affinity.
+     *
+     * @param {PolkadotPrimitivesV7CoreIndex} arg
+     * @param {Callback<BinaryHeapEnqueuedOrder> =} callback
+     **/
+    affinityEntries: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotPrimitivesV7CoreIndex) => BinaryHeapEnqueuedOrder,
+      PolkadotPrimitivesV7CoreIndex
+    >;
+
+    /**
+     * Keeps track of accumulated revenue from on demand order sales.
+     *
+     * @param {Callback<Array<bigint>> =} callback
+     **/
+    revenue: GenericStorageQuery<Rv, () => Array<bigint>>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `CoretimeAssignmentProvider`'s storage queries
+   **/
+  coretimeAssignmentProvider: {
+    /**
+     * Scheduled assignment sets.
+     *
+     * Assignments as of the given block number. They will go into state once the block number is
+     * reached (and replace whatever was in there before).
+     *
+     * @param {[number, PolkadotPrimitivesV7CoreIndex]} arg
+     * @param {Callback<PolkadotRuntimeParachainsAssignerCoretimeSchedule | undefined> =} callback
+     **/
+    coreSchedules: GenericStorageQuery<
+      Rv,
+      (arg: [number, PolkadotPrimitivesV7CoreIndex]) => PolkadotRuntimeParachainsAssignerCoretimeSchedule | undefined,
+      [number, PolkadotPrimitivesV7CoreIndex]
+    >;
+
+    /**
+     * Assignments which are currently active.
+     *
+     * They will be picked from `PendingAssignments` once we reach the scheduled block number in
+     * `PendingAssignments`.
+     *
+     * @param {PolkadotPrimitivesV7CoreIndex} arg
+     * @param {Callback<PolkadotRuntimeParachainsAssignerCoretimeCoreDescriptor> =} callback
+     **/
+    coreDescriptors: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotPrimitivesV7CoreIndex) => PolkadotRuntimeParachainsAssignerCoretimeCoreDescriptor,
+      PolkadotPrimitivesV7CoreIndex
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Registrar`'s storage queries
+   **/
+  registrar: {
+    /**
+     * Pending swap operations.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<PolkadotParachainPrimitivesPrimitivesId | undefined> =} callback
+     **/
+    pendingSwap: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => PolkadotParachainPrimitivesPrimitivesId | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * 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.)
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<PolkadotRuntimeCommonParasRegistrarParaInfo | undefined> =} callback
+     **/
+    paras: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => PolkadotRuntimeCommonParasRegistrarParaInfo | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * The next free `ParaId`.
+     *
+     * @param {Callback<PolkadotParachainPrimitivesPrimitivesId> =} callback
+     **/
+    nextFreeParaId: GenericStorageQuery<Rv, () => PolkadotParachainPrimitivesPrimitivesId>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Slots`'s storage queries
+   **/
+  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.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<Array<[AccountId32, bigint] | undefined>> =} callback
+     **/
+    leases: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => Array<[AccountId32, bigint] | undefined>,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Auctions`'s storage queries
+   **/
+  auctions: {
+    /**
+     * Number of auctions started so far.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    auctionCounter: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<[number, number] | undefined> =} callback
+     **/
+    auctionInfo: GenericStorageQuery<Rv, () => [number, number] | undefined>;
+
+    /**
+     * Amounts currently reserved in the accounts of the bidders currently winning
+     * (sub-)ranges.
+     *
+     * @param {[AccountId32Like, PolkadotParachainPrimitivesPrimitivesId]} arg
+     * @param {Callback<bigint | undefined> =} callback
+     **/
+    reservedAmounts: GenericStorageQuery<
+      Rv,
+      (arg: [AccountId32Like, PolkadotParachainPrimitivesPrimitivesId]) => bigint | undefined,
+      [AccountId32, PolkadotParachainPrimitivesPrimitivesId]
+    >;
+
+    /**
+     * 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`.
+     *
+     * @param {number} arg
+     * @param {Callback<FixedArray<[AccountId32, PolkadotParachainPrimitivesPrimitivesId, bigint] | undefined, 36> | undefined> =} callback
+     **/
+    winning: GenericStorageQuery<
+      Rv,
+      (
+        arg: number,
+      ) => FixedArray<[AccountId32, PolkadotParachainPrimitivesPrimitivesId, bigint] | undefined, 36> | undefined,
+      number
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Crowdloan`'s storage queries
+   **/
+  crowdloan: {
+    /**
+     * Info on all of the funds.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<PolkadotRuntimeCommonCrowdloanFundInfo | undefined> =} callback
+     **/
+    funds: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => PolkadotRuntimeCommonCrowdloanFundInfo | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<Array<PolkadotParachainPrimitivesPrimitivesId>> =} callback
+     **/
+    newRaise: GenericStorageQuery<Rv, () => Array<PolkadotParachainPrimitivesPrimitivesId>>;
+
+    /**
+     * The number of auctions that have entered into their ending period so far.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    endingsCount: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Tracker for the next available fund index
+     *
+     * @param {Callback<number> =} callback
+     **/
+    nextFundIndex: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `AssignedSlots`'s storage queries
+   **/
+  assignedSlots: {
+    /**
+     * Assigned permanent slots, with their start lease period, and duration.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<[number, number] | undefined> =} callback
+     **/
+    permanentSlots: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotParachainPrimitivesPrimitivesId) => [number, number] | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * Number of assigned (and active) permanent slots.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    permanentSlotCount: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Assigned temporary slots.
+     *
+     * @param {PolkadotParachainPrimitivesPrimitivesId} arg
+     * @param {Callback<PolkadotRuntimeCommonAssignedSlotsParachainTemporarySlot | undefined> =} callback
+     **/
+    temporarySlots: GenericStorageQuery<
+      Rv,
+      (
+        arg: PolkadotParachainPrimitivesPrimitivesId,
+      ) => PolkadotRuntimeCommonAssignedSlotsParachainTemporarySlot | undefined,
+      PolkadotParachainPrimitivesPrimitivesId
+    >;
+
+    /**
+     * Number of assigned temporary slots.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    temporarySlotCount: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Number of active temporary slots in current slot lease period.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    activeTemporarySlotCount: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * The max number of temporary slots that can be assigned.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    maxTemporarySlots: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * The max number of permanent slots that can be assigned.
+     *
+     * @param {Callback<number> =} callback
+     **/
+    maxPermanentSlots: GenericStorageQuery<Rv, () => number>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `XcmPallet`'s storage queries
+   **/
+  xcmPallet: {
+    /**
+     * The latest available query index.
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    queryCounter: GenericStorageQuery<Rv, () => bigint>;
+
+    /**
+     * The ongoing queries.
+     *
+     * @param {bigint} arg
+     * @param {Callback<PalletXcmQueryStatus | undefined> =} callback
+     **/
+    queries: GenericStorageQuery<Rv, (arg: bigint) => PalletXcmQueryStatus | undefined, bigint>;
+
+    /**
+     * The existing asset traps.
+     *
+     * Key is the blake2 256 hash of (origin, versioned `Assets`) pair. Value is the number of
+     * times this pair has been trapped (usually just 1 if it exists at all).
+     *
+     * @param {H256} arg
+     * @param {Callback<number> =} callback
+     **/
+    assetTraps: GenericStorageQuery<Rv, (arg: H256) => number, H256>;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    safeXcmVersion: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * The Latest versions that we know various locations support.
+     *
+     * @param {[number, XcmVersionedLocation]} arg
+     * @param {Callback<number | undefined> =} callback
+     **/
+    supportedVersion: GenericStorageQuery<
+      Rv,
+      (arg: [number, XcmVersionedLocation]) => number | undefined,
+      [number, XcmVersionedLocation]
+    >;
+
+    /**
+     * All locations that we have requested version notifications from.
+     *
+     * @param {[number, XcmVersionedLocation]} arg
+     * @param {Callback<bigint | undefined> =} callback
+     **/
+    versionNotifiers: GenericStorageQuery<
+      Rv,
+      (arg: [number, XcmVersionedLocation]) => bigint | undefined,
+      [number, XcmVersionedLocation]
+    >;
+
+    /**
+     * The target locations that are subscribed to our version changes, as well as the most recent
+     * of our versions we informed them of.
+     *
+     * @param {[number, XcmVersionedLocation]} arg
+     * @param {Callback<[bigint, SpWeightsWeightV2Weight, number] | undefined> =} callback
+     **/
+    versionNotifyTargets: GenericStorageQuery<
+      Rv,
+      (arg: [number, XcmVersionedLocation]) => [bigint, SpWeightsWeightV2Weight, number] | undefined,
+      [number, XcmVersionedLocation]
+    >;
+
+    /**
+     * 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.
+     *
+     * @param {Callback<Array<[XcmVersionedLocation, number]>> =} callback
+     **/
+    versionDiscoveryQueue: GenericStorageQuery<Rv, () => Array<[XcmVersionedLocation, number]>>;
+
+    /**
+     * The current migration's stage, if any.
+     *
+     * @param {Callback<PalletXcmVersionMigrationStage | undefined> =} callback
+     **/
+    currentMigration: GenericStorageQuery<Rv, () => PalletXcmVersionMigrationStage | undefined>;
+
+    /**
+     * Fungible assets which we know are locked on a remote chain.
+     *
+     * @param {[number, AccountId32Like, XcmVersionedAssetId]} arg
+     * @param {Callback<PalletXcmRemoteLockedFungibleRecord | undefined> =} callback
+     **/
+    remoteLockedFungibles: GenericStorageQuery<
+      Rv,
+      (arg: [number, AccountId32Like, XcmVersionedAssetId]) => PalletXcmRemoteLockedFungibleRecord | undefined,
+      [number, AccountId32, XcmVersionedAssetId]
+    >;
+
+    /**
+     * Fungible assets which we know are locked on this chain.
+     *
+     * @param {AccountId32Like} arg
+     * @param {Callback<Array<[bigint, XcmVersionedLocation]> | undefined> =} callback
+     **/
+    lockedFungibles: GenericStorageQuery<
+      Rv,
+      (arg: AccountId32Like) => Array<[bigint, XcmVersionedLocation]> | undefined,
+      AccountId32
+    >;
+
+    /**
+     * Global suspension state of the XCM executor.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    xcmExecutionSuspended: GenericStorageQuery<Rv, () => boolean>;
+
+    /**
+     * Whether or not incoming XCMs (both executed locally and received) should be recorded.
+     * Only one XCM program will be recorded at a time.
+     * This is meant to be used in runtime APIs, and it's advised it stays false
+     * for all other use cases, so as to not degrade regular performance.
+     *
+     * Only relevant if this pallet is being used as the [`xcm_executor::traits::RecordXcm`]
+     * implementation in the XCM executor configuration.
+     *
+     * @param {Callback<boolean> =} callback
+     **/
+    shouldRecordXcm: GenericStorageQuery<Rv, () => boolean>;
+
+    /**
+     * If [`ShouldRecordXcm`] is set to true, then the last XCM program executed locally
+     * will be stored here.
+     * Runtime APIs can fetch the XCM that was executed by accessing this value.
+     *
+     * Only relevant if this pallet is being used as the [`xcm_executor::traits::RecordXcm`]
+     * implementation in the XCM executor configuration.
+     *
+     * @param {Callback<StagingXcmV4Xcm | undefined> =} callback
+     **/
+    recordedXcm: GenericStorageQuery<Rv, () => StagingXcmV4Xcm | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `MessageQueue`'s storage queries
+   **/
+  messageQueue: {
+    /**
+     * The index of the first and last (non-empty) pages.
+     *
+     * @param {PolkadotRuntimeParachainsInclusionAggregateMessageOrigin} arg
+     * @param {Callback<PalletMessageQueueBookState> =} callback
+     **/
+    bookStateFor: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotRuntimeParachainsInclusionAggregateMessageOrigin) => PalletMessageQueueBookState,
+      PolkadotRuntimeParachainsInclusionAggregateMessageOrigin
+    >;
+
+    /**
+     * The origin at which we should begin servicing.
+     *
+     * @param {Callback<PolkadotRuntimeParachainsInclusionAggregateMessageOrigin | undefined> =} callback
+     **/
+    serviceHead: GenericStorageQuery<Rv, () => PolkadotRuntimeParachainsInclusionAggregateMessageOrigin | undefined>;
+
+    /**
+     * The map of page indices to pages.
+     *
+     * @param {[PolkadotRuntimeParachainsInclusionAggregateMessageOrigin, number]} arg
+     * @param {Callback<PalletMessageQueuePage | undefined> =} callback
+     **/
+    pages: GenericStorageQuery<
+      Rv,
+      (arg: [PolkadotRuntimeParachainsInclusionAggregateMessageOrigin, number]) => PalletMessageQueuePage | undefined,
+      [PolkadotRuntimeParachainsInclusionAggregateMessageOrigin, number]
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `AssetRate`'s storage queries
+   **/
+  assetRate: {
+    /**
+     * Maps an asset to its fixed point representation in the native balance.
+     *
+     * E.g. `native_amount = asset_amount * ConversionRateToNative::<T>::get(asset_kind)`
+     *
+     * @param {PolkadotRuntimeCommonImplsVersionedLocatableAsset} arg
+     * @param {Callback<FixedU128 | undefined> =} callback
+     **/
+    conversionRateToNative: GenericStorageQuery<
+      Rv,
+      (arg: PolkadotRuntimeCommonImplsVersionedLocatableAsset) => FixedU128 | undefined,
+      PolkadotRuntimeCommonImplsVersionedLocatableAsset
+    >;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Beefy`'s storage queries
+   **/
+  beefy: {
+    /**
+     * The current authorities set
+     *
+     * @param {Callback<Array<SpConsensusBeefyEcdsaCryptoPublic>> =} callback
+     **/
+    authorities: GenericStorageQuery<Rv, () => Array<SpConsensusBeefyEcdsaCryptoPublic>>;
+
+    /**
+     * The current validator set id
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    validatorSetId: GenericStorageQuery<Rv, () => bigint>;
+
+    /**
+     * Authorities set scheduled to be used with the next session
+     *
+     * @param {Callback<Array<SpConsensusBeefyEcdsaCryptoPublic>> =} callback
+     **/
+    nextAuthorities: GenericStorageQuery<Rv, () => Array<SpConsensusBeefyEcdsaCryptoPublic>>;
+
+    /**
+     * A mapping from BEEFY set ID to the index of the *most recent* session for which its
+     * members were responsible.
+     *
+     * This is only used for validating equivocation proofs. An equivocation proof must
+     * contains a key-ownership proof for a given session, therefore we need a way to tie
+     * together sessions and BEEFY set ids, i.e. we need to validate that a validator
+     * was the owner of a given key on a given session, and what the active set ID was
+     * during that session.
+     *
+     * TWOX-NOTE: `ValidatorSetId` is not under user control.
+     *
+     * @param {bigint} arg
+     * @param {Callback<number | undefined> =} callback
+     **/
+    setIdSession: GenericStorageQuery<Rv, (arg: bigint) => number | undefined, bigint>;
+
+    /**
+     * Block number where BEEFY consensus is enabled/started.
+     * By changing this (through privileged `set_new_genesis()`), BEEFY consensus is effectively
+     * restarted from the newly set block number.
+     *
+     * @param {Callback<number | undefined> =} callback
+     **/
+    genesisBlock: GenericStorageQuery<Rv, () => number | undefined>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `Mmr`'s storage queries
+   **/
+  mmr: {
+    /**
+     * Latest MMR Root hash.
+     *
+     * @param {Callback<H256> =} callback
+     **/
+    rootHash: GenericStorageQuery<Rv, () => H256>;
+
+    /**
+     * Current size of the MMR (number of leaves).
+     *
+     * @param {Callback<bigint> =} callback
+     **/
+    numberOfLeaves: GenericStorageQuery<Rv, () => bigint>;
+
+    /**
+     * Hashes of the nodes in the MMR.
+     *
+     * Note this collection only contains MMR peaks, the inner nodes (and leaves)
+     * are pruned and only stored in the Offchain DB.
+     *
+     * @param {bigint} arg
+     * @param {Callback<H256 | undefined> =} callback
+     **/
+    nodes: GenericStorageQuery<Rv, (arg: bigint) => H256 | undefined, bigint>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+  /**
+   * Pallet `BeefyMmrLeaf`'s storage queries
+   **/
+  beefyMmrLeaf: {
+    /**
+     * Details of current BEEFY authority set.
+     *
+     * @param {Callback<SpConsensusBeefyMmrBeefyAuthoritySet> =} callback
+     **/
+    beefyAuthorities: GenericStorageQuery<Rv, () => SpConsensusBeefyMmrBeefyAuthoritySet>;
+
+    /**
+     * Details of next BEEFY authority set.
+     *
+     * This storage entry is used as cache for calls to `update_beefy_next_authority_set`.
+     *
+     * @param {Callback<SpConsensusBeefyMmrBeefyAuthoritySet> =} callback
+     **/
+    beefyNextAuthorities: GenericStorageQuery<Rv, () => SpConsensusBeefyMmrBeefyAuthoritySet>;
+
+    /**
+     * Generic pallet storage query
+     **/
+    [storage: string]: GenericStorageQuery<Rv>;
+  };
+}