git.delta.rocks / unique-network / refs/commits / 70abe578b643

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, 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, OpalRuntimeRuntimeCommonSessionKeys, OrmlTokensAccountData, OrmlTokensBalanceLock, OrmlTokensReserveData, OrmlVestingVestingSchedule, PalletAuthorshipUncleEntryItem, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReleases, PalletBalancesReserveData, PalletConfigurationAppPromotionConfiguration, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmContractHelpersSponsoringModeT, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletNonfungibleItemData, PalletRefungibleItemData, PalletTransactionPaymentReleases, PalletTreasuryProposal, PhantomTypeUpDataStructs, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpCoreCryptoKeyTypeId, 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 amount of stakes for an `Account`.27       * 28       * * **Key** - Staker account.29       * * **Value** - Amount of stakes.30       **/31      pendingUnstake: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[AccountId32, u128]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;32      /**33       * Stores a key for record for which the revenue recalculation was performed.34       * If `None`, then recalculation has not yet been performed or calculations have been completed for all stakers.35       **/36      previousCalculatedRecord: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[AccountId32, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;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    authorship: {63      /**64       * Author of current block.65       **/66      author: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;67      /**68       * Whether uncles were already set in this block.69       **/70      didSetUncles: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;71      /**72       * Uncles73       **/74      uncles: AugmentedQuery<ApiType, () => Observable<Vec<PalletAuthorshipUncleEntryItem>>, []> & QueryableStorageEntry<ApiType, []>;75      /**76       * Generic query77       **/78      [key: string]: QueryableStorageEntry<ApiType>;79    };80    balances: {81      /**82       * The Balances pallet example of storing the balance of an account.83       * 84       * # Example85       * 86       * ```nocompile87       * impl pallet_balances::Config for Runtime {88       * type AccountStore = StorageMapShim<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>89       * }90       * ```91       * 92       * You can also store the balance of an account in the `System` pallet.93       * 94       * # Example95       * 96       * ```nocompile97       * impl pallet_balances::Config for Runtime {98       * type AccountStore = System99       * }100       * ```101       * 102       * But this comes with tradeoffs, storing account balances in the system pallet stores103       * `frame_system` data alongside the account data contrary to storing account balances in the104       * `Balances` pallet, which uses a `StorageMap` to store balances data only.105       * NOTE: This is only used in the case that this pallet is used to store balances.106       **/107      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletBalancesAccountData>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;108      /**109       * Any liquidity locks on some account balances.110       * NOTE: Should only be accessed when setting, changing and freeing a lock.111       **/112      locks: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesBalanceLock>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;113      /**114       * Named reserves on some account balances.115       **/116      reserves: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesReserveData>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;117      /**118       * Storage version of the pallet.119       * 120       * This is set to v2.0.0 for new networks.121       **/122      storageVersion: AugmentedQuery<ApiType, () => Observable<PalletBalancesReleases>, []> & QueryableStorageEntry<ApiType, []>;123      /**124       * The total units issued in the system.125       **/126      totalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;127      /**128       * Generic query129       **/130      [key: string]: QueryableStorageEntry<ApiType>;131    };132    charging: {133      /**134       * Generic query135       **/136      [key: string]: QueryableStorageEntry<ApiType>;137    };138    collatorSelection: {139      /**140       * The (community, limited) collation candidates.141       **/142      candidates: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;143      /**144       * Desired number of candidates.145       * 146       * This should ideally always be less than [`Config::MaxCollators`] for weights to be correct.147       **/148      desiredCollators: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;149      /**150       * The invulnerable, fixed collators.151       **/152      invulnerables: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;153      /**154       * Collator will be kicked if it does not produce a block within the threshold (does not apply to invulnerables).155       * 156       * Should be a multiple of session or things will get inconsistent. todo:collator reword?157       **/158      kickThreshold: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;159      /**160       * Last block authored by collator.161       **/162      lastAuthoredBlock: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u32>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;163      /**164       * Fixed amount to deposit to become a collator.165       * 166       * When a collator calls `leave_intent` they immediately receive the deposit back.167       **/168      licenseBond: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;169      /**170       * The (community) collation license holders.171       **/172      licenses: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u128>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;173      /**174       * Generic query175       **/176      [key: string]: QueryableStorageEntry<ApiType>;177    };178    common: {179      /**180       * Storage of the amount of collection admins.181       **/182      adminAmount: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;183      /**184       * Allowlisted collection users.185       **/186      allowlist: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;187      /**188       * Storage of collection info.189       **/190      collectionById: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<UpDataStructsCollection>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;191      /**192       * Storage of collection properties.193       **/194      collectionProperties: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;195      /**196       * Storage of token property permissions of a collection.197       **/198      collectionPropertyPermissions: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<BTreeMap<Bytes, UpDataStructsPropertyPermission>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;199      /**200       * Storage of the count of created collections. Essentially contains the last collection ID.201       **/202      createdCollectionCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;203      /**204       * Storage of the count of deleted collections.205       **/206      destroyedCollectionCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;207      /**208       * Not used by code, exists only to provide some types to metadata.209       **/210      dummyStorageValue: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[UpDataStructsCollectionStats, u32, u32, UpDataStructsTokenChild, PhantomTypeUpDataStructs]>>>, []> & QueryableStorageEntry<ApiType, []>;211      /**212       * List of collection admins.213       **/214      isAdmin: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;215      /**216       * Generic query217       **/218      [key: string]: QueryableStorageEntry<ApiType>;219    };220    configuration: {221      appPromomotionConfigurationOverride: AugmentedQuery<ApiType, () => Observable<PalletConfigurationAppPromotionConfiguration>, []> & QueryableStorageEntry<ApiType, []>;222      minGasPriceOverride: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;223      weightToFeeCoefficientOverride: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;224      xcmAllowedLocationsOverride: AugmentedQuery<ApiType, () => Observable<Option<Vec<XcmV1MultiLocation>>>, []> & QueryableStorageEntry<ApiType, []>;225      /**226       * Generic query227       **/228      [key: string]: QueryableStorageEntry<ApiType>;229    };230    dmpQueue: {231      /**232       * The configuration.233       **/234      configuration: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;235      /**236       * The overweight messages.237       **/238      overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;239      /**240       * The page index.241       **/242      pageIndex: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueuePageIndexData>, []> & QueryableStorageEntry<ApiType, []>;243      /**244       * The queue pages.245       **/246      pages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, Bytes]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;247      /**248       * Generic query249       **/250      [key: string]: QueryableStorageEntry<ApiType>;251    };252    ethereum: {253      blockHash: AugmentedQuery<ApiType, (arg: U256 | AnyNumber | Uint8Array) => Observable<H256>, [U256]> & QueryableStorageEntry<ApiType, [U256]>;254      /**255       * The current Ethereum block.256       **/257      currentBlock: AugmentedQuery<ApiType, () => Observable<Option<EthereumBlock>>, []> & QueryableStorageEntry<ApiType, []>;258      /**259       * The current Ethereum receipts.260       **/261      currentReceipts: AugmentedQuery<ApiType, () => Observable<Option<Vec<EthereumReceiptReceiptV3>>>, []> & QueryableStorageEntry<ApiType, []>;262      /**263       * The current transaction statuses.264       **/265      currentTransactionStatuses: AugmentedQuery<ApiType, () => Observable<Option<Vec<FpRpcTransactionStatus>>>, []> & QueryableStorageEntry<ApiType, []>;266      /**267       * Injected transactions should have unique nonce, here we store current268       **/269      injectedNonce: AugmentedQuery<ApiType, () => Observable<U256>, []> & QueryableStorageEntry<ApiType, []>;270      /**271       * Current building block's transactions and receipts.272       **/273      pending: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[EthereumTransactionTransactionV2, FpRpcTransactionStatus, EthereumReceiptReceiptV3]>>>, []> & QueryableStorageEntry<ApiType, []>;274      /**275       * Generic query276       **/277      [key: string]: QueryableStorageEntry<ApiType>;278    };279    evm: {280      accountCodes: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Bytes>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;281      accountStorages: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H256 | string | Uint8Array) => Observable<H256>, [H160, H256]> & QueryableStorageEntry<ApiType, [H160, H256]>;282      /**283       * Written on log, reset after transaction284       * Should be empty between transactions285       **/286      currentLogs: AugmentedQuery<ApiType, () => Observable<Vec<EthereumLog>>, []> & QueryableStorageEntry<ApiType, []>;287      /**288       * Generic query289       **/290      [key: string]: QueryableStorageEntry<ApiType>;291    };292    evmCoderSubstrate: {293      /**294       * Generic query295       **/296      [key: string]: QueryableStorageEntry<ApiType>;297    };298    evmContractHelpers: {299      /**300       * Storage for users that allowed for sponsorship.301       * 302       * ### Usage303       * Prefer to delete record from storage if user no more allowed for sponsorship.304       * 305       * * **Key1** - contract address.306       * * **Key2** - user that allowed for sponsorship.307       * * **Value** - allowance for sponsorship.308       **/309      allowlist: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H160 | string | Uint8Array) => Observable<bool>, [H160, H160]> & QueryableStorageEntry<ApiType, [H160, H160]>;310      /**311       * Storege for contracts with [`Allowlisted`](SponsoringModeT::Allowlisted) sponsoring mode.312       * 313       * ### Usage314       * Prefer to delete collection from storage if mode chaged to non `Allowlisted`, than set **Value** to **false**.315       * 316       * * **Key** - contract address.317       * * **Value** - is contract in [`Allowlisted`](SponsoringModeT::Allowlisted) mode.318       **/319      allowlistEnabled: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;320      /**321       * Store owner for contract.322       * 323       * * **Key** - contract address.324       * * **Value** - owner for contract.325       **/326      owner: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<H160>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;327      selfSponsoring: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;328      sponsorBasket: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H160 | string | Uint8Array) => Observable<Option<u32>>, [H160, H160]> & QueryableStorageEntry<ApiType, [H160, H160]>;329      /**330       * Store for contract sponsorship state.331       * 332       * * **Key** - contract address.333       * * **Value** - sponsorship state.334       **/335      sponsoring: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<UpDataStructsSponsorshipStateBasicCrossAccountIdRepr>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;336      /**337       * Storage for last sponsored block.338       * 339       * * **Key1** - contract address.340       * * **Key2** - sponsored user address.341       * * **Value** - last sponsored block number.342       **/343      sponsoringFeeLimit: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<BTreeMap<u32, U256>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;344      /**345       * Store for sponsoring mode.346       * 347       * ### Usage348       * Prefer to delete collection from storage if mode chaged to [`Disabled`](SponsoringModeT::Disabled).349       * 350       * * **Key** - contract address.351       * * **Value** - [`sponsoring mode`](SponsoringModeT).352       **/353      sponsoringMode: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<PalletEvmContractHelpersSponsoringModeT>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;354      /**355       * Storage for sponsoring rate limit in blocks.356       * 357       * * **Key** - contract address.358       * * **Value** - amount of sponsored blocks.359       **/360      sponsoringRateLimit: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<u32>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;361      /**362       * Generic query363       **/364      [key: string]: QueryableStorageEntry<ApiType>;365    };366    evmMigration: {367      migrationPending: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;368      /**369       * Generic query370       **/371      [key: string]: QueryableStorageEntry<ApiType>;372    };373    foreignAssets: {374      /**375       * The storages for assets to fungible collection binding376       * 377       **/378      assetBinding: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;379      /**380       * The storages for AssetMetadatas.381       * 382       * AssetMetadatas: map AssetIds => Option<AssetMetadata>383       **/384      assetMetadatas: AugmentedQuery<ApiType, (arg: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Option<PalletForeignAssetsModuleAssetMetadata>>, [PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [PalletForeignAssetsAssetIds]>;385      /**386       * The storages for MultiLocations.387       * 388       * ForeignAssetLocations: map ForeignAssetId => Option<MultiLocation>389       **/390      foreignAssetLocations: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<XcmV1MultiLocation>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;391      /**392       * The storages for CurrencyIds.393       * 394       * LocationToCurrencyIds: map MultiLocation => Option<ForeignAssetId>395       **/396      locationToCurrencyIds: AugmentedQuery<ApiType, (arg: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array) => Observable<Option<u32>>, [XcmV1MultiLocation]> & QueryableStorageEntry<ApiType, [XcmV1MultiLocation]>;397      /**398       * Next available Foreign AssetId ID.399       * 400       * NextForeignAssetId: ForeignAssetId401       **/402      nextForeignAssetId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;403      /**404       * Generic query405       **/406      [key: string]: QueryableStorageEntry<ApiType>;407    };408    fungible: {409      /**410       * Storage for assets delegated to a limited extent to other users.411       **/412      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]>;413      /**414       * Amount of tokens owned by an account inside a collection.415       **/416      balance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u128>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;417      /**418       * Total amount of fungible tokens inside a collection.419       **/420      totalSupply: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;421      /**422       * Generic query423       **/424      [key: string]: QueryableStorageEntry<ApiType>;425    };426    inflation: {427      /**428       * Current inflation for `InflationBlockInterval` number of blocks429       **/430      blockInflation: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;431      /**432       * Next target (relay) block when inflation will be applied433       **/434      nextInflationBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;435      /**436       * Next target (relay) block when inflation is recalculated437       **/438      nextRecalculationBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;439      /**440       * Relay block when inflation has started441       **/442      startBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;443      /**444       * starting year total issuance445       **/446      startingYearTotalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;447      /**448       * Generic query449       **/450      [key: string]: QueryableStorageEntry<ApiType>;451    };452    maintenance: {453      enabled: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;454      /**455       * Generic query456       **/457      [key: string]: QueryableStorageEntry<ApiType>;458    };459    nonfungible: {460      /**461       * Amount of tokens owned by an account in a collection.462       **/463      accountBalance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u32>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;464      /**465       * Allowance set by a token owner for another user to perform one of certain transactions on a token.466       **/467      allowance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletEvmAccountBasicCrossAccountIdRepr>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;468      /**469       * Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.470       **/471      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]>;472      /**473       * Used to enumerate tokens owned by account.474       **/475      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]>;476      /**477       * Custom data of a token that is serialized to bytes,478       * primarily reserved for on-chain operations,479       * normally obscured from the external users.480       * 481       * Auxiliary properties are slightly different from482       * usual [`TokenProperties`] due to an unlimited number483       * and separately stored and written-to key-value pairs.484       * 485       * Currently used to store RMRK data.486       **/487      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]>;488      /**489       * Used to enumerate token's children.490       **/491      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]>]>;492      /**493       * Token data, used to partially describe a token.494       **/495      tokenData: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNonfungibleItemData>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;496      /**497       * Map of key-value pairs, describing the metadata of a token.498       **/499      tokenProperties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;500      /**501       * Amount of burnt tokens in a collection.502       **/503      tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;504      /**505       * Total amount of minted tokens in a collection.506       **/507      tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;508      /**509       * Generic query510       **/511      [key: string]: QueryableStorageEntry<ApiType>;512    };513    parachainInfo: {514      parachainId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;515      /**516       * Generic query517       **/518      [key: string]: QueryableStorageEntry<ApiType>;519    };520    parachainSystem: {521      /**522       * The number of HRMP messages we observed in `on_initialize` and thus used that number for523       * announcing the weight of `on_initialize` and `on_finalize`.524       **/525      announcedHrmpMessagesPerCandidate: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;526      /**527       * The next authorized upgrade, if there is one.528       **/529      authorizedUpgrade: AugmentedQuery<ApiType, () => Observable<Option<H256>>, []> & QueryableStorageEntry<ApiType, []>;530      /**531       * A custom head data that should be returned as result of `validate_block`.532       * 533       * See [`Pallet::set_custom_validation_head_data`] for more information.534       **/535      customValidationHeadData: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;536      /**537       * Were the validation data set to notify the relay chain?538       **/539      didSetValidationCode: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;540      /**541       * The parachain host configuration that was obtained from the relay parent.542       * 543       * This field is meant to be updated each block with the validation data inherent. Therefore,544       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.545       * 546       * This data is also absent from the genesis.547       **/548      hostConfiguration: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV2AbridgedHostConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;549      /**550       * HRMP messages that were sent in a block.551       * 552       * This will be cleared in `on_initialize` of each new block.553       **/554      hrmpOutboundMessages: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotCorePrimitivesOutboundHrmpMessage>>, []> & QueryableStorageEntry<ApiType, []>;555      /**556       * HRMP watermark that was set in a block.557       * 558       * This will be cleared in `on_initialize` of each new block.559       **/560      hrmpWatermark: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;561      /**562       * The last downward message queue chain head we have observed.563       * 564       * This value is loaded before and saved after processing inbound downward messages carried565       * by the system inherent.566       **/567      lastDmqMqcHead: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;568      /**569       * The message queue chain heads we have observed per each channel incoming channel.570       * 571       * This value is loaded before and saved after processing inbound downward messages carried572       * by the system inherent.573       **/574      lastHrmpMqcHeads: AugmentedQuery<ApiType, () => Observable<BTreeMap<u32, H256>>, []> & QueryableStorageEntry<ApiType, []>;575      /**576       * The relay chain block number associated with the last parachain block.577       **/578      lastRelayChainBlockNumber: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;579      /**580       * Validation code that is set by the parachain and is to be communicated to collator and581       * consequently the relay-chain.582       * 583       * This will be cleared in `on_initialize` of each new block if no other pallet already set584       * the value.585       **/586      newValidationCode: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;587      /**588       * Upward messages that are still pending and not yet send to the relay chain.589       **/590      pendingUpwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;591      /**592       * In case of a scheduled upgrade, this storage field contains the validation code to be applied.593       * 594       * As soon as the relay chain gives us the go-ahead signal, we will overwrite the [`:code`][well_known_keys::CODE]595       * which will result the next block process with the new validation code. This concludes the upgrade process.596       * 597       * [well_known_keys::CODE]: sp_core::storage::well_known_keys::CODE598       **/599      pendingValidationCode: AugmentedQuery<ApiType, () => Observable<Bytes>, []> & QueryableStorageEntry<ApiType, []>;600      /**601       * Number of downward messages processed in a block.602       * 603       * This will be cleared in `on_initialize` of each new block.604       **/605      processedDownwardMessages: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;606      /**607       * The state proof for the last relay parent block.608       * 609       * This field is meant to be updated each block with the validation data inherent. Therefore,610       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.611       * 612       * This data is also absent from the genesis.613       **/614      relayStateProof: AugmentedQuery<ApiType, () => Observable<Option<SpTrieStorageProof>>, []> & QueryableStorageEntry<ApiType, []>;615      /**616       * The snapshot of some state related to messaging relevant to the current parachain as per617       * the relay parent.618       * 619       * This field is meant to be updated each block with the validation data inherent. Therefore,620       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.621       * 622       * This data is also absent from the genesis.623       **/624      relevantMessagingState: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot>>, []> & QueryableStorageEntry<ApiType, []>;625      /**626       * The weight we reserve at the beginning of the block for processing DMP messages. This627       * overrides the amount set in the Config trait.628       **/629      reservedDmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;630      /**631       * The weight we reserve at the beginning of the block for processing XCMP messages. This632       * overrides the amount set in the Config trait.633       **/634      reservedXcmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;635      /**636       * An option which indicates if the relay-chain restricts signalling a validation code upgrade.637       * In other words, if this is `Some` and [`NewValidationCode`] is `Some` then the produced638       * candidate will be invalid.639       * 640       * This storage item is a mirror of the corresponding value for the current parachain from the641       * relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is642       * set after the inherent.643       **/644      upgradeRestrictionSignal: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV2UpgradeRestriction>>, []> & QueryableStorageEntry<ApiType, []>;645      /**646       * Upward messages that were sent in a block.647       * 648       * This will be cleared in `on_initialize` of each new block.649       **/650      upwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;651      /**652       * The [`PersistedValidationData`] set for this block.653       * This value is expected to be set only once per block and it's never stored654       * in the trie.655       **/656      validationData: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV2PersistedValidationData>>, []> & QueryableStorageEntry<ApiType, []>;657      /**658       * Generic query659       **/660      [key: string]: QueryableStorageEntry<ApiType>;661    };662    randomnessCollectiveFlip: {663      /**664       * Series of block headers from the last 81 blocks that acts as random seed material. This665       * is arranged as a ring buffer with `block_number % 81` being the index into the `Vec` of666       * the oldest hash.667       **/668      randomMaterial: AugmentedQuery<ApiType, () => Observable<Vec<H256>>, []> & QueryableStorageEntry<ApiType, []>;669      /**670       * Generic query671       **/672      [key: string]: QueryableStorageEntry<ApiType>;673    };674    refungible: {675      /**676       * Amount of tokens (not pieces) partially owned by an account within a collection.677       **/678      accountBalance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u32>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;679      /**680       * Allowance set by a token owner for another user to perform one of certain transactions on a number of pieces of a token.681       **/682      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]>;683      /**684       * Amount of token pieces owned by account.685       **/686      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]>;687      /**688       * Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.689       **/690      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]>;691      /**692       * Used to enumerate tokens owned by account.693       **/694      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]>;695      /**696       * Token data, used to partially describe a token.697       **/698      tokenData: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<PalletRefungibleItemData>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;699      /**700       * Amount of pieces a refungible token is split into.701       **/702      tokenProperties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;703      /**704       * Amount of tokens burnt in a collection.705       **/706      tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;707      /**708       * Total amount of minted tokens in a collection.709       **/710      tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;711      /**712       * Total amount of pieces for token713       **/714      totalSupply: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;715      /**716       * Generic query717       **/718      [key: string]: QueryableStorageEntry<ApiType>;719    };720    rmrkCore: {721      /**722       * Latest yet-unused collection ID.723       **/724      collectionIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;725      /**726       * Mapping from RMRK collection ID to Unique's.727       **/728      uniqueCollectionId: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;729      /**730       * Generic query731       **/732      [key: string]: QueryableStorageEntry<ApiType>;733    };734    rmrkEquip: {735      /**736       * Checkmark that a Base has a Theme NFT named "default".737       **/738      baseHasDefaultTheme: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<bool>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;739      /**740       * Map of a Base ID and a Part ID to an NFT in the Base collection serving as the Part.741       **/742      inernalPartId: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;743      /**744       * Generic query745       **/746      [key: string]: QueryableStorageEntry<ApiType>;747    };748    session: {749      /**750       * Current index of the session.751       **/752      currentIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;753      /**754       * Indices of disabled validators.755       * 756       * The vec is always kept sorted so that we can find whether a given validator is757       * disabled using binary search. It gets cleared when `on_session_ending` returns758       * a new set of identities.759       **/760      disabledValidators: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;761      /**762       * The owner of a key. The key is the `KeyTypeId` + the encoded key.763       **/764      keyOwner: AugmentedQuery<ApiType, (arg: ITuple<[SpCoreCryptoKeyTypeId, Bytes]> | [SpCoreCryptoKeyTypeId | string | Uint8Array, Bytes | string | Uint8Array]) => Observable<Option<AccountId32>>, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]> & QueryableStorageEntry<ApiType, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]>;765      /**766       * The next session keys for a validator.767       **/768      nextKeys: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<OpalRuntimeRuntimeCommonSessionKeys>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;769      /**770       * True if the underlying economic identities or weighting behind the validators771       * has changed in the queued validator set.772       **/773      queuedChanged: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;774      /**775       * The queued keys for the next session. When the next session begins, these keys776       * will be used to determine the validator's session keys.777       **/778      queuedKeys: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[AccountId32, OpalRuntimeRuntimeCommonSessionKeys]>>>, []> & QueryableStorageEntry<ApiType, []>;779      /**780       * The current set of validators.781       **/782      validators: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;783      /**784       * Generic query785       **/786      [key: string]: QueryableStorageEntry<ApiType>;787    };788    structure: {789      /**790       * Generic query791       **/792      [key: string]: QueryableStorageEntry<ApiType>;793    };794    sudo: {795      /**796       * The `AccountId` of the sudo key.797       **/798      key: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;799      /**800       * Generic query801       **/802      [key: string]: QueryableStorageEntry<ApiType>;803    };804    system: {805      /**806       * The full account information for a particular account ID.807       **/808      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<FrameSystemAccountInfo>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;809      /**810       * Total length (in bytes) for all extrinsics put together, for the current block.811       **/812      allExtrinsicsLen: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;813      /**814       * Map of block numbers to block hashes.815       **/816      blockHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<H256>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;817      /**818       * The current weight for the block.819       **/820      blockWeight: AugmentedQuery<ApiType, () => Observable<FrameSupportDispatchPerDispatchClassWeight>, []> & QueryableStorageEntry<ApiType, []>;821      /**822       * Digest of the current block, also part of the block header.823       **/824      digest: AugmentedQuery<ApiType, () => Observable<SpRuntimeDigest>, []> & QueryableStorageEntry<ApiType, []>;825      /**826       * The number of events in the `Events<T>` list.827       **/828      eventCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;829      /**830       * Events deposited for the current block.831       * 832       * NOTE: The item is unbound and should therefore never be read on chain.833       * It could otherwise inflate the PoV size of a block.834       * 835       * Events have a large in-memory size. Box the events to not go out-of-memory836       * just in case someone still reads them from within the runtime.837       **/838      events: AugmentedQuery<ApiType, () => Observable<Vec<FrameSystemEventRecord>>, []> & QueryableStorageEntry<ApiType, []>;839      /**840       * Mapping between a topic (represented by T::Hash) and a vector of indexes841       * of events in the `<Events<T>>` list.842       * 843       * All topic vectors have deterministic storage locations depending on the topic. This844       * allows light-clients to leverage the changes trie storage tracking mechanism and845       * in case of changes fetch the list of events of interest.846       * 847       * The value has the type `(T::BlockNumber, EventIndex)` because if we used only just848       * the `EventIndex` then in case if the topic has the same contents on the next block849       * no notification will be triggered thus the event might be lost.850       **/851      eventTopics: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Vec<ITuple<[u32, u32]>>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;852      /**853       * The execution phase of the block.854       **/855      executionPhase: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemPhase>>, []> & QueryableStorageEntry<ApiType, []>;856      /**857       * Total extrinsics count for the current block.858       **/859      extrinsicCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;860      /**861       * Extrinsics data for the current block (maps an extrinsic's index to its data).862       **/863      extrinsicData: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;864      /**865       * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.866       **/867      lastRuntimeUpgrade: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemLastRuntimeUpgradeInfo>>, []> & QueryableStorageEntry<ApiType, []>;868      /**869       * The current block number being processed. Set by `execute_block`.870       **/871      number: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;872      /**873       * Hash of the previous block.874       **/875      parentHash: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;876      /**877       * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False878       * (default) if not.879       **/880      upgradedToTripleRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;881      /**882       * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.883       **/884      upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;885      /**886       * Generic query887       **/888      [key: string]: QueryableStorageEntry<ApiType>;889    };890    testUtils: {891      enabled: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;892      testValue: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;893      /**894       * Generic query895       **/896      [key: string]: QueryableStorageEntry<ApiType>;897    };898    timestamp: {899      /**900       * Did the timestamp get updated in this block?901       **/902      didUpdate: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;903      /**904       * Current time for the current block.905       **/906      now: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;907      /**908       * Generic query909       **/910      [key: string]: QueryableStorageEntry<ApiType>;911    };912    tokens: {913      /**914       * The balance of a token type under an account.915       * 916       * NOTE: If the total is ever zero, decrease account ref account.917       * 918       * NOTE: This is only used in the case that this module is used to store919       * balances.920       **/921      accounts: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<OrmlTokensAccountData>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;922      /**923       * Any liquidity locks of a token type under an account.924       * NOTE: Should only be accessed when setting, changing and freeing a lock.925       **/926      locks: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Vec<OrmlTokensBalanceLock>>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;927      /**928       * Named reserves on some account balances.929       **/930      reserves: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Vec<OrmlTokensReserveData>>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;931      /**932       * The total issuance of a token type.933       **/934      totalIssuance: AugmentedQuery<ApiType, (arg: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<u128>, [PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [PalletForeignAssetsAssetIds]>;935      /**936       * Generic query937       **/938      [key: string]: QueryableStorageEntry<ApiType>;939    };940    transactionPayment: {941      nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;942      storageVersion: AugmentedQuery<ApiType, () => Observable<PalletTransactionPaymentReleases>, []> & QueryableStorageEntry<ApiType, []>;943      /**944       * Generic query945       **/946      [key: string]: QueryableStorageEntry<ApiType>;947    };948    treasury: {949      /**950       * Proposal indices that have been approved but not yet awarded.951       **/952      approvals: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;953      /**954       * Number of proposals that have been made.955       **/956      proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;957      /**958       * Proposals that have been made.959       **/960      proposals: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletTreasuryProposal>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;961      /**962       * Generic query963       **/964      [key: string]: QueryableStorageEntry<ApiType>;965    };966    unique: {967      /**968       * Used for migrations969       **/970      chainVersion: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;971      /**972       * (Collection id (controlled?2), who created (real))973       * TODO: Off chain worker should remove from this map when collection gets removed974       **/975      createItemBasket: AugmentedQuery<ApiType, (arg: ITuple<[u32, AccountId32]> | [u32 | AnyNumber | Uint8Array, AccountId32 | string | Uint8Array]) => Observable<Option<u32>>, [ITuple<[u32, AccountId32]>]> & QueryableStorageEntry<ApiType, [ITuple<[u32, AccountId32]>]>;976      /**977       * Last sponsoring of fungible tokens approval in a collection978       **/979      fungibleApproveBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;980      /**981       * Collection id (controlled?2), owning user (real)982       **/983      fungibleTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;984      /**985       * Last sponsoring of NFT approval in a collection986       **/987      nftApproveBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;988      /**989       * Collection id (controlled?2), token id (controlled?2)990       **/991      nftTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;992      /**993       * Last sponsoring of RFT approval in a collection994       **/995      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]>;996      /**997       * Collection id (controlled?2), token id (controlled?2)998       **/999      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]>;1000      /**1001       * Last sponsoring of token property setting // todo:doc rephrase this and the following1002       **/1003      tokenPropertyBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1004      /**1005       * Variable metadata sponsoring1006       * Collection id (controlled?2), token id (controlled?2)1007       **/1008      variableMetaDataBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1009      /**1010       * Generic query1011       **/1012      [key: string]: QueryableStorageEntry<ApiType>;1013    };1014    vesting: {1015      /**1016       * Vesting schedules of an account.1017       * 1018       * VestingSchedules: map AccountId => Vec<VestingSchedule>1019       **/1020      vestingSchedules: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<OrmlVestingVestingSchedule>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;1021      /**1022       * Generic query1023       **/1024      [key: string]: QueryableStorageEntry<ApiType>;1025    };1026    xcmpQueue: {1027      /**1028       * Inbound aggregate XCMP messages. It can only be one per ParaId/block.1029       **/1030      inboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1031      /**1032       * Status of the inbound XCMP channels.1033       **/1034      inboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueInboundChannelDetails>>, []> & QueryableStorageEntry<ApiType, []>;1035      /**1036       * The messages outbound in a given XCMP channel.1037       **/1038      outboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u16 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u16]> & QueryableStorageEntry<ApiType, [u32, u16]>;1039      /**1040       * The non-empty XCMP channels in order of becoming non-empty, and the index of the first1041       * and last outbound message. If the two indices are equal, then it indicates an empty1042       * queue and there must be a non-`Ok` `OutboundStatus`. We assume queues grow no greater1043       * than 65535 items. Queue indices for normal messages begin at one; zero is reserved in1044       * case of the need to send a high-priority signal message this block.1045       * The bool is true if there is a signal message waiting to be sent.1046       **/1047      outboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueOutboundChannelDetails>>, []> & QueryableStorageEntry<ApiType, []>;1048      /**1049       * The messages that exceeded max individual message weight budget.1050       * 1051       * These message stay in this storage map until they are manually dispatched via1052       * `service_overweight`.1053       **/1054      overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;1055      /**1056       * The number of overweight messages ever recorded in `Overweight`. Also doubles as the next1057       * available free overweight index.1058       **/1059      overweightCount: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;1060      /**1061       * The configuration which controls the dynamics of the outbound queue.1062       **/1063      queueConfig: AugmentedQuery<ApiType, () => Observable<CumulusPalletXcmpQueueQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;1064      /**1065       * Whether or not the XCMP queue is suspended from executing incoming XCMs or not.1066       **/1067      queueSuspended: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;1068      /**1069       * Any signal messages waiting to be sent.1070       **/1071      signalMessages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1072      /**1073       * Generic query1074       **/1075      [key: string]: QueryableStorageEntry<ApiType>;1076    };1077  } // AugmentedQueries1078} // declare module