git.delta.rocks / unique-network / refs/commits / cfd200020468

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 { BTreeMap, Bytes, Option, U256, U8aFixed, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';10import type { AnyNumber, ITuple } from '@polkadot/types-codec/types';11import type { AccountId32, H160, H256 } from '@polkadot/types/interfaces/runtime';12import type { CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, EthereumBlock, EthereumLog, EthereumReceiptReceiptV3, EthereumTransactionTransactionV2, FpRpcTransactionStatus, FrameSupportDispatchPerDispatchClassWeight, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, OrmlTokensAccountData, OrmlTokensBalanceLock, OrmlTokensReserveData, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReleases, PalletBalancesReserveData, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmContractHelpersSponsoringModeT, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletNonfungibleItemData, PalletRefungibleItemData, PalletTransactionPaymentReleases, PalletTreasuryProposal, PalletUniqueSchedulerV2BlockAgenda, PhantomTypeUpDataStructs, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpRuntimeDigest, SpTrieStorageProof, SpWeightsWeightV2Weight, UpDataStructsCollection, UpDataStructsCollectionStats, UpDataStructsProperties, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsPropertyPermission, UpDataStructsPropertyScope, UpDataStructsSponsorshipStateBasicCrossAccountIdRepr, UpDataStructsTokenChild, XcmV1MultiLocation } from '@polkadot/types/lookup';13import type { Observable } from '@polkadot/types/types';1415export type __AugmentedQuery<ApiType extends ApiTypes> = AugmentedQuery<ApiType, () => unknown>;16export type __QueryableStorageEntry<ApiType extends ApiTypes> = QueryableStorageEntry<ApiType>;1718declare module '@polkadot/api-base/types/storage' {19  interface AugmentedQueries<ApiType extends ApiTypes> {20    appPromotion: {21      /**22       * Stores the `admin` account. Some extrinsics can only be executed if they were signed by `admin`.23       **/24      admin: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;25      /**26       * Stores a key for record for which the next revenue recalculation would be performed.27       * If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.28       **/29      nextCalculatedRecord: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[AccountId32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;30      /**31       * Stores amount of stakes for an `Account`.32       * 33       * * **Key** - Staker account.34       * * **Value** - Amount of stakes.35       **/36      pendingUnstake: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[AccountId32, u128]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;37      /**38       * Stores the amount of tokens staked by account in the blocknumber.39       * 40       * * **Key1** - Staker account.41       * * **Key2** - Relay block number when the stake was made.42       * * **(Balance, BlockNumber)** - Balance of the stake.43       * The number of the relay block in which we must perform the interest recalculation44       **/45      staked: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<ITuple<[u128, u32]>>, [AccountId32, u32]> & QueryableStorageEntry<ApiType, [AccountId32, u32]>;46      /**47       * Stores amount of stakes for an `Account`.48       * 49       * * **Key** - Staker account.50       * * **Value** - Amount of stakes.51       **/52      stakesPerAccount: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u8>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;53      /**54       * Stores the total staked amount.55       **/56      totalStaked: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;57      /**58       * Generic query59       **/60      [key: string]: QueryableStorageEntry<ApiType>;61    };62    balances: {63      /**64       * The Balances pallet example of storing the balance of an account.65       * 66       * # Example67       * 68       * ```nocompile69       * impl pallet_balances::Config for Runtime {70       * type AccountStore = StorageMapShim<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>71       * }72       * ```73       * 74       * You can also store the balance of an account in the `System` pallet.75       * 76       * # Example77       * 78       * ```nocompile79       * impl pallet_balances::Config for Runtime {80       * type AccountStore = System81       * }82       * ```83       * 84       * But this comes with tradeoffs, storing account balances in the system pallet stores85       * `frame_system` data alongside the account data contrary to storing account balances in the86       * `Balances` pallet, which uses a `StorageMap` to store balances data only.87       * NOTE: This is only used in the case that this pallet is used to store balances.88       **/89      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletBalancesAccountData>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;90      /**91       * Any liquidity locks on some account balances.92       * NOTE: Should only be accessed when setting, changing and freeing a lock.93       **/94      locks: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesBalanceLock>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;95      /**96       * Named reserves on some account balances.97       **/98      reserves: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesReserveData>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;99      /**100       * Storage version of the pallet.101       * 102       * This is set to v2.0.0 for new networks.103       **/104      storageVersion: AugmentedQuery<ApiType, () => Observable<PalletBalancesReleases>, []> & QueryableStorageEntry<ApiType, []>;105      /**106       * The total units issued in the system.107       **/108      totalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;109      /**110       * Generic query111       **/112      [key: string]: QueryableStorageEntry<ApiType>;113    };114    charging: {115      /**116       * Generic query117       **/118      [key: string]: QueryableStorageEntry<ApiType>;119    };120    common: {121      /**122       * Storage of the amount of collection admins.123       **/124      adminAmount: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;125      /**126       * Allowlisted collection users.127       **/128      allowlist: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;129      /**130       * Storage of collection info.131       **/132      collectionById: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<UpDataStructsCollection>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;133      /**134       * Storage of collection properties.135       **/136      collectionProperties: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;137      /**138       * Storage of token property permissions of a collection.139       **/140      collectionPropertyPermissions: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<BTreeMap<Bytes, UpDataStructsPropertyPermission>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;141      /**142       * Storage of the count of created collections. Essentially contains the last collection ID.143       **/144      createdCollectionCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;145      /**146       * Storage of the count of deleted collections.147       **/148      destroyedCollectionCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;149      /**150       * Not used by code, exists only to provide some types to metadata.151       **/152      dummyStorageValue: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[UpDataStructsCollectionStats, u32, u32, UpDataStructsTokenChild, PhantomTypeUpDataStructs]>>>, []> & QueryableStorageEntry<ApiType, []>;153      /**154       * List of collection admins.155       **/156      isAdmin: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;157      /**158       * Generic query159       **/160      [key: string]: QueryableStorageEntry<ApiType>;161    };162    configuration: {163      minGasPriceOverride: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;164      weightToFeeCoefficientOverride: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;165      /**166       * Generic query167       **/168      [key: string]: QueryableStorageEntry<ApiType>;169    };170    dmpQueue: {171      /**172       * The configuration.173       **/174      configuration: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;175      /**176       * The overweight messages.177       **/178      overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;179      /**180       * The page index.181       **/182      pageIndex: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueuePageIndexData>, []> & QueryableStorageEntry<ApiType, []>;183      /**184       * The queue pages.185       **/186      pages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, Bytes]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;187      /**188       * Generic query189       **/190      [key: string]: QueryableStorageEntry<ApiType>;191    };192    ethereum: {193      blockHash: AugmentedQuery<ApiType, (arg: U256 | AnyNumber | Uint8Array) => Observable<H256>, [U256]> & QueryableStorageEntry<ApiType, [U256]>;194      /**195       * The current Ethereum block.196       **/197      currentBlock: AugmentedQuery<ApiType, () => Observable<Option<EthereumBlock>>, []> & QueryableStorageEntry<ApiType, []>;198      /**199       * The current Ethereum receipts.200       **/201      currentReceipts: AugmentedQuery<ApiType, () => Observable<Option<Vec<EthereumReceiptReceiptV3>>>, []> & QueryableStorageEntry<ApiType, []>;202      /**203       * The current transaction statuses.204       **/205      currentTransactionStatuses: AugmentedQuery<ApiType, () => Observable<Option<Vec<FpRpcTransactionStatus>>>, []> & QueryableStorageEntry<ApiType, []>;206      /**207       * Injected transactions should have unique nonce, here we store current208       **/209      injectedNonce: AugmentedQuery<ApiType, () => Observable<U256>, []> & QueryableStorageEntry<ApiType, []>;210      /**211       * Current building block's transactions and receipts.212       **/213      pending: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[EthereumTransactionTransactionV2, FpRpcTransactionStatus, EthereumReceiptReceiptV3]>>>, []> & QueryableStorageEntry<ApiType, []>;214      /**215       * Generic query216       **/217      [key: string]: QueryableStorageEntry<ApiType>;218    };219    evm: {220      accountCodes: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Bytes>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;221      accountStorages: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H256 | string | Uint8Array) => Observable<H256>, [H160, H256]> & QueryableStorageEntry<ApiType, [H160, H256]>;222      /**223       * Written on log, reset after transaction224       * Should be empty between transactions225       **/226      currentLogs: AugmentedQuery<ApiType, () => Observable<Vec<EthereumLog>>, []> & QueryableStorageEntry<ApiType, []>;227      /**228       * Generic query229       **/230      [key: string]: QueryableStorageEntry<ApiType>;231    };232    evmCoderSubstrate: {233      /**234       * Generic query235       **/236      [key: string]: QueryableStorageEntry<ApiType>;237    };238    evmContractHelpers: {239      /**240       * Storage for users that allowed for sponsorship.241       * 242       * ### Usage243       * Prefer to delete record from storage if user no more allowed for sponsorship.244       * 245       * * **Key1** - contract address.246       * * **Key2** - user that allowed for sponsorship.247       * * **Value** - allowance for sponsorship.248       **/249      allowlist: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H160 | string | Uint8Array) => Observable<bool>, [H160, H160]> & QueryableStorageEntry<ApiType, [H160, H160]>;250      /**251       * Storege for contracts with [`Allowlisted`](SponsoringModeT::Allowlisted) sponsoring mode.252       * 253       * ### Usage254       * Prefer to delete collection from storage if mode chaged to non `Allowlisted`, than set **Value** to **false**.255       * 256       * * **Key** - contract address.257       * * **Value** - is contract in [`Allowlisted`](SponsoringModeT::Allowlisted) mode.258       **/259      allowlistEnabled: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;260      /**261       * Store owner for contract.262       * 263       * * **Key** - contract address.264       * * **Value** - owner for contract.265       **/266      owner: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<H160>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;267      selfSponsoring: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;268      sponsorBasket: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H160 | string | Uint8Array) => Observable<Option<u32>>, [H160, H160]> & QueryableStorageEntry<ApiType, [H160, H160]>;269      /**270       * Store for contract sponsorship state.271       * 272       * * **Key** - contract address.273       * * **Value** - sponsorship state.274       **/275      sponsoring: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<UpDataStructsSponsorshipStateBasicCrossAccountIdRepr>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;276      /**277       * Storage for last sponsored block.278       * 279       * * **Key1** - contract address.280       * * **Key2** - sponsored user address.281       * * **Value** - last sponsored block number.282       **/283      sponsoringFeeLimit: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<BTreeMap<u32, U256>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;284      /**285       * Store for sponsoring mode.286       * 287       * ### Usage288       * Prefer to delete collection from storage if mode chaged to [`Disabled`](SponsoringModeT::Disabled).289       * 290       * * **Key** - contract address.291       * * **Value** - [`sponsoring mode`](SponsoringModeT).292       **/293      sponsoringMode: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<PalletEvmContractHelpersSponsoringModeT>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;294      /**295       * Storage for sponsoring rate limit in blocks.296       * 297       * * **Key** - contract address.298       * * **Value** - amount of sponsored blocks.299       **/300      sponsoringRateLimit: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<u32>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;301      /**302       * Generic query303       **/304      [key: string]: QueryableStorageEntry<ApiType>;305    };306    evmMigration: {307      migrationPending: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;308      /**309       * Generic query310       **/311      [key: string]: QueryableStorageEntry<ApiType>;312    };313    foreignAssets: {314      /**315       * The storages for assets to fungible collection binding316       * 317       **/318      assetBinding: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;319      /**320       * The storages for AssetMetadatas.321       * 322       * AssetMetadatas: map AssetIds => Option<AssetMetadata>323       **/324      assetMetadatas: AugmentedQuery<ApiType, (arg: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Option<PalletForeignAssetsModuleAssetMetadata>>, [PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [PalletForeignAssetsAssetIds]>;325      /**326       * The storages for MultiLocations.327       * 328       * ForeignAssetLocations: map ForeignAssetId => Option<MultiLocation>329       **/330      foreignAssetLocations: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<XcmV1MultiLocation>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;331      /**332       * The storages for CurrencyIds.333       * 334       * LocationToCurrencyIds: map MultiLocation => Option<ForeignAssetId>335       **/336      locationToCurrencyIds: AugmentedQuery<ApiType, (arg: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array) => Observable<Option<u32>>, [XcmV1MultiLocation]> & QueryableStorageEntry<ApiType, [XcmV1MultiLocation]>;337      /**338       * Next available Foreign AssetId ID.339       * 340       * NextForeignAssetId: ForeignAssetId341       **/342      nextForeignAssetId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;343      /**344       * Generic query345       **/346      [key: string]: QueryableStorageEntry<ApiType>;347    };348    fungible: {349      /**350       * Storage for assets delegated to a limited extent to other users.351       **/352      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]>;353      /**354       * Amount of tokens owned by an account inside a collection.355       **/356      balance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u128>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;357      /**358       * Total amount of fungible tokens inside a collection.359       **/360      totalSupply: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;361      /**362       * Generic query363       **/364      [key: string]: QueryableStorageEntry<ApiType>;365    };366    inflation: {367      /**368       * Current inflation for `InflationBlockInterval` number of blocks369       **/370      blockInflation: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;371      /**372       * Next target (relay) block when inflation will be applied373       **/374      nextInflationBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;375      /**376       * Next target (relay) block when inflation is recalculated377       **/378      nextRecalculationBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;379      /**380       * Relay block when inflation has started381       **/382      startBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;383      /**384       * starting year total issuance385       **/386      startingYearTotalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;387      /**388       * Generic query389       **/390      [key: string]: QueryableStorageEntry<ApiType>;391    };392    maintenance: {393      enabled: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;394      /**395       * Generic query396       **/397      [key: string]: QueryableStorageEntry<ApiType>;398    };399    nonfungible: {400      /**401       * Amount of tokens owned by an account in a collection.402       **/403      accountBalance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u32>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;404      /**405       * Allowance set by a token owner for another user to perform one of certain transactions on a token.406       **/407      allowance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletEvmAccountBasicCrossAccountIdRepr>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;408      /**409       * Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.410       **/411      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]>;412      /**413       * Used to enumerate tokens owned by account.414       **/415      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]>;416      /**417       * Custom data of a token that is serialized to bytes,418       * primarily reserved for on-chain operations,419       * normally obscured from the external users.420       * 421       * Auxiliary properties are slightly different from422       * usual [`TokenProperties`] due to an unlimited number423       * and separately stored and written-to key-value pairs.424       * 425       * Currently used to store RMRK data.426       **/427      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]>;428      /**429       * Used to enumerate token's children.430       **/431      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]>]>;432      /**433       * Token data, used to partially describe a token.434       **/435      tokenData: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNonfungibleItemData>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;436      /**437       * Map of key-value pairs, describing the metadata of a token.438       **/439      tokenProperties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;440      /**441       * Amount of burnt tokens in a collection.442       **/443      tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;444      /**445       * Total amount of minted tokens in a collection.446       **/447      tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;448      /**449       * Generic query450       **/451      [key: string]: QueryableStorageEntry<ApiType>;452    };453    parachainInfo: {454      parachainId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;455      /**456       * Generic query457       **/458      [key: string]: QueryableStorageEntry<ApiType>;459    };460    parachainSystem: {461      /**462       * The number of HRMP messages we observed in `on_initialize` and thus used that number for463       * announcing the weight of `on_initialize` and `on_finalize`.464       **/465      announcedHrmpMessagesPerCandidate: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;466      /**467       * The next authorized upgrade, if there is one.468       **/469      authorizedUpgrade: AugmentedQuery<ApiType, () => Observable<Option<H256>>, []> & QueryableStorageEntry<ApiType, []>;470      /**471       * A custom head data that should be returned as result of `validate_block`.472       * 473       * See [`Pallet::set_custom_validation_head_data`] for more information.474       **/475      customValidationHeadData: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;476      /**477       * Were the validation data set to notify the relay chain?478       **/479      didSetValidationCode: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;480      /**481       * The parachain host configuration that was obtained from the relay parent.482       * 483       * This field is meant to be updated each block with the validation data inherent. Therefore,484       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.485       * 486       * This data is also absent from the genesis.487       **/488      hostConfiguration: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV2AbridgedHostConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;489      /**490       * HRMP messages that were sent in a block.491       * 492       * This will be cleared in `on_initialize` of each new block.493       **/494      hrmpOutboundMessages: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotCorePrimitivesOutboundHrmpMessage>>, []> & QueryableStorageEntry<ApiType, []>;495      /**496       * HRMP watermark that was set in a block.497       * 498       * This will be cleared in `on_initialize` of each new block.499       **/500      hrmpWatermark: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;501      /**502       * The last downward message queue chain head we have observed.503       * 504       * This value is loaded before and saved after processing inbound downward messages carried505       * by the system inherent.506       **/507      lastDmqMqcHead: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;508      /**509       * The message queue chain heads we have observed per each channel incoming channel.510       * 511       * This value is loaded before and saved after processing inbound downward messages carried512       * by the system inherent.513       **/514      lastHrmpMqcHeads: AugmentedQuery<ApiType, () => Observable<BTreeMap<u32, H256>>, []> & QueryableStorageEntry<ApiType, []>;515      /**516       * The relay chain block number associated with the last parachain block.517       **/518      lastRelayChainBlockNumber: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;519      /**520       * Validation code that is set by the parachain and is to be communicated to collator and521       * consequently the relay-chain.522       * 523       * This will be cleared in `on_initialize` of each new block if no other pallet already set524       * the value.525       **/526      newValidationCode: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;527      /**528       * Upward messages that are still pending and not yet send to the relay chain.529       **/530      pendingUpwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;531      /**532       * In case of a scheduled upgrade, this storage field contains the validation code to be applied.533       * 534       * As soon as the relay chain gives us the go-ahead signal, we will overwrite the [`:code`][well_known_keys::CODE]535       * which will result the next block process with the new validation code. This concludes the upgrade process.536       * 537       * [well_known_keys::CODE]: sp_core::storage::well_known_keys::CODE538       **/539      pendingValidationCode: AugmentedQuery<ApiType, () => Observable<Bytes>, []> & QueryableStorageEntry<ApiType, []>;540      /**541       * Number of downward messages processed in a block.542       * 543       * This will be cleared in `on_initialize` of each new block.544       **/545      processedDownwardMessages: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;546      /**547       * The state proof for the last relay parent block.548       * 549       * This field is meant to be updated each block with the validation data inherent. Therefore,550       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.551       * 552       * This data is also absent from the genesis.553       **/554      relayStateProof: AugmentedQuery<ApiType, () => Observable<Option<SpTrieStorageProof>>, []> & QueryableStorageEntry<ApiType, []>;555      /**556       * The snapshot of some state related to messaging relevant to the current parachain as per557       * the relay parent.558       * 559       * This field is meant to be updated each block with the validation data inherent. Therefore,560       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.561       * 562       * This data is also absent from the genesis.563       **/564      relevantMessagingState: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot>>, []> & QueryableStorageEntry<ApiType, []>;565      /**566       * The weight we reserve at the beginning of the block for processing DMP messages. This567       * overrides the amount set in the Config trait.568       **/569      reservedDmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;570      /**571       * The weight we reserve at the beginning of the block for processing XCMP messages. This572       * overrides the amount set in the Config trait.573       **/574      reservedXcmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;575      /**576       * An option which indicates if the relay-chain restricts signalling a validation code upgrade.577       * In other words, if this is `Some` and [`NewValidationCode`] is `Some` then the produced578       * candidate will be invalid.579       * 580       * This storage item is a mirror of the corresponding value for the current parachain from the581       * relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is582       * set after the inherent.583       **/584      upgradeRestrictionSignal: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV2UpgradeRestriction>>, []> & QueryableStorageEntry<ApiType, []>;585      /**586       * Upward messages that were sent in a block.587       * 588       * This will be cleared in `on_initialize` of each new block.589       **/590      upwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;591      /**592       * The [`PersistedValidationData`] set for this block.593       * This value is expected to be set only once per block and it's never stored594       * in the trie.595       **/596      validationData: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV2PersistedValidationData>>, []> & QueryableStorageEntry<ApiType, []>;597      /**598       * Generic query599       **/600      [key: string]: QueryableStorageEntry<ApiType>;601    };602    randomnessCollectiveFlip: {603      /**604       * Series of block headers from the last 81 blocks that acts as random seed material. This605       * is arranged as a ring buffer with `block_number % 81` being the index into the `Vec` of606       * the oldest hash.607       **/608      randomMaterial: AugmentedQuery<ApiType, () => Observable<Vec<H256>>, []> & QueryableStorageEntry<ApiType, []>;609      /**610       * Generic query611       **/612      [key: string]: QueryableStorageEntry<ApiType>;613    };614    refungible: {615      /**616       * Amount of tokens (not pieces) partially owned by an account within a collection.617       **/618      accountBalance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u32>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;619      /**620       * Allowance set by a token owner for another user to perform one of certain transactions on a number of pieces of a token.621       **/622      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]>;623      /**624       * Amount of token pieces owned by account.625       **/626      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]>;627      /**628       * Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.629       **/630      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]>;631      /**632       * Used to enumerate tokens owned by account.633       **/634      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]>;635      /**636       * Token data, used to partially describe a token.637       **/638      tokenData: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<PalletRefungibleItemData>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;639      /**640       * Amount of pieces a refungible token is split into.641       **/642      tokenProperties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;643      /**644       * Amount of tokens burnt in a collection.645       **/646      tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;647      /**648       * Total amount of minted tokens in a collection.649       **/650      tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;651      /**652       * Total amount of pieces for token653       **/654      totalSupply: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;655      /**656       * Generic query657       **/658      [key: string]: QueryableStorageEntry<ApiType>;659    };660    rmrkCore: {661      /**662       * Latest yet-unused collection ID.663       **/664      collectionIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;665      /**666       * Mapping from RMRK collection ID to Unique's.667       **/668      uniqueCollectionId: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;669      /**670       * Generic query671       **/672      [key: string]: QueryableStorageEntry<ApiType>;673    };674    rmrkEquip: {675      /**676       * Checkmark that a Base has a Theme NFT named "default".677       **/678      baseHasDefaultTheme: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<bool>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;679      /**680       * Map of a Base ID and a Part ID to an NFT in the Base collection serving as the Part.681       **/682      inernalPartId: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;683      /**684       * Generic query685       **/686      [key: string]: QueryableStorageEntry<ApiType>;687    };688    scheduler: {689      /**690       * Items to be executed, indexed by the block number that they should be executed on.691       **/692      agenda: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<PalletUniqueSchedulerV2BlockAgenda>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;693      /**694       * It contains the block number from which we should service tasks.695       * It's used for delaying the servicing of future blocks' agendas if we had overweight tasks.696       **/697      incompleteSince: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;698      /**699       * Lookup from a name to the block number and index of the task.700       **/701      lookup: AugmentedQuery<ApiType, (arg: U8aFixed | string | Uint8Array) => Observable<Option<ITuple<[u32, u32]>>>, [U8aFixed]> & QueryableStorageEntry<ApiType, [U8aFixed]>;702      /**703       * Generic query704       **/705      [key: string]: QueryableStorageEntry<ApiType>;706    };707    structure: {708      /**709       * Generic query710       **/711      [key: string]: QueryableStorageEntry<ApiType>;712    };713    sudo: {714      /**715       * The `AccountId` of the sudo key.716       **/717      key: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;718      /**719       * Generic query720       **/721      [key: string]: QueryableStorageEntry<ApiType>;722    };723    system: {724      /**725       * The full account information for a particular account ID.726       **/727      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<FrameSystemAccountInfo>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;728      /**729       * Total length (in bytes) for all extrinsics put together, for the current block.730       **/731      allExtrinsicsLen: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;732      /**733       * Map of block numbers to block hashes.734       **/735      blockHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<H256>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;736      /**737       * The current weight for the block.738       **/739      blockWeight: AugmentedQuery<ApiType, () => Observable<FrameSupportDispatchPerDispatchClassWeight>, []> & QueryableStorageEntry<ApiType, []>;740      /**741       * Digest of the current block, also part of the block header.742       **/743      digest: AugmentedQuery<ApiType, () => Observable<SpRuntimeDigest>, []> & QueryableStorageEntry<ApiType, []>;744      /**745       * The number of events in the `Events<T>` list.746       **/747      eventCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;748      /**749       * Events deposited for the current block.750       * 751       * NOTE: The item is unbound and should therefore never be read on chain.752       * It could otherwise inflate the PoV size of a block.753       * 754       * Events have a large in-memory size. Box the events to not go out-of-memory755       * just in case someone still reads them from within the runtime.756       **/757      events: AugmentedQuery<ApiType, () => Observable<Vec<FrameSystemEventRecord>>, []> & QueryableStorageEntry<ApiType, []>;758      /**759       * Mapping between a topic (represented by T::Hash) and a vector of indexes760       * of events in the `<Events<T>>` list.761       * 762       * All topic vectors have deterministic storage locations depending on the topic. This763       * allows light-clients to leverage the changes trie storage tracking mechanism and764       * in case of changes fetch the list of events of interest.765       * 766       * The value has the type `(T::BlockNumber, EventIndex)` because if we used only just767       * the `EventIndex` then in case if the topic has the same contents on the next block768       * no notification will be triggered thus the event might be lost.769       **/770      eventTopics: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Vec<ITuple<[u32, u32]>>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;771      /**772       * The execution phase of the block.773       **/774      executionPhase: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemPhase>>, []> & QueryableStorageEntry<ApiType, []>;775      /**776       * Total extrinsics count for the current block.777       **/778      extrinsicCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;779      /**780       * Extrinsics data for the current block (maps an extrinsic's index to its data).781       **/782      extrinsicData: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;783      /**784       * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.785       **/786      lastRuntimeUpgrade: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemLastRuntimeUpgradeInfo>>, []> & QueryableStorageEntry<ApiType, []>;787      /**788       * The current block number being processed. Set by `execute_block`.789       **/790      number: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;791      /**792       * Hash of the previous block.793       **/794      parentHash: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;795      /**796       * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False797       * (default) if not.798       **/799      upgradedToTripleRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;800      /**801       * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.802       **/803      upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;804      /**805       * Generic query806       **/807      [key: string]: QueryableStorageEntry<ApiType>;808    };809    testUtils: {810      enabled: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;811      testValue: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;812      /**813       * Generic query814       **/815      [key: string]: QueryableStorageEntry<ApiType>;816    };817    timestamp: {818      /**819       * Did the timestamp get updated in this block?820       **/821      didUpdate: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;822      /**823       * Current time for the current block.824       **/825      now: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;826      /**827       * Generic query828       **/829      [key: string]: QueryableStorageEntry<ApiType>;830    };831    tokens: {832      /**833       * The balance of a token type under an account.834       * 835       * NOTE: If the total is ever zero, decrease account ref account.836       * 837       * NOTE: This is only used in the case that this module is used to store838       * balances.839       **/840      accounts: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<OrmlTokensAccountData>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;841      /**842       * Any liquidity locks of a token type under an account.843       * NOTE: Should only be accessed when setting, changing and freeing a lock.844       **/845      locks: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Vec<OrmlTokensBalanceLock>>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;846      /**847       * Named reserves on some account balances.848       **/849      reserves: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Vec<OrmlTokensReserveData>>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;850      /**851       * The total issuance of a token type.852       **/853      totalIssuance: AugmentedQuery<ApiType, (arg: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<u128>, [PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [PalletForeignAssetsAssetIds]>;854      /**855       * Generic query856       **/857      [key: string]: QueryableStorageEntry<ApiType>;858    };859    transactionPayment: {860      nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;861      storageVersion: AugmentedQuery<ApiType, () => Observable<PalletTransactionPaymentReleases>, []> & QueryableStorageEntry<ApiType, []>;862      /**863       * Generic query864       **/865      [key: string]: QueryableStorageEntry<ApiType>;866    };867    treasury: {868      /**869       * Proposal indices that have been approved but not yet awarded.870       **/871      approvals: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;872      /**873       * Number of proposals that have been made.874       **/875      proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;876      /**877       * Proposals that have been made.878       **/879      proposals: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletTreasuryProposal>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;880      /**881       * Generic query882       **/883      [key: string]: QueryableStorageEntry<ApiType>;884    };885    unique: {886      /**887       * Used for migrations888       **/889      chainVersion: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;890      /**891       * (Collection id (controlled?2), who created (real))892       * TODO: Off chain worker should remove from this map when collection gets removed893       **/894      createItemBasket: AugmentedQuery<ApiType, (arg: ITuple<[u32, AccountId32]> | [u32 | AnyNumber | Uint8Array, AccountId32 | string | Uint8Array]) => Observable<Option<u32>>, [ITuple<[u32, AccountId32]>]> & QueryableStorageEntry<ApiType, [ITuple<[u32, AccountId32]>]>;895      /**896       * Last sponsoring of fungible tokens approval in a collection897       **/898      fungibleApproveBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;899      /**900       * Collection id (controlled?2), owning user (real)901       **/902      fungibleTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;903      /**904       * Last sponsoring of NFT approval in a collection905       **/906      nftApproveBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;907      /**908       * Collection id (controlled?2), token id (controlled?2)909       **/910      nftTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;911      /**912       * Last sponsoring of RFT approval in a collection913       **/914      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]>;915      /**916       * Collection id (controlled?2), token id (controlled?2)917       **/918      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]>;919      /**920       * Last sponsoring of token property setting // todo:doc rephrase this and the following921       **/922      tokenPropertyBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;923      /**924       * Variable metadata sponsoring925       * Collection id (controlled?2), token id (controlled?2)926       **/927      variableMetaDataBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;928      /**929       * Generic query930       **/931      [key: string]: QueryableStorageEntry<ApiType>;932    };933    vesting: {934      /**935       * Vesting schedules of an account.936       * 937       * VestingSchedules: map AccountId => Vec<VestingSchedule>938       **/939      vestingSchedules: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<OrmlVestingVestingSchedule>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;940      /**941       * Generic query942       **/943      [key: string]: QueryableStorageEntry<ApiType>;944    };945    xcmpQueue: {946      /**947       * Inbound aggregate XCMP messages. It can only be one per ParaId/block.948       **/949      inboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;950      /**951       * Status of the inbound XCMP channels.952       **/953      inboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueInboundChannelDetails>>, []> & QueryableStorageEntry<ApiType, []>;954      /**955       * The messages outbound in a given XCMP channel.956       **/957      outboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u16 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u16]> & QueryableStorageEntry<ApiType, [u32, u16]>;958      /**959       * The non-empty XCMP channels in order of becoming non-empty, and the index of the first960       * and last outbound message. If the two indices are equal, then it indicates an empty961       * queue and there must be a non-`Ok` `OutboundStatus`. We assume queues grow no greater962       * than 65535 items. Queue indices for normal messages begin at one; zero is reserved in963       * case of the need to send a high-priority signal message this block.964       * The bool is true if there is a signal message waiting to be sent.965       **/966      outboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueOutboundChannelDetails>>, []> & QueryableStorageEntry<ApiType, []>;967      /**968       * The messages that exceeded max individual message weight budget.969       * 970       * These message stay in this storage map until they are manually dispatched via971       * `service_overweight`.972       **/973      overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;974      /**975       * The number of overweight messages ever recorded in `Overweight`. Also doubles as the next976       * available free overweight index.977       **/978      overweightCount: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;979      /**980       * The configuration which controls the dynamics of the outbound queue.981       **/982      queueConfig: AugmentedQuery<ApiType, () => Observable<CumulusPalletXcmpQueueQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;983      /**984       * Whether or not the XCMP queue is suspended from executing incoming XCMs or not.985       **/986      queueSuspended: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;987      /**988       * Any signal messages waiting to be sent.989       **/990      signalMessages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;991      /**992       * Generic query993       **/994      [key: string]: QueryableStorageEntry<ApiType>;995    };996  } // AugmentedQueries997} // declare module