@polkadot/api-augment 16.4.9 → 16.5.1

package/cjs/assetHubKusama/query.d.ts

@@ -2,13 +2,116 @@ import '@polkadot/api-base/types/storage';
 import type { ApiTypes, AugmentedQuery, QueryableStorageEntry } from '@polkadot/api-base/types';
 import type { BTreeMap, BTreeSet, Bytes, Null, Option, Struct, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
 import type { AnyNumber, ITuple } from '@polkadot/types-codec/types';
-import type { AccountId32, H160, H256, Perbill } from '@polkadot/types/interfaces/runtime';
-import type { AssetHubKusamaRuntimeRuntimeHoldReason, AssetHubKusamaRuntimeSessionKeys, BpXcmBridgeHubRouterBridgeState, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletParachainSystemUnincludedSegmentAncestor, CumulusPalletParachainSystemUnincludedSegmentSegmentTracker, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesCoreAggregateMessageOrigin, FrameSupportDispatchPerDispatchClassWeight, FrameSupportTokensMiscIdAmount, FrameSystemAccountInfo, FrameSystemCodeUpgradeAuthorization, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, PalletAssetConversionPoolInfo, PalletAssetsApproval, PalletAssetsAssetAccount, PalletAssetsAssetDetails, PalletAssetsAssetMetadata, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReserveData, PalletCollatorSelectionCandidateInfo, PalletMessageQueueBookState, PalletMessageQueuePage, PalletMultisigMultisig, PalletNftFractionalizationDetails, PalletNftsAttributeDeposit, PalletNftsAttributeNamespace, PalletNftsCollectionConfig, PalletNftsCollectionDetails, PalletNftsCollectionMetadata, PalletNftsItemConfig, PalletNftsItemDetails, PalletNftsItemMetadata, PalletNftsPendingSwap, PalletProxyAnnouncement, PalletProxyProxyDefinition, PalletReviveStorageContractInfo, PalletReviveStorageDeletionQueueManager, PalletReviveWasmCodeInfo, PalletStateTrieMigrationMigrationLimits, PalletStateTrieMigrationMigrationTask, PalletTransactionPaymentReleases, PalletUniquesCollectionDetails, PalletUniquesCollectionMetadata, PalletUniquesItemDetails, PalletUniquesItemMetadata, PalletVestingReleases, PalletVestingVestingInfo, PalletXcmAuthorizedAliasesEntry, PalletXcmQueryStatus, PalletXcmRemoteLockedFungibleRecord, PalletXcmVersionMigrationStage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV8AbridgedHostConfiguration, PolkadotPrimitivesV8PersistedValidationData, PolkadotPrimitivesV8UpgradeGoAhead, PolkadotPrimitivesV8UpgradeRestriction, SpConsensusAuraSr25519AppSr25519Public, SpCoreCryptoKeyTypeId, SpRuntimeDigest, SpTrieStorageProof, SpWeightsWeightV2Weight, StagingXcmV4Location, StagingXcmV5Instruction, XcmVersionedAssetId, XcmVersionedLocation } from '@polkadot/types/lookup';
+import type { EthereumAddress } from '@polkadot/types/interfaces/eth';
+import type { AccountId32, H160, H256, Perbill, Percent } from '@polkadot/types/interfaces/runtime';
+import type { AssetHubKusamaRuntimeRuntimeParametersKey, AssetHubKusamaRuntimeRuntimeParametersValue, AssetHubKusamaRuntimeSessionKeys, AssetHubKusamaRuntimeStakingNposCompactSolution24, BpXcmBridgeHubRouterBridgeState, CumulusPalletParachainSystemParachainInherentInboundMessageId, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletParachainSystemUnincludedSegmentAncestor, CumulusPalletParachainSystemUnincludedSegmentSegmentTracker, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesCoreAggregateMessageOrigin, FrameElectionProviderSupportBoundedSupports, FrameSupportDispatchPerDispatchClassWeight, FrameSupportTokensMiscIdAmountRuntimeFreezeReason, FrameSupportTokensMiscIdAmountRuntimeHoldReason, FrameSystemAccountInfo, FrameSystemCodeUpgradeAuthorization, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, PalletAhMigratorBalancesBefore, PalletAhMigratorMigrationStage, PalletAssetConversionPoolInfo, PalletAssetsApproval, PalletAssetsAssetAccount, PalletAssetsAssetDetails, PalletAssetsAssetMetadata, PalletBagsListListBag, PalletBagsListListNode, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReserveData, PalletBountiesBounty, PalletChildBountiesChildBounty, PalletCollatorSelectionCandidateInfo, PalletConvictionVotingVoteVoting, PalletDelegatedStakingAgentLedger, PalletDelegatedStakingDelegation, PalletElectionProviderMultiBlockPhase, PalletElectionProviderMultiBlockSignedSubmissionMetadata, PalletElectionProviderMultiBlockVerifierImplsPartialBackings, PalletElectionProviderMultiBlockVerifierImplsStatus, PalletElectionProviderMultiBlockVerifierImplsValidSolution, PalletMessageQueueBookState, PalletMessageQueuePage, PalletMigrationsMigrationCursor, PalletMultisigMultisig, PalletNftFractionalizationDetails, PalletNftsAttributeDeposit, PalletNftsAttributeNamespace, PalletNftsCollectionConfig, PalletNftsCollectionDetails, PalletNftsCollectionMetadata, PalletNftsItemConfig, PalletNftsItemDetails, PalletNftsItemMetadata, PalletNftsPendingSwap, PalletNominationPoolsBondedPoolInner, PalletNominationPoolsClaimPermission, PalletNominationPoolsPoolMember, PalletNominationPoolsRewardPool, PalletNominationPoolsSubPools, PalletPreimageOldRequestStatus, PalletPreimageRequestStatus, PalletProxyAnnouncement, PalletProxyProxyDefinitionAssetHubKusamaRuntimeProxyType, PalletRcMigratorAccountsAccount, PalletRcMigratorQueuePriority, PalletRecoveryActiveRecovery, PalletRecoveryRecoveryConfig, PalletReferendaReferendumInfoOriginCaller, PalletReviveStorageAccountInfo, PalletReviveStorageDeletionQueueManager, PalletReviveVmCodeInfo, PalletSchedulerRetryConfig, PalletSchedulerScheduled, PalletSocietyBid, PalletSocietyCandidacy, PalletSocietyGroupParams, PalletSocietyIntakeRecord, PalletSocietyMemberRecord, PalletSocietyPayoutRecord, PalletSocietyTally, PalletSocietyVote, PalletStakingAsyncActiveEraInfo, PalletStakingAsyncEraRewardPoints, PalletStakingAsyncForcing, PalletStakingAsyncLedgerStakingLedger, PalletStakingAsyncNominations, PalletStakingAsyncPalletBoundedExposurePage, PalletStakingAsyncPalletPruningStep, PalletStakingAsyncRcClientSessionReport, PalletStakingAsyncRcClientValidatorSetReport, PalletStakingAsyncRewardDestination, PalletStakingAsyncSlashingOffenceRecord, PalletStakingAsyncSnapshotStatus, PalletStakingAsyncUnappliedSlash, PalletStakingAsyncValidatorPrefs, PalletStateTrieMigrationMigrationLimits, PalletStateTrieMigrationMigrationTask, PalletTransactionPaymentReleases, PalletTreasuryProposal, PalletTreasurySpendStatus, PalletUniquesCollectionDetails, PalletUniquesCollectionMetadata, PalletUniquesItemDetails, PalletUniquesItemMetadata, PalletVestingReleases, PalletVestingVestingInfo, PalletXcmAuthorizedAliasesEntry, PalletXcmQueryStatus, PalletXcmRemoteLockedFungibleRecord, PalletXcmVersionMigrationStage, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV8AbridgedHostConfiguration, PolkadotPrimitivesV8PersistedValidationData, PolkadotPrimitivesV8UpgradeGoAhead, PolkadotPrimitivesV8UpgradeRestriction, PolkadotRuntimeCommonClaimsStatementKind, PolkadotRuntimeCommonImplsVersionedLocatableAsset, SpConsensusAuraSr25519AppSr25519Public, SpCoreCryptoKeyTypeId, SpNposElectionsElectionScore, SpRuntimeDigest, SpStakingPagedExposureMetadata, SpTrieStorageProof, SpWeightsWeightV2Weight, StagingXcmV5Instruction, StagingXcmV5Location, XcmVersionedAssetId, XcmVersionedLocation } from '@polkadot/types/lookup';
 import type { Observable } from '@polkadot/types/types';
 export type __AugmentedQuery<ApiType extends ApiTypes> = AugmentedQuery<ApiType, () => unknown>;
 export type __QueryableStorageEntry<ApiType extends ApiTypes> = QueryableStorageEntry<ApiType>;
 declare module '@polkadot/api-base/types/storage' {
     interface AugmentedQueries<ApiType extends ApiTypes> {
+        ahMigrator: {
+            /**
+             * Helper storage item to store the total balance / total issuance of native token at the start
+             * of the migration. Since teleports are disabled during migration, the total issuance will not
+             * change for other reason than the migration itself.
+             **/
+            ahBalancesBefore: AugmentedQuery<ApiType, () => Observable<PalletAhMigratorBalancesBefore>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The Asset Hub migration state.
+             **/
+            ahMigrationStage: AugmentedQuery<ApiType, () => Observable<PalletAhMigratorMigrationStage>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The priority of the DMP queue during migration.
+             *
+             * Controls how the DMP (Downward Message Passing) queue is processed relative to other queues
+             * during the migration process. This helps ensure timely processing of migration messages.
+             * The default priority pattern is defined in the pallet configuration, but can be overridden
+             * by a storage value of this type.
+             **/
+            dmpQueuePriorityConfig: AugmentedQuery<ApiType, () => Observable<PalletRcMigratorQueuePriority>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * An optional account id of a manager.
+             *
+             * This account id has similar privileges to [`Config::AdminOrigin`] except that it
+             * can not set the manager account id via `set_manager` call.
+             **/
+            manager: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Block number when migration finished and extrinsics were unlocked.
+             *
+             * This is set when entering the `MigrationDone` stage hence when
+             * `RcMigrationStage::is_finished()` becomes `true`.
+             **/
+            migrationEndBlock: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The block number at which the migration began and the pallet's extrinsics were locked.
+             *
+             * This value is set when entering the `WaitingForAh` stage, i.e., when
+             * `RcMigrationStage::is_ongoing()` becomes `true`.
+             **/
+            migrationStartBlock: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * RC accounts that failed to migrate when were received on the Asset Hub.
+             *
+             * This is unlikely to happen, since we dry run the migration, but we keep it for completeness.
+             **/
+            rcAccounts: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletRcMigratorAccountsAccount>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        ahOps: {
+            /**
+             * Amount of balance that a contributor made towards a crowdloan.
+             *
+             * `withdraw_crowdloan_contribution` can be permissionlessly called once the block number
+             * passed to unlock the balance for a specific account.
+             *
+             * The keys are as follows:
+             * - Block number after which the balance can be unlocked.
+             * - The para_id of the crowdloan.
+             * - The account that made the contribution.
+             *
+             * The value is (fund_pot, balance). The contribution pot is the second key in the
+             * `RcCrowdloanContribution` storage.
+             **/
+            rcCrowdloanContribution: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: AccountId32 | string | Uint8Array) => Observable<Option<ITuple<[AccountId32, u128]>>>, [u32, u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, u32, AccountId32]>;
+            /**
+             * The reserve that was taken to create a crowdloan.
+             *
+             * This is normally 500 DOT and can be refunded as last step after all
+             * `RcCrowdloanContribution`s of this loan have been withdrawn.
+             *
+             * Keys:
+             * - Block number after which this can be unreserved
+             * - The para_id of the crowdloan
+             * - The account that will have the balance unreserved
+             **/
+            rcCrowdloanReserve: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: AccountId32 | string | Uint8Array) => Observable<Option<u128>>, [u32, u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, u32, AccountId32]>;
+            /**
+             * Amount of balance that was reserved for winning a lease auction.
+             *
+             * `unreserve_lease_deposit` can be permissionlessly called once the block number passed to
+             * unreserve the deposit. It is implicitly called by `withdraw_crowdloan_contribution`.
+             *
+             * The account here can either be a crowdloan account or a solo bidder. If it is a crowdloan
+             * account, then the summed up contributions for it in the contributions map will equate the
+             * reserved balance here.
+             *
+             * The keys are as follows:
+             * - Block number after which the deposit can be unreserved.
+             * - The para_id of the lease slot.
+             * - The account that will have the balance unreserved.
+             * - The balance to be unreserved.
+             **/
+            rcLeaseReserve: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: AccountId32 | string | Uint8Array) => Observable<Option<u128>>, [u32, u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, u32, AccountId32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
         assetConversion: {
             /**
              * Stores the `PoolAssetId` that is going to be used for the next lp token.
@@ -19,13 +122,31 @@ declare module '@polkadot/api-base/types/storage' {
              * Map from `PoolAssetId` to `PoolInfo`. This establishes whether a pool has been officially
              * created rather than people sending tokens directly to a pool's public account.
              **/
-            pools: AugmentedQuery<ApiType, (arg: ITuple<[StagingXcmV4Location, StagingXcmV4Location]> | [StagingXcmV4Location | {
+            pools: AugmentedQuery<ApiType, (arg: ITuple<[StagingXcmV5Location, StagingXcmV5Location]> | [StagingXcmV5Location | {
                 parents?: any;
                 interior?: any;
-            } | string | Uint8Array, StagingXcmV4Location | {
+            } | string | Uint8Array, StagingXcmV5Location | {
                 parents?: any;
                 interior?: any;
-            } | string | Uint8Array]) => Observable<Option<PalletAssetConversionPoolInfo>>, [ITuple<[StagingXcmV4Location, StagingXcmV4Location]>]> & QueryableStorageEntry<ApiType, [ITuple<[StagingXcmV4Location, StagingXcmV4Location]>]>;
+            } | string | Uint8Array]) => Observable<Option<PalletAssetConversionPoolInfo>>, [ITuple<[StagingXcmV5Location, StagingXcmV5Location]>]> & QueryableStorageEntry<ApiType, [ITuple<[StagingXcmV5Location, StagingXcmV5Location]>]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        assetRate: {
+            /**
+             * Maps an asset to its fixed point representation in the native balance.
+             *
+             * E.g. `native_amount = asset_amount * ConversionRateToNative::<T>::get(asset_kind)`
+             **/
+            conversionRateToNative: AugmentedQuery<ApiType, (arg: PolkadotRuntimeCommonImplsVersionedLocatableAsset | {
+                V3: any;
+            } | {
+                V4: any;
+            } | {
+                V5: any;
+            } | string | Uint8Array) => Observable<Option<u128>>, [PolkadotRuntimeCommonImplsVersionedLocatableAsset]> & QueryableStorageEntry<ApiType, [PolkadotRuntimeCommonImplsVersionedLocatableAsset]>;
             /**
              * Generic query
              **/
@@ -151,14 +272,11 @@ declare module '@polkadot/api-base/types/storage' {
             /**
              * Freeze locks on account balances.
              **/
-            freezes: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<FrameSupportTokensMiscIdAmount>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            freezes: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<FrameSupportTokensMiscIdAmountRuntimeFreezeReason>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
             /**
              * Holds on account balances.
              **/
-            holds: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<{
-                readonly id: AssetHubKusamaRuntimeRuntimeHoldReason;
-                readonly amount: u128;
-            } & Struct>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            holds: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<FrameSupportTokensMiscIdAmountRuntimeHoldReason>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
             /**
              * The total units of outstanding deactivated balance in the system.
              **/
@@ -185,6 +303,93 @@ declare module '@polkadot/api-base/types/storage' {
              **/
             [key: string]: QueryableStorageEntry<ApiType>;
         };
+        bounties: {
+            /**
+             * Bounties that have been made.
+             **/
+            bounties: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletBountiesBounty>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Bounty indices that have been approved but not yet funded.
+             **/
+            bountyApprovals: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Number of bounty proposals that have been made.
+             **/
+            bountyCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The description of each bounty.
+             **/
+            bountyDescriptions: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        childBounties: {
+            /**
+             * Child bounties that have been added.
+             **/
+            childBounties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletChildBountiesChildBounty>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+            /**
+             * DEPRECATED: Replaced with `ParentTotalChildBounties` storage item keeping dedicated counts
+             * for each parent bounty. Number of total child bounties. Will be removed in May 2025.
+             **/
+            childBountyCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The description of each child-bounty. Indexed by `(parent_id, child_id)`.
+             *
+             * This item replaces the `ChildBountyDescriptions` storage item from the V0 storage version.
+             **/
+            childBountyDescriptionsV1: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+            /**
+             * The cumulative child-bounty curator fee for each parent bounty.
+             **/
+            childrenCuratorFees: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Number of active child bounties per parent bounty.
+             * Map of parent bounty index to number of child bounties.
+             **/
+            parentChildBounties: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Number of total child bounties per parent bounty, including completed bounties.
+             **/
+            parentTotalChildBounties: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The mapping of the child bounty ids from storage version `V0` to the new `V1` version.
+             *
+             * The `V0` ids based on total child bounty count [`ChildBountyCount`]`. The `V1` version ids
+             * based on the child bounty count per parent bounty [`ParentTotalChildBounties`].
+             * The item intended solely for client convenience and not used in the pallet's core logic.
+             **/
+            v0ToV1ChildBountyIds: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, u32]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        claims: {
+            claims: AugmentedQuery<ApiType, (arg: EthereumAddress | string | Uint8Array) => Observable<Option<u128>>, [EthereumAddress]> & QueryableStorageEntry<ApiType, [EthereumAddress]>;
+            /**
+             * Pre-claimed Ethereum accounts, by the Account ID that they are claimed to.
+             **/
+            preclaims: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<EthereumAddress>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * The statement kind that must be signed, if any.
+             **/
+            signing: AugmentedQuery<ApiType, (arg: EthereumAddress | string | Uint8Array) => Observable<Option<PolkadotRuntimeCommonClaimsStatementKind>>, [EthereumAddress]> & QueryableStorageEntry<ApiType, [EthereumAddress]>;
+            total: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Vesting schedule for a claim.
+             * First balance is the total amount that should be held for vesting.
+             * Second balance is how much should be unlocked per block.
+             * The block number is when the vesting should start.
+             **/
+            vesting: AugmentedQuery<ApiType, (arg: EthereumAddress | string | Uint8Array) => Observable<Option<ITuple<[u128, u128, u32]>>>, [EthereumAddress]> & QueryableStorageEntry<ApiType, [EthereumAddress]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
         collatorSelection: {
             /**
              * Fixed amount to deposit to become a collator.
@@ -219,34 +424,76 @@ declare module '@polkadot/api-base/types/storage' {
              **/
             [key: string]: QueryableStorageEntry<ApiType>;
         };
+        convictionVoting: {
+            /**
+             * 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.
+             **/
+            classLocksFor: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<ITuple<[u16, u128]>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * All voting for a particular voter in a particular voting class. We store the balance for the
+             * number of votes that we have recorded.
+             **/
+            votingFor: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: u16 | AnyNumber | Uint8Array) => Observable<PalletConvictionVotingVoteVoting>, [AccountId32, u16]> & QueryableStorageEntry<ApiType, [AccountId32, u16]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        delegatedStaking: {
+            /**
+             * Map of `Agent` to their `Ledger`.
+             **/
+            agents: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletDelegatedStakingAgentLedger>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Counter for the related counted storage map
+             **/
+            counterForAgents: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Counter for the related counted storage map
+             **/
+            counterForDelegators: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * 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.
+             **/
+            delegators: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletDelegatedStakingDelegation>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
         foreignAssets: {
             /**
              * The holdings of a specific account for a specific asset.
              **/
-            account: AugmentedQuery<ApiType, (arg1: StagingXcmV4Location | {
+            account: AugmentedQuery<ApiType, (arg1: StagingXcmV5Location | {
                 parents?: any;
                 interior?: any;
-            } | string | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<PalletAssetsAssetAccount>>, [StagingXcmV4Location, AccountId32]> & QueryableStorageEntry<ApiType, [StagingXcmV4Location, AccountId32]>;
+            } | string | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<PalletAssetsAssetAccount>>, [StagingXcmV5Location, AccountId32]> & QueryableStorageEntry<ApiType, [StagingXcmV5Location, AccountId32]>;
             /**
              * Approved balance transfers. First balance is the amount approved for transfer. Second
              * is the amount of `T::Currency` reserved for storing this.
              * First key is the asset ID, second key is the owner and third key is the delegate.
              **/
-            approvals: AugmentedQuery<ApiType, (arg1: StagingXcmV4Location | {
+            approvals: AugmentedQuery<ApiType, (arg1: StagingXcmV5Location | {
                 parents?: any;
                 interior?: any;
-            } | string | Uint8Array, arg2: AccountId32 | string | Uint8Array, arg3: AccountId32 | string | Uint8Array) => Observable<Option<PalletAssetsApproval>>, [StagingXcmV4Location, AccountId32, AccountId32]> & QueryableStorageEntry<ApiType, [StagingXcmV4Location, AccountId32, AccountId32]>;
+            } | string | Uint8Array, arg2: AccountId32 | string | Uint8Array, arg3: AccountId32 | string | Uint8Array) => Observable<Option<PalletAssetsApproval>>, [StagingXcmV5Location, AccountId32, AccountId32]> & QueryableStorageEntry<ApiType, [StagingXcmV5Location, AccountId32, AccountId32]>;
             /**
              * Details of an asset.
              **/
-            asset: AugmentedQuery<ApiType, (arg: StagingXcmV4Location | {
+            asset: AugmentedQuery<ApiType, (arg: StagingXcmV5Location | {
                 parents?: any;
                 interior?: any;
-            } | string | Uint8Array) => Observable<Option<PalletAssetsAssetDetails>>, [StagingXcmV4Location]> & QueryableStorageEntry<ApiType, [StagingXcmV4Location]>;
+            } | string | Uint8Array) => Observable<Option<PalletAssetsAssetDetails>>, [StagingXcmV5Location]> & QueryableStorageEntry<ApiType, [StagingXcmV5Location]>;
             /**
              * Metadata of an asset.
              **/
-            metadata: AugmentedQuery<ApiType, (arg: StagingXcmV4Location | {
+            metadata: AugmentedQuery<ApiType, (arg: StagingXcmV5Location | {
                 parents?: any;
                 interior?: any;
             } | string | Uint8Array) => Observable<{
@@ -255,7 +502,7 @@ declare module '@polkadot/api-base/types/storage' {
                 readonly symbol: Bytes;
                 readonly decimals: u8;
                 readonly isFrozen: bool;
-            } & Struct>, [StagingXcmV4Location]> & QueryableStorageEntry<ApiType, [StagingXcmV4Location]>;
+            } & Struct>, [StagingXcmV5Location]> & QueryableStorageEntry<ApiType, [StagingXcmV5Location]>;
             /**
              * The asset ID enforced for the next asset creation, if any present. Otherwise, this storage
              * item has no effect.
@@ -267,7 +514,17 @@ declare module '@polkadot/api-base/types/storage' {
              * The initial next asset ID can be set using the [`GenesisConfig`] or the
              * [SetNextAssetId](`migration::next_asset_id::SetNextAssetId`) migration.
              **/
-            nextAssetId: AugmentedQuery<ApiType, () => Observable<Option<StagingXcmV4Location>>, []> & QueryableStorageEntry<ApiType, []>;
+            nextAssetId: AugmentedQuery<ApiType, () => Observable<Option<StagingXcmV5Location>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        indices: {
+            /**
+             * The lookup from index to account.
+             **/
+            accounts: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[AccountId32, u128, bool]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
             /**
              * Generic query
              **/
@@ -303,6 +560,150 @@ declare module '@polkadot/api-base/types/storage' {
              **/
             [key: string]: QueryableStorageEntry<ApiType>;
         };
+        multiBlockElection: {
+            /**
+             * Current phase.
+             **/
+            currentPhase: AugmentedQuery<ApiType, () => Observable<PalletElectionProviderMultiBlockPhase>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Desired number of targets to elect for this round.
+             **/
+            desiredTargets: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Paginated target snapshot.
+             *
+             * For the time being, since we assume one pages of targets, at most ONE key will exist.
+             **/
+            pagedTargetSnapshot: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<Vec<AccountId32>>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+            /**
+             * Same as [`PagedTargetSnapshot`], but it will store the hash of the snapshot.
+             *
+             * The hash is generated using [`frame_system::Config::Hashing`].
+             **/
+            pagedTargetSnapshotHash: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<H256>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+            /**
+             * Paginated voter snapshot. At most [`T::Pages`] keys will exist.
+             **/
+            pagedVoterSnapshot: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<Vec<ITuple<[AccountId32, u64, Vec<AccountId32>]>>>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+            /**
+             * Same as [`PagedVoterSnapshot`], but it will store the hash of the snapshot.
+             *
+             * The hash is generated using [`frame_system::Config::Hashing`].
+             **/
+            pagedVoterSnapshotHash: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<H256>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+            /**
+             * Internal counter for the number of rounds.
+             *
+             * This is useful for de-duplication of transactions submitted to the pool, and general
+             * diagnostics of the pallet.
+             *
+             * This is merely incremented once per every time that an upstream `elect` is called.
+             **/
+            round: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        multiBlockElectionSigned: {
+            /**
+             * Accounts whitelisted by governance to always submit their solutions.
+             *
+             * They are different in that:
+             *
+             * * They always pay a fixed deposit for submission, specified by
+             * [`Config::InvulnerableDeposit`]. They pay no page deposit.
+             * * If _ejected_ by better solution from [`SortedScores`], they will get their full deposit
+             * back.
+             * * They always get their tx-fee back even if they are _discarded_.
+             **/
+            invulnerables: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
+            sortedScores: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[AccountId32, SpNposElectionsElectionScore]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Map from account to the metadata of their submission.
+             *
+             * invariant: for any Key1 of type `AccountId` in [`Submissions`], this storage map also has a
+             * value.
+             **/
+            submissionMetadataStorage: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<PalletElectionProviderMultiBlockSignedSubmissionMetadata>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
+            /**
+             * Triple map from (round, account, page) to a solution page.
+             **/
+            submissionStorage: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array, arg3: u32 | AnyNumber | Uint8Array) => Observable<Option<AssetHubKusamaRuntimeStakingNposCompactSolution24>>, [u32, AccountId32, u32]> & QueryableStorageEntry<ApiType, [u32, AccountId32, u32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        multiBlockElectionVerifier: {
+            /**
+             * The minimum score that each solution must attain in order to be considered feasible.
+             **/
+            minimumScore: AugmentedQuery<ApiType, () => Observable<Option<SpNposElectionsElectionScore>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The `(amount, count)` of backings, divided per page.
+             *
+             * This is stored because in the last block of verification we need them to compute the score,
+             * and check `MaxBackersPerWinnerFinal`.
+             *
+             * This can only ever live for the invalid variant of the solution. Once it is valid, we don't
+             * need this information anymore; the score is already computed once in
+             * [`QueuedSolutionScore`], and the backing counts are checked.
+             **/
+            queuedSolutionBackings: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<Vec<ITuple<[AccountId32, PalletElectionProviderMultiBlockVerifierImplsPartialBackings]>>>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+            /**
+             * The score of the valid variant of [`QueuedSolution`].
+             *
+             * This only ever lives for the `valid` variant.
+             **/
+            queuedSolutionScore: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<SpNposElectionsElectionScore>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The `X` variant of the current queued solution. Might be the valid one or not.
+             *
+             * The two variants of this storage item is to avoid the need of copying. Recall that once a
+             * `VerifyingSolution` is being processed, it needs to write its partial supports *somewhere*.
+             * Writing theses supports on top of a *good* queued supports is wrong, since we might bail.
+             * Writing them to a bugger and copying at the ned is slightly better, but expensive. This flag
+             * system is best of both worlds.
+             **/
+            queuedSolutionX: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<FrameElectionProviderSupportBoundedSupports>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+            /**
+             * The `Y` variant of the current queued solution. Might be the valid one or not.
+             **/
+            queuedSolutionY: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<FrameElectionProviderSupportBoundedSupports>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+            /**
+             * Pointer to the variant of [`QueuedSolutionX`] or [`QueuedSolutionY`] that is currently
+             * valid.
+             **/
+            queuedValidVariant: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<PalletElectionProviderMultiBlockVerifierImplsValidSolution>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Storage item for [`Status`].
+             **/
+            statusStorage: AugmentedQuery<ApiType, () => Observable<PalletElectionProviderMultiBlockVerifierImplsStatus>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        multiBlockMigrations: {
+            /**
+             * The currently active migration to run and its cursor.
+             *
+             * `None` indicates that no migration is running.
+             **/
+            cursor: AugmentedQuery<ApiType, () => Observable<Option<PalletMigrationsMigrationCursor>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Set of all successfully executed migrations.
+             *
+             * This is used as blacklist, to not re-execute migrations that have not been removed from the
+             * codebase yet. Governance can regularly clear this out via `clear_historic`.
+             **/
+            historic: AugmentedQuery<ApiType, (arg: Bytes | string | Uint8Array) => Observable<Option<Null>>, [Bytes]> & QueryableStorageEntry<ApiType, [Bytes]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
         multisig: {
             /**
              * The set of open multisig operations.
@@ -401,6 +802,118 @@ declare module '@polkadot/api-base/types/storage' {
              **/
             [key: string]: QueryableStorageEntry<ApiType>;
         };
+        nominationPools: {
+            /**
+             * Storage for bonded pools.
+             **/
+            bondedPools: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNominationPoolsBondedPoolInner>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Map from a pool member account to their opted claim permission.
+             **/
+            claimPermissions: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletNominationPoolsClaimPermission>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Counter for the related counted storage map
+             **/
+            counterForBondedPools: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Counter for the related counted storage map
+             **/
+            counterForMetadata: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Counter for the related counted storage map
+             **/
+            counterForPoolMembers: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Counter for the related counted storage map
+             **/
+            counterForReversePoolIdLookup: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Counter for the related counted storage map
+             **/
+            counterForRewardPools: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Counter for the related counted storage map
+             **/
+            counterForSubPoolsStorage: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * 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.
+             **/
+            globalMaxCommission: AugmentedQuery<ApiType, () => Observable<Option<Perbill>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Ever increasing number of all pools created so far.
+             **/
+            lastPoolId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Maximum number of members that can exist in the system. If `None`, then the count
+             * members are not bound on a system wide basis.
+             **/
+            maxPoolMembers: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Maximum number of members that may belong to pool. If `None`, then the count of
+             * members is not bound on a per pool basis.
+             **/
+            maxPoolMembersPerPool: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Maximum number of nomination pools that can exist. If `None`, then an unbounded number of
+             * pools can exist.
+             **/
+            maxPools: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Metadata for the pool.
+             **/
+            metadata: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * 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.
+             **/
+            minCreateBond: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Minimum amount to bond to join a pool.
+             **/
+            minJoinBond: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Active members.
+             *
+             * TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+             **/
+            poolMembers: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletNominationPoolsPoolMember>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * 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.
+             **/
+            reversePoolIdLookup: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * 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.
+             **/
+            rewardPools: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNominationPoolsRewardPool>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * 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.
+             **/
+            subPoolsStorage: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNominationPoolsSubPools>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * 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.
+             **/
+            totalValueLocked: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
         parachainInfo: {
             parachainId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
             /**
@@ -447,8 +960,6 @@ declare module '@polkadot/api-base/types/storage' {
             hrmpOutboundMessages: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotCorePrimitivesOutboundHrmpMessage>>, []> & QueryableStorageEntry<ApiType, []>;
             /**
              * HRMP watermark that was set in a block.
-             *
-             * This will be cleared in `on_initialize` of each new block.
              **/
             hrmpWatermark: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
             /**
@@ -465,6 +976,18 @@ declare module '@polkadot/api-base/types/storage' {
              * by the system inherent.
              **/
             lastHrmpMqcHeads: AugmentedQuery<ApiType, () => Observable<BTreeMap<u32, H256>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The last processed downward message.
+             *
+             * We need to keep track of this to filter the messages that have been already processed.
+             **/
+            lastProcessedDownwardMessage: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemParachainInherentInboundMessageId>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The last processed HRMP message.
+             *
+             * We need to keep track of this to filter the messages that have been already processed.
+             **/
+            lastProcessedHrmpMessage: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemParachainInherentInboundMessageId>>, []> & QueryableStorageEntry<ApiType, []>;
             /**
              * The relay chain block number associated with the last parachain block.
              *
@@ -575,6 +1098,26 @@ declare module '@polkadot/api-base/types/storage' {
              **/
             [key: string]: QueryableStorageEntry<ApiType>;
         };
+        parameters: {
+            /**
+             * Stored parameters.
+             **/
+            parameters: AugmentedQuery<ApiType, (arg: AssetHubKusamaRuntimeRuntimeParametersKey | {
+                Issuance: any;
+            } | {
+                Treasury: any;
+            } | {
+                StakingElection: any;
+            } | {
+                Scheduler: any;
+            } | {
+                MessageQueue: any;
+            } | string | Uint8Array) => Observable<Option<AssetHubKusamaRuntimeRuntimeParametersValue>>, [AssetHubKusamaRuntimeRuntimeParametersKey]> & QueryableStorageEntry<ApiType, [AssetHubKusamaRuntimeRuntimeParametersKey]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
         polkadotXcm: {
             /**
              * The existing asset traps.
@@ -727,6 +1270,21 @@ declare module '@polkadot/api-base/types/storage' {
              **/
             [key: string]: QueryableStorageEntry<ApiType>;
         };
+        preimage: {
+            preimageFor: AugmentedQuery<ApiType, (arg: ITuple<[H256, u32]> | [H256 | string | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<Option<Bytes>>, [ITuple<[H256, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[H256, u32]>]>;
+            /**
+             * The request status of a given hash.
+             **/
+            requestStatusFor: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletPreimageRequestStatus>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
+            /**
+             * The request status of a given hash.
+             **/
+            statusFor: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletPreimageOldRequestStatus>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
         proxy: {
             /**
              * The announcements made by the proxy (key).
@@ -736,7 +1294,64 @@ declare module '@polkadot/api-base/types/storage' {
              * The set of account proxies. Maps the account which has delegated to the accounts
              * which are being delegated to, together with the amount held on deposit.
              **/
-            proxies: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[Vec<PalletProxyProxyDefinition>, u128]>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            proxies: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[Vec<PalletProxyProxyDefinitionAssetHubKusamaRuntimeProxyType>, u128]>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        recovery: {
+            /**
+             * Active recovery attempts.
+             *
+             * First account is the account to be recovered, and the second account
+             * is the user trying to recover the account.
+             **/
+            activeRecoveries: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<PalletRecoveryActiveRecovery>>, [AccountId32, AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32, AccountId32]>;
+            /**
+             * The list of allowed proxy accounts.
+             *
+             * Map from the user who can access it to the recovered account.
+             **/
+            proxy: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<AccountId32>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * The set of recoverable accounts and their recovery configuration.
+             **/
+            recoverable: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletRecoveryRecoveryConfig>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        referenda: {
+            /**
+             * The number of referenda being decided currently.
+             **/
+            decidingCount: AugmentedQuery<ApiType, (arg: u16 | AnyNumber | Uint8Array) => Observable<u32>, [u16]> & QueryableStorageEntry<ApiType, [u16]>;
+            /**
+             * 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.
+             **/
+            metadataOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<H256>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The next free referendum index, aka the number of referenda started so far.
+             **/
+            referendumCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Information concerning any given referendum.
+             **/
+            referendumInfoFor: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletReferendaReferendumInfoOriginCaller>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * 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`.
+             **/
+            trackQueue: AugmentedQuery<ApiType, (arg: u16 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, u128]>>>, [u16]> & QueryableStorageEntry<ApiType, [u16]>;
             /**
              * Generic query
              **/
@@ -755,13 +1370,13 @@ declare module '@polkadot/api-base/types/storage' {
         };
         revive: {
             /**
-             * A mapping from a contract's code hash to its code info.
+             * The data associated to a contract or externally owned account.
              **/
-            codeInfoOf: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletReviveWasmCodeInfo>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
+            accountInfoOf: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<PalletReviveStorageAccountInfo>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;
             /**
-             * The code associated with a given account.
+             * A mapping from a contract's code hash to its code info.
              **/
-            contractInfoOf: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<PalletReviveStorageContractInfo>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;
+            codeInfoOf: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletReviveVmCodeInfo>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
             /**
              * Evicted contracts that await child trie deletion.
              *
@@ -796,6 +1411,31 @@ declare module '@polkadot/api-base/types/storage' {
              **/
             [key: string]: QueryableStorageEntry<ApiType>;
         };
+        scheduler: {
+            /**
+             * Items to be executed, indexed by the block number that they should be executed on.
+             **/
+            agenda: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<Option<PalletSchedulerScheduled>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Block number at which the agenda began incomplete execution.
+             **/
+            incompleteSince: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Lookup from a name to the block number and index of the task.
+             *
+             * For v3 -> v4 the previously unbounded identities are Blake2-256 hashed to form the v4
+             * identities.
+             **/
+            lookup: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Option<ITuple<[u32, u32]>>>, [U8aFixed]> & QueryableStorageEntry<ApiType, [U8aFixed]>;
+            /**
+             * Retry configurations for items to be executed, indexed by task address.
+             **/
+            retries: AugmentedQuery<ApiType, (arg: ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<Option<PalletSchedulerRetryConfig>>, [ITuple<[u32, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[u32, u32]>]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
         session: {
             /**
              * Current index of the session.
@@ -836,6 +1476,431 @@ declare module '@polkadot/api-base/types/storage' {
              **/
             [key: string]: QueryableStorageEntry<ApiType>;
         };
+        society: {
+            /**
+             * The current bids, stored ordered by the value of the bid.
+             **/
+            bids: AugmentedQuery<ApiType, () => Observable<Vec<PalletSocietyBid>>, []> & QueryableStorageEntry<ApiType, []>;
+            candidates: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletSocietyCandidacy>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * The number of challenge rounds there have been. Used to identify stale DefenderVotes.
+             **/
+            challengeRoundCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Votes for the defender, keyed by challenge round.
+             **/
+            defenderVotes: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<PalletSocietyVote>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
+            /**
+             * The defending member currently being challenged, along with a running tally of votes.
+             **/
+            defending: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[AccountId32, AccountId32, PalletSocietyTally]>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The first member.
+             **/
+            founder: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The most primary from the most recently approved rank 0 members in the society.
+             **/
+            head: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The current items in `Members` keyed by their unique index. Keys are densely populated
+             * `0..MemberCount` (does not include `MemberCount`).
+             **/
+            memberByIndex: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<AccountId32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The number of items in `Members` currently. (Doesn't include `SuspendedMembers`.)
+             **/
+            memberCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The current members and their rank. Doesn't include `SuspendedMembers`.
+             **/
+            members: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletSocietyMemberRecord>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Next challenge rotation scheduled with [Config::BlockNumberProvider].
+             **/
+            nextChallengeAt: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * At the end of the claim period, this contains the most recently approved members (along with
+             * their bid and round ID) who is from the most recent round with the lowest bid. They will
+             * become the new `Head`.
+             **/
+            nextHead: AugmentedQuery<ApiType, () => Observable<Option<PalletSocietyIntakeRecord>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Next intake rotation scheduled with [Config::BlockNumberProvider].
+             **/
+            nextIntakeAt: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The max number of members for the society at one time.
+             **/
+            parameters: AugmentedQuery<ApiType, () => Observable<Option<PalletSocietyGroupParams>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Information regarding rank-0 payouts, past and future.
+             **/
+            payouts: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletSocietyPayoutRecord>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Amount of our account balance that is specifically for the next round's bid(s).
+             **/
+            pot: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The number of rounds which have passed.
+             **/
+            roundCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * A hash of the rules of this society concerning membership. Can only be set once and
+             * only by the founder.
+             **/
+            rules: AugmentedQuery<ApiType, () => Observable<Option<H256>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The current skeptic.
+             **/
+            skeptic: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The set of suspended members, with their old membership record.
+             **/
+            suspendedMembers: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletSocietyMemberRecord>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Clear-cursor for Vote, map from Candidate -> (Maybe) Cursor.
+             **/
+            voteClearCursor: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<Bytes>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Double map from Candidate -> Voter -> (Maybe) Vote.
+             **/
+            votes: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<PalletSocietyVote>>, [AccountId32, AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32, AccountId32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        staking: {
+            /**
+             * The active era information, it holds index and start.
+             *
+             * The active era is the era being currently rewarded. Validator set of this era must be
+             * equal to what is RC's session pallet.
+             **/
+            activeEra: AugmentedQuery<ApiType, () => Observable<Option<PalletStakingAsyncActiveEraInfo>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Map from all locked "stash" accounts to the controller account.
+             *
+             * TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+             **/
+            bonded: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<AccountId32>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * A mapping from still-bonded eras to the first session index of that era.
+             *
+             * Must contains information for eras for the range:
+             * `[active_era - bounding_duration; active_era]`
+             **/
+            bondedEras: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The amount of currency given to reporters of a slash event which was
+             * canceled by extraordinary circumstances (e.g. governance).
+             **/
+            canceledSlashPayout: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Cancelled slashes by era and validator with maximum slash fraction to be cancelled.
+             *
+             * When slashes are cancelled by governance, this stores the era and the validators
+             * whose slashes should be cancelled, along with the maximum slash fraction that should
+             * be cancelled for each validator.
+             **/
+            cancelledSlashes: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[AccountId32, Perbill]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The threshold for when users can start calling `chill_other` for other validators /
+             * nominators. The threshold is compared to the actual number of validators / nominators
+             * (`CountFor*`) in the system compared to the configured max (`Max*Count`).
+             **/
+            chillThreshold: AugmentedQuery<ApiType, () => Observable<Option<Percent>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * 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.
+             **/
+            claimedRewards: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Vec<u32>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
+            /**
+             * Counter for the related counted storage map
+             **/
+            counterForNominators: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Counter for the related counted storage map
+             **/
+            counterForValidators: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Counter for the related counted storage map
+             **/
+            counterForVirtualStakers: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The current planned era index.
+             *
+             * This is the latest planned era, depending on how the Session pallet queues the validator
+             * set, it might be active or not.
+             **/
+            currentEra: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * A bounded list of the "electable" stashes that resulted from a successful election.
+             **/
+            electableStashes: AugmentedQuery<ApiType, () => Observable<BTreeSet<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Tracks the current step of era pruning process for each era being lazily pruned.
+             **/
+            eraPruningState: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletStakingAsyncPalletPruningStep>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Rewards for the last [`Config::HistoryDepth`] eras.
+             * If reward hasn't been set or has been removed then 0 reward is returned.
+             **/
+            erasRewardPoints: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<PalletStakingAsyncEraRewardPoints>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * 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 `Eras`.
+             *
+             * Is it removed after [`Config::HistoryDepth`] eras.
+             * If stakers hasn't been set or has been removed then empty overview is returned.
+             **/
+            erasStakersOverview: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<SpStakingPagedExposureMetadata>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, 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 `Eras`.
+             *
+             * This is cleared after [`Config::HistoryDepth`] eras.
+             **/
+            erasStakersPaged: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array, arg3: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletStakingAsyncPalletBoundedExposurePage>>, [u32, AccountId32, u32]> & QueryableStorageEntry<ApiType, [u32, AccountId32, u32]>;
+            /**
+             * 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.
+             **/
+            erasTotalStake: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Exposure of validator at era with 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.
+             **/
+            erasValidatorPrefs: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<PalletStakingAsyncValidatorPrefs>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, 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.
+             **/
+            erasValidatorReward: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u128>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Mode of era forcing.
+             **/
+            forceEra: AugmentedQuery<ApiType, () => Observable<PalletStakingAsyncForcing>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Any validators that may never be slashed or forcibly kicked. It's a Vec since they're
+             * easy to initialize and the performance hit is minimal (we expect no more than four
+             * invulnerables) and restricted to testnets.
+             **/
+            invulnerables: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Map from all (unlocked) "controller" accounts to the info regarding the staking.
+             *
+             * Note: All the reads and mutations to this storage *MUST* be done through the methods exposed
+             * by [`StakingLedger`] to ensure data and lock consistency.
+             **/
+            ledger: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletStakingAsyncLedgerStakingLedger>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * The maximum nominator count before we stop allowing new validators to join.
+             *
+             * When this value is not set, no limits are enforced.
+             **/
+            maxNominatorsCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Maximum staked rewards, i.e. the percentage of the era inflation that
+             * is used for stake rewards.
+             * See [Era payout](./index.html#era-payout).
+             **/
+            maxStakedRewards: AugmentedQuery<ApiType, () => Observable<Option<Percent>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The maximum validator count before we stop allowing new validators to join.
+             *
+             * When this value is not set, no limits are enforced.
+             **/
+            maxValidatorsCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The minimum amount of commission that validators can set.
+             *
+             * If set to `0`, no limit exists.
+             **/
+            minCommission: AugmentedQuery<ApiType, () => Observable<Perbill>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The minimum active nominator stake of the last successful election.
+             **/
+            minimumActiveStake: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The minimum active bond to become and maintain the role of a nominator.
+             **/
+            minNominatorBond: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The minimum active bond to become and maintain the role of a validator.
+             **/
+            minValidatorBond: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Keeps track of an ongoing multi-page election solution request.
+             *
+             * If `Some(_)``, it is the next page that we intend to elect. If `None`, we are not in the
+             * election process.
+             *
+             * This is only set in multi-block elections. Should always be `None` otherwise.
+             **/
+            nextElectionPage: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * 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.
+             **/
+            nominators: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletStakingAsyncNominations>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Stores reported offences in a queue until they are processed in subsequent blocks.
+             *
+             * Each offence is recorded under the corresponding era index and the offending validator's
+             * account. If an offence spans multiple pages, only one page is processed at a time. Offences
+             * are handled sequentially, with their associated slashes computed and stored in
+             * `UnappliedSlashes`. These slashes are then applied in a future era as determined by
+             * `SlashDeferDuration`.
+             *
+             * Any offences tied to an era older than `BondingDuration` are automatically dropped.
+             * Processing always prioritizes the oldest era first.
+             **/
+            offenceQueue: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<PalletStakingAsyncSlashingOffenceRecord>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
+            /**
+             * Tracks the eras that contain offences in `OffenceQueue`, sorted from **earliest to latest**.
+             *
+             * - This ensures efficient retrieval of the oldest offence without iterating through
+             * `OffenceQueue`.
+             * - When a new offence is added to `OffenceQueue`, its era is **inserted in sorted order**
+             * if not already present.
+             * - When all offences for an era are processed, it is **removed** from this list.
+             * - The maximum length of this vector is bounded by `BondingDuration`.
+             *
+             * This eliminates the need for expensive iteration and sorting when fetching the next offence
+             * to process.
+             **/
+            offenceQueueEras: AugmentedQuery<ApiType, () => Observable<Option<Vec<u32>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Where the reward payment should be made. Keyed by stash.
+             *
+             * TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+             **/
+            payee: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletStakingAsyncRewardDestination>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Tracks the currently processed offence record from the `OffenceQueue`.
+             *
+             * - When processing offences, an offence record is **popped** from the oldest era in
+             * `OffenceQueue` and stored here.
+             * - The function `process_offence` reads from this storage, processing one page of exposure at
+             * a time.
+             * - After processing a page, the `exposure_page` count is **decremented** until it reaches
+             * zero.
+             * - Once fully processed, the offence record is removed from this storage.
+             *
+             * This ensures that offences are processed incrementally, preventing excessive computation
+             * in a single block while maintaining correct slashing behavior.
+             **/
+            processingOffence: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[u32, AccountId32, PalletStakingAsyncSlashingOffenceRecord]>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The percentage of the slash that is distributed to reporters.
+             *
+             * The rest of the slashed value is handled by the `Slash`.
+             **/
+            slashRewardFraction: AugmentedQuery<ApiType, () => Observable<Perbill>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * All unapplied slashes that are queued for later.
+             **/
+            unappliedSlashes: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: ITuple<[AccountId32, Perbill, u32]> | [AccountId32 | string | Uint8Array, Perbill | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<Option<PalletStakingAsyncUnappliedSlash>>, [u32, ITuple<[AccountId32, Perbill, u32]>]> & QueryableStorageEntry<ApiType, [u32, ITuple<[AccountId32, Perbill, u32]>]>;
+            /**
+             * The ideal number of active validators.
+             **/
+            validatorCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The map from (wannabe) validator stash key to the preferences of that validator.
+             *
+             * TWOX-NOTE: SAFE since `AccountId` is a secure hash.
+             **/
+            validators: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletStakingAsyncValidatorPrefs>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * All slashing events on validators, mapped by era to the highest slash proportion
+             * and slash value of the era.
+             **/
+            validatorSlashInEra: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<ITuple<[Perbill, u128]>>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
+            /**
+             * 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.
+             **/
+            virtualStakers: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<Null>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Voter snapshot progress status.
+             *
+             * If the status is `Ongoing`, it keeps a cursor of the last voter retrieved to proceed when
+             * creating the next snapshot page.
+             **/
+            voterSnapshotStatus: AugmentedQuery<ApiType, () => Observable<PalletStakingAsyncSnapshotStatus>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        stakingRcClient: {
+            /**
+             * An incomplete incoming session report that we have not acted upon yet.
+             **/
+            incompleteSessionReport: AugmentedQuery<ApiType, () => Observable<Option<PalletStakingAsyncRcClientSessionReport>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The last session report's `end_index` that we have acted upon.
+             *
+             * This allows this pallet to ensure a sequentially increasing sequence of session reports
+             * passed to staking.
+             *
+             * Note that with the XCM being the backbone of communication, we have a guarantee on the
+             * ordering of messages. As long as the RC sends session reports in order, we _eventually_
+             * receive them in the same correct order as well.
+             **/
+            lastSessionReportEndingIndex: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * A validator set that is outgoing, and should be sent.
+             *
+             * This will be attempted to be sent, possibly on every `on_initialize` call, until it is sent,
+             * or the second value reaches zero, at which point we drop it.
+             **/
+            outgoingValidatorSet: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[PalletStakingAsyncRcClientValidatorSetReport, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
         stateTrieMigration: {
             /**
              * The limits that are imposed on automatic migrations.
@@ -1006,6 +2071,49 @@ declare module '@polkadot/api-base/types/storage' {
              **/
             [key: string]: QueryableStorageEntry<ApiType>;
         };
+        treasury: {
+            /**
+             * DEPRECATED: associated with `spend_local` call and will be removed in May 2025.
+             * Refer to <https://github.com/paritytech/polkadot-sdk/pull/5961> for migration to `spend`.
+             *
+             * Proposal indices that have been approved but not yet awarded.
+             **/
+            approvals: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The amount which has been reported as inactive to Currency.
+             **/
+            deactivated: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * The blocknumber for the last triggered spend period.
+             **/
+            lastSpendPeriod: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * DEPRECATED: associated with `spend_local` call and will be removed in May 2025.
+             * Refer to <https://github.com/paritytech/polkadot-sdk/pull/5961> for migration to `spend`.
+             *
+             * Number of proposals that have been made.
+             **/
+            proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * DEPRECATED: associated with `spend_local` call and will be removed in May 2025.
+             * Refer to <https://github.com/paritytech/polkadot-sdk/pull/5961> for migration to `spend`.
+             *
+             * Proposals that have been made.
+             **/
+            proposals: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletTreasuryProposal>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * The count of spends that have been made.
+             **/
+            spendCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Spends that have been approved and being processed.
+             **/
+            spends: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletTreasurySpendStatus>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
         uniques: {
             /**
              * The items held by any given account; set out this way so that items owned by a single
@@ -1070,6 +2178,47 @@ declare module '@polkadot/api-base/types/storage' {
              **/
             [key: string]: QueryableStorageEntry<ApiType>;
         };
+        voterList: {
+            /**
+             * Counter for the related counted storage map
+             **/
+            counterForListNodes: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * A bag stored in storage.
+             *
+             * Stores a `Bag` struct, which stores head and tail pointers to itself.
+             **/
+            listBags: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<PalletBagsListListBag>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
+            /**
+             * A single node, within some bag.
+             *
+             * Nodes store links forward and back within their respective bags.
+             **/
+            listNodes: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletBagsListListNode>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+            /**
+             * Lock all updates to this pallet.
+             *
+             * If any nodes needs updating, removal or addition due to a temporary lock, the
+             * [`Call::rebag`] can be used.
+             **/
+            lock: AugmentedQuery<ApiType, () => Observable<Option<Null>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Pointer that remembers the next node that will be auto-rebagged.
+             * When `None`, the next scan will start from the list head again.
+             **/
+            nextNodeAutoRebagged: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
+        whitelist: {
+            whitelistedCall: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<Null>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
+            /**
+             * Generic query
+             **/
+            [key: string]: QueryableStorageEntry<ApiType>;
+        };
         xcmpQueue: {
             /**
              * The factor to multiply the base delivery fee by.