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 { 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.
             * This gets incremented whenever a new lp pool is created.
             **/
            nextPoolAssetId: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * 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<[StagingXcmV5Location, StagingXcmV5Location]> | [StagingXcmV5Location | {
                parents?: any;
                interior?: any;
            } | string | Uint8Array, StagingXcmV5Location | {
                parents?: any;
                interior?: any;
            } | 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
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        assets: {
            /**
             * The holdings of a specific account for a specific asset.
             **/
            account: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<PalletAssetsAssetAccount>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, 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: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array, arg3: AccountId32 | string | Uint8Array) => Observable<Option<PalletAssetsApproval>>, [u32, AccountId32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32, AccountId32]>;
            /**
             * Details of an asset.
             **/
            asset: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletAssetsAssetDetails>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Metadata of an asset.
             **/
            metadata: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<{
                readonly deposit: u128;
                readonly name: Bytes;
                readonly symbol: Bytes;
                readonly decimals: u8;
                readonly isFrozen: bool;
            } & Struct>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * The asset ID enforced for the next asset creation, if any present. Otherwise, this storage
             * item has no effect.
             *
             * This can be useful for setting up constraints for IDs of the new assets. For example, by
             * providing an initial [`NextAssetId`] and using the [`crate::AutoIncAssetId`] callback, an
             * auto-increment model can be applied to all new asset IDs.
             *
             * 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<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        aura: {
            /**
             * The current authority set.
             **/
            authorities: AugmentedQuery<ApiType, () => Observable<Vec<SpConsensusAuraSr25519AppSr25519Public>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The current slot of this block.
             *
             * This will be set in `on_initialize`.
             **/
            currentSlot: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        auraExt: {
            /**
             * Serves as cache for the authorities.
             *
             * The authorities in AuRa are overwritten in `on_initialize` when we switch to a new session,
             * but we require the old authorities to verify the seal when validating a PoV. This will
             * always be updated to the latest AuRa authorities in `on_finalize`.
             **/
            authorities: AugmentedQuery<ApiType, () => Observable<Vec<SpConsensusAuraSr25519AppSr25519Public>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Current relay chain slot paired with a number of authored blocks.
             *
             * This is updated in [`FixedVelocityConsensusHook::on_state_proof`] with the current relay
             * chain slot as provided by the relay chain state proof.
             **/
            relaySlotInfo: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[u64, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        authorship: {
            /**
             * Author of current block.
             **/
            author: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        balances: {
            /**
             * The Balances pallet example of storing the balance of an account.
             *
             * # Example
             *
             * ```nocompile
             * impl pallet_balances::Config for Runtime {
             * type AccountStore = StorageMapShim<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>
             * }
             * ```
             *
             * You can also store the balance of an account in the `System` pallet.
             *
             * # Example
             *
             * ```nocompile
             * impl pallet_balances::Config for Runtime {
             * type AccountStore = System
             * }
             * ```
             *
             * But this comes with tradeoffs, storing account balances in the system pallet stores
             * `frame_system` data alongside the account data contrary to storing account balances in the
             * `Balances` pallet, which uses a `StorageMap` to store balances data only.
             * NOTE: This is only used in the case that this pallet is used to store balances.
             **/
            account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletBalancesAccountData>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Freeze locks on account balances.
             **/
            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<FrameSupportTokensMiscIdAmountRuntimeHoldReason>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * The total units of outstanding deactivated balance in the system.
             **/
            inactiveIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Any liquidity locks on some account balances.
             * NOTE: Should only be accessed when setting, changing and freeing a lock.
             *
             * Use of locks is deprecated in favour of freezes. See `https://github.com/paritytech/substrate/pull/12951/`
             **/
            locks: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesBalanceLock>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Named reserves on some account balances.
             *
             * Use of reserves is deprecated in favour of holds. See `https://github.com/paritytech/substrate/pull/12951/`
             **/
            reserves: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesReserveData>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * The total units issued in the system.
             **/
            totalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        bounties: {
            /**
             * Bounties that have been made.
             **/
            bounties: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletBountiesBounty>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Bounty indices that have been approved but not yet funded.
             **/
            bountyApprovals: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Number of bounty proposals that have been made.
             **/
            bountyCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The description of each bounty.
             **/
            bountyDescriptions: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        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.
             *
             * When a collator calls `leave_intent` they immediately receive the deposit back.
             **/
            candidacyBond: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The (community, limited) collation candidates. `Candidates` and `Invulnerables` should be
             * mutually exclusive.
             *
             * This list is sorted in ascending order by deposit and when the deposits are equal, the least
             * recently updated is considered greater.
             **/
            candidateList: AugmentedQuery<ApiType, () => Observable<Vec<PalletCollatorSelectionCandidateInfo>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Desired number of candidates.
             *
             * This should ideally always be less than [`Config::MaxCandidates`] for weights to be correct.
             **/
            desiredCandidates: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The invulnerable, permissioned collators. This list must be sorted.
             **/
            invulnerables: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Last block authored by collator.
             **/
            lastAuthoredBlock: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u32>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Generic query
             **/
            [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: StagingXcmV5Location | {
                parents?: any;
                interior?: any;
            } | 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: StagingXcmV5Location | {
                parents?: any;
                interior?: any;
            } | 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: StagingXcmV5Location | {
                parents?: any;
                interior?: any;
            } | string | Uint8Array) => Observable<Option<PalletAssetsAssetDetails>>, [StagingXcmV5Location]> & QueryableStorageEntry<ApiType, [StagingXcmV5Location]>;
            /**
             * Metadata of an asset.
             **/
            metadata: AugmentedQuery<ApiType, (arg: StagingXcmV5Location | {
                parents?: any;
                interior?: any;
            } | string | Uint8Array) => Observable<{
                readonly deposit: u128;
                readonly name: Bytes;
                readonly symbol: Bytes;
                readonly decimals: u8;
                readonly isFrozen: bool;
            } & Struct>, [StagingXcmV5Location]> & QueryableStorageEntry<ApiType, [StagingXcmV5Location]>;
            /**
             * The asset ID enforced for the next asset creation, if any present. Otherwise, this storage
             * item has no effect.
             *
             * This can be useful for setting up constraints for IDs of the new assets. For example, by
             * providing an initial [`NextAssetId`] and using the [`crate::AutoIncAssetId`] callback, an
             * auto-increment model can be applied to all new asset IDs.
             *
             * 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<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
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        messageQueue: {
            /**
             * The index of the first and last (non-empty) pages.
             **/
            bookStateFor: AugmentedQuery<ApiType, (arg: CumulusPrimitivesCoreAggregateMessageOrigin | {
                Here: any;
            } | {
                Parent: any;
            } | {
                Sibling: any;
            } | string | Uint8Array) => Observable<PalletMessageQueueBookState>, [CumulusPrimitivesCoreAggregateMessageOrigin]> & QueryableStorageEntry<ApiType, [CumulusPrimitivesCoreAggregateMessageOrigin]>;
            /**
             * The map of page indices to pages.
             **/
            pages: AugmentedQuery<ApiType, (arg1: CumulusPrimitivesCoreAggregateMessageOrigin | {
                Here: any;
            } | {
                Parent: any;
            } | {
                Sibling: any;
            } | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletMessageQueuePage>>, [CumulusPrimitivesCoreAggregateMessageOrigin, u32]> & QueryableStorageEntry<ApiType, [CumulusPrimitivesCoreAggregateMessageOrigin, u32]>;
            /**
             * The origin at which we should begin servicing.
             **/
            serviceHead: AugmentedQuery<ApiType, () => Observable<Option<CumulusPrimitivesCoreAggregateMessageOrigin>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [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.
             **/
            multisigs: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: U8aFixed | string | Uint8Array) => Observable<Option<PalletMultisigMultisig>>, [AccountId32, U8aFixed]> & QueryableStorageEntry<ApiType, [AccountId32, U8aFixed]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        nftFractionalization: {
            /**
             * Keeps track of the corresponding NFT ID, asset ID and amount minted.
             **/
            nftToAsset: AugmentedQuery<ApiType, (arg: ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<Option<PalletNftFractionalizationDetails>>, [ITuple<[u32, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[u32, u32]>]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        nfts: {
            /**
             * The items held by any given account; set out this way so that items owned by a single
             * account can be enumerated.
             **/
            account: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: u32 | AnyNumber | Uint8Array) => Observable<Option<Null>>, [AccountId32, u32, u32]> & QueryableStorageEntry<ApiType, [AccountId32, u32, u32]>;
            /**
             * Attributes of a collection.
             **/
            attribute: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: Option<u32> | null | Uint8Array | u32 | AnyNumber, arg3: PalletNftsAttributeNamespace | {
                Pallet: any;
            } | {
                CollectionOwner: any;
            } | {
                ItemOwner: any;
            } | {
                Account: any;
            } | string | Uint8Array, arg4: Bytes | string | Uint8Array) => Observable<Option<ITuple<[Bytes, PalletNftsAttributeDeposit]>>>, [u32, Option<u32>, PalletNftsAttributeNamespace, Bytes]> & QueryableStorageEntry<ApiType, [u32, Option<u32>, PalletNftsAttributeNamespace, Bytes]>;
            /**
             * Details of a collection.
             **/
            collection: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNftsCollectionDetails>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * The collections owned by any given account; set out this way so that collections owned by
             * a single account can be enumerated.
             **/
            collectionAccount: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<Null>>, [AccountId32, u32]> & QueryableStorageEntry<ApiType, [AccountId32, u32]>;
            /**
             * Config of a collection.
             **/
            collectionConfigOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNftsCollectionConfig>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Metadata of a collection.
             **/
            collectionMetadataOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNftsCollectionMetadata>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * The items in existence and their ownership details.
             * Stores collection roles as per account.
             **/
            collectionRoleOf: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u8>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
            /**
             * The items in existence and their ownership details.
             **/
            item: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNftsItemDetails>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
            /**
             * Item attribute approvals.
             **/
            itemAttributesApprovalsOf: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<BTreeSet<AccountId32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
            /**
             * Config of an item.
             **/
            itemConfigOf: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNftsItemConfig>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
            /**
             * Metadata of an item.
             **/
            itemMetadataOf: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNftsItemMetadata>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
            /**
             * A price of an item.
             **/
            itemPriceOf: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u128, Option<AccountId32>]>>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
            /**
             * Stores the `CollectionId` that is going to be used for the next collection.
             * This gets incremented whenever a new collection is created.
             **/
            nextCollectionId: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The collection, if any, of which an account is willing to take ownership.
             **/
            ownershipAcceptance: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Handles all the pending swaps.
             **/
            pendingSwapOf: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNftsPendingSwap>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
            /**
             * Generic query
             **/
            [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, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        parachainSystem: {
            /**
             * Storage field that keeps track of bandwidth used by the unincluded segment along with the
             * latest HRMP watermark. Used for limiting the acceptance of new blocks with
             * respect to relay chain constraints.
             **/
            aggregatedUnincludedSegment: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemUnincludedSegmentSegmentTracker>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The number of HRMP messages we observed in `on_initialize` and thus used that number for
             * announcing the weight of `on_initialize` and `on_finalize`.
             **/
            announcedHrmpMessagesPerCandidate: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * A custom head data that should be returned as result of `validate_block`.
             *
             * See `Pallet::set_custom_validation_head_data` for more information.
             **/
            customValidationHeadData: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Were the validation data set to notify the relay chain?
             **/
            didSetValidationCode: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The parachain host configuration that was obtained from the relay parent.
             *
             * This field is meant to be updated each block with the validation data inherent. Therefore,
             * before processing of the inherent, e.g. in `on_initialize` this data may be stale.
             *
             * This data is also absent from the genesis.
             **/
            hostConfiguration: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV8AbridgedHostConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * HRMP messages that were sent in a block.
             *
             * This will be cleared in `on_initialize` of each new block.
             **/
            hrmpOutboundMessages: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotCorePrimitivesOutboundHrmpMessage>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * HRMP watermark that was set in a block.
             **/
            hrmpWatermark: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The last downward message queue chain head we have observed.
             *
             * This value is loaded before and saved after processing inbound downward messages carried
             * by the system inherent.
             **/
            lastDmqMqcHead: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The message queue chain heads we have observed per each channel incoming channel.
             *
             * This value is loaded before and saved after processing inbound downward messages carried
             * 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.
             *
             * This is updated in `on_finalize`.
             **/
            lastRelayChainBlockNumber: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Validation code that is set by the parachain and is to be communicated to collator and
             * consequently the relay-chain.
             *
             * This will be cleared in `on_initialize` of each new block if no other pallet already set
             * the value.
             **/
            newValidationCode: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Upward messages that are still pending and not yet send to the relay chain.
             **/
            pendingUpwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * In case of a scheduled upgrade, this storage field contains the validation code to be
             * applied.
             *
             * As soon as the relay chain gives us the go-ahead signal, we will overwrite the
             * [`:code`][sp_core::storage::well_known_keys::CODE] which will result the next block process
             * with the new validation code. This concludes the upgrade process.
             **/
            pendingValidationCode: AugmentedQuery<ApiType, () => Observable<Bytes>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Number of downward messages processed in a block.
             *
             * This will be cleared in `on_initialize` of each new block.
             **/
            processedDownwardMessages: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The state proof for the last relay parent block.
             *
             * This field is meant to be updated each block with the validation data inherent. Therefore,
             * before processing of the inherent, e.g. in `on_initialize` this data may be stale.
             *
             * This data is also absent from the genesis.
             **/
            relayStateProof: AugmentedQuery<ApiType, () => Observable<Option<SpTrieStorageProof>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The snapshot of some state related to messaging relevant to the current parachain as per
             * the relay parent.
             *
             * This field is meant to be updated each block with the validation data inherent. Therefore,
             * before processing of the inherent, e.g. in `on_initialize` this data may be stale.
             *
             * This data is also absent from the genesis.
             **/
            relevantMessagingState: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The weight we reserve at the beginning of the block for processing DMP messages. This
             * overrides the amount set in the Config trait.
             **/
            reservedDmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The weight we reserve at the beginning of the block for processing XCMP messages. This
             * overrides the amount set in the Config trait.
             **/
            reservedXcmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Latest included block descendants the runtime accepted. In other words, these are
             * ancestors of the currently executing block which have not been included in the observed
             * relay-chain state.
             *
             * The segment length is limited by the capacity returned from the [`ConsensusHook`] configured
             * in the pallet.
             **/
            unincludedSegment: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletParachainSystemUnincludedSegmentAncestor>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Optional upgrade go-ahead signal from the relay-chain.
             *
             * This storage item is a mirror of the corresponding value for the current parachain from the
             * relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is
             * set after the inherent.
             **/
            upgradeGoAhead: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV8UpgradeGoAhead>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * An option which indicates if the relay-chain restricts signalling a validation code upgrade.
             * In other words, if this is `Some` and [`NewValidationCode`] is `Some` then the produced
             * candidate will be invalid.
             *
             * This storage item is a mirror of the corresponding value for the current parachain from the
             * relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is
             * set after the inherent.
             **/
            upgradeRestrictionSignal: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV8UpgradeRestriction>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The factor to multiply the base delivery fee by for UMP.
             **/
            upwardDeliveryFeeFactor: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Upward messages that were sent in a block.
             *
             * This will be cleared in `on_initialize` of each new block.
             **/
            upwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The [`PersistedValidationData`] set for this block.
             * This value is expected to be set only once per block and it's never stored
             * in the trie.
             **/
            validationData: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV8PersistedValidationData>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [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.
             *
             * Key is the blake2 256 hash of (origin, versioned `Assets`) pair. Value is the number of
             * times this pair has been trapped (usually just 1 if it exists at all).
             **/
            assetTraps: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<u32>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
            /**
             * Map of authorized aliasers of local origins. Each local location can authorize a list of
             * other locations to alias into it. Each aliaser is only valid until its inner `expiry`
             * block number.
             **/
            authorizedAliases: AugmentedQuery<ApiType, (arg: XcmVersionedLocation | {
                V3: any;
            } | {
                V4: any;
            } | {
                V5: any;
            } | string | Uint8Array) => Observable<Option<PalletXcmAuthorizedAliasesEntry>>, [XcmVersionedLocation]> & QueryableStorageEntry<ApiType, [XcmVersionedLocation]>;
            /**
             * The current migration's stage, if any.
             **/
            currentMigration: AugmentedQuery<ApiType, () => Observable<Option<PalletXcmVersionMigrationStage>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Fungible assets which we know are locked on this chain.
             **/
            lockedFungibles: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<Vec<ITuple<[u128, XcmVersionedLocation]>>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * The ongoing queries.
             **/
            queries: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<PalletXcmQueryStatus>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
            /**
             * The latest available query index.
             **/
            queryCounter: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * If [`ShouldRecordXcm`] is set to true, then the last XCM program executed locally
             * will be stored here.
             * Runtime APIs can fetch the XCM that was executed by accessing this value.
             *
             * Only relevant if this pallet is being used as the [`xcm_executor::traits::RecordXcm`]
             * implementation in the XCM executor configuration.
             **/
            recordedXcm: AugmentedQuery<ApiType, () => Observable<Option<Vec<StagingXcmV5Instruction>>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Fungible assets which we know are locked on a remote chain.
             **/
            remoteLockedFungibles: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array, arg3: XcmVersionedAssetId | {
                V3: any;
            } | {
                V4: any;
            } | {
                V5: any;
            } | string | Uint8Array) => Observable<Option<PalletXcmRemoteLockedFungibleRecord>>, [u32, AccountId32, XcmVersionedAssetId]> & QueryableStorageEntry<ApiType, [u32, AccountId32, XcmVersionedAssetId]>;
            /**
             * Default version to encode XCM when latest version of destination is unknown. If `None`,
             * then the destinations whose XCM version is unknown are considered unreachable.
             **/
            safeXcmVersion: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Whether or not incoming XCMs (both executed locally and received) should be recorded.
             * Only one XCM program will be recorded at a time.
             * This is meant to be used in runtime APIs, and it's advised it stays false
             * for all other use cases, so as to not degrade regular performance.
             *
             * Only relevant if this pallet is being used as the [`xcm_executor::traits::RecordXcm`]
             * implementation in the XCM executor configuration.
             **/
            shouldRecordXcm: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The Latest versions that we know various locations support.
             **/
            supportedVersion: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedLocation | {
                V3: any;
            } | {
                V4: any;
            } | {
                V5: any;
            } | string | Uint8Array) => Observable<Option<u32>>, [u32, XcmVersionedLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedLocation]>;
            /**
             * Destinations whose latest XCM version we would like to know. Duplicates not allowed, and
             * the `u32` counter is the number of times that a send to the destination has been attempted,
             * which is used as a prioritization.
             **/
            versionDiscoveryQueue: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[XcmVersionedLocation, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * All locations that we have requested version notifications from.
             **/
            versionNotifiers: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedLocation | {
                V3: any;
            } | {
                V4: any;
            } | {
                V5: any;
            } | string | Uint8Array) => Observable<Option<u64>>, [u32, XcmVersionedLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedLocation]>;
            /**
             * The target locations that are subscribed to our version changes, as well as the most recent
             * of our versions we informed them of.
             **/
            versionNotifyTargets: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedLocation | {
                V3: any;
            } | {
                V4: any;
            } | {
                V5: any;
            } | string | Uint8Array) => Observable<Option<ITuple<[u64, SpWeightsWeightV2Weight, u32]>>>, [u32, XcmVersionedLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedLocation]>;
            /**
             * Global suspension state of the XCM executor.
             **/
            xcmExecutionSuspended: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        poolAssets: {
            /**
             * The holdings of a specific account for a specific asset.
             **/
            account: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<PalletAssetsAssetAccount>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, 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: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array, arg3: AccountId32 | string | Uint8Array) => Observable<Option<PalletAssetsApproval>>, [u32, AccountId32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32, AccountId32]>;
            /**
             * Details of an asset.
             **/
            asset: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletAssetsAssetDetails>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Metadata of an asset.
             **/
            metadata: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<PalletAssetsAssetMetadata>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * The asset ID enforced for the next asset creation, if any present. Otherwise, this storage
             * item has no effect.
             *
             * This can be useful for setting up constraints for IDs of the new assets. For example, by
             * providing an initial [`NextAssetId`] and using the [`crate::AutoIncAssetId`] callback, an
             * auto-increment model can be applied to all new asset IDs.
             *
             * 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<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [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).
             **/
            announcements: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[Vec<PalletProxyAnnouncement>, u128]>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * The set of account proxies. Maps the account which has delegated to the accounts
             * which are being delegated to, together with the amount held on deposit.
             **/
            proxies: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[Vec<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
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        remoteProxyRelayChain: {
            /**
             * Stores the last [`Config::MaxStorageRootsToKeep`] block to storage root mappings of the
             * target chain.
             **/
            blockToRoot: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, H256]>>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        revive: {
            /**
             * The data associated to a contract or externally owned account.
             **/
            accountInfoOf: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<PalletReviveStorageAccountInfo>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;
            /**
             * A mapping from a contract's code hash to its code info.
             **/
            codeInfoOf: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletReviveVmCodeInfo>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
            /**
             * Evicted contracts that await child trie deletion.
             *
             * Child trie deletion is a heavy operation depending on the amount of storage items
             * stored in said trie. Therefore this operation is performed lazily in `on_idle`.
             **/
            deletionQueue: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * A pair of monotonic counters used to track the latest contract marked for deletion
             * and the latest deleted contract in queue.
             **/
            deletionQueueCounter: AugmentedQuery<ApiType, () => Observable<PalletReviveStorageDeletionQueueManager>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The immutable data associated with a given account.
             **/
            immutableDataOf: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<Bytes>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;
            /**
             * Map a Ethereum address to its original `AccountId32`.
             *
             * When deriving a `H160` from an `AccountId32` we use a hash function. In order to
             * reconstruct the original account we need to store the reverse mapping here.
             * Register your `AccountId32` using [`Pallet::map_account`] in order to
             * use it with this pallet.
             **/
            originalAccount: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<AccountId32>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;
            /**
             * A mapping from a contract's code hash to its code.
             **/
            pristineCode: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<Bytes>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        scheduler: {
            /**
             * Items to be executed, indexed by the block number that they should be executed on.
             **/
            agenda: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<Option<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.
             **/
            currentIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Indices of disabled validators.
             *
             * The vec is always kept sorted so that we can find whether a given validator is
             * disabled using binary search. It gets cleared when `on_session_ending` returns
             * a new set of identities.
             **/
            disabledValidators: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, Perbill]>>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The owner of a key. The key is the `KeyTypeId` + the encoded key.
             **/
            keyOwner: AugmentedQuery<ApiType, (arg: ITuple<[SpCoreCryptoKeyTypeId, Bytes]> | [SpCoreCryptoKeyTypeId | string | Uint8Array, Bytes | string | Uint8Array]) => Observable<Option<AccountId32>>, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]> & QueryableStorageEntry<ApiType, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]>;
            /**
             * The next session keys for a validator.
             **/
            nextKeys: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<AssetHubKusamaRuntimeSessionKeys>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * True if the underlying economic identities or weighting behind the validators
             * has changed in the queued validator set.
             **/
            queuedChanged: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The queued keys for the next session. When the next session begins, these keys
             * will be used to determine the validator's session keys.
             **/
            queuedKeys: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[AccountId32, AssetHubKusamaRuntimeSessionKeys]>>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The current set of validators.
             **/
            validators: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        society: {
            /**
             * The current bids, stored ordered by the value of the bid.
             **/
            bids: AugmentedQuery<ApiType, () => Observable<Vec<PalletSocietyBid>>, []> & QueryableStorageEntry<ApiType, []>;
            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.
             *
             * If set to None, then no automatic migration happens.
             **/
            autoLimits: AugmentedQuery<ApiType, () => Observable<Option<PalletStateTrieMigrationMigrationLimits>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Migration progress.
             *
             * This stores the snapshot of the last migrated keys. It can be set into motion and move
             * forward by any of the means provided by this pallet.
             **/
            migrationProcess: AugmentedQuery<ApiType, () => Observable<PalletStateTrieMigrationMigrationTask>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The maximum limits that the signed migration could use.
             *
             * If not set, no signed submission is allowed.
             **/
            signedMigrationMaxLimits: AugmentedQuery<ApiType, () => Observable<Option<PalletStateTrieMigrationMigrationLimits>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        system: {
            /**
             * The full account information for a particular account ID.
             **/
            account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<FrameSystemAccountInfo>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Total length (in bytes) for all extrinsics put together, for the current block.
             **/
            allExtrinsicsLen: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * `Some` if a code upgrade has been authorized.
             **/
            authorizedUpgrade: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemCodeUpgradeAuthorization>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Map of block numbers to block hashes.
             **/
            blockHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<H256>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * The current weight for the block.
             **/
            blockWeight: AugmentedQuery<ApiType, () => Observable<FrameSupportDispatchPerDispatchClassWeight>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Digest of the current block, also part of the block header.
             **/
            digest: AugmentedQuery<ApiType, () => Observable<SpRuntimeDigest>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The number of events in the `Events<T>` list.
             **/
            eventCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Events deposited for the current block.
             *
             * NOTE: The item is unbound and should therefore never be read on chain.
             * It could otherwise inflate the PoV size of a block.
             *
             * Events have a large in-memory size. Box the events to not go out-of-memory
             * just in case someone still reads them from within the runtime.
             **/
            events: AugmentedQuery<ApiType, () => Observable<Vec<FrameSystemEventRecord>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Mapping between a topic (represented by T::Hash) and a vector of indexes
             * of events in the `<Events<T>>` list.
             *
             * All topic vectors have deterministic storage locations depending on the topic. This
             * allows light-clients to leverage the changes trie storage tracking mechanism and
             * in case of changes fetch the list of events of interest.
             *
             * The value has the type `(BlockNumberFor<T>, EventIndex)` because if we used only just
             * the `EventIndex` then in case if the topic has the same contents on the next block
             * no notification will be triggered thus the event might be lost.
             **/
            eventTopics: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Vec<ITuple<[u32, u32]>>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
            /**
             * The execution phase of the block.
             **/
            executionPhase: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemPhase>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Total extrinsics count for the current block.
             **/
            extrinsicCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Extrinsics data for the current block (maps an extrinsic's index to its data).
             **/
            extrinsicData: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * The weight reclaimed for the extrinsic.
             *
             * This information is available until the end of the extrinsic execution.
             * More precisely this information is removed in `note_applied_extrinsic`.
             *
             * Logic doing some post dispatch weight reduction must update this storage to avoid duplicate
             * reduction.
             **/
            extrinsicWeightReclaimed: AugmentedQuery<ApiType, () => Observable<SpWeightsWeightV2Weight>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Whether all inherents have been applied.
             **/
            inherentsApplied: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.
             **/
            lastRuntimeUpgrade: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemLastRuntimeUpgradeInfo>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The current block number being processed. Set by `execute_block`.
             **/
            number: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Hash of the previous block.
             **/
            parentHash: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False
             * (default) if not.
             **/
            upgradedToTripleRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.
             **/
            upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        timestamp: {
            /**
             * Whether the timestamp has been updated in this block.
             *
             * This value is updated to `true` upon successful submission of a timestamp by a node.
             * It is then checked at the end of each block execution in the `on_finalize` hook.
             **/
            didUpdate: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The current time for the current block.
             **/
            now: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        toPolkadotXcmRouter: {
            /**
             * Bridge that we are using.
             *
             * **bridges-v1** assumptions: all outbound messages through this router are using single lane
             * and to single remote consensus. If there is some other remote consensus that uses the same
             * bridge hub, the separate pallet instance shall be used, In `v2` we'll have all required
             * primitives (lane-id aka bridge-id, derived from XCM locations) to support multiple  bridges
             * by the same pallet instance.
             **/
            bridge: AugmentedQuery<ApiType, () => Observable<BpXcmBridgeHubRouterBridgeState>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        transactionPayment: {
            nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
            storageVersion: AugmentedQuery<ApiType, () => Observable<PalletTransactionPaymentReleases>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        treasury: {
            /**
             * 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
             * account can be enumerated.
             **/
            account: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: u32 | AnyNumber | Uint8Array) => Observable<Option<Null>>, [AccountId32, u32, u32]> & QueryableStorageEntry<ApiType, [AccountId32, u32, u32]>;
            /**
             * The items in existence and their ownership details.
             **/
            asset: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletUniquesItemDetails>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
            /**
             * Attributes of a collection.
             **/
            attribute: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: Option<u32> | null | Uint8Array | u32 | AnyNumber, arg3: Bytes | string | Uint8Array) => Observable<Option<ITuple<[Bytes, u128]>>>, [u32, Option<u32>, Bytes]> & QueryableStorageEntry<ApiType, [u32, Option<u32>, Bytes]>;
            /**
             * Details of a collection.
             **/
            class: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletUniquesCollectionDetails>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * The collections owned by any given account; set out this way so that collections owned by
             * a single account can be enumerated.
             **/
            classAccount: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<Null>>, [AccountId32, u32]> & QueryableStorageEntry<ApiType, [AccountId32, u32]>;
            /**
             * Metadata of a collection.
             **/
            classMetadataOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletUniquesCollectionMetadata>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Keeps track of the number of items a collection might have.
             **/
            collectionMaxSupply: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Metadata of an item.
             **/
            instanceMetadataOf: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletUniquesItemMetadata>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
            /**
             * Price of an asset instance.
             **/
            itemPriceOf: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u128, Option<AccountId32>]>>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
            /**
             * The collection, if any, of which an account is willing to take ownership.
             **/
            ownershipAcceptance: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        vesting: {
            /**
             * Storage version of the pallet.
             *
             * New networks start with latest version, as determined by the genesis build.
             **/
            storageVersion: AugmentedQuery<ApiType, () => Observable<PalletVestingReleases>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Information regarding the vesting of a given account.
             **/
            vesting: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<Vec<PalletVestingVestingInfo>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
        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.
             **/
            deliveryFeeFactor: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * The suspended inbound XCMP channels. All others are not suspended.
             *
             * This is a `StorageValue` instead of a `StorageMap` since we expect multiple reads per block
             * to different keys with a one byte payload. The access to `BoundedBTreeSet` will be cached
             * within the block and therefore only included once in the proof size.
             *
             * NOTE: The PoV benchmarking cannot know this and will over-estimate, but the actual proof
             * will be smaller.
             **/
            inboundXcmpSuspended: AugmentedQuery<ApiType, () => Observable<BTreeSet<u32>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The messages outbound in a given XCMP channel.
             **/
            outboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u16 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u16]> & QueryableStorageEntry<ApiType, [u32, u16]>;
            /**
             * The non-empty XCMP channels in order of becoming non-empty, and the index of the first
             * and last outbound message. If the two indices are equal, then it indicates an empty
             * queue and there must be a non-`Ok` `OutboundStatus`. We assume queues grow no greater
             * than 65535 items. Queue indices for normal messages begin at one; zero is reserved in
             * case of the need to send a high-priority signal message this block.
             * The bool is true if there is a signal message waiting to be sent.
             **/
            outboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueOutboundChannelDetails>>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * The configuration which controls the dynamics of the outbound queue.
             **/
            queueConfig: AugmentedQuery<ApiType, () => Observable<CumulusPalletXcmpQueueQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Whether or not the XCMP queue is suspended from executing incoming XCMs or not.
             **/
            queueSuspended: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
            /**
             * Any signal messages waiting to be sent.
             **/
            signalMessages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
            /**
             * Generic query
             **/
            [key: string]: QueryableStorageEntry<ApiType>;
        };
    }
}