git.delta.rocks / unique-network / refs/commits / 7f04dc961d64

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, Struct, 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, CumulusPalletParachainSystemUnincludedSegmentAncestor, CumulusPalletParachainSystemUnincludedSegmentSegmentTracker, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, EthereumBlock, EthereumLog, EthereumReceiptReceiptV3, EthereumTransactionTransactionV2, FpRpcTransactionStatus, FrameSupportDispatchPerDispatchClassWeight, FrameSupportPreimagesBounded, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, OpalRuntimeRuntimeCommonSessionKeys, OpalRuntimeRuntimeHoldReason, OrmlTokensAccountData, OrmlTokensBalanceLock, OrmlTokensReserveData, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesIdAmount, PalletBalancesReserveData, PalletCollectiveVotes, PalletConfigurationAppPromotionConfiguration, PalletDemocracyMetadataOwner, PalletDemocracyReferendumInfo, PalletDemocracyVoteThreshold, PalletDemocracyVoteVoting, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmCodeMetadata, PalletEvmContractHelpersSponsoringModeT, PalletForeignAssetsAssetId, PalletForeignAssetsModuleAssetMetadata, PalletIdentityRegistrarInfo, PalletIdentityRegistration, PalletNonfungibleItemData, PalletPreimageRequestStatus, PalletRankedCollectiveMemberRecord, PalletRankedCollectiveVoteRecord, PalletReferendaReferendumInfo, PalletSchedulerScheduled, PalletStateTrieMigrationMigrationLimits, PalletStateTrieMigrationMigrationTask, PalletTransactionPaymentReleases, PalletTreasuryProposal, PalletXcmQueryStatus, PalletXcmRemoteLockedFungibleRecord, PalletXcmVersionMigrationStage, PhantomTypeUpDataStructs, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV5AbridgedHostConfiguration, PolkadotPrimitivesV5PersistedValidationData, PolkadotPrimitivesV5UpgradeGoAhead, PolkadotPrimitivesV5UpgradeRestriction, SpConsensusAuraSr25519AppSr25519Public, SpCoreCryptoKeyTypeId, SpRuntimeDigest, SpTrieStorageProof, SpWeightsWeightV2Weight, StagingXcmV3MultiLocation, StagingXcmVersionedAssetId, StagingXcmVersionedMultiLocation, UpDataStructsCollection, UpDataStructsCollectionStats, UpDataStructsProperties, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsPropertyScope, UpDataStructsSponsorshipStateBasicCrossAccountIdRepr, UpDataStructsTokenChild } 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 will85       * always be updated to the latest AuRa authorities in `on_finalize`.86       **/87      authorities: AugmentedQuery<ApiType, () => Observable<Vec<SpConsensusAuraSr25519AppSr25519Public>>, []> & QueryableStorageEntry<ApiType, []>;88      /**89       * Current slot paired with a number of authored blocks.90       * 91       * Updated on each block initialization.92       **/93      slotInfo: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[u64, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;94      /**95       * Generic query96       **/97      [key: string]: QueryableStorageEntry<ApiType>;98    };99    authorship: {100      /**101       * Author of current block.102       **/103      author: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;104      /**105       * Generic query106       **/107      [key: string]: QueryableStorageEntry<ApiType>;108    };109    balances: {110      /**111       * The Balances pallet example of storing the balance of an account.112       * 113       * # Example114       * 115       * ```nocompile116       * impl pallet_balances::Config for Runtime {117       * type AccountStore = StorageMapShim<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>118       * }119       * ```120       * 121       * You can also store the balance of an account in the `System` pallet.122       * 123       * # Example124       * 125       * ```nocompile126       * impl pallet_balances::Config for Runtime {127       * type AccountStore = System128       * }129       * ```130       * 131       * But this comes with tradeoffs, storing account balances in the system pallet stores132       * `frame_system` data alongside the account data contrary to storing account balances in the133       * `Balances` pallet, which uses a `StorageMap` to store balances data only.134       * NOTE: This is only used in the case that this pallet is used to store balances.135       **/136      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletBalancesAccountData>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;137      /**138       * Freeze locks on account balances.139       **/140      freezes: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesIdAmount>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;141      /**142       * Holds on account balances.143       **/144      holds: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<{145    readonly id: OpalRuntimeRuntimeHoldReason;146    readonly amount: u128;147  } & Struct>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;148      /**149       * The total units of outstanding deactivated balance in the system.150       **/151      inactiveIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;152      /**153       * Any liquidity locks on some account balances.154       * NOTE: Should only be accessed when setting, changing and freeing a lock.155       **/156      locks: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesBalanceLock>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;157      /**158       * Named reserves on some account balances.159       **/160      reserves: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesReserveData>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;161      /**162       * The total units issued in the system.163       **/164      totalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;165      /**166       * Generic query167       **/168      [key: string]: QueryableStorageEntry<ApiType>;169    };170    collatorSelection: {171      /**172       * The (community, limited) collation candidates.173       **/174      candidates: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;175      /**176       * The invulnerable, fixed collators.177       **/178      invulnerables: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;179      /**180       * Last block authored by collator.181       **/182      lastAuthoredBlock: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u32>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;183      /**184       * The (community) collation license holders.185       **/186      licenseDepositOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u128>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;187      /**188       * Generic query189       **/190      [key: string]: QueryableStorageEntry<ApiType>;191    };192    common: {193      /**194       * Storage of the amount of collection admins.195       **/196      adminAmount: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;197      /**198       * Allowlisted collection users.199       **/200      allowlist: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;201      /**202       * Storage of collection info.203       **/204      collectionById: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<UpDataStructsCollection>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;205      /**206       * Storage of collection properties.207       **/208      collectionProperties: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;209      /**210       * Storage of token property permissions of a collection.211       **/212      collectionPropertyPermissions: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsPropertiesMapPropertyPermission>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;213      /**214       * Storage of the count of created collections. Essentially contains the last collection ID.215       **/216      createdCollectionCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;217      /**218       * Storage of the count of deleted collections.219       **/220      destroyedCollectionCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;221      /**222       * Not used by code, exists only to provide some types to metadata.223       **/224      dummyStorageValue: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[UpDataStructsCollectionStats, u32, u32, UpDataStructsTokenChild, PhantomTypeUpDataStructs]>>>, []> & QueryableStorageEntry<ApiType, []>;225      /**226       * List of collection admins.227       **/228      isAdmin: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;229      /**230       * Generic query231       **/232      [key: string]: QueryableStorageEntry<ApiType>;233    };234    configuration: {235      appPromomotionConfigurationOverride: AugmentedQuery<ApiType, () => Observable<PalletConfigurationAppPromotionConfiguration>, []> & QueryableStorageEntry<ApiType, []>;236      collatorSelectionDesiredCollatorsOverride: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;237      collatorSelectionKickThresholdOverride: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;238      collatorSelectionLicenseBondOverride: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;239      minGasPriceOverride: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;240      weightToFeeCoefficientOverride: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;241      /**242       * Generic query243       **/244      [key: string]: QueryableStorageEntry<ApiType>;245    };246    council: {247      /**248       * The current members of the collective. This is stored sorted (just by value).249       **/250      members: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;251      /**252       * The prime member that helps determine the default vote behavior in case of absentations.253       **/254      prime: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;255      /**256       * Proposals so far.257       **/258      proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;259      /**260       * Actual proposal for a given hash, if it's current.261       **/262      proposalOf: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<Call>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;263      /**264       * The hashes of the active proposals.265       **/266      proposals: AugmentedQuery<ApiType, () => Observable<Vec<H256>>, []> & QueryableStorageEntry<ApiType, []>;267      /**268       * Votes on a given proposal, if it is ongoing.269       **/270      voting: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletCollectiveVotes>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;271      /**272       * Generic query273       **/274      [key: string]: QueryableStorageEntry<ApiType>;275    };276    councilMembership: {277      /**278       * The current membership, stored as an ordered Vec.279       **/280      members: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;281      /**282       * The current prime member, if one exists.283       **/284      prime: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;285      /**286       * Generic query287       **/288      [key: string]: QueryableStorageEntry<ApiType>;289    };290    democracy: {291      /**292       * A record of who vetoed what. Maps proposal hash to a possible existent block number293       * (until when it may not be resubmitted) and who vetoed it.294       **/295      blacklist: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<ITuple<[u32, Vec<AccountId32>]>>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;296      /**297       * Record of all proposals that have been subject to emergency cancellation.298       **/299      cancellations: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<bool>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;300      /**301       * Those who have locked a deposit.302       * 303       * TWOX-NOTE: Safe, as increasing integer keys are safe.304       **/305      depositOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[Vec<AccountId32>, u128]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;306      /**307       * True if the last referendum tabled was submitted externally. False if it was a public308       * proposal.309       **/310      lastTabledWasExternal: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;311      /**312       * The lowest referendum index representing an unbaked referendum. Equal to313       * `ReferendumCount` if there isn't a unbaked referendum.314       **/315      lowestUnbaked: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;316      /**317       * General information concerning any proposal or referendum.318       * The `PreimageHash` refers to the preimage of the `Preimages` provider which can be a JSON319       * dump or IPFS hash of a JSON file.320       * 321       * Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)322       * large preimages.323       **/324      metadataOf: AugmentedQuery<ApiType, (arg: PalletDemocracyMetadataOwner | { External: any } | { Proposal: any } | { Referendum: any } | string | Uint8Array) => Observable<Option<H256>>, [PalletDemocracyMetadataOwner]> & QueryableStorageEntry<ApiType, [PalletDemocracyMetadataOwner]>;325      /**326       * The referendum to be tabled whenever it would be valid to table an external proposal.327       * This happens when a referendum needs to be tabled and one of two conditions are met:328       * - `LastTabledWasExternal` is `false`; or329       * - `PublicProps` is empty.330       **/331      nextExternal: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[FrameSupportPreimagesBounded, PalletDemocracyVoteThreshold]>>>, []> & QueryableStorageEntry<ApiType, []>;332      /**333       * The number of (public) proposals that have been made so far.334       **/335      publicPropCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;336      /**337       * The public proposals. Unsorted. The second item is the proposal.338       **/339      publicProps: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, FrameSupportPreimagesBounded, AccountId32]>>>, []> & QueryableStorageEntry<ApiType, []>;340      /**341       * The next free referendum index, aka the number of referenda started so far.342       **/343      referendumCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;344      /**345       * Information concerning any given referendum.346       * 347       * TWOX-NOTE: SAFE as indexes are not under an attacker’s control.348       **/349      referendumInfoOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletDemocracyReferendumInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;350      /**351       * All votes for a particular voter. We store the balance for the number of votes that we352       * have recorded. The second item is the total amount of delegations, that will be added.353       * 354       * TWOX-NOTE: SAFE as `AccountId`s are crypto hashes anyway.355       **/356      votingOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletDemocracyVoteVoting>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;357      /**358       * Generic query359       **/360      [key: string]: QueryableStorageEntry<ApiType>;361    };362    dmpQueue: {363      /**364       * The configuration.365       **/366      configuration: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;367      /**368       * Counter for the related counted storage map369       **/370      counterForOverweight: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;371      /**372       * The overweight messages.373       **/374      overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;375      /**376       * The page index.377       **/378      pageIndex: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueuePageIndexData>, []> & QueryableStorageEntry<ApiType, []>;379      /**380       * The queue pages.381       **/382      pages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, Bytes]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;383      /**384       * Generic query385       **/386      [key: string]: QueryableStorageEntry<ApiType>;387    };388    ethereum: {389      blockHash: AugmentedQuery<ApiType, (arg: U256 | AnyNumber | Uint8Array) => Observable<H256>, [U256]> & QueryableStorageEntry<ApiType, [U256]>;390      /**391       * The current Ethereum block.392       **/393      currentBlock: AugmentedQuery<ApiType, () => Observable<Option<EthereumBlock>>, []> & QueryableStorageEntry<ApiType, []>;394      /**395       * The current Ethereum receipts.396       **/397      currentReceipts: AugmentedQuery<ApiType, () => Observable<Option<Vec<EthereumReceiptReceiptV3>>>, []> & QueryableStorageEntry<ApiType, []>;398      /**399       * The current transaction statuses.400       **/401      currentTransactionStatuses: AugmentedQuery<ApiType, () => Observable<Option<Vec<FpRpcTransactionStatus>>>, []> & QueryableStorageEntry<ApiType, []>;402      /**403       * Injected transactions should have unique nonce, here we store current404       **/405      injectedNonce: AugmentedQuery<ApiType, () => Observable<U256>, []> & QueryableStorageEntry<ApiType, []>;406      /**407       * Current building block's transactions and receipts.408       **/409      pending: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[EthereumTransactionTransactionV2, FpRpcTransactionStatus, EthereumReceiptReceiptV3]>>>, []> & QueryableStorageEntry<ApiType, []>;410      /**411       * Generic query412       **/413      [key: string]: QueryableStorageEntry<ApiType>;414    };415    evm: {416      accountCodes: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Bytes>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;417      accountCodesMetadata: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<PalletEvmCodeMetadata>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;418      accountStorages: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H256 | string | Uint8Array) => Observable<H256>, [H160, H256]> & QueryableStorageEntry<ApiType, [H160, H256]>;419      /**420       * Written on log, reset after transaction421       * Should be empty between transactions422       **/423      currentLogs: AugmentedQuery<ApiType, () => Observable<Vec<EthereumLog>>, []> & QueryableStorageEntry<ApiType, []>;424      /**425       * Generic query426       **/427      [key: string]: QueryableStorageEntry<ApiType>;428    };429    evmContractHelpers: {430      /**431       * Storage for users that allowed for sponsorship.432       * 433       * ### Usage434       * Prefer to delete record from storage if user no more allowed for sponsorship.435       * 436       * * **Key1** - contract address.437       * * **Key2** - user that allowed for sponsorship.438       * * **Value** - allowance for sponsorship.439       **/440      allowlist: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H160 | string | Uint8Array) => Observable<bool>, [H160, H160]> & QueryableStorageEntry<ApiType, [H160, H160]>;441      /**442       * Storege for contracts with [`Allowlisted`](SponsoringModeT::Allowlisted) sponsoring mode.443       * 444       * ### Usage445       * Prefer to delete collection from storage if mode chaged to non `Allowlisted`, than set **Value** to **false**.446       * 447       * * **Key** - contract address.448       * * **Value** - is contract in [`Allowlisted`](SponsoringModeT::Allowlisted) mode.449       **/450      allowlistEnabled: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;451      /**452       * Store owner for contract.453       * 454       * * **Key** - contract address.455       * * **Value** - owner for contract.456       **/457      owner: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<H160>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;458      /**459       * Deprecated: this storage is deprecated460       **/461      selfSponsoring: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;462      sponsorBasket: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H160 | string | Uint8Array) => Observable<Option<u32>>, [H160, H160]> & QueryableStorageEntry<ApiType, [H160, H160]>;463      /**464       * Store for contract sponsorship state.465       * 466       * * **Key** - contract address.467       * * **Value** - sponsorship state.468       **/469      sponsoring: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<UpDataStructsSponsorshipStateBasicCrossAccountIdRepr>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;470      /**471       * Storage for last sponsored block.472       * 473       * * **Key1** - contract address.474       * * **Key2** - sponsored user address.475       * * **Value** - last sponsored block number.476       **/477      sponsoringFeeLimit: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<BTreeMap<u32, U256>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;478      /**479       * Store for sponsoring mode.480       * 481       * ### Usage482       * Prefer to delete collection from storage if mode chaged to [`Disabled`](SponsoringModeT::Disabled).483       * 484       * * **Key** - contract address.485       * * **Value** - [`sponsoring mode`](SponsoringModeT).486       **/487      sponsoringMode: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<PalletEvmContractHelpersSponsoringModeT>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;488      /**489       * Storage for sponsoring rate limit in blocks.490       * 491       * * **Key** - contract address.492       * * **Value** - amount of sponsored blocks.493       **/494      sponsoringRateLimit: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<u32>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;495      /**496       * Generic query497       **/498      [key: string]: QueryableStorageEntry<ApiType>;499    };500    evmMigration: {501      migrationPending: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;502      /**503       * Generic query504       **/505      [key: string]: QueryableStorageEntry<ApiType>;506    };507    fellowshipCollective: {508      /**509       * The index of each ranks's member into the group of members who have at least that rank.510       **/511      idToIndex: AugmentedQuery<ApiType, (arg1: u16 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u16, AccountId32]> & QueryableStorageEntry<ApiType, [u16, AccountId32]>;512      /**513       * The members in the collective by index. All indices in the range `0..MemberCount` will514       * return `Some`, however a member's index is not guaranteed to remain unchanged over time.515       **/516      indexToId: AugmentedQuery<ApiType, (arg1: u16 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<AccountId32>>, [u16, u32]> & QueryableStorageEntry<ApiType, [u16, u32]>;517      /**518       * The number of members in the collective who have at least the rank according to the index519       * of the vec.520       **/521      memberCount: AugmentedQuery<ApiType, (arg: u16 | AnyNumber | Uint8Array) => Observable<u32>, [u16]> & QueryableStorageEntry<ApiType, [u16]>;522      /**523       * The current members of the collective.524       **/525      members: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletRankedCollectiveMemberRecord>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;526      /**527       * Votes on a given proposal, if it is ongoing.528       **/529      voting: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<PalletRankedCollectiveVoteRecord>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;530      votingCleanup: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<Bytes>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;531      /**532       * Generic query533       **/534      [key: string]: QueryableStorageEntry<ApiType>;535    };536    fellowshipReferenda: {537      /**538       * The number of referenda being decided currently.539       **/540      decidingCount: AugmentedQuery<ApiType, (arg: u16 | AnyNumber | Uint8Array) => Observable<u32>, [u16]> & QueryableStorageEntry<ApiType, [u16]>;541      /**542       * The metadata is a general information concerning the referendum.543       * The `PreimageHash` refers to the preimage of the `Preimages` provider which can be a JSON544       * dump or IPFS hash of a JSON file.545       * 546       * Consider a garbage collection for a metadata of finished referendums to `unrequest` (remove)547       * large preimages.548       **/549      metadataOf: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<H256>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;550      /**551       * The next free referendum index, aka the number of referenda started so far.552       **/553      referendumCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;554      /**555       * Information concerning any given referendum.556       **/557      referendumInfoFor: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletReferendaReferendumInfo>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;558      /**559       * The sorted list of referenda ready to be decided but not yet being decided, ordered by560       * conviction-weighted approvals.561       * 562       * This should be empty if `DecidingCount` is less than `TrackInfo::max_deciding`.563       **/564      trackQueue: AugmentedQuery<ApiType, (arg: u16 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, u32]>>>, [u16]> & QueryableStorageEntry<ApiType, [u16]>;565      /**566       * Generic query567       **/568      [key: string]: QueryableStorageEntry<ApiType>;569    };570    foreignAssets: {571      /**572       * The storages for assets to fungible collection binding573       * 574       **/575      assetBinding: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;576      /**577       * The storages for AssetMetadatas.578       * 579       * AssetMetadatas: map AssetIds => Option<AssetMetadata>580       **/581      assetMetadatas: AugmentedQuery<ApiType, (arg: PalletForeignAssetsAssetId | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Option<PalletForeignAssetsModuleAssetMetadata>>, [PalletForeignAssetsAssetId]> & QueryableStorageEntry<ApiType, [PalletForeignAssetsAssetId]>;582      /**583       * The storages for MultiLocations.584       * 585       * ForeignAssetLocations: map ForeignAssetId => Option<MultiLocation>586       **/587      foreignAssetLocations: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<StagingXcmV3MultiLocation>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;588      /**589       * The storages for CurrencyIds.590       * 591       * LocationToCurrencyIds: map MultiLocation => Option<ForeignAssetId>592       **/593      locationToCurrencyIds: AugmentedQuery<ApiType, (arg: StagingXcmV3MultiLocation | { parents?: any; interior?: any } | string | Uint8Array) => Observable<Option<u32>>, [StagingXcmV3MultiLocation]> & QueryableStorageEntry<ApiType, [StagingXcmV3MultiLocation]>;594      /**595       * Next available Foreign AssetId ID.596       * 597       * NextForeignAssetId: ForeignAssetId598       **/599      nextForeignAssetId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;600      /**601       * Generic query602       **/603      [key: string]: QueryableStorageEntry<ApiType>;604    };605    fungible: {606      /**607       * Storage for assets delegated to a limited extent to other users.608       **/609      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]>;610      /**611       * Amount of tokens owned by an account inside a collection.612       **/613      balance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u128>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;614      /**615       * Total amount of fungible tokens inside a collection.616       **/617      totalSupply: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;618      /**619       * Generic query620       **/621      [key: string]: QueryableStorageEntry<ApiType>;622    };623    identity: {624      /**625       * Information that is pertinent to identify the entity behind an account.626       * 627       * TWOX-NOTE: OK ― `AccountId` is a secure hash.628       **/629      identityOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletIdentityRegistration>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;630      /**631       * The set of registrars. Not expected to get very big as can only be added through a632       * special origin (likely a council motion).633       * 634       * The index into this can be cast to `RegistrarIndex` to get a valid value.635       **/636      registrars: AugmentedQuery<ApiType, () => Observable<Vec<Option<PalletIdentityRegistrarInfo>>>, []> & QueryableStorageEntry<ApiType, []>;637      /**638       * Alternative "sub" identities of this account.639       * 640       * The first item is the deposit, the second is a vector of the accounts.641       * 642       * TWOX-NOTE: OK ― `AccountId` is a secure hash.643       **/644      subsOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[u128, Vec<AccountId32>]>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;645      /**646       * The super-identity of an alternative "sub" identity together with its name, within that647       * context. If the account is not some other account's sub-identity, then just `None`.648       **/649      superOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<ITuple<[AccountId32, Data]>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;650      /**651       * Generic query652       **/653      [key: string]: QueryableStorageEntry<ApiType>;654    };655    inflation: {656      /**657       * Current inflation for `InflationBlockInterval` number of blocks658       **/659      blockInflation: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;660      /**661       * Next target (relay) block when inflation will be applied662       **/663      nextInflationBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;664      /**665       * Next target (relay) block when inflation is recalculated666       **/667      nextRecalculationBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;668      /**669       * Relay block when inflation has started670       **/671      startBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;672      /**673       * starting year total issuance674       **/675      startingYearTotalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;676      /**677       * Generic query678       **/679      [key: string]: QueryableStorageEntry<ApiType>;680    };681    maintenance: {682      enabled: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;683      /**684       * Generic query685       **/686      [key: string]: QueryableStorageEntry<ApiType>;687    };688    nonfungible: {689      /**690       * Amount of tokens owned by an account in a collection.691       **/692      accountBalance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u32>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;693      /**694       * Allowance set by a token owner for another user to perform one of certain transactions on a token.695       **/696      allowance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletEvmAccountBasicCrossAccountIdRepr>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;697      /**698       * Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.699       **/700      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]>;701      /**702       * Used to enumerate tokens owned by account.703       **/704      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]>;705      /**706       * Custom data of a token that is serialized to bytes,707       * primarily reserved for on-chain operations,708       * normally obscured from the external users.709       * 710       * Auxiliary properties are slightly different from711       * usual [`TokenProperties`] due to an unlimited number712       * and separately stored and written-to key-value pairs.713       * 714       * Currently unused.715       **/716      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]>;717      /**718       * Used to enumerate token's children.719       **/720      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]>]>;721      /**722       * Token data, used to partially describe a token.723       **/724      tokenData: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNonfungibleItemData>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;725      /**726       * Map of key-value pairs, describing the metadata of a token.727       **/728      tokenProperties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<UpDataStructsProperties>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;729      /**730       * Amount of burnt tokens in a collection.731       **/732      tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;733      /**734       * Total amount of minted tokens in a collection.735       **/736      tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;737      /**738       * Generic query739       **/740      [key: string]: QueryableStorageEntry<ApiType>;741    };742    parachainInfo: {743      parachainId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;744      /**745       * Generic query746       **/747      [key: string]: QueryableStorageEntry<ApiType>;748    };749    parachainSystem: {750      /**751       * Storage field that keeps track of bandwidth used by the unincluded segment along with the752       * latest the latest HRMP watermark. Used for limiting the acceptance of new blocks with753       * respect to relay chain constraints.754       **/755      aggregatedUnincludedSegment: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemUnincludedSegmentSegmentTracker>>, []> & QueryableStorageEntry<ApiType, []>;756      /**757       * The number of HRMP messages we observed in `on_initialize` and thus used that number for758       * announcing the weight of `on_initialize` and `on_finalize`.759       **/760      announcedHrmpMessagesPerCandidate: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;761      /**762       * The next authorized upgrade, if there is one.763       **/764      authorizedUpgrade: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemCodeUpgradeAuthorization>>, []> & QueryableStorageEntry<ApiType, []>;765      /**766       * A custom head data that should be returned as result of `validate_block`.767       * 768       * See `Pallet::set_custom_validation_head_data` for more information.769       **/770      customValidationHeadData: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;771      /**772       * Were the validation data set to notify the relay chain?773       **/774      didSetValidationCode: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;775      /**776       * The parachain host configuration that was obtained from the relay parent.777       * 778       * This field is meant to be updated each block with the validation data inherent. Therefore,779       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.780       * 781       * This data is also absent from the genesis.782       **/783      hostConfiguration: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV5AbridgedHostConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;784      /**785       * HRMP messages that were sent in a block.786       * 787       * This will be cleared in `on_initialize` of each new block.788       **/789      hrmpOutboundMessages: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotCorePrimitivesOutboundHrmpMessage>>, []> & QueryableStorageEntry<ApiType, []>;790      /**791       * HRMP watermark that was set in a block.792       * 793       * This will be cleared in `on_initialize` of each new block.794       **/795      hrmpWatermark: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;796      /**797       * The last downward message queue chain head we have observed.798       * 799       * This value is loaded before and saved after processing inbound downward messages carried800       * by the system inherent.801       **/802      lastDmqMqcHead: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;803      /**804       * The message queue chain heads we have observed per each channel incoming channel.805       * 806       * This value is loaded before and saved after processing inbound downward messages carried807       * by the system inherent.808       **/809      lastHrmpMqcHeads: AugmentedQuery<ApiType, () => Observable<BTreeMap<u32, H256>>, []> & QueryableStorageEntry<ApiType, []>;810      /**811       * The relay chain block number associated with the last parachain block.812       **/813      lastRelayChainBlockNumber: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;814      /**815       * Validation code that is set by the parachain and is to be communicated to collator and816       * consequently the relay-chain.817       * 818       * This will be cleared in `on_initialize` of each new block if no other pallet already set819       * the value.820       **/821      newValidationCode: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;822      /**823       * Upward messages that are still pending and not yet send to the relay chain.824       **/825      pendingUpwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;826      /**827       * In case of a scheduled upgrade, this storage field contains the validation code to be828       * applied.829       * 830       * As soon as the relay chain gives us the go-ahead signal, we will overwrite the831       * [`:code`][sp_core::storage::well_known_keys::CODE] which will result the next block process832       * with the new validation code. This concludes the upgrade process.833       **/834      pendingValidationCode: AugmentedQuery<ApiType, () => Observable<Bytes>, []> & QueryableStorageEntry<ApiType, []>;835      /**836       * Number of downward messages processed in a block.837       * 838       * This will be cleared in `on_initialize` of each new block.839       **/840      processedDownwardMessages: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;841      /**842       * The state proof for the last relay parent block.843       * 844       * This field is meant to be updated each block with the validation data inherent. Therefore,845       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.846       * 847       * This data is also absent from the genesis.848       **/849      relayStateProof: AugmentedQuery<ApiType, () => Observable<Option<SpTrieStorageProof>>, []> & QueryableStorageEntry<ApiType, []>;850      /**851       * The snapshot of some state related to messaging relevant to the current parachain as per852       * the relay parent.853       * 854       * This field is meant to be updated each block with the validation data inherent. Therefore,855       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.856       * 857       * This data is also absent from the genesis.858       **/859      relevantMessagingState: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot>>, []> & QueryableStorageEntry<ApiType, []>;860      /**861       * The weight we reserve at the beginning of the block for processing DMP messages. This862       * overrides the amount set in the Config trait.863       **/864      reservedDmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;865      /**866       * The weight we reserve at the beginning of the block for processing XCMP messages. This867       * overrides the amount set in the Config trait.868       **/869      reservedXcmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;870      /**871       * Latest included block descendants the runtime accepted. In other words, these are872       * ancestors of the currently executing block which have not been included in the observed873       * relay-chain state.874       * 875       * The segment length is limited by the capacity returned from the [`ConsensusHook`] configured876       * in the pallet.877       **/878      unincludedSegment: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletParachainSystemUnincludedSegmentAncestor>>, []> & QueryableStorageEntry<ApiType, []>;879      /**880       * Optional upgrade go-ahead signal from the relay-chain.881       * 882       * This storage item is a mirror of the corresponding value for the current parachain from the883       * relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is884       * set after the inherent.885       **/886      upgradeGoAhead: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV5UpgradeGoAhead>>, []> & QueryableStorageEntry<ApiType, []>;887      /**888       * An option which indicates if the relay-chain restricts signalling a validation code upgrade.889       * In other words, if this is `Some` and [`NewValidationCode`] is `Some` then the produced890       * candidate will be invalid.891       * 892       * This storage item is a mirror of the corresponding value for the current parachain from the893       * relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is894       * set after the inherent.895       **/896      upgradeRestrictionSignal: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV5UpgradeRestriction>>, []> & QueryableStorageEntry<ApiType, []>;897      /**898       * Upward messages that were sent in a block.899       * 900       * This will be cleared in `on_initialize` of each new block.901       **/902      upwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;903      /**904       * The [`PersistedValidationData`] set for this block.905       * This value is expected to be set only once per block and it's never stored906       * in the trie.907       **/908      validationData: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV5PersistedValidationData>>, []> & QueryableStorageEntry<ApiType, []>;909      /**910       * Generic query911       **/912      [key: string]: QueryableStorageEntry<ApiType>;913    };914    polkadotXcm: {915      /**916       * The existing asset traps.917       * 918       * Key is the blake2 256 hash of (origin, versioned `MultiAssets`) pair. Value is the number of919       * times this pair has been trapped (usually just 1 if it exists at all).920       **/921      assetTraps: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<u32>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;922      /**923       * The current migration's stage, if any.924       **/925      currentMigration: AugmentedQuery<ApiType, () => Observable<Option<PalletXcmVersionMigrationStage>>, []> & QueryableStorageEntry<ApiType, []>;926      /**927       * Fungible assets which we know are locked on this chain.928       **/929      lockedFungibles: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<Vec<ITuple<[u128, StagingXcmVersionedMultiLocation]>>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;930      /**931       * The ongoing queries.932       **/933      queries: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<PalletXcmQueryStatus>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;934      /**935       * The latest available query index.936       **/937      queryCounter: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;938      /**939       * Fungible assets which we know are locked on a remote chain.940       **/941      remoteLockedFungibles: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array, arg3: StagingXcmVersionedAssetId | { V3: any } | string | Uint8Array) => Observable<Option<PalletXcmRemoteLockedFungibleRecord>>, [u32, AccountId32, StagingXcmVersionedAssetId]> & QueryableStorageEntry<ApiType, [u32, AccountId32, StagingXcmVersionedAssetId]>;942      /**943       * Default version to encode XCM when latest version of destination is unknown. If `None`,944       * then the destinations whose XCM version is unknown are considered unreachable.945       **/946      safeXcmVersion: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;947      /**948       * The Latest versions that we know various locations support.949       **/950      supportedVersion: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: StagingXcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => Observable<Option<u32>>, [u32, StagingXcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, StagingXcmVersionedMultiLocation]>;951      /**952       * Destinations whose latest XCM version we would like to know. Duplicates not allowed, and953       * the `u32` counter is the number of times that a send to the destination has been attempted,954       * which is used as a prioritization.955       **/956      versionDiscoveryQueue: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[StagingXcmVersionedMultiLocation, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;957      /**958       * All locations that we have requested version notifications from.959       **/960      versionNotifiers: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: StagingXcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => Observable<Option<u64>>, [u32, StagingXcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, StagingXcmVersionedMultiLocation]>;961      /**962       * The target locations that are subscribed to our version changes, as well as the most recent963       * of our versions we informed them of.964       **/965      versionNotifyTargets: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: StagingXcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => Observable<Option<ITuple<[u64, SpWeightsWeightV2Weight, u32]>>>, [u32, StagingXcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, StagingXcmVersionedMultiLocation]>;966      /**967       * Global suspension state of the XCM executor.968       **/969      xcmExecutionSuspended: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;970      /**971       * Generic query972       **/973      [key: string]: QueryableStorageEntry<ApiType>;974    };975    preimage: {976      preimageFor: AugmentedQuery<ApiType, (arg: ITuple<[H256, u32]> | [H256 | string | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<Option<Bytes>>, [ITuple<[H256, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[H256, u32]>]>;977      /**978       * The request status of a given hash.979       **/980      statusFor: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletPreimageRequestStatus>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;981      /**982       * Generic query983       **/984      [key: string]: QueryableStorageEntry<ApiType>;985    };986    refungible: {987      /**988       * Amount of tokens (not pieces) partially owned by an account within a collection.989       **/990      accountBalance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u32>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;991      /**992       * Allowance set by a token owner for another user to perform one of certain transactions on a number of pieces of a token.993       **/994      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]>;995      /**996       * Amount of token pieces owned by account.997       **/998      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]>;999      /**1000       * Spender set by a wallet owner that could perform certain transactions on all tokens in the wallet.1001       **/1002      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]>;1003      /**1004       * Used to enumerate tokens owned by account.1005       **/1006      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]>;1007      /**1008       * Amount of pieces a refungible token is split into.1009       **/1010      tokenProperties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<UpDataStructsProperties>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1011      /**1012       * Amount of tokens burnt in a collection.1013       **/1014      tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1015      /**1016       * Total amount of minted tokens in a collection.1017       **/1018      tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1019      /**1020       * Total amount of pieces for token1021       **/1022      totalSupply: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1023      /**1024       * Generic query1025       **/1026      [key: string]: QueryableStorageEntry<ApiType>;1027    };1028    scheduler: {1029      /**1030       * Items to be executed, indexed by the block number that they should be executed on.1031       **/1032      agenda: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<Option<PalletSchedulerScheduled>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1033      incompleteSince: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;1034      /**1035       * Lookup from a name to the block number and index of the task.1036       * 1037       * For v3 -> v4 the previously unbounded identities are Blake2-256 hashed to form the v41038       * identities.1039       **/1040      lookup: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Option<ITuple<[u32, u32]>>>, [U8aFixed]> & QueryableStorageEntry<ApiType, [U8aFixed]>;1041      /**1042       * Generic query1043       **/1044      [key: string]: QueryableStorageEntry<ApiType>;1045    };1046    session: {1047      /**1048       * Current index of the session.1049       **/1050      currentIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1051      /**1052       * Indices of disabled validators.1053       * 1054       * The vec is always kept sorted so that we can find whether a given validator is1055       * disabled using binary search. It gets cleared when `on_session_ending` returns1056       * a new set of identities.1057       **/1058      disabledValidators: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;1059      /**1060       * The owner of a key. The key is the `KeyTypeId` + the encoded key.1061       **/1062      keyOwner: AugmentedQuery<ApiType, (arg: ITuple<[SpCoreCryptoKeyTypeId, Bytes]> | [SpCoreCryptoKeyTypeId | string | Uint8Array, Bytes | string | Uint8Array]) => Observable<Option<AccountId32>>, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]> & QueryableStorageEntry<ApiType, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]>;1063      /**1064       * The next session keys for a validator.1065       **/1066      nextKeys: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<OpalRuntimeRuntimeCommonSessionKeys>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;1067      /**1068       * True if the underlying economic identities or weighting behind the validators1069       * has changed in the queued validator set.1070       **/1071      queuedChanged: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;1072      /**1073       * The queued keys for the next session. When the next session begins, these keys1074       * will be used to determine the validator's session keys.1075       **/1076      queuedKeys: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[AccountId32, OpalRuntimeRuntimeCommonSessionKeys]>>>, []> & QueryableStorageEntry<ApiType, []>;1077      /**1078       * The current set of validators.1079       **/1080      validators: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;1081      /**1082       * Generic query1083       **/1084      [key: string]: QueryableStorageEntry<ApiType>;1085    };1086    stateTrieMigration: {1087      /**1088       * The limits that are imposed on automatic migrations.1089       * 1090       * If set to None, then no automatic migration happens.1091       **/1092      autoLimits: AugmentedQuery<ApiType, () => Observable<Option<PalletStateTrieMigrationMigrationLimits>>, []> & QueryableStorageEntry<ApiType, []>;1093      /**1094       * Migration progress.1095       * 1096       * This stores the snapshot of the last migrated keys. It can be set into motion and move1097       * forward by any of the means provided by this pallet.1098       **/1099      migrationProcess: AugmentedQuery<ApiType, () => Observable<PalletStateTrieMigrationMigrationTask>, []> & QueryableStorageEntry<ApiType, []>;1100      /**1101       * The maximum limits that the signed migration could use.1102       * 1103       * If not set, no signed submission is allowed.1104       **/1105      signedMigrationMaxLimits: AugmentedQuery<ApiType, () => Observable<Option<PalletStateTrieMigrationMigrationLimits>>, []> & QueryableStorageEntry<ApiType, []>;1106      /**1107       * Generic query1108       **/1109      [key: string]: QueryableStorageEntry<ApiType>;1110    };1111    sudo: {1112      /**1113       * The `AccountId` of the sudo key.1114       **/1115      key: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;1116      /**1117       * Generic query1118       **/1119      [key: string]: QueryableStorageEntry<ApiType>;1120    };1121    system: {1122      /**1123       * The full account information for a particular account ID.1124       **/1125      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<FrameSystemAccountInfo>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;1126      /**1127       * Total length (in bytes) for all extrinsics put together, for the current block.1128       **/1129      allExtrinsicsLen: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;1130      /**1131       * Map of block numbers to block hashes.1132       **/1133      blockHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<H256>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1134      /**1135       * The current weight for the block.1136       **/1137      blockWeight: AugmentedQuery<ApiType, () => Observable<FrameSupportDispatchPerDispatchClassWeight>, []> & QueryableStorageEntry<ApiType, []>;1138      /**1139       * Digest of the current block, also part of the block header.1140       **/1141      digest: AugmentedQuery<ApiType, () => Observable<SpRuntimeDigest>, []> & QueryableStorageEntry<ApiType, []>;1142      /**1143       * The number of events in the `Events<T>` list.1144       **/1145      eventCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1146      /**1147       * Events deposited for the current block.1148       * 1149       * NOTE: The item is unbound and should therefore never be read on chain.1150       * It could otherwise inflate the PoV size of a block.1151       * 1152       * Events have a large in-memory size. Box the events to not go out-of-memory1153       * just in case someone still reads them from within the runtime.1154       **/1155      events: AugmentedQuery<ApiType, () => Observable<Vec<FrameSystemEventRecord>>, []> & QueryableStorageEntry<ApiType, []>;1156      /**1157       * Mapping between a topic (represented by T::Hash) and a vector of indexes1158       * of events in the `<Events<T>>` list.1159       * 1160       * All topic vectors have deterministic storage locations depending on the topic. This1161       * allows light-clients to leverage the changes trie storage tracking mechanism and1162       * in case of changes fetch the list of events of interest.1163       * 1164       * The value has the type `(BlockNumberFor<T>, EventIndex)` because if we used only just1165       * the `EventIndex` then in case if the topic has the same contents on the next block1166       * no notification will be triggered thus the event might be lost.1167       **/1168      eventTopics: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Vec<ITuple<[u32, u32]>>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;1169      /**1170       * The execution phase of the block.1171       **/1172      executionPhase: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemPhase>>, []> & QueryableStorageEntry<ApiType, []>;1173      /**1174       * Total extrinsics count for the current block.1175       **/1176      extrinsicCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;1177      /**1178       * Extrinsics data for the current block (maps an extrinsic's index to its data).1179       **/1180      extrinsicData: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1181      /**1182       * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.1183       **/1184      lastRuntimeUpgrade: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemLastRuntimeUpgradeInfo>>, []> & QueryableStorageEntry<ApiType, []>;1185      /**1186       * The current block number being processed. Set by `execute_block`.1187       **/1188      number: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1189      /**1190       * Hash of the previous block.1191       **/1192      parentHash: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;1193      /**1194       * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False1195       * (default) if not.1196       **/1197      upgradedToTripleRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;1198      /**1199       * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.1200       **/1201      upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;1202      /**1203       * Generic query1204       **/1205      [key: string]: QueryableStorageEntry<ApiType>;1206    };1207    technicalCommittee: {1208      /**1209       * The current members of the collective. This is stored sorted (just by value).1210       **/1211      members: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;1212      /**1213       * The prime member that helps determine the default vote behavior in case of absentations.1214       **/1215      prime: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;1216      /**1217       * Proposals so far.1218       **/1219      proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1220      /**1221       * Actual proposal for a given hash, if it's current.1222       **/1223      proposalOf: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<Call>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;1224      /**1225       * The hashes of the active proposals.1226       **/1227      proposals: AugmentedQuery<ApiType, () => Observable<Vec<H256>>, []> & QueryableStorageEntry<ApiType, []>;1228      /**1229       * Votes on a given proposal, if it is ongoing.1230       **/1231      voting: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletCollectiveVotes>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;1232      /**1233       * Generic query1234       **/1235      [key: string]: QueryableStorageEntry<ApiType>;1236    };1237    technicalCommitteeMembership: {1238      /**1239       * The current membership, stored as an ordered Vec.1240       **/1241      members: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;1242      /**1243       * The current prime member, if one exists.1244       **/1245      prime: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;1246      /**1247       * Generic query1248       **/1249      [key: string]: QueryableStorageEntry<ApiType>;1250    };1251    testUtils: {1252      enabled: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;1253      testValue: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1254      /**1255       * Generic query1256       **/1257      [key: string]: QueryableStorageEntry<ApiType>;1258    };1259    timestamp: {1260      /**1261       * Did the timestamp get updated in this block?1262       **/1263      didUpdate: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;1264      /**1265       * Current time for the current block.1266       **/1267      now: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;1268      /**1269       * Generic query1270       **/1271      [key: string]: QueryableStorageEntry<ApiType>;1272    };1273    tokens: {1274      /**1275       * The balance of a token type under an account.1276       * 1277       * NOTE: If the total is ever zero, decrease account ref account.1278       * 1279       * NOTE: This is only used in the case that this module is used to store1280       * balances.1281       **/1282      accounts: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetId | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<OrmlTokensAccountData>, [AccountId32, PalletForeignAssetsAssetId]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetId]>;1283      /**1284       * Any liquidity locks of a token type under an account.1285       * NOTE: Should only be accessed when setting, changing and freeing a lock.1286       **/1287      locks: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetId | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Vec<OrmlTokensBalanceLock>>, [AccountId32, PalletForeignAssetsAssetId]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetId]>;1288      /**1289       * Named reserves on some account balances.1290       **/1291      reserves: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetId | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Vec<OrmlTokensReserveData>>, [AccountId32, PalletForeignAssetsAssetId]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetId]>;1292      /**1293       * The total issuance of a token type.1294       **/1295      totalIssuance: AugmentedQuery<ApiType, (arg: PalletForeignAssetsAssetId | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<u128>, [PalletForeignAssetsAssetId]> & QueryableStorageEntry<ApiType, [PalletForeignAssetsAssetId]>;1296      /**1297       * Generic query1298       **/1299      [key: string]: QueryableStorageEntry<ApiType>;1300    };1301    transactionPayment: {1302      nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;1303      storageVersion: AugmentedQuery<ApiType, () => Observable<PalletTransactionPaymentReleases>, []> & QueryableStorageEntry<ApiType, []>;1304      /**1305       * Generic query1306       **/1307      [key: string]: QueryableStorageEntry<ApiType>;1308    };1309    treasury: {1310      /**1311       * Proposal indices that have been approved but not yet awarded.1312       **/1313      approvals: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;1314      /**1315       * The amount which has been reported as inactive to Currency.1316       **/1317      deactivated: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;1318      /**1319       * Number of proposals that have been made.1320       **/1321      proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1322      /**1323       * Proposals that have been made.1324       **/1325      proposals: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletTreasuryProposal>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1326      /**1327       * Generic query1328       **/1329      [key: string]: QueryableStorageEntry<ApiType>;1330    };1331    unique: {1332      /**1333       * Used for migrations1334       **/1335      chainVersion: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;1336      /**1337       * (Collection id (controlled?2), who created (real))1338       * TODO: Off chain worker should remove from this map when collection gets removed1339       **/1340      createItemBasket: AugmentedQuery<ApiType, (arg: ITuple<[u32, AccountId32]> | [u32 | AnyNumber | Uint8Array, AccountId32 | string | Uint8Array]) => Observable<Option<u32>>, [ITuple<[u32, AccountId32]>]> & QueryableStorageEntry<ApiType, [ITuple<[u32, AccountId32]>]>;1341      /**1342       * Last sponsoring of fungible tokens approval in a collection1343       **/1344      fungibleApproveBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;1345      /**1346       * Collection id (controlled?2), owning user (real)1347       **/1348      fungibleTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;1349      /**1350       * Last sponsoring of NFT approval in a collection1351       **/1352      nftApproveBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1353      /**1354       * Collection id (controlled?2), token id (controlled?2)1355       **/1356      nftTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1357      /**1358       * Last sponsoring of RFT approval in a collection1359       **/1360      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]>;1361      /**1362       * Collection id (controlled?2), token id (controlled?2)1363       **/1364      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]>;1365      /**1366       * Last sponsoring of token property setting // todo:doc rephrase this and the following1367       **/1368      tokenPropertyBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1369      /**1370       * Generic query1371       **/1372      [key: string]: QueryableStorageEntry<ApiType>;1373    };1374    vesting: {1375      /**1376       * Vesting schedules of an account.1377       * 1378       * VestingSchedules: map AccountId => Vec<VestingSchedule>1379       **/1380      vestingSchedules: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<OrmlVestingVestingSchedule>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;1381      /**1382       * Generic query1383       **/1384      [key: string]: QueryableStorageEntry<ApiType>;1385    };1386    xcmpQueue: {1387      /**1388       * Counter for the related counted storage map1389       **/1390      counterForOverweight: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1391      /**1392       * Inbound aggregate XCMP messages. It can only be one per ParaId/block.1393       **/1394      inboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1395      /**1396       * Status of the inbound XCMP channels.1397       **/1398      inboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueInboundChannelDetails>>, []> & QueryableStorageEntry<ApiType, []>;1399      /**1400       * The messages outbound in a given XCMP channel.1401       **/1402      outboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u16 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u16]> & QueryableStorageEntry<ApiType, [u32, u16]>;1403      /**1404       * The non-empty XCMP channels in order of becoming non-empty, and the index of the first1405       * and last outbound message. If the two indices are equal, then it indicates an empty1406       * queue and there must be a non-`Ok` `OutboundStatus`. We assume queues grow no greater1407       * than 65535 items. Queue indices for normal messages begin at one; zero is reserved in1408       * case of the need to send a high-priority signal message this block.1409       * The bool is true if there is a signal message waiting to be sent.1410       **/1411      outboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueOutboundChannelDetails>>, []> & QueryableStorageEntry<ApiType, []>;1412      /**1413       * The messages that exceeded max individual message weight budget.1414       * 1415       * These message stay in this storage map until they are manually dispatched via1416       * `service_overweight`.1417       **/1418      overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;1419      /**1420       * The number of overweight messages ever recorded in `Overweight`. Also doubles as the next1421       * available free overweight index.1422       **/1423      overweightCount: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;1424      /**1425       * The configuration which controls the dynamics of the outbound queue.1426       **/1427      queueConfig: AugmentedQuery<ApiType, () => Observable<CumulusPalletXcmpQueueQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;1428      /**1429       * Whether or not the XCMP queue is suspended from executing incoming XCMs or not.1430       **/1431      queueSuspended: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;1432      /**1433       * Any signal messages waiting to be sent.1434       **/1435      signalMessages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1436      /**1437       * Generic query1438       **/1439      [key: string]: QueryableStorageEntry<ApiType>;1440    };1441  } // AugmentedQueries1442} // declare module