git.delta.rocks / unique-network / refs/commits / 1a4aa2d6346d

1// Auto-generated via `yarn polkadot-types-from-chain`, do not edit2/* eslint-disable */34// import type lookup before we augment - in some environments5// this is required to allow for ambient/previous definitions6import '@polkadot/api-base/types/storage';78import type { ApiTypes, AugmentedQuery, QueryableStorageEntry } from '@polkadot/api-base/types';9import type { Data } from '@polkadot/types';10import type { BTreeMap, Bytes, Option, U256, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';11import type { AnyNumber, ITuple } from '@polkadot/types-codec/types';12import type { AccountId32, Call, H160, H256 } from '@polkadot/types/interfaces/runtime';13import type { CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCodeUpgradeAuthorization, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, EthereumBlock, EthereumLog, EthereumReceiptReceiptV3, EthereumTransactionTransactionV2, FpRpcTransactionStatus, FrameSupportDispatchPerDispatchClassWeight, FrameSupportPreimagesBounded, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, OrmlTokensAccountData, OrmlTokensBalanceLock, OrmlTokensReserveData, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesIdAmount, PalletBalancesReserveData, PalletCollectiveVotes, PalletConfigurationAppPromotionConfiguration, PalletDemocracyMetadataOwner, PalletDemocracyReferendumInfo, PalletDemocracyVoteThreshold, PalletDemocracyVoteVoting, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCodeMetadata, PalletEvmContractHelpersSponsoringModeT, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletIdentityRegistrarInfo, PalletIdentityRegistration, PalletNonfungibleItemData, PalletPreimageRequestStatus, PalletRankedCollectiveMemberRecord, PalletRankedCollectiveVoteRecord, PalletReferendaReferendumInfo, PalletSchedulerScheduled, PalletStateTrieMigrationMigrationLimits, PalletStateTrieMigrationMigrationTask, PalletTransactionPaymentReleases, PalletTreasuryProposal, PalletXcmQueryStatus, PalletXcmRemoteLockedFungibleRecord, PalletXcmVersionMigrationStage, PhantomTypeUpDataStructs, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV4AbridgedHostConfiguration, PolkadotPrimitivesV4PersistedValidationData, PolkadotPrimitivesV4UpgradeRestriction, QuartzRuntimeRuntimeCommonSessionKeys, SpConsensusAuraSr25519AppSr25519Public, SpCoreCryptoKeyTypeId, SpRuntimeDigest, SpTrieStorageProof, SpWeightsWeightV2Weight, UpDataStructsCollection, UpDataStructsCollectionStats, UpDataStructsProperties, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsPropertyScope, UpDataStructsSponsorshipStateBasicCrossAccountIdRepr, UpDataStructsTokenChild, XcmV3MultiLocation, XcmVersionedAssetId, XcmVersionedMultiLocation } from '@polkadot/types/lookup';14import type { Observable } from '@polkadot/types/types';1516export type __AugmentedQuery<ApiType extends ApiTypes> = AugmentedQuery<ApiType, () => unknown>;17export type __QueryableStorageEntry<ApiType extends ApiTypes> = QueryableStorageEntry<ApiType>;1819declare module '@polkadot/api-base/types/storage' {20  interface AugmentedQueries<ApiType extends ApiTypes> {21    appPromotion: {22      /**23       * Stores the `admin` account. Some extrinsics can only be executed if they were signed by `admin`.24       **/25      admin: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;26      /**27       * Pending unstake records for an `Account`.28       * 29       * * **Key** - Staker account.30       * * **Value** - Amount of stakes.31       **/32      pendingUnstake: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[AccountId32, u128]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;33      /**34       * Stores a key for record for which the revenue recalculation was performed.35       * If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.36       **/37      previousCalculatedRecord: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[AccountId32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;38      /**39       * Stores the amount of tokens staked by account in the blocknumber.40       * 41       * * **Key1** - Staker account.42       * * **Key2** - Relay block number when the stake was made.43       * * **(Balance, BlockNumber)** - Balance of the stake.44       * The number of the relay block in which we must perform the interest recalculation45       **/46      staked: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<ITuple<[u128, u32]>>, [AccountId32, u32]> & QueryableStorageEntry<ApiType, [AccountId32, u32]>;47      /**48       * Stores number of stake records for an `Account`.49       * 50       * * **Key** - Staker account.51       * * **Value** - Amount of stakes.52       **/53      stakesPerAccount: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u8>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;54      /**55       * Stores the total staked amount.56       **/57      totalStaked: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;58      /**59       * Generic query60       **/61      [key: string]: QueryableStorageEntry<ApiType>;62    };63    aura: {64      /**65       * The current authority set.66       **/67      authorities: AugmentedQuery<ApiType, () => Observable<Vec<SpConsensusAuraSr25519AppSr25519Public>>, []> & QueryableStorageEntry<ApiType, []>;68      /**69       * The current slot of this block.70       * 71       * This will be set in `on_initialize`.72       **/73      currentSlot: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;74      /**75       * Generic query76       **/77      [key: string]: QueryableStorageEntry<ApiType>;78    };79    auraExt: {80      /**81       * Serves as cache for the authorities.82       * 83       * The authorities in AuRa are overwritten in `on_initialize` when we switch to a new session,84       * but we require the old authorities to verify the seal when validating a PoV. This will always85       * be updated to the latest AuRa authorities in `on_finalize`.86       **/87      authorities: AugmentedQuery<ApiType, () => Observable<Vec<SpConsensusAuraSr25519AppSr25519Public>>, []> & QueryableStorageEntry<ApiType, []>;88      /**89       * Generic query90       **/91      [key: string]: QueryableStorageEntry<ApiType>;92    };93    authorship: {94      /**95       * Author of current block.96       **/97      author: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;98      /**99       * Generic query100       **/101      [key: string]: QueryableStorageEntry<ApiType>;102    };103    balances: {104      /**105       * The Balances pallet example of storing the balance of an account.106       * 107       * # Example108       * 109       * ```nocompile110       * impl pallet_balances::Config for Runtime {111       * type AccountStore = StorageMapShim<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>112       * }113       * ```114       * 115       * You can also store the balance of an account in the `System` pallet.116       * 117       * # Example118       * 119       * ```nocompile120       * impl pallet_balances::Config for Runtime {121       * type AccountStore = System122       * }123       * ```124       * 125       * But this comes with tradeoffs, storing account balances in the system pallet stores126       * `frame_system` data alongside the account data contrary to storing account balances in the127       * `Balances` pallet, which uses a `StorageMap` to store balances data only.128       * NOTE: This is only used in the case that this pallet is used to store balances.129       **/130      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletBalancesAccountData>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;131      /**132       * Freeze locks on account balances.133       **/134      freezes: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesIdAmount>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;135      /**136       * Holds on account balances.137       **/138      holds: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesIdAmount>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;139      /**140       * The total units of outstanding deactivated balance in the system.141       **/142      inactiveIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;143      /**144       * Any liquidity locks on some account balances.145       * NOTE: Should only be accessed when setting, changing and freeing a lock.146       **/147      locks: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesBalanceLock>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;148      /**149       * Named reserves on some account balances.150       **/151      reserves: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesReserveData>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;152      /**153       * The total units issued in the system.154       **/155      totalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;156      /**157       * Generic query158       **/159      [key: string]: QueryableStorageEntry<ApiType>;160    };161    collatorSelection: {162      /**163       * The (community, limited) collation candidates.164       **/165      candidates: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;166      /**167       * The invulnerable, fixed collators.168       **/169      invulnerables: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;170      /**171       * Last block authored by collator.172       **/173      lastAuthoredBlock: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u32>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;174      /**175       * The (community) collation license holders.176       **/177      licenseDepositOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u128>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;178      /**179       * Generic query180       **/181      [key: string]: QueryableStorageEntry<ApiType>;182    };183    common: {184      /**185       * Storage of the amount of collection admins.186       **/187      adminAmount: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;188      /**189       * Allowlisted collection users.190       **/191      allowlist: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;192      /**193       * Storage of collection info.194       **/195      collectionById: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<UpDataStructsCollection>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;196      /**197       * Storage of collection properties.198       **/199      collectionProperties: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;200      /**201       * Storage of token property permissions of a collection.202       **/203      collectionPropertyPermissions: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsPropertiesMapPropertyPermission>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;204      /**205       * Storage of the count of created collections. Essentially contains the last collection ID.206       **/207      createdCollectionCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;208      /**209       * Storage of the count of deleted collections.210       **/211      destroyedCollectionCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;212      /**213       * Not used by code, exists only to provide some types to metadata.214       **/215      dummyStorageValue: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[UpDataStructsCollectionStats, u32, u32, UpDataStructsTokenChild, PhantomTypeUpDataStructs]>>>, []> & QueryableStorageEntry<ApiType, []>;216      /**217       * List of collection admins.218       **/219      isAdmin: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;220      /**221       * Generic query222       **/223      [key: string]: QueryableStorageEntry<ApiType>;224    };225    configuration: {226      appPromomotionConfigurationOverride: AugmentedQuery<ApiType, () => Observable<PalletConfigurationAppPromotionConfiguration>, []> & QueryableStorageEntry<ApiType, []>;227      collatorSelectionDesiredCollatorsOverride: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;228      collatorSelectionKickThresholdOverride: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;229      collatorSelectionLicenseBondOverride: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;230      minGasPriceOverride: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;231      weightToFeeCoefficientOverride: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;232      /**233       * Generic query234       **/235      [key: string]: QueryableStorageEntry<ApiType>;236    };237    council: {238      /**239       * The current members of the collective. This is stored sorted (just by value).240       **/241      members: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;242      /**243       * The prime member that helps determine the default vote behavior in case of absentations.244       **/245      prime: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;246      /**247       * Proposals so far.248       **/249      proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;250      /**251       * Actual proposal for a given hash, if it's current.252       **/253      proposalOf: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<Call>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;254      /**255       * The hashes of the active proposals.256       **/257      proposals: AugmentedQuery<ApiType, () => Observable<Vec<H256>>, []> & QueryableStorageEntry<ApiType, []>;258      /**259       * Votes on a given proposal, if it is ongoing.260       **/261      voting: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletCollectiveVotes>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;262      /**263       * Generic query264       **/265      [key: string]: QueryableStorageEntry<ApiType>;266    };267    councilMembership: {268      /**269       * The current membership, stored as an ordered Vec.270       **/271      members: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;272      /**273       * The current prime member, if one exists.274       **/275      prime: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;276      /**277       * Generic query278       **/279      [key: string]: QueryableStorageEntry<ApiType>;280    };281    democracy: {282      /**283       * A record of who vetoed what. Maps proposal hash to a possible existent block number284       * (until when it may not be resubmitted) and who vetoed it.285       **/286      blacklist: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<ITuple<[u32, Vec<AccountId32>]>>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;287      /**288       * Record of all proposals that have been subject to emergency cancellation.289       **/290      cancellations: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<bool>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;291      /**292       * Those who have locked a deposit.293       * 294       * TWOX-NOTE: Safe, as increasing integer keys are safe.295       **/296      depositOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[Vec<AccountId32>, u128]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;297      /**298       * True if the last referendum tabled was submitted externally. False if it was a public299       * proposal.300       **/301      lastTabledWasExternal: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;302      /**303       * The lowest referendum index representing an unbaked referendum. Equal to304       * `ReferendumCount` if there isn't a unbaked referendum.305       **/306      lowestUnbaked: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;307      /**308       * General information concerning any proposal or referendum.309       * The `PreimageHash` refers to the preimage of the `Preimages` provider which can be a JSON310       * dump or IPFS hash of a JSON file.311       * 312       * Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)313       * large preimages.314       **/315      metadataOf: AugmentedQuery<ApiType, (arg: PalletDemocracyMetadataOwner | { External: any } | { Proposal: any } | { Referendum: any } | string | Uint8Array) => Observable<Option<H256>>, [PalletDemocracyMetadataOwner]> & QueryableStorageEntry<ApiType, [PalletDemocracyMetadataOwner]>;316      /**317       * The referendum to be tabled whenever it would be valid to table an external proposal.318       * This happens when a referendum needs to be tabled and one of two conditions are met:319       * - `LastTabledWasExternal` is `false`; or320       * - `PublicProps` is empty.321       **/322      nextExternal: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[FrameSupportPreimagesBounded, PalletDemocracyVoteThreshold]>>>, []> & QueryableStorageEntry<ApiType, []>;323      /**324       * The number of (public) proposals that have been made so far.325       **/326      publicPropCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;327      /**328       * The public proposals. Unsorted. The second item is the proposal.329       **/330      publicProps: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, FrameSupportPreimagesBounded, AccountId32]>>>, []> & QueryableStorageEntry<ApiType, []>;331      /**332       * The next free referendum index, aka the number of referenda started so far.333       **/334      referendumCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;335      /**336       * Information concerning any given referendum.337       * 338       * TWOX-NOTE: SAFE as indexes are not under an attacker’s control.339       **/340      referendumInfoOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletDemocracyReferendumInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;341      /**342       * All votes for a particular voter. We store the balance for the number of votes that we343       * have recorded. The second item is the total amount of delegations, that will be added.344       * 345       * TWOX-NOTE: SAFE as `AccountId`s are crypto hashes anyway.346       **/347      votingOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletDemocracyVoteVoting>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;348      /**349       * Generic query350       **/351      [key: string]: QueryableStorageEntry<ApiType>;352    };353    dmpQueue: {354      /**355       * The configuration.356       **/357      configuration: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;358      /**359       * Counter for the related counted storage map360       **/361      counterForOverweight: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;362      /**363       * The overweight messages.364       **/365      overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;366      /**367       * The page index.368       **/369      pageIndex: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueuePageIndexData>, []> & QueryableStorageEntry<ApiType, []>;370      /**371       * The queue pages.372       **/373      pages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, Bytes]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;374      /**375       * Generic query376       **/377      [key: string]: QueryableStorageEntry<ApiType>;378    };379    ethereum: {380      blockHash: AugmentedQuery<ApiType, (arg: U256 | AnyNumber | Uint8Array) => Observable<H256>, [U256]> & QueryableStorageEntry<ApiType, [U256]>;381      /**382       * The current Ethereum block.383       **/384      currentBlock: AugmentedQuery<ApiType, () => Observable<Option<EthereumBlock>>, []> & QueryableStorageEntry<ApiType, []>;385      /**386       * The current Ethereum receipts.387       **/388      currentReceipts: AugmentedQuery<ApiType, () => Observable<Option<Vec<EthereumReceiptReceiptV3>>>, []> & QueryableStorageEntry<ApiType, []>;389      /**390       * The current transaction statuses.391       **/392      currentTransactionStatuses: AugmentedQuery<ApiType, () => Observable<Option<Vec<FpRpcTransactionStatus>>>, []> & QueryableStorageEntry<ApiType, []>;393      /**394       * Injected transactions should have unique nonce, here we store current395       **/396      injectedNonce: AugmentedQuery<ApiType, () => Observable<U256>, []> & QueryableStorageEntry<ApiType, []>;397      /**398       * Current building block's transactions and receipts.399       **/400      pending: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[EthereumTransactionTransactionV2, FpRpcTransactionStatus, EthereumReceiptReceiptV3]>>>, []> & QueryableStorageEntry<ApiType, []>;401      /**402       * Generic query403       **/404      [key: string]: QueryableStorageEntry<ApiType>;405    };406    evm: {407      accountCodes: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Bytes>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;408      accountCodesMetadata: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<PalletEvmCodeMetadata>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;409      accountStorages: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H256 | string | Uint8Array) => Observable<H256>, [H160, H256]> & QueryableStorageEntry<ApiType, [H160, H256]>;410      /**411       * Written on log, reset after transaction412       * Should be empty between transactions413       **/414      currentLogs: AugmentedQuery<ApiType, () => Observable<Vec<EthereumLog>>, []> & QueryableStorageEntry<ApiType, []>;415      /**416       * Generic query417       **/418      [key: string]: QueryableStorageEntry<ApiType>;419    };420    evmContractHelpers: {421      /**422       * Storage for users that allowed for sponsorship.423       * 424       * ### Usage425       * Prefer to delete record from storage if user no more allowed for sponsorship.426       * 427       * * **Key1** - contract address.428       * * **Key2** - user that allowed for sponsorship.429       * * **Value** - allowance for sponsorship.430       **/431      allowlist: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H160 | string | Uint8Array) => Observable<bool>, [H160, H160]> & QueryableStorageEntry<ApiType, [H160, H160]>;432      /**433       * Storege for contracts with [`Allowlisted`](SponsoringModeT::Allowlisted) sponsoring mode.434       * 435       * ### Usage436       * Prefer to delete collection from storage if mode chaged to non `Allowlisted`, than set **Value** to **false**.437       * 438       * * **Key** - contract address.439       * * **Value** - is contract in [`Allowlisted`](SponsoringModeT::Allowlisted) mode.440       **/441      allowlistEnabled: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;442      /**443       * Store owner for contract.444       * 445       * * **Key** - contract address.446       * * **Value** - owner for contract.447       **/448      owner: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<H160>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;449      /**450       * Deprecated: this storage is deprecated451       **/452      selfSponsoring: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;453      sponsorBasket: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H160 | string | Uint8Array) => Observable<Option<u32>>, [H160, H160]> & QueryableStorageEntry<ApiType, [H160, H160]>;454      /**455       * Store for contract sponsorship state.456       * 457       * * **Key** - contract address.458       * * **Value** - sponsorship state.459       **/460      sponsoring: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<UpDataStructsSponsorshipStateBasicCrossAccountIdRepr>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;461      /**462       * Storage for last sponsored block.463       * 464       * * **Key1** - contract address.465       * * **Key2** - sponsored user address.466       * * **Value** - last sponsored block number.467       **/468      sponsoringFeeLimit: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<BTreeMap<u32, U256>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;469      /**470       * Store for sponsoring mode.471       * 472       * ### Usage473       * Prefer to delete collection from storage if mode chaged to [`Disabled`](SponsoringModeT::Disabled).474       * 475       * * **Key** - contract address.476       * * **Value** - [`sponsoring mode`](SponsoringModeT).477       **/478      sponsoringMode: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<PalletEvmContractHelpersSponsoringModeT>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;479      /**480       * Storage for sponsoring rate limit in blocks.481       * 482       * * **Key** - contract address.483       * * **Value** - amount of sponsored blocks.484       **/485      sponsoringRateLimit: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<u32>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;486      /**487       * Generic query488       **/489      [key: string]: QueryableStorageEntry<ApiType>;490    };491    evmMigration: {492      migrationPending: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;493      /**494       * Generic query495       **/496      [key: string]: QueryableStorageEntry<ApiType>;497    };498    fellowshipCollective: {499      /**500       * The index of each ranks's member into the group of members who have at least that rank.501       **/502      idToIndex: AugmentedQuery<ApiType, (arg1: u16 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u16, AccountId32]> & QueryableStorageEntry<ApiType, [u16, AccountId32]>;503      /**504       * The members in the collective by index. All indices in the range `0..MemberCount` will505       * return `Some`, however a member's index is not guaranteed to remain unchanged over time.506       **/507      indexToId: AugmentedQuery<ApiType, (arg1: u16 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<AccountId32>>, [u16, u32]> & QueryableStorageEntry<ApiType, [u16, u32]>;508      /**509       * The number of members in the collective who have at least the rank according to the index510       * of the vec.511       **/512      memberCount: AugmentedQuery<ApiType, (arg: u16 | AnyNumber | Uint8Array) => Observable<u32>, [u16]> & QueryableStorageEntry<ApiType, [u16]>;513      /**514       * The current members of the collective.515       **/516      members: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletRankedCollectiveMemberRecord>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;517      /**518       * Votes on a given proposal, if it is ongoing.519       **/520      voting: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<PalletRankedCollectiveVoteRecord>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;521      votingCleanup: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;522      /**523       * Generic query524       **/525      [key: string]: QueryableStorageEntry<ApiType>;526    };527    fellowshipReferenda: {528      /**529       * The number of referenda being decided currently.530       **/531      decidingCount: AugmentedQuery<ApiType, (arg: u16 | AnyNumber | Uint8Array) => Observable<u32>, [u16]> & QueryableStorageEntry<ApiType, [u16]>;532      /**533       * The metadata is a general information concerning the referendum.534       * The `PreimageHash` refers to the preimage of the `Preimages` provider which can be a JSON535       * dump or IPFS hash of a JSON file.536       * 537       * Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)538       * large preimages.539       **/540      metadataOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<H256>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;541      /**542       * The next free referendum index, aka the number of referenda started so far.543       **/544      referendumCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;545      /**546       * Information concerning any given referendum.547       **/548      referendumInfoFor: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletReferendaReferendumInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;549      /**550       * The sorted list of referenda ready to be decided but not yet being decided, ordered by551       * conviction-weighted approvals.552       * 553       * This should be empty if `DecidingCount` is less than `TrackInfo::max_deciding`.554       **/555      trackQueue: AugmentedQuery<ApiType, (arg: u16 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, u32]>>>, [u16]> & QueryableStorageEntry<ApiType, [u16]>;556      /**557       * Generic query558       **/559      [key: string]: QueryableStorageEntry<ApiType>;560    };561    foreignAssets: {562      /**563       * The storages for assets to fungible collection binding564       * 565       **/566      assetBinding: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;567      /**568       * The storages for AssetMetadatas.569       * 570       * AssetMetadatas: map AssetIds => Option<AssetMetadata>571       **/572      assetMetadatas: AugmentedQuery<ApiType, (arg: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Option<PalletForeignAssetsModuleAssetMetadata>>, [PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [PalletForeignAssetsAssetIds]>;573      /**574       * The storages for MultiLocations.575       * 576       * ForeignAssetLocations: map ForeignAssetId => Option<MultiLocation>577       **/578      foreignAssetLocations: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<XcmV3MultiLocation>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;579      /**580       * The storages for CurrencyIds.581       * 582       * LocationToCurrencyIds: map MultiLocation => Option<ForeignAssetId>583       **/584      locationToCurrencyIds: AugmentedQuery<ApiType, (arg: XcmV3MultiLocation | { parents?: any; interior?: any } | string | Uint8Array) => Observable<Option<u32>>, [XcmV3MultiLocation]> & QueryableStorageEntry<ApiType, [XcmV3MultiLocation]>;585      /**586       * Next available Foreign AssetId ID.587       * 588       * NextForeignAssetId: ForeignAssetId589       **/590      nextForeignAssetId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;591      /**592       * Generic query593       **/594      [key: string]: QueryableStorageEntry<ApiType>;595    };596    fungible: {597      /**598       * Storage for assets delegated to a limited extent to other users.599       **/600      allowance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, arg3: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u128>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr]>;601      /**602       * Amount of tokens owned by an account inside a collection.603       **/604      balance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u128>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;605      /**606       * Total amount of fungible tokens inside a collection.607       **/608      totalSupply: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;609      /**610       * Generic query611       **/612      [key: string]: QueryableStorageEntry<ApiType>;613    };614    govScheduler: {615      /**616       * Items to be executed, indexed by the block number that they should be executed on.617       **/618      agenda: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<Option<PalletSchedulerScheduled>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;619      incompleteSince: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;620      /**621       * Lookup from a name to the block number and index of the task.622       * 623       * For v3 -> v4 the previously unbounded identities are Blake2-256 hashed to form the v4624       * identities.625       **/626      lookup: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Option<ITuple<[u32, u32]>>>, [U8aFixed]> & QueryableStorageEntry<ApiType, [U8aFixed]>;627      /**628       * Generic query629       **/630      [key: string]: QueryableStorageEntry<ApiType>;631    };632    identity: {633      /**634       * Information that is pertinent to identify the entity behind an account.635       * 636       * TWOX-NOTE: OK ― `AccountId` is a secure hash.637       **/638      identityOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletIdentityRegistration>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;639      /**640       * The set of registrars. Not expected to get very big as can only be added through a641       * special origin (likely a council motion).642       * 643       * The index into this can be cast to `RegistrarIndex` to get a valid value.644       **/645      registrars: AugmentedQuery<ApiType, () => Observable<Vec<Option<PalletIdentityRegistrarInfo>>>, []> & QueryableStorageEntry<ApiType, []>;646      /**647       * Alternative "sub" identities of this account.648       * 649       * The first item is the deposit, the second is a vector of the accounts.650       * 651       * TWOX-NOTE: OK ― `AccountId` is a secure hash.652       **/653      subsOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[u128, Vec<AccountId32>]>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;654      /**655       * The super-identity of an alternative "sub" identity together with its name, within that656       * context. If the account is not some other account's sub-identity, then just `None`.657       **/658      superOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<ITuple<[AccountId32, Data]>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;659      /**660       * Generic query661       **/662      [key: string]: QueryableStorageEntry<ApiType>;663    };664    inflation: {665      /**666       * Current inflation for `InflationBlockInterval` number of blocks667       **/668      blockInflation: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;669      /**670       * Next target (relay) block when inflation will be applied671       **/672      nextInflationBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;673      /**674       * Next target (relay) block when inflation is recalculated675       **/676      nextRecalculationBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;677      /**678       * Relay block when inflation has started679       **/680      startBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;681      /**682       * starting year total issuance683       **/684      startingYearTotalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;685      /**686       * Generic query687       **/688      [key: string]: QueryableStorageEntry<ApiType>;689    };690    maintenance: {691      enabled: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;692      /**693       * Generic query694       **/695      [key: string]: QueryableStorageEntry<ApiType>;696    };697    nonfungible: {698      /**699       * Amount of tokens owned by an account in a collection.700       **/701      accountBalance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u32>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;702      /**703       * Allowance set by a token owner for another user to perform one of certain transactions on a token.704       **/705      allowance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletEvmAccountBasicCrossAccountIdRepr>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;706      /**707       * Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.708       **/709      collectionAllowance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, arg3: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr]>;710      /**711       * Used to enumerate tokens owned by account.712       **/713      owned: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, arg3: u32 | AnyNumber | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, u32]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr, u32]>;714      /**715       * Custom data of a token that is serialized to bytes,716       * primarily reserved for on-chain operations,717       * normally obscured from the external users.718       * 719       * Auxiliary properties are slightly different from720       * usual [`TokenProperties`] due to an unlimited number721       * and separately stored and written-to key-value pairs.722       * 723       * Currently unused.724       **/725      tokenAuxProperties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: UpDataStructsPropertyScope | 'None' | 'Rmrk' | number | Uint8Array, arg4: Bytes | string | Uint8Array) => Observable<Option<Bytes>>, [u32, u32, UpDataStructsPropertyScope, Bytes]> & QueryableStorageEntry<ApiType, [u32, u32, UpDataStructsPropertyScope, Bytes]>;726      /**727       * Used to enumerate token's children.728       **/729      tokenChildren: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: ITuple<[u32, u32]> | [u32 | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<bool>, [u32, u32, ITuple<[u32, u32]>]> & QueryableStorageEntry<ApiType, [u32, u32, ITuple<[u32, u32]>]>;730      /**731       * Token data, used to partially describe a token.732       **/733      tokenData: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNonfungibleItemData>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;734      /**735       * Map of key-value pairs, describing the metadata of a token.736       **/737      tokenProperties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;738      /**739       * Amount of burnt tokens in a collection.740       **/741      tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;742      /**743       * Total amount of minted tokens in a collection.744       **/745      tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;746      /**747       * Generic query748       **/749      [key: string]: QueryableStorageEntry<ApiType>;750    };751    parachainInfo: {752      parachainId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;753      /**754       * Generic query755       **/756      [key: string]: QueryableStorageEntry<ApiType>;757    };758    parachainSystem: {759      /**760       * The number of HRMP messages we observed in `on_initialize` and thus used that number for761       * announcing the weight of `on_initialize` and `on_finalize`.762       **/763      announcedHrmpMessagesPerCandidate: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;764      /**765       * The next authorized upgrade, if there is one.766       **/767      authorizedUpgrade: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemCodeUpgradeAuthorization>>, []> & QueryableStorageEntry<ApiType, []>;768      /**769       * A custom head data that should be returned as result of `validate_block`.770       * 771       * See [`Pallet::set_custom_validation_head_data`] for more information.772       **/773      customValidationHeadData: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;774      /**775       * Were the validation data set to notify the relay chain?776       **/777      didSetValidationCode: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;778      /**779       * The parachain host configuration that was obtained from the relay parent.780       * 781       * This field is meant to be updated each block with the validation data inherent. Therefore,782       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.783       * 784       * This data is also absent from the genesis.785       **/786      hostConfiguration: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV4AbridgedHostConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;787      /**788       * HRMP messages that were sent in a block.789       * 790       * This will be cleared in `on_initialize` of each new block.791       **/792      hrmpOutboundMessages: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotCorePrimitivesOutboundHrmpMessage>>, []> & QueryableStorageEntry<ApiType, []>;793      /**794       * HRMP watermark that was set in a block.795       * 796       * This will be cleared in `on_initialize` of each new block.797       **/798      hrmpWatermark: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;799      /**800       * The last downward message queue chain head we have observed.801       * 802       * This value is loaded before and saved after processing inbound downward messages carried803       * by the system inherent.804       **/805      lastDmqMqcHead: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;806      /**807       * The message queue chain heads we have observed per each channel incoming channel.808       * 809       * This value is loaded before and saved after processing inbound downward messages carried810       * by the system inherent.811       **/812      lastHrmpMqcHeads: AugmentedQuery<ApiType, () => Observable<BTreeMap<u32, H256>>, []> & QueryableStorageEntry<ApiType, []>;813      /**814       * The relay chain block number associated with the last parachain block.815       **/816      lastRelayChainBlockNumber: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;817      /**818       * Validation code that is set by the parachain and is to be communicated to collator and819       * consequently the relay-chain.820       * 821       * This will be cleared in `on_initialize` of each new block if no other pallet already set822       * the value.823       **/824      newValidationCode: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;825      /**826       * Upward messages that are still pending and not yet send to the relay chain.827       **/828      pendingUpwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;829      /**830       * In case of a scheduled upgrade, this storage field contains the validation code to be applied.831       * 832       * As soon as the relay chain gives us the go-ahead signal, we will overwrite the [`:code`][well_known_keys::CODE]833       * which will result the next block process with the new validation code. This concludes the upgrade process.834       * 835       * [well_known_keys::CODE]: sp_core::storage::well_known_keys::CODE836       **/837      pendingValidationCode: AugmentedQuery<ApiType, () => Observable<Bytes>, []> & QueryableStorageEntry<ApiType, []>;838      /**839       * Number of downward messages processed in a block.840       * 841       * This will be cleared in `on_initialize` of each new block.842       **/843      processedDownwardMessages: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;844      /**845       * The state proof for the last relay parent block.846       * 847       * This field is meant to be updated each block with the validation data inherent. Therefore,848       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.849       * 850       * This data is also absent from the genesis.851       **/852      relayStateProof: AugmentedQuery<ApiType, () => Observable<Option<SpTrieStorageProof>>, []> & QueryableStorageEntry<ApiType, []>;853      /**854       * The snapshot of some state related to messaging relevant to the current parachain as per855       * the relay parent.856       * 857       * This field is meant to be updated each block with the validation data inherent. Therefore,858       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.859       * 860       * This data is also absent from the genesis.861       **/862      relevantMessagingState: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot>>, []> & QueryableStorageEntry<ApiType, []>;863      /**864       * The weight we reserve at the beginning of the block for processing DMP messages. This865       * overrides the amount set in the Config trait.866       **/867      reservedDmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;868      /**869       * The weight we reserve at the beginning of the block for processing XCMP messages. This870       * overrides the amount set in the Config trait.871       **/872      reservedXcmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;873      /**874       * An option which indicates if the relay-chain restricts signalling a validation code upgrade.875       * In other words, if this is `Some` and [`NewValidationCode`] is `Some` then the produced876       * candidate will be invalid.877       * 878       * This storage item is a mirror of the corresponding value for the current parachain from the879       * relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is880       * set after the inherent.881       **/882      upgradeRestrictionSignal: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV4UpgradeRestriction>>, []> & QueryableStorageEntry<ApiType, []>;883      /**884       * Upward messages that were sent in a block.885       * 886       * This will be cleared in `on_initialize` of each new block.887       **/888      upwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;889      /**890       * The [`PersistedValidationData`] set for this block.891       * This value is expected to be set only once per block and it's never stored892       * in the trie.893       **/894      validationData: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV4PersistedValidationData>>, []> & QueryableStorageEntry<ApiType, []>;895      /**896       * Generic query897       **/898      [key: string]: QueryableStorageEntry<ApiType>;899    };900    polkadotXcm: {901      /**902       * The existing asset traps.903       * 904       * Key is the blake2 256 hash of (origin, versioned `MultiAssets`) pair. Value is the number of905       * times this pair has been trapped (usually just 1 if it exists at all).906       **/907      assetTraps: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<u32>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;908      /**909       * The current migration's stage, if any.910       **/911      currentMigration: AugmentedQuery<ApiType, () => Observable<Option<PalletXcmVersionMigrationStage>>, []> & QueryableStorageEntry<ApiType, []>;912      /**913       * Fungible assets which we know are locked on this chain.914       **/915      lockedFungibles: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<Vec<ITuple<[u128, XcmVersionedMultiLocation]>>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;916      /**917       * The ongoing queries.918       **/919      queries: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<PalletXcmQueryStatus>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;920      /**921       * The latest available query index.922       **/923      queryCounter: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;924      /**925       * Fungible assets which we know are locked on a remote chain.926       **/927      remoteLockedFungibles: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array, arg3: XcmVersionedAssetId | { V3: any } | string | Uint8Array) => Observable<Option<PalletXcmRemoteLockedFungibleRecord>>, [u32, AccountId32, XcmVersionedAssetId]> & QueryableStorageEntry<ApiType, [u32, AccountId32, XcmVersionedAssetId]>;928      /**929       * Default version to encode XCM when latest version of destination is unknown. If `None`,930       * then the destinations whose XCM version is unknown are considered unreachable.931       **/932      safeXcmVersion: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;933      /**934       * The Latest versions that we know various locations support.935       **/936      supportedVersion: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => Observable<Option<u32>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedMultiLocation]>;937      /**938       * Destinations whose latest XCM version we would like to know. Duplicates not allowed, and939       * the `u32` counter is the number of times that a send to the destination has been attempted,940       * which is used as a prioritization.941       **/942      versionDiscoveryQueue: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[XcmVersionedMultiLocation, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;943      /**944       * All locations that we have requested version notifications from.945       **/946      versionNotifiers: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => Observable<Option<u64>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedMultiLocation]>;947      /**948       * The target locations that are subscribed to our version changes, as well as the most recent949       * of our versions we informed them of.950       **/951      versionNotifyTargets: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => Observable<Option<ITuple<[u64, SpWeightsWeightV2Weight, u32]>>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedMultiLocation]>;952      /**953       * Global suspension state of the XCM executor.954       **/955      xcmExecutionSuspended: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;956      /**957       * Generic query958       **/959      [key: string]: QueryableStorageEntry<ApiType>;960    };961    preimage: {962      preimageFor: AugmentedQuery<ApiType, (arg: ITuple<[H256, u32]> | [H256 | string | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<Option<Bytes>>, [ITuple<[H256, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[H256, u32]>]>;963      /**964       * The request status of a given hash.965       **/966      statusFor: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletPreimageRequestStatus>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;967      /**968       * Generic query969       **/970      [key: string]: QueryableStorageEntry<ApiType>;971    };972    refungible: {973      /**974       * Amount of tokens (not pieces) partially owned by an account within a collection.975       **/976      accountBalance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u32>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;977      /**978       * Allowance set by a token owner for another user to perform one of certain transactions on a number of pieces of a token.979       **/980      allowance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, arg4: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u128>, [u32, u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr]>;981      /**982       * Amount of token pieces owned by account.983       **/984      balance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u128>, [u32, u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, u32, PalletEvmAccountBasicCrossAccountIdRepr]>;985      /**986       * Spender set by a wallet owner that could perform certain transactions on all tokens in the wallet.987       **/988      collectionAllowance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, arg3: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr]>;989      /**990       * Used to enumerate tokens owned by account.991       **/992      owned: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, arg3: u32 | AnyNumber | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr, u32]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr, u32]>;993      /**994       * Amount of pieces a refungible token is split into.995       **/996      tokenProperties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;997      /**998       * Amount of tokens burnt in a collection.999       **/1000      tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1001      /**1002       * Total amount of minted tokens in a collection.1003       **/1004      tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1005      /**1006       * Total amount of pieces for token1007       **/1008      totalSupply: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1009      /**1010       * Generic query1011       **/1012      [key: string]: QueryableStorageEntry<ApiType>;1013    };1014    session: {1015      /**1016       * Current index of the session.1017       **/1018      currentIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1019      /**1020       * Indices of disabled validators.1021       * 1022       * The vec is always kept sorted so that we can find whether a given validator is1023       * disabled using binary search. It gets cleared when `on_session_ending` returns1024       * a new set of identities.1025       **/1026      disabledValidators: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;1027      /**1028       * The owner of a key. The key is the `KeyTypeId` + the encoded key.1029       **/1030      keyOwner: AugmentedQuery<ApiType, (arg: ITuple<[SpCoreCryptoKeyTypeId, Bytes]> | [SpCoreCryptoKeyTypeId | string | Uint8Array, Bytes | string | Uint8Array]) => Observable<Option<AccountId32>>, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]> & QueryableStorageEntry<ApiType, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]>;1031      /**1032       * The next session keys for a validator.1033       **/1034      nextKeys: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<QuartzRuntimeRuntimeCommonSessionKeys>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;1035      /**1036       * True if the underlying economic identities or weighting behind the validators1037       * has changed in the queued validator set.1038       **/1039      queuedChanged: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;1040      /**1041       * The queued keys for the next session. When the next session begins, these keys1042       * will be used to determine the validator's session keys.1043       **/1044      queuedKeys: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[AccountId32, QuartzRuntimeRuntimeCommonSessionKeys]>>>, []> & QueryableStorageEntry<ApiType, []>;1045      /**1046       * The current set of validators.1047       **/1048      validators: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;1049      /**1050       * Generic query1051       **/1052      [key: string]: QueryableStorageEntry<ApiType>;1053    };1054    stateTrieMigration: {1055      /**1056       * The limits that are imposed on automatic migrations.1057       * 1058       * If set to None, then no automatic migration happens.1059       **/1060      autoLimits: AugmentedQuery<ApiType, () => Observable<Option<PalletStateTrieMigrationMigrationLimits>>, []> & QueryableStorageEntry<ApiType, []>;1061      /**1062       * Migration progress.1063       * 1064       * This stores the snapshot of the last migrated keys. It can be set into motion and move1065       * forward by any of the means provided by this pallet.1066       **/1067      migrationProcess: AugmentedQuery<ApiType, () => Observable<PalletStateTrieMigrationMigrationTask>, []> & QueryableStorageEntry<ApiType, []>;1068      /**1069       * The maximum limits that the signed migration could use.1070       * 1071       * If not set, no signed submission is allowed.1072       **/1073      signedMigrationMaxLimits: AugmentedQuery<ApiType, () => Observable<Option<PalletStateTrieMigrationMigrationLimits>>, []> & QueryableStorageEntry<ApiType, []>;1074      /**1075       * Generic query1076       **/1077      [key: string]: QueryableStorageEntry<ApiType>;1078    };1079    sudo: {1080      /**1081       * The `AccountId` of the sudo key.1082       **/1083      key: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;1084      /**1085       * Generic query1086       **/1087      [key: string]: QueryableStorageEntry<ApiType>;1088    };1089    system: {1090      /**1091       * The full account information for a particular account ID.1092       **/1093      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<FrameSystemAccountInfo>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;1094      /**1095       * Total length (in bytes) for all extrinsics put together, for the current block.1096       **/1097      allExtrinsicsLen: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;1098      /**1099       * Map of block numbers to block hashes.1100       **/1101      blockHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<H256>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1102      /**1103       * The current weight for the block.1104       **/1105      blockWeight: AugmentedQuery<ApiType, () => Observable<FrameSupportDispatchPerDispatchClassWeight>, []> & QueryableStorageEntry<ApiType, []>;1106      /**1107       * Digest of the current block, also part of the block header.1108       **/1109      digest: AugmentedQuery<ApiType, () => Observable<SpRuntimeDigest>, []> & QueryableStorageEntry<ApiType, []>;1110      /**1111       * The number of events in the `Events<T>` list.1112       **/1113      eventCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1114      /**1115       * Events deposited for the current block.1116       * 1117       * NOTE: The item is unbound and should therefore never be read on chain.1118       * It could otherwise inflate the PoV size of a block.1119       * 1120       * Events have a large in-memory size. Box the events to not go out-of-memory1121       * just in case someone still reads them from within the runtime.1122       **/1123      events: AugmentedQuery<ApiType, () => Observable<Vec<FrameSystemEventRecord>>, []> & QueryableStorageEntry<ApiType, []>;1124      /**1125       * Mapping between a topic (represented by T::Hash) and a vector of indexes1126       * of events in the `<Events<T>>` list.1127       * 1128       * All topic vectors have deterministic storage locations depending on the topic. This1129       * allows light-clients to leverage the changes trie storage tracking mechanism and1130       * in case of changes fetch the list of events of interest.1131       * 1132       * The value has the type `(T::BlockNumber, EventIndex)` because if we used only just1133       * the `EventIndex` then in case if the topic has the same contents on the next block1134       * no notification will be triggered thus the event might be lost.1135       **/1136      eventTopics: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Vec<ITuple<[u32, u32]>>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;1137      /**1138       * The execution phase of the block.1139       **/1140      executionPhase: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemPhase>>, []> & QueryableStorageEntry<ApiType, []>;1141      /**1142       * Total extrinsics count for the current block.1143       **/1144      extrinsicCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;1145      /**1146       * Extrinsics data for the current block (maps an extrinsic's index to its data).1147       **/1148      extrinsicData: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1149      /**1150       * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.1151       **/1152      lastRuntimeUpgrade: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemLastRuntimeUpgradeInfo>>, []> & QueryableStorageEntry<ApiType, []>;1153      /**1154       * The current block number being processed. Set by `execute_block`.1155       **/1156      number: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1157      /**1158       * Hash of the previous block.1159       **/1160      parentHash: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;1161      /**1162       * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False1163       * (default) if not.1164       **/1165      upgradedToTripleRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;1166      /**1167       * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.1168       **/1169      upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;1170      /**1171       * Generic query1172       **/1173      [key: string]: QueryableStorageEntry<ApiType>;1174    };1175    technicalCommittee: {1176      /**1177       * The current members of the collective. This is stored sorted (just by value).1178       **/1179      members: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;1180      /**1181       * The prime member that helps determine the default vote behavior in case of absentations.1182       **/1183      prime: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;1184      /**1185       * Proposals so far.1186       **/1187      proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1188      /**1189       * Actual proposal for a given hash, if it's current.1190       **/1191      proposalOf: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<Call>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;1192      /**1193       * The hashes of the active proposals.1194       **/1195      proposals: AugmentedQuery<ApiType, () => Observable<Vec<H256>>, []> & QueryableStorageEntry<ApiType, []>;1196      /**1197       * Votes on a given proposal, if it is ongoing.1198       **/1199      voting: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletCollectiveVotes>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;1200      /**1201       * Generic query1202       **/1203      [key: string]: QueryableStorageEntry<ApiType>;1204    };1205    technicalCommitteeMembership: {1206      /**1207       * The current membership, stored as an ordered Vec.1208       **/1209      members: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;1210      /**1211       * The current prime member, if one exists.1212       **/1213      prime: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;1214      /**1215       * Generic query1216       **/1217      [key: string]: QueryableStorageEntry<ApiType>;1218    };1219    testUtils: {1220      enabled: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;1221      testValue: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1222      /**1223       * Generic query1224       **/1225      [key: string]: QueryableStorageEntry<ApiType>;1226    };1227    timestamp: {1228      /**1229       * Did the timestamp get updated in this block?1230       **/1231      didUpdate: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;1232      /**1233       * Current time for the current block.1234       **/1235      now: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;1236      /**1237       * Generic query1238       **/1239      [key: string]: QueryableStorageEntry<ApiType>;1240    };1241    tokens: {1242      /**1243       * The balance of a token type under an account.1244       * 1245       * NOTE: If the total is ever zero, decrease account ref account.1246       * 1247       * NOTE: This is only used in the case that this module is used to store1248       * balances.1249       **/1250      accounts: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<OrmlTokensAccountData>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;1251      /**1252       * Any liquidity locks of a token type under an account.1253       * NOTE: Should only be accessed when setting, changing and freeing a lock.1254       **/1255      locks: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Vec<OrmlTokensBalanceLock>>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;1256      /**1257       * Named reserves on some account balances.1258       **/1259      reserves: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Vec<OrmlTokensReserveData>>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;1260      /**1261       * The total issuance of a token type.1262       **/1263      totalIssuance: AugmentedQuery<ApiType, (arg: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<u128>, [PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [PalletForeignAssetsAssetIds]>;1264      /**1265       * Generic query1266       **/1267      [key: string]: QueryableStorageEntry<ApiType>;1268    };1269    transactionPayment: {1270      nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;1271      storageVersion: AugmentedQuery<ApiType, () => Observable<PalletTransactionPaymentReleases>, []> & QueryableStorageEntry<ApiType, []>;1272      /**1273       * Generic query1274       **/1275      [key: string]: QueryableStorageEntry<ApiType>;1276    };1277    treasury: {1278      /**1279       * Proposal indices that have been approved but not yet awarded.1280       **/1281      approvals: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;1282      /**1283       * The amount which has been reported as inactive to Currency.1284       **/1285      deactivated: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;1286      /**1287       * Number of proposals that have been made.1288       **/1289      proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1290      /**1291       * Proposals that have been made.1292       **/1293      proposals: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletTreasuryProposal>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1294      /**1295       * Generic query1296       **/1297      [key: string]: QueryableStorageEntry<ApiType>;1298    };1299    unique: {1300      /**1301       * Used for migrations1302       **/1303      chainVersion: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;1304      /**1305       * (Collection id (controlled?2), who created (real))1306       * TODO: Off chain worker should remove from this map when collection gets removed1307       **/1308      createItemBasket: AugmentedQuery<ApiType, (arg: ITuple<[u32, AccountId32]> | [u32 | AnyNumber | Uint8Array, AccountId32 | string | Uint8Array]) => Observable<Option<u32>>, [ITuple<[u32, AccountId32]>]> & QueryableStorageEntry<ApiType, [ITuple<[u32, AccountId32]>]>;1309      /**1310       * Last sponsoring of fungible tokens approval in a collection1311       **/1312      fungibleApproveBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;1313      /**1314       * Collection id (controlled?2), owning user (real)1315       **/1316      fungibleTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;1317      /**1318       * Last sponsoring of NFT approval in a collection1319       **/1320      nftApproveBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1321      /**1322       * Collection id (controlled?2), token id (controlled?2)1323       **/1324      nftTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1325      /**1326       * Last sponsoring of RFT approval in a collection1327       **/1328      refungibleApproveBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u32, u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, u32, AccountId32]>;1329      /**1330       * Collection id (controlled?2), token id (controlled?2)1331       **/1332      reFungibleTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u32, u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, u32, AccountId32]>;1333      /**1334       * Last sponsoring of token property setting // todo:doc rephrase this and the following1335       **/1336      tokenPropertyBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1337      /**1338       * Generic query1339       **/1340      [key: string]: QueryableStorageEntry<ApiType>;1341    };1342    vesting: {1343      /**1344       * Vesting schedules of an account.1345       * 1346       * VestingSchedules: map AccountId => Vec<VestingSchedule>1347       **/1348      vestingSchedules: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<OrmlVestingVestingSchedule>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;1349      /**1350       * Generic query1351       **/1352      [key: string]: QueryableStorageEntry<ApiType>;1353    };1354    xcmpQueue: {1355      /**1356       * Counter for the related counted storage map1357       **/1358      counterForOverweight: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1359      /**1360       * Inbound aggregate XCMP messages. It can only be one per ParaId/block.1361       **/1362      inboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1363      /**1364       * Status of the inbound XCMP channels.1365       **/1366      inboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueInboundChannelDetails>>, []> & QueryableStorageEntry<ApiType, []>;1367      /**1368       * The messages outbound in a given XCMP channel.1369       **/1370      outboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u16 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u16]> & QueryableStorageEntry<ApiType, [u32, u16]>;1371      /**1372       * The non-empty XCMP channels in order of becoming non-empty, and the index of the first1373       * and last outbound message. If the two indices are equal, then it indicates an empty1374       * queue and there must be a non-`Ok` `OutboundStatus`. We assume queues grow no greater1375       * than 65535 items. Queue indices for normal messages begin at one; zero is reserved in1376       * case of the need to send a high-priority signal message this block.1377       * The bool is true if there is a signal message waiting to be sent.1378       **/1379      outboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueOutboundChannelDetails>>, []> & QueryableStorageEntry<ApiType, []>;1380      /**1381       * The messages that exceeded max individual message weight budget.1382       * 1383       * These message stay in this storage map until they are manually dispatched via1384       * `service_overweight`.1385       **/1386      overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;1387      /**1388       * The number of overweight messages ever recorded in `Overweight`. Also doubles as the next1389       * available free overweight index.1390       **/1391      overweightCount: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;1392      /**1393       * The configuration which controls the dynamics of the outbound queue.1394       **/1395      queueConfig: AugmentedQuery<ApiType, () => Observable<CumulusPalletXcmpQueueQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;1396      /**1397       * Whether or not the XCMP queue is suspended from executing incoming XCMs or not.1398       **/1399      queueSuspended: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;1400      /**1401       * Any signal messages waiting to be sent.1402       **/1403      signalMessages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1404      /**1405       * Generic query1406       **/1407      [key: string]: QueryableStorageEntry<ApiType>;1408    };1409  } // AugmentedQueries1410} // declare module