git.delta.rocks / unique-network / refs/commits / 026e1c389a95

1// Auto-generated via `yarn polkadot-types-from-chain`, do not edit2/* eslint-disable */34// import type lookup before we augment - in some environments5// this is required to allow for ambient/previous definitions6import '@polkadot/api-base/types/storage';78import type { ApiTypes, AugmentedQuery, QueryableStorageEntry } from '@polkadot/api-base/types';9import type { Data } from '@polkadot/types';10import type { BTreeMap, Bytes, Option, U256, Vec, bool, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';11import type { AnyNumber, ITuple } from '@polkadot/types-codec/types';12import type { AccountId32, H160, H256 } from '@polkadot/types/interfaces/runtime';13import type { CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemCodeUpgradeAuthorization, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, EthereumBlock, EthereumLog, EthereumReceiptReceiptV3, EthereumTransactionTransactionV2, FpRpcTransactionStatus, FrameSupportDispatchPerDispatchClassWeight, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, OpalRuntimeRuntimeCommonSessionKeys, OrmlTokensAccountData, OrmlTokensBalanceLock, OrmlTokensReserveData, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesIdAmount, PalletBalancesReserveData, PalletConfigurationAppPromotionConfiguration, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmContractHelpersSponsoringModeT, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletIdentityRegistrarInfo, PalletIdentityRegistration, PalletNonfungibleItemData, PalletPreimageRequestStatus, PalletTransactionPaymentReleases, PalletTreasuryProposal, PalletXcmQueryStatus, PalletXcmRemoteLockedFungibleRecord, PalletXcmVersionMigrationStage, PhantomTypeUpDataStructs, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV4AbridgedHostConfiguration, PolkadotPrimitivesV4PersistedValidationData, PolkadotPrimitivesV4UpgradeRestriction, SpConsensusAuraSr25519AppSr25519Public, SpCoreCryptoKeyTypeId, SpRuntimeDigest, SpTrieStorageProof, SpWeightsWeightV2Weight, UpDataStructsCollection, UpDataStructsCollectionStats, UpDataStructsProperties, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsPropertyScope, UpDataStructsSponsorshipStateBasicCrossAccountIdRepr, UpDataStructsTokenChild, XcmV3MultiLocation, XcmVersionedAssetId, XcmVersionedMultiLocation } from '@polkadot/types/lookup';14import type { Observable } from '@polkadot/types/types';1516export type __AugmentedQuery<ApiType extends ApiTypes> = AugmentedQuery<ApiType, () => unknown>;17export type __QueryableStorageEntry<ApiType extends ApiTypes> = QueryableStorageEntry<ApiType>;1819declare module '@polkadot/api-base/types/storage' {20  interface AugmentedQueries<ApiType extends ApiTypes> {21    appPromotion: {22      /**23       * Stores the `admin` account. Some extrinsics can only be executed if they were signed by `admin`.24       **/25      admin: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;26      /**27       * Pending unstake records for an `Account`.28       * 29       * * **Key** - Staker account.30       * * **Value** - Amount of stakes.31       **/32      pendingUnstake: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[AccountId32, u128]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;33      /**34       * Stores a key for record for which the revenue recalculation was performed.35       * If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.36       **/37      previousCalculatedRecord: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[AccountId32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;38      /**39       * Stores the amount of tokens staked by account in the blocknumber.40       * 41       * * **Key1** - Staker account.42       * * **Key2** - Relay block number when the stake was made.43       * * **(Balance, BlockNumber)** - Balance of the stake.44       * The number of the relay block in which we must perform the interest recalculation45       **/46      staked: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<ITuple<[u128, u32]>>, [AccountId32, u32]> & QueryableStorageEntry<ApiType, [AccountId32, u32]>;47      /**48       * Stores number of stake records for an `Account`.49       * 50       * * **Key** - Staker account.51       * * **Value** - Amount of stakes.52       **/53      stakesPerAccount: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u8>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;54      /**55       * Stores the total staked amount.56       **/57      totalStaked: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;58      /**59       * Generic query60       **/61      [key: string]: QueryableStorageEntry<ApiType>;62    };63    aura: {64      /**65       * The current authority set.66       **/67      authorities: AugmentedQuery<ApiType, () => Observable<Vec<SpConsensusAuraSr25519AppSr25519Public>>, []> & QueryableStorageEntry<ApiType, []>;68      /**69       * The current slot of this block.70       * 71       * This will be set in `on_initialize`.72       **/73      currentSlot: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;74      /**75       * Generic query76       **/77      [key: string]: QueryableStorageEntry<ApiType>;78    };79    auraExt: {80      /**81       * Serves as cache for the authorities.82       * 83       * The authorities in AuRa are overwritten in `on_initialize` when we switch to a new session,84       * but we require the old authorities to verify the seal when validating a PoV. This will always85       * be updated to the latest AuRa authorities in `on_finalize`.86       **/87      authorities: AugmentedQuery<ApiType, () => Observable<Vec<SpConsensusAuraSr25519AppSr25519Public>>, []> & QueryableStorageEntry<ApiType, []>;88      /**89       * Generic query90       **/91      [key: string]: QueryableStorageEntry<ApiType>;92    };93    authorship: {94      /**95       * Author of current block.96       **/97      author: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;98      /**99       * Generic query100       **/101      [key: string]: QueryableStorageEntry<ApiType>;102    };103    balances: {104      /**105       * The Balances pallet example of storing the balance of an account.106       * 107       * # Example108       * 109       * ```nocompile110       * impl pallet_balances::Config for Runtime {111       * type AccountStore = StorageMapShim<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>112       * }113       * ```114       * 115       * You can also store the balance of an account in the `System` pallet.116       * 117       * # Example118       * 119       * ```nocompile120       * impl pallet_balances::Config for Runtime {121       * type AccountStore = System122       * }123       * ```124       * 125       * But this comes with tradeoffs, storing account balances in the system pallet stores126       * `frame_system` data alongside the account data contrary to storing account balances in the127       * `Balances` pallet, which uses a `StorageMap` to store balances data only.128       * NOTE: This is only used in the case that this pallet is used to store balances.129       **/130      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletBalancesAccountData>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;131      /**132       * Freeze locks on account balances.133       **/134      freezes: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesIdAmount>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;135      /**136       * Holds on account balances.137       **/138      holds: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesIdAmount>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;139      /**140       * The total units of outstanding deactivated balance in the system.141       **/142      inactiveIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;143      /**144       * Any liquidity locks on some account balances.145       * NOTE: Should only be accessed when setting, changing and freeing a lock.146       **/147      locks: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesBalanceLock>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;148      /**149       * Named reserves on some account balances.150       **/151      reserves: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesReserveData>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;152      /**153       * The total units issued in the system.154       **/155      totalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;156      /**157       * Generic query158       **/159      [key: string]: QueryableStorageEntry<ApiType>;160    };161    collatorSelection: {162      /**163       * The (community, limited) collation candidates.164       **/165      candidates: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;166      /**167       * The invulnerable, fixed collators.168       **/169      invulnerables: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;170      /**171       * Last block authored by collator.172       **/173      lastAuthoredBlock: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u32>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;174      /**175       * The (community) collation license holders.176       **/177      licenseDepositOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u128>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;178      /**179       * Generic query180       **/181      [key: string]: QueryableStorageEntry<ApiType>;182    };183    common: {184      /**185       * Storage of the amount of collection admins.186       **/187      adminAmount: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;188      /**189       * Allowlisted collection users.190       **/191      allowlist: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;192      /**193       * Storage of collection info.194       **/195      collectionById: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<UpDataStructsCollection>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;196      /**197       * Storage of collection properties.198       **/199      collectionProperties: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;200      /**201       * Storage of token property permissions of a collection.202       **/203      collectionPropertyPermissions: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsPropertiesMapPropertyPermission>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;204      /**205       * Storage of the count of created collections. Essentially contains the last collection ID.206       **/207      createdCollectionCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;208      /**209       * Storage of the count of deleted collections.210       **/211      destroyedCollectionCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;212      /**213       * Not used by code, exists only to provide some types to metadata.214       **/215      dummyStorageValue: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[UpDataStructsCollectionStats, u32, u32, UpDataStructsTokenChild, PhantomTypeUpDataStructs]>>>, []> & QueryableStorageEntry<ApiType, []>;216      /**217       * List of collection admins.218       **/219      isAdmin: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;220      /**221       * Generic query222       **/223      [key: string]: QueryableStorageEntry<ApiType>;224    };225    configuration: {226      appPromomotionConfigurationOverride: AugmentedQuery<ApiType, () => Observable<PalletConfigurationAppPromotionConfiguration>, []> & QueryableStorageEntry<ApiType, []>;227      collatorSelectionDesiredCollatorsOverride: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;228      collatorSelectionKickThresholdOverride: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;229      collatorSelectionLicenseBondOverride: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;230      minGasPriceOverride: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;231      weightToFeeCoefficientOverride: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;232      /**233       * Generic query234       **/235      [key: string]: QueryableStorageEntry<ApiType>;236    };237    dmpQueue: {238      /**239       * The configuration.240       **/241      configuration: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;242      /**243       * Counter for the related counted storage map244       **/245      counterForOverweight: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;246      /**247       * The overweight messages.248       **/249      overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;250      /**251       * The page index.252       **/253      pageIndex: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueuePageIndexData>, []> & QueryableStorageEntry<ApiType, []>;254      /**255       * The queue pages.256       **/257      pages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, Bytes]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;258      /**259       * Generic query260       **/261      [key: string]: QueryableStorageEntry<ApiType>;262    };263    ethereum: {264      blockHash: AugmentedQuery<ApiType, (arg: U256 | AnyNumber | Uint8Array) => Observable<H256>, [U256]> & QueryableStorageEntry<ApiType, [U256]>;265      /**266       * The current Ethereum block.267       **/268      currentBlock: AugmentedQuery<ApiType, () => Observable<Option<EthereumBlock>>, []> & QueryableStorageEntry<ApiType, []>;269      /**270       * The current Ethereum receipts.271       **/272      currentReceipts: AugmentedQuery<ApiType, () => Observable<Option<Vec<EthereumReceiptReceiptV3>>>, []> & QueryableStorageEntry<ApiType, []>;273      /**274       * The current transaction statuses.275       **/276      currentTransactionStatuses: AugmentedQuery<ApiType, () => Observable<Option<Vec<FpRpcTransactionStatus>>>, []> & QueryableStorageEntry<ApiType, []>;277      /**278       * Injected transactions should have unique nonce, here we store current279       **/280      injectedNonce: AugmentedQuery<ApiType, () => Observable<U256>, []> & QueryableStorageEntry<ApiType, []>;281      /**282       * Current building block's transactions and receipts.283       **/284      pending: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[EthereumTransactionTransactionV2, FpRpcTransactionStatus, EthereumReceiptReceiptV3]>>>, []> & QueryableStorageEntry<ApiType, []>;285      /**286       * Generic query287       **/288      [key: string]: QueryableStorageEntry<ApiType>;289    };290    evm: {291      accountCodes: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Bytes>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;292      accountStorages: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H256 | string | Uint8Array) => Observable<H256>, [H160, H256]> & QueryableStorageEntry<ApiType, [H160, H256]>;293      /**294       * Written on log, reset after transaction295       * Should be empty between transactions296       **/297      currentLogs: AugmentedQuery<ApiType, () => Observable<Vec<EthereumLog>>, []> & QueryableStorageEntry<ApiType, []>;298      /**299       * Generic query300       **/301      [key: string]: QueryableStorageEntry<ApiType>;302    };303    evmContractHelpers: {304      /**305       * Storage for users that allowed for sponsorship.306       * 307       * ### Usage308       * Prefer to delete record from storage if user no more allowed for sponsorship.309       * 310       * * **Key1** - contract address.311       * * **Key2** - user that allowed for sponsorship.312       * * **Value** - allowance for sponsorship.313       **/314      allowlist: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H160 | string | Uint8Array) => Observable<bool>, [H160, H160]> & QueryableStorageEntry<ApiType, [H160, H160]>;315      /**316       * Storege for contracts with [`Allowlisted`](SponsoringModeT::Allowlisted) sponsoring mode.317       * 318       * ### Usage319       * Prefer to delete collection from storage if mode chaged to non `Allowlisted`, than set **Value** to **false**.320       * 321       * * **Key** - contract address.322       * * **Value** - is contract in [`Allowlisted`](SponsoringModeT::Allowlisted) mode.323       **/324      allowlistEnabled: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;325      /**326       * Store owner for contract.327       * 328       * * **Key** - contract address.329       * * **Value** - owner for contract.330       **/331      owner: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<H160>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;332      /**333       * Deprecated: this storage is deprecated334       **/335      selfSponsoring: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;336      sponsorBasket: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H160 | string | Uint8Array) => Observable<Option<u32>>, [H160, H160]> & QueryableStorageEntry<ApiType, [H160, H160]>;337      /**338       * Store for contract sponsorship state.339       * 340       * * **Key** - contract address.341       * * **Value** - sponsorship state.342       **/343      sponsoring: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<UpDataStructsSponsorshipStateBasicCrossAccountIdRepr>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;344      /**345       * Storage for last sponsored block.346       * 347       * * **Key1** - contract address.348       * * **Key2** - sponsored user address.349       * * **Value** - last sponsored block number.350       **/351      sponsoringFeeLimit: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<BTreeMap<u32, U256>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;352      /**353       * Store for sponsoring mode.354       * 355       * ### Usage356       * Prefer to delete collection from storage if mode chaged to [`Disabled`](SponsoringModeT::Disabled).357       * 358       * * **Key** - contract address.359       * * **Value** - [`sponsoring mode`](SponsoringModeT).360       **/361      sponsoringMode: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<PalletEvmContractHelpersSponsoringModeT>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;362      /**363       * Storage for sponsoring rate limit in blocks.364       * 365       * * **Key** - contract address.366       * * **Value** - amount of sponsored blocks.367       **/368      sponsoringRateLimit: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<u32>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;369      /**370       * Generic query371       **/372      [key: string]: QueryableStorageEntry<ApiType>;373    };374    evmMigration: {375      migrationPending: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;376      /**377       * Generic query378       **/379      [key: string]: QueryableStorageEntry<ApiType>;380    };381    foreignAssets: {382      /**383       * The storages for assets to fungible collection binding384       * 385       **/386      assetBinding: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;387      /**388       * The storages for AssetMetadatas.389       * 390       * AssetMetadatas: map AssetIds => Option<AssetMetadata>391       **/392      assetMetadatas: AugmentedQuery<ApiType, (arg: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Option<PalletForeignAssetsModuleAssetMetadata>>, [PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [PalletForeignAssetsAssetIds]>;393      /**394       * The storages for MultiLocations.395       * 396       * ForeignAssetLocations: map ForeignAssetId => Option<MultiLocation>397       **/398      foreignAssetLocations: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<XcmV3MultiLocation>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;399      /**400       * The storages for CurrencyIds.401       * 402       * LocationToCurrencyIds: map MultiLocation => Option<ForeignAssetId>403       **/404      locationToCurrencyIds: AugmentedQuery<ApiType, (arg: XcmV3MultiLocation | { parents?: any; interior?: any } | string | Uint8Array) => Observable<Option<u32>>, [XcmV3MultiLocation]> & QueryableStorageEntry<ApiType, [XcmV3MultiLocation]>;405      /**406       * Next available Foreign AssetId ID.407       * 408       * NextForeignAssetId: ForeignAssetId409       **/410      nextForeignAssetId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;411      /**412       * Generic query413       **/414      [key: string]: QueryableStorageEntry<ApiType>;415    };416    fungible: {417      /**418       * Storage for assets delegated to a limited extent to other users.419       **/420      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]>;421      /**422       * Amount of tokens owned by an account inside a collection.423       **/424      balance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u128>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;425      /**426       * Total amount of fungible tokens inside a collection.427       **/428      totalSupply: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;429      /**430       * Generic query431       **/432      [key: string]: QueryableStorageEntry<ApiType>;433    };434    identity: {435      /**436       * Information that is pertinent to identify the entity behind an account.437       * 438       * TWOX-NOTE: OK ― `AccountId` is a secure hash.439       **/440      identityOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletIdentityRegistration>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;441      /**442       * The set of registrars. Not expected to get very big as can only be added through a443       * special origin (likely a council motion).444       * 445       * The index into this can be cast to `RegistrarIndex` to get a valid value.446       **/447      registrars: AugmentedQuery<ApiType, () => Observable<Vec<Option<PalletIdentityRegistrarInfo>>>, []> & QueryableStorageEntry<ApiType, []>;448      /**449       * Alternative "sub" identities of this account.450       * 451       * The first item is the deposit, the second is a vector of the accounts.452       * 453       * TWOX-NOTE: OK ― `AccountId` is a secure hash.454       **/455      subsOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[u128, Vec<AccountId32>]>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;456      /**457       * The super-identity of an alternative "sub" identity together with its name, within that458       * context. If the account is not some other account's sub-identity, then just `None`.459       **/460      superOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<ITuple<[AccountId32, Data]>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;461      /**462       * Generic query463       **/464      [key: string]: QueryableStorageEntry<ApiType>;465    };466    inflation: {467      /**468       * Current inflation for `InflationBlockInterval` number of blocks469       **/470      blockInflation: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;471      /**472       * Next target (relay) block when inflation will be applied473       **/474      nextInflationBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;475      /**476       * Next target (relay) block when inflation is recalculated477       **/478      nextRecalculationBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;479      /**480       * Relay block when inflation has started481       **/482      startBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;483      /**484       * starting year total issuance485       **/486      startingYearTotalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;487      /**488       * Generic query489       **/490      [key: string]: QueryableStorageEntry<ApiType>;491    };492    maintenance: {493      enabled: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;494      /**495       * Generic query496       **/497      [key: string]: QueryableStorageEntry<ApiType>;498    };499    nonfungible: {500      /**501       * Amount of tokens owned by an account in a collection.502       **/503      accountBalance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u32>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;504      /**505       * Allowance set by a token owner for another user to perform one of certain transactions on a token.506       **/507      allowance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletEvmAccountBasicCrossAccountIdRepr>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;508      /**509       * Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.510       **/511      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]>;512      /**513       * Used to enumerate tokens owned by account.514       **/515      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]>;516      /**517       * Custom data of a token that is serialized to bytes,518       * primarily reserved for on-chain operations,519       * normally obscured from the external users.520       * 521       * Auxiliary properties are slightly different from522       * usual [`TokenProperties`] due to an unlimited number523       * and separately stored and written-to key-value pairs.524       * 525       * Currently unused.526       **/527      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]>;528      /**529       * Used to enumerate token's children.530       **/531      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]>]>;532      /**533       * Token data, used to partially describe a token.534       **/535      tokenData: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNonfungibleItemData>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;536      /**537       * Map of key-value pairs, describing the metadata of a token.538       **/539      tokenProperties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;540      /**541       * Amount of burnt tokens in a collection.542       **/543      tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;544      /**545       * Total amount of minted tokens in a collection.546       **/547      tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;548      /**549       * Generic query550       **/551      [key: string]: QueryableStorageEntry<ApiType>;552    };553    parachainInfo: {554      parachainId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;555      /**556       * Generic query557       **/558      [key: string]: QueryableStorageEntry<ApiType>;559    };560    parachainSystem: {561      /**562       * The number of HRMP messages we observed in `on_initialize` and thus used that number for563       * announcing the weight of `on_initialize` and `on_finalize`.564       **/565      announcedHrmpMessagesPerCandidate: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;566      /**567       * The next authorized upgrade, if there is one.568       **/569      authorizedUpgrade: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemCodeUpgradeAuthorization>>, []> & QueryableStorageEntry<ApiType, []>;570      /**571       * A custom head data that should be returned as result of `validate_block`.572       * 573       * See [`Pallet::set_custom_validation_head_data`] for more information.574       **/575      customValidationHeadData: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;576      /**577       * Were the validation data set to notify the relay chain?578       **/579      didSetValidationCode: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;580      /**581       * The parachain host configuration that was obtained from the relay parent.582       * 583       * This field is meant to be updated each block with the validation data inherent. Therefore,584       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.585       * 586       * This data is also absent from the genesis.587       **/588      hostConfiguration: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV4AbridgedHostConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;589      /**590       * HRMP messages that were sent in a block.591       * 592       * This will be cleared in `on_initialize` of each new block.593       **/594      hrmpOutboundMessages: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotCorePrimitivesOutboundHrmpMessage>>, []> & QueryableStorageEntry<ApiType, []>;595      /**596       * HRMP watermark that was set in a block.597       * 598       * This will be cleared in `on_initialize` of each new block.599       **/600      hrmpWatermark: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;601      /**602       * The last downward message queue chain head we have observed.603       * 604       * This value is loaded before and saved after processing inbound downward messages carried605       * by the system inherent.606       **/607      lastDmqMqcHead: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;608      /**609       * The message queue chain heads we have observed per each channel incoming channel.610       * 611       * This value is loaded before and saved after processing inbound downward messages carried612       * by the system inherent.613       **/614      lastHrmpMqcHeads: AugmentedQuery<ApiType, () => Observable<BTreeMap<u32, H256>>, []> & QueryableStorageEntry<ApiType, []>;615      /**616       * The relay chain block number associated with the last parachain block.617       **/618      lastRelayChainBlockNumber: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;619      /**620       * Validation code that is set by the parachain and is to be communicated to collator and621       * consequently the relay-chain.622       * 623       * This will be cleared in `on_initialize` of each new block if no other pallet already set624       * the value.625       **/626      newValidationCode: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;627      /**628       * Upward messages that are still pending and not yet send to the relay chain.629       **/630      pendingUpwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;631      /**632       * In case of a scheduled upgrade, this storage field contains the validation code to be applied.633       * 634       * As soon as the relay chain gives us the go-ahead signal, we will overwrite the [`:code`][well_known_keys::CODE]635       * which will result the next block process with the new validation code. This concludes the upgrade process.636       * 637       * [well_known_keys::CODE]: sp_core::storage::well_known_keys::CODE638       **/639      pendingValidationCode: AugmentedQuery<ApiType, () => Observable<Bytes>, []> & QueryableStorageEntry<ApiType, []>;640      /**641       * Number of downward messages processed in a block.642       * 643       * This will be cleared in `on_initialize` of each new block.644       **/645      processedDownwardMessages: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;646      /**647       * The state proof for the last relay parent block.648       * 649       * This field is meant to be updated each block with the validation data inherent. Therefore,650       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.651       * 652       * This data is also absent from the genesis.653       **/654      relayStateProof: AugmentedQuery<ApiType, () => Observable<Option<SpTrieStorageProof>>, []> & QueryableStorageEntry<ApiType, []>;655      /**656       * The snapshot of some state related to messaging relevant to the current parachain as per657       * the relay parent.658       * 659       * This field is meant to be updated each block with the validation data inherent. Therefore,660       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.661       * 662       * This data is also absent from the genesis.663       **/664      relevantMessagingState: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot>>, []> & QueryableStorageEntry<ApiType, []>;665      /**666       * The weight we reserve at the beginning of the block for processing DMP messages. This667       * overrides the amount set in the Config trait.668       **/669      reservedDmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;670      /**671       * The weight we reserve at the beginning of the block for processing XCMP messages. This672       * overrides the amount set in the Config trait.673       **/674      reservedXcmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;675      /**676       * An option which indicates if the relay-chain restricts signalling a validation code upgrade.677       * In other words, if this is `Some` and [`NewValidationCode`] is `Some` then the produced678       * candidate will be invalid.679       * 680       * This storage item is a mirror of the corresponding value for the current parachain from the681       * relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is682       * set after the inherent.683       **/684      upgradeRestrictionSignal: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV4UpgradeRestriction>>, []> & QueryableStorageEntry<ApiType, []>;685      /**686       * Upward messages that were sent in a block.687       * 688       * This will be cleared in `on_initialize` of each new block.689       **/690      upwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;691      /**692       * The [`PersistedValidationData`] set for this block.693       * This value is expected to be set only once per block and it's never stored694       * in the trie.695       **/696      validationData: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV4PersistedValidationData>>, []> & QueryableStorageEntry<ApiType, []>;697      /**698       * Generic query699       **/700      [key: string]: QueryableStorageEntry<ApiType>;701    };702    polkadotXcm: {703      /**704       * The existing asset traps.705       * 706       * Key is the blake2 256 hash of (origin, versioned `MultiAssets`) pair. Value is the number of707       * times this pair has been trapped (usually just 1 if it exists at all).708       **/709      assetTraps: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<u32>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;710      /**711       * The current migration's stage, if any.712       **/713      currentMigration: AugmentedQuery<ApiType, () => Observable<Option<PalletXcmVersionMigrationStage>>, []> & QueryableStorageEntry<ApiType, []>;714      /**715       * Fungible assets which we know are locked on this chain.716       **/717      lockedFungibles: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<Vec<ITuple<[u128, XcmVersionedMultiLocation]>>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;718      /**719       * The ongoing queries.720       **/721      queries: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<PalletXcmQueryStatus>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;722      /**723       * The latest available query index.724       **/725      queryCounter: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;726      /**727       * Fungible assets which we know are locked on a remote chain.728       **/729      remoteLockedFungibles: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array, arg3: XcmVersionedAssetId | { V3: any } | string | Uint8Array) => Observable<Option<PalletXcmRemoteLockedFungibleRecord>>, [u32, AccountId32, XcmVersionedAssetId]> & QueryableStorageEntry<ApiType, [u32, AccountId32, XcmVersionedAssetId]>;730      /**731       * Default version to encode XCM when latest version of destination is unknown. If `None`,732       * then the destinations whose XCM version is unknown are considered unreachable.733       **/734      safeXcmVersion: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;735      /**736       * The Latest versions that we know various locations support.737       **/738      supportedVersion: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => Observable<Option<u32>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedMultiLocation]>;739      /**740       * Destinations whose latest XCM version we would like to know. Duplicates not allowed, and741       * the `u32` counter is the number of times that a send to the destination has been attempted,742       * which is used as a prioritization.743       **/744      versionDiscoveryQueue: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[XcmVersionedMultiLocation, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;745      /**746       * All locations that we have requested version notifications from.747       **/748      versionNotifiers: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => Observable<Option<u64>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedMultiLocation]>;749      /**750       * The target locations that are subscribed to our version changes, as well as the most recent751       * of our versions we informed them of.752       **/753      versionNotifyTargets: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => Observable<Option<ITuple<[u64, SpWeightsWeightV2Weight, u32]>>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedMultiLocation]>;754      /**755       * Global suspension state of the XCM executor.756       **/757      xcmExecutionSuspended: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;758      /**759       * Generic query760       **/761      [key: string]: QueryableStorageEntry<ApiType>;762    };763    preimage: {764      preimageFor: AugmentedQuery<ApiType, (arg: ITuple<[H256, u32]> | [H256 | string | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<Option<Bytes>>, [ITuple<[H256, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[H256, u32]>]>;765      /**766       * The request status of a given hash.767       **/768      statusFor: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletPreimageRequestStatus>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;769      /**770       * Generic query771       **/772      [key: string]: QueryableStorageEntry<ApiType>;773    };774    refungible: {775      /**776       * Amount of tokens (not pieces) partially owned by an account within a collection.777       **/778      accountBalance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u32>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;779      /**780       * Allowance set by a token owner for another user to perform one of certain transactions on a number of pieces of a token.781       **/782      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]>;783      /**784       * Amount of token pieces owned by account.785       **/786      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]>;787      /**788       * Spender set by a wallet owner that could perform certain transactions on all tokens in the wallet.789       **/790      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]>;791      /**792       * Used to enumerate tokens owned by account.793       **/794      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]>;795      /**796       * Amount of pieces a refungible token is split into.797       **/798      tokenProperties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;799      /**800       * Amount of tokens burnt in a collection.801       **/802      tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;803      /**804       * Total amount of minted tokens in a collection.805       **/806      tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;807      /**808       * Total amount of pieces for token809       **/810      totalSupply: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;811      /**812       * Generic query813       **/814      [key: string]: QueryableStorageEntry<ApiType>;815    };816    session: {817      /**818       * Current index of the session.819       **/820      currentIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;821      /**822       * Indices of disabled validators.823       * 824       * The vec is always kept sorted so that we can find whether a given validator is825       * disabled using binary search. It gets cleared when `on_session_ending` returns826       * a new set of identities.827       **/828      disabledValidators: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;829      /**830       * The owner of a key. The key is the `KeyTypeId` + the encoded key.831       **/832      keyOwner: AugmentedQuery<ApiType, (arg: ITuple<[SpCoreCryptoKeyTypeId, Bytes]> | [SpCoreCryptoKeyTypeId | string | Uint8Array, Bytes | string | Uint8Array]) => Observable<Option<AccountId32>>, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]> & QueryableStorageEntry<ApiType, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]>;833      /**834       * The next session keys for a validator.835       **/836      nextKeys: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<OpalRuntimeRuntimeCommonSessionKeys>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;837      /**838       * True if the underlying economic identities or weighting behind the validators839       * has changed in the queued validator set.840       **/841      queuedChanged: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;842      /**843       * The queued keys for the next session. When the next session begins, these keys844       * will be used to determine the validator's session keys.845       **/846      queuedKeys: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[AccountId32, OpalRuntimeRuntimeCommonSessionKeys]>>>, []> & QueryableStorageEntry<ApiType, []>;847      /**848       * The current set of validators.849       **/850      validators: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;851      /**852       * Generic query853       **/854      [key: string]: QueryableStorageEntry<ApiType>;855    };856    sudo: {857      /**858       * The `AccountId` of the sudo key.859       **/860      key: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;861      /**862       * Generic query863       **/864      [key: string]: QueryableStorageEntry<ApiType>;865    };866    system: {867      /**868       * The full account information for a particular account ID.869       **/870      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<FrameSystemAccountInfo>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;871      /**872       * Total length (in bytes) for all extrinsics put together, for the current block.873       **/874      allExtrinsicsLen: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;875      /**876       * Map of block numbers to block hashes.877       **/878      blockHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<H256>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;879      /**880       * The current weight for the block.881       **/882      blockWeight: AugmentedQuery<ApiType, () => Observable<FrameSupportDispatchPerDispatchClassWeight>, []> & QueryableStorageEntry<ApiType, []>;883      /**884       * Digest of the current block, also part of the block header.885       **/886      digest: AugmentedQuery<ApiType, () => Observable<SpRuntimeDigest>, []> & QueryableStorageEntry<ApiType, []>;887      /**888       * The number of events in the `Events<T>` list.889       **/890      eventCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;891      /**892       * Events deposited for the current block.893       * 894       * NOTE: The item is unbound and should therefore never be read on chain.895       * It could otherwise inflate the PoV size of a block.896       * 897       * Events have a large in-memory size. Box the events to not go out-of-memory898       * just in case someone still reads them from within the runtime.899       **/900      events: AugmentedQuery<ApiType, () => Observable<Vec<FrameSystemEventRecord>>, []> & QueryableStorageEntry<ApiType, []>;901      /**902       * Mapping between a topic (represented by T::Hash) and a vector of indexes903       * of events in the `<Events<T>>` list.904       * 905       * All topic vectors have deterministic storage locations depending on the topic. This906       * allows light-clients to leverage the changes trie storage tracking mechanism and907       * in case of changes fetch the list of events of interest.908       * 909       * The value has the type `(T::BlockNumber, EventIndex)` because if we used only just910       * the `EventIndex` then in case if the topic has the same contents on the next block911       * no notification will be triggered thus the event might be lost.912       **/913      eventTopics: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Vec<ITuple<[u32, u32]>>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;914      /**915       * The execution phase of the block.916       **/917      executionPhase: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemPhase>>, []> & QueryableStorageEntry<ApiType, []>;918      /**919       * Total extrinsics count for the current block.920       **/921      extrinsicCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;922      /**923       * Extrinsics data for the current block (maps an extrinsic's index to its data).924       **/925      extrinsicData: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;926      /**927       * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.928       **/929      lastRuntimeUpgrade: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemLastRuntimeUpgradeInfo>>, []> & QueryableStorageEntry<ApiType, []>;930      /**931       * The current block number being processed. Set by `execute_block`.932       **/933      number: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;934      /**935       * Hash of the previous block.936       **/937      parentHash: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;938      /**939       * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False940       * (default) if not.941       **/942      upgradedToTripleRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;943      /**944       * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.945       **/946      upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;947      /**948       * Generic query949       **/950      [key: string]: QueryableStorageEntry<ApiType>;951    };952    testUtils: {953      enabled: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;954      testValue: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;955      /**956       * Generic query957       **/958      [key: string]: QueryableStorageEntry<ApiType>;959    };960    timestamp: {961      /**962       * Did the timestamp get updated in this block?963       **/964      didUpdate: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;965      /**966       * Current time for the current block.967       **/968      now: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;969      /**970       * Generic query971       **/972      [key: string]: QueryableStorageEntry<ApiType>;973    };974    tokens: {975      /**976       * The balance of a token type under an account.977       * 978       * NOTE: If the total is ever zero, decrease account ref account.979       * 980       * NOTE: This is only used in the case that this module is used to store981       * balances.982       **/983      accounts: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<OrmlTokensAccountData>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;984      /**985       * Any liquidity locks of a token type under an account.986       * NOTE: Should only be accessed when setting, changing and freeing a lock.987       **/988      locks: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Vec<OrmlTokensBalanceLock>>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;989      /**990       * Named reserves on some account balances.991       **/992      reserves: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Vec<OrmlTokensReserveData>>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;993      /**994       * The total issuance of a token type.995       **/996      totalIssuance: AugmentedQuery<ApiType, (arg: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<u128>, [PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [PalletForeignAssetsAssetIds]>;997      /**998       * Generic query999       **/1000      [key: string]: QueryableStorageEntry<ApiType>;1001    };1002    transactionPayment: {1003      nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;1004      storageVersion: AugmentedQuery<ApiType, () => Observable<PalletTransactionPaymentReleases>, []> & QueryableStorageEntry<ApiType, []>;1005      /**1006       * Generic query1007       **/1008      [key: string]: QueryableStorageEntry<ApiType>;1009    };1010    treasury: {1011      /**1012       * Proposal indices that have been approved but not yet awarded.1013       **/1014      approvals: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;1015      /**1016       * The amount which has been reported as inactive to Currency.1017       **/1018      deactivated: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;1019      /**1020       * Number of proposals that have been made.1021       **/1022      proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1023      /**1024       * Proposals that have been made.1025       **/1026      proposals: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletTreasuryProposal>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1027      /**1028       * Generic query1029       **/1030      [key: string]: QueryableStorageEntry<ApiType>;1031    };1032    unique: {1033      /**1034       * Used for migrations1035       **/1036      chainVersion: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;1037      /**1038       * (Collection id (controlled?2), who created (real))1039       * TODO: Off chain worker should remove from this map when collection gets removed1040       **/1041      createItemBasket: AugmentedQuery<ApiType, (arg: ITuple<[u32, AccountId32]> | [u32 | AnyNumber | Uint8Array, AccountId32 | string | Uint8Array]) => Observable<Option<u32>>, [ITuple<[u32, AccountId32]>]> & QueryableStorageEntry<ApiType, [ITuple<[u32, AccountId32]>]>;1042      /**1043       * Last sponsoring of fungible tokens approval in a collection1044       **/1045      fungibleApproveBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;1046      /**1047       * Collection id (controlled?2), owning user (real)1048       **/1049      fungibleTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;1050      /**1051       * Last sponsoring of NFT approval in a collection1052       **/1053      nftApproveBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1054      /**1055       * Collection id (controlled?2), token id (controlled?2)1056       **/1057      nftTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1058      /**1059       * Last sponsoring of RFT approval in a collection1060       **/1061      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]>;1062      /**1063       * Collection id (controlled?2), token id (controlled?2)1064       **/1065      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]>;1066      /**1067       * Last sponsoring of token property setting // todo:doc rephrase this and the following1068       **/1069      tokenPropertyBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1070      /**1071       * Generic query1072       **/1073      [key: string]: QueryableStorageEntry<ApiType>;1074    };1075    vesting: {1076      /**1077       * Vesting schedules of an account.1078       * 1079       * VestingSchedules: map AccountId => Vec<VestingSchedule>1080       **/1081      vestingSchedules: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<OrmlVestingVestingSchedule>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;1082      /**1083       * Generic query1084       **/1085      [key: string]: QueryableStorageEntry<ApiType>;1086    };1087    xcmpQueue: {1088      /**1089       * Counter for the related counted storage map1090       **/1091      counterForOverweight: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1092      /**1093       * Inbound aggregate XCMP messages. It can only be one per ParaId/block.1094       **/1095      inboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1096      /**1097       * Status of the inbound XCMP channels.1098       **/1099      inboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueInboundChannelDetails>>, []> & QueryableStorageEntry<ApiType, []>;1100      /**1101       * The messages outbound in a given XCMP channel.1102       **/1103      outboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u16 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u16]> & QueryableStorageEntry<ApiType, [u32, u16]>;1104      /**1105       * The non-empty XCMP channels in order of becoming non-empty, and the index of the first1106       * and last outbound message. If the two indices are equal, then it indicates an empty1107       * queue and there must be a non-`Ok` `OutboundStatus`. We assume queues grow no greater1108       * than 65535 items. Queue indices for normal messages begin at one; zero is reserved in1109       * case of the need to send a high-priority signal message this block.1110       * The bool is true if there is a signal message waiting to be sent.1111       **/1112      outboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueOutboundChannelDetails>>, []> & QueryableStorageEntry<ApiType, []>;1113      /**1114       * The messages that exceeded max individual message weight budget.1115       * 1116       * These message stay in this storage map until they are manually dispatched via1117       * `service_overweight`.1118       **/1119      overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;1120      /**1121       * The number of overweight messages ever recorded in `Overweight`. Also doubles as the next1122       * available free overweight index.1123       **/1124      overweightCount: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;1125      /**1126       * The configuration which controls the dynamics of the outbound queue.1127       **/1128      queueConfig: AugmentedQuery<ApiType, () => Observable<CumulusPalletXcmpQueueQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;1129      /**1130       * Whether or not the XCMP queue is suspended from executing incoming XCMs or not.1131       **/1132      queueSuspended: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;1133      /**1134       * Any signal messages waiting to be sent.1135       **/1136      signalMessages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1137      /**1138       * Generic query1139       **/1140      [key: string]: QueryableStorageEntry<ApiType>;1141    };1142  } // AugmentedQueries1143} // declare module