git.delta.rocks / unique-network / refs/commits / 3b4aae883c1e

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, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmpQueueInboundChannelDetails, CumulusPalletXcmpQueueOutboundChannelDetails, CumulusPalletXcmpQueueQueueConfigData, EthereumBlock, EthereumLog, EthereumReceiptReceiptV3, EthereumTransactionTransactionV2, FpRpcTransactionStatus, FrameSupportDispatchPerDispatchClassWeight, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, OpalRuntimeRuntimeCommonSessionKeys, OrmlTokensAccountData, OrmlTokensBalanceLock, OrmlTokensReserveData, OrmlVestingVestingSchedule, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReserveData, PalletConfigurationAppPromotionConfiguration, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmContractHelpersSponsoringModeT, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletIdentityRegistrarInfo, PalletIdentityRegistration, PalletNonfungibleItemData, PalletPreimageRequestStatus, PalletTransactionPaymentReleases, PalletTreasuryProposal, PalletXcmQueryStatus, PalletXcmRemoteLockedFungibleRecord, PalletXcmVersionMigrationStage, PhantomTypeUpDataStructs, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, 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      upgradedToReserves: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;59      /**60       * Generic query61       **/62      [key: string]: QueryableStorageEntry<ApiType>;63    };64    aura: {65      /**66       * The current authority set.67       **/68      authorities: AugmentedQuery<ApiType, () => Observable<Vec<SpConsensusAuraSr25519AppSr25519Public>>, []> & QueryableStorageEntry<ApiType, []>;69      /**70       * The current slot of this block.71       * 72       * This will be set in `on_initialize`.73       **/74      currentSlot: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;75      /**76       * Generic query77       **/78      [key: string]: QueryableStorageEntry<ApiType>;79    };80    auraExt: {81      /**82       * Serves as cache for the authorities.83       * 84       * The authorities in AuRa are overwritten in `on_initialize` when we switch to a new session,85       * but we require the old authorities to verify the seal when validating a PoV. This will always86       * be updated to the latest AuRa authorities in `on_finalize`.87       **/88      authorities: AugmentedQuery<ApiType, () => Observable<Vec<SpConsensusAuraSr25519AppSr25519Public>>, []> & QueryableStorageEntry<ApiType, []>;89      /**90       * Generic query91       **/92      [key: string]: QueryableStorageEntry<ApiType>;93    };94    authorship: {95      /**96       * Author of current block.97       **/98      author: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;99      /**100       * Generic query101       **/102      [key: string]: QueryableStorageEntry<ApiType>;103    };104    balances: {105      /**106       * The Balances pallet example of storing the balance of an account.107       * 108       * # Example109       * 110       * ```nocompile111       * impl pallet_balances::Config for Runtime {112       * type AccountStore = StorageMapShim<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>113       * }114       * ```115       * 116       * You can also store the balance of an account in the `System` pallet.117       * 118       * # Example119       * 120       * ```nocompile121       * impl pallet_balances::Config for Runtime {122       * type AccountStore = System123       * }124       * ```125       * 126       * But this comes with tradeoffs, storing account balances in the system pallet stores127       * `frame_system` data alongside the account data contrary to storing account balances in the128       * `Balances` pallet, which uses a `StorageMap` to store balances data only.129       * NOTE: This is only used in the case that this pallet is used to store balances.130       **/131      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletBalancesAccountData>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;132      /**133       * The total units of outstanding deactivated balance in the system.134       **/135      inactiveIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;136      /**137       * Any liquidity locks on some account balances.138       * NOTE: Should only be accessed when setting, changing and freeing a lock.139       **/140      locks: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesBalanceLock>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;141      /**142       * Named reserves on some account balances.143       **/144      reserves: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesReserveData>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;145      /**146       * The total units issued in the system.147       **/148      totalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;149      /**150       * Generic query151       **/152      [key: string]: QueryableStorageEntry<ApiType>;153    };154    charging: {155      /**156       * Generic query157       **/158      [key: string]: QueryableStorageEntry<ApiType>;159    };160    collatorSelection: {161      /**162       * The (community, limited) collation candidates.163       **/164      candidates: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;165      /**166       * The invulnerable, fixed collators.167       **/168      invulnerables: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;169      /**170       * Last block authored by collator.171       **/172      lastAuthoredBlock: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u32>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;173      /**174       * The (community) collation license holders.175       **/176      licenseDepositOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u128>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;177      /**178       * Generic query179       **/180      [key: string]: QueryableStorageEntry<ApiType>;181    };182    common: {183      /**184       * Storage of the amount of collection admins.185       **/186      adminAmount: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;187      /**188       * Allowlisted collection users.189       **/190      allowlist: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;191      /**192       * Storage of collection info.193       **/194      collectionById: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<UpDataStructsCollection>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;195      /**196       * Storage of collection properties.197       **/198      collectionProperties: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;199      /**200       * Storage of token property permissions of a collection.201       **/202      collectionPropertyPermissions: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsPropertiesMapPropertyPermission>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;203      /**204       * Storage of the count of created collections. Essentially contains the last collection ID.205       **/206      createdCollectionCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;207      /**208       * Storage of the count of deleted collections.209       **/210      destroyedCollectionCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;211      /**212       * Not used by code, exists only to provide some types to metadata.213       **/214      dummyStorageValue: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[UpDataStructsCollectionStats, u32, u32, UpDataStructsTokenChild, PhantomTypeUpDataStructs]>>>, []> & QueryableStorageEntry<ApiType, []>;215      /**216       * List of collection admins.217       **/218      isAdmin: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;219      /**220       * Generic query221       **/222      [key: string]: QueryableStorageEntry<ApiType>;223    };224    configuration: {225      appPromomotionConfigurationOverride: AugmentedQuery<ApiType, () => Observable<PalletConfigurationAppPromotionConfiguration>, []> & QueryableStorageEntry<ApiType, []>;226      collatorSelectionDesiredCollatorsOverride: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;227      collatorSelectionKickThresholdOverride: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;228      collatorSelectionLicenseBondOverride: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;229      minGasPriceOverride: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;230      weightToFeeCoefficientOverride: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;231      /**232       * Generic query233       **/234      [key: string]: QueryableStorageEntry<ApiType>;235    };236    dmpQueue: {237      /**238       * The configuration.239       **/240      configuration: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;241      /**242       * Counter for the related counted storage map243       **/244      counterForOverweight: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;245      /**246       * The overweight messages.247       **/248      overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;249      /**250       * The page index.251       **/252      pageIndex: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueuePageIndexData>, []> & QueryableStorageEntry<ApiType, []>;253      /**254       * The queue pages.255       **/256      pages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, Bytes]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;257      /**258       * Generic query259       **/260      [key: string]: QueryableStorageEntry<ApiType>;261    };262    ethereum: {263      blockHash: AugmentedQuery<ApiType, (arg: U256 | AnyNumber | Uint8Array) => Observable<H256>, [U256]> & QueryableStorageEntry<ApiType, [U256]>;264      /**265       * The current Ethereum block.266       **/267      currentBlock: AugmentedQuery<ApiType, () => Observable<Option<EthereumBlock>>, []> & QueryableStorageEntry<ApiType, []>;268      /**269       * The current Ethereum receipts.270       **/271      currentReceipts: AugmentedQuery<ApiType, () => Observable<Option<Vec<EthereumReceiptReceiptV3>>>, []> & QueryableStorageEntry<ApiType, []>;272      /**273       * The current transaction statuses.274       **/275      currentTransactionStatuses: AugmentedQuery<ApiType, () => Observable<Option<Vec<FpRpcTransactionStatus>>>, []> & QueryableStorageEntry<ApiType, []>;276      /**277       * Injected transactions should have unique nonce, here we store current278       **/279      injectedNonce: AugmentedQuery<ApiType, () => Observable<U256>, []> & QueryableStorageEntry<ApiType, []>;280      /**281       * Current building block's transactions and receipts.282       **/283      pending: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[EthereumTransactionTransactionV2, FpRpcTransactionStatus, EthereumReceiptReceiptV3]>>>, []> & QueryableStorageEntry<ApiType, []>;284      /**285       * Generic query286       **/287      [key: string]: QueryableStorageEntry<ApiType>;288    };289    evm: {290      accountCodes: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Bytes>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;291      accountStorages: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H256 | string | Uint8Array) => Observable<H256>, [H160, H256]> & QueryableStorageEntry<ApiType, [H160, H256]>;292      /**293       * Written on log, reset after transaction294       * Should be empty between transactions295       **/296      currentLogs: AugmentedQuery<ApiType, () => Observable<Vec<EthereumLog>>, []> & QueryableStorageEntry<ApiType, []>;297      /**298       * Generic query299       **/300      [key: string]: QueryableStorageEntry<ApiType>;301    };302    evmContractHelpers: {303      /**304       * Storage for users that allowed for sponsorship.305       * 306       * ### Usage307       * Prefer to delete record from storage if user no more allowed for sponsorship.308       * 309       * * **Key1** - contract address.310       * * **Key2** - user that allowed for sponsorship.311       * * **Value** - allowance for sponsorship.312       **/313      allowlist: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H160 | string | Uint8Array) => Observable<bool>, [H160, H160]> & QueryableStorageEntry<ApiType, [H160, H160]>;314      /**315       * Storege for contracts with [`Allowlisted`](SponsoringModeT::Allowlisted) sponsoring mode.316       * 317       * ### Usage318       * Prefer to delete collection from storage if mode chaged to non `Allowlisted`, than set **Value** to **false**.319       * 320       * * **Key** - contract address.321       * * **Value** - is contract in [`Allowlisted`](SponsoringModeT::Allowlisted) mode.322       **/323      allowlistEnabled: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;324      /**325       * Store owner for contract.326       * 327       * * **Key** - contract address.328       * * **Value** - owner for contract.329       **/330      owner: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<H160>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;331      /**332       * Deprecated: this storage is deprecated333       **/334      selfSponsoring: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;335      sponsorBasket: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H160 | string | Uint8Array) => Observable<Option<u32>>, [H160, H160]> & QueryableStorageEntry<ApiType, [H160, H160]>;336      /**337       * Store for contract sponsorship state.338       * 339       * * **Key** - contract address.340       * * **Value** - sponsorship state.341       **/342      sponsoring: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<UpDataStructsSponsorshipStateBasicCrossAccountIdRepr>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;343      /**344       * Storage for last sponsored block.345       * 346       * * **Key1** - contract address.347       * * **Key2** - sponsored user address.348       * * **Value** - last sponsored block number.349       **/350      sponsoringFeeLimit: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<BTreeMap<u32, U256>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;351      /**352       * Store for sponsoring mode.353       * 354       * ### Usage355       * Prefer to delete collection from storage if mode chaged to [`Disabled`](SponsoringModeT::Disabled).356       * 357       * * **Key** - contract address.358       * * **Value** - [`sponsoring mode`](SponsoringModeT).359       **/360      sponsoringMode: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<PalletEvmContractHelpersSponsoringModeT>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;361      /**362       * Storage for sponsoring rate limit in blocks.363       * 364       * * **Key** - contract address.365       * * **Value** - amount of sponsored blocks.366       **/367      sponsoringRateLimit: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<u32>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;368      /**369       * Generic query370       **/371      [key: string]: QueryableStorageEntry<ApiType>;372    };373    evmMigration: {374      migrationPending: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;375      /**376       * Generic query377       **/378      [key: string]: QueryableStorageEntry<ApiType>;379    };380    foreignAssets: {381      /**382       * The storages for assets to fungible collection binding383       * 384       **/385      assetBinding: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;386      /**387       * The storages for AssetMetadatas.388       * 389       * AssetMetadatas: map AssetIds => Option<AssetMetadata>390       **/391      assetMetadatas: AugmentedQuery<ApiType, (arg: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Option<PalletForeignAssetsModuleAssetMetadata>>, [PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [PalletForeignAssetsAssetIds]>;392      /**393       * The storages for MultiLocations.394       * 395       * ForeignAssetLocations: map ForeignAssetId => Option<MultiLocation>396       **/397      foreignAssetLocations: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<XcmV3MultiLocation>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;398      /**399       * The storages for CurrencyIds.400       * 401       * LocationToCurrencyIds: map MultiLocation => Option<ForeignAssetId>402       **/403      locationToCurrencyIds: AugmentedQuery<ApiType, (arg: XcmV3MultiLocation | { parents?: any; interior?: any } | string | Uint8Array) => Observable<Option<u32>>, [XcmV3MultiLocation]> & QueryableStorageEntry<ApiType, [XcmV3MultiLocation]>;404      /**405       * Next available Foreign AssetId ID.406       * 407       * NextForeignAssetId: ForeignAssetId408       **/409      nextForeignAssetId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;410      /**411       * Generic query412       **/413      [key: string]: QueryableStorageEntry<ApiType>;414    };415    fungible: {416      /**417       * Storage for assets delegated to a limited extent to other users.418       **/419      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]>;420      /**421       * Amount of tokens owned by an account inside a collection.422       **/423      balance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u128>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;424      /**425       * Total amount of fungible tokens inside a collection.426       **/427      totalSupply: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;428      /**429       * Generic query430       **/431      [key: string]: QueryableStorageEntry<ApiType>;432    };433    identity: {434      /**435       * Information that is pertinent to identify the entity behind an account.436       * 437       * TWOX-NOTE: OK ― `AccountId` is a secure hash.438       **/439      identityOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletIdentityRegistration>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;440      /**441       * The set of registrars. Not expected to get very big as can only be added through a442       * special origin (likely a council motion).443       * 444       * The index into this can be cast to `RegistrarIndex` to get a valid value.445       **/446      registrars: AugmentedQuery<ApiType, () => Observable<Vec<Option<PalletIdentityRegistrarInfo>>>, []> & QueryableStorageEntry<ApiType, []>;447      /**448       * Alternative "sub" identities of this account.449       * 450       * The first item is the deposit, the second is a vector of the accounts.451       * 452       * TWOX-NOTE: OK ― `AccountId` is a secure hash.453       **/454      subsOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[u128, Vec<AccountId32>]>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;455      /**456       * The super-identity of an alternative "sub" identity together with its name, within that457       * context. If the account is not some other account's sub-identity, then just `None`.458       **/459      superOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<ITuple<[AccountId32, Data]>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;460      /**461       * Generic query462       **/463      [key: string]: QueryableStorageEntry<ApiType>;464    };465    inflation: {466      /**467       * Current inflation for `InflationBlockInterval` number of blocks468       **/469      blockInflation: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;470      /**471       * Next target (relay) block when inflation will be applied472       **/473      nextInflationBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;474      /**475       * Next target (relay) block when inflation is recalculated476       **/477      nextRecalculationBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;478      /**479       * Relay block when inflation has started480       **/481      startBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;482      /**483       * starting year total issuance484       **/485      startingYearTotalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;486      /**487       * Generic query488       **/489      [key: string]: QueryableStorageEntry<ApiType>;490    };491    maintenance: {492      enabled: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;493      /**494       * Generic query495       **/496      [key: string]: QueryableStorageEntry<ApiType>;497    };498    nonfungible: {499      /**500       * Amount of tokens owned by an account in a collection.501       **/502      accountBalance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u32>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;503      /**504       * Allowance set by a token owner for another user to perform one of certain transactions on a token.505       **/506      allowance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletEvmAccountBasicCrossAccountIdRepr>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;507      /**508       * Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.509       **/510      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]>;511      /**512       * Used to enumerate tokens owned by account.513       **/514      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]>;515      /**516       * Custom data of a token that is serialized to bytes,517       * primarily reserved for on-chain operations,518       * normally obscured from the external users.519       * 520       * Auxiliary properties are slightly different from521       * usual [`TokenProperties`] due to an unlimited number522       * and separately stored and written-to key-value pairs.523       * 524       * Currently unused.525       **/526      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]>;527      /**528       * Used to enumerate token's children.529       **/530      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]>]>;531      /**532       * Token data, used to partially describe a token.533       **/534      tokenData: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNonfungibleItemData>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;535      /**536       * Map of key-value pairs, describing the metadata of a token.537       **/538      tokenProperties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;539      /**540       * Amount of burnt tokens in a collection.541       **/542      tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;543      /**544       * Total amount of minted tokens in a collection.545       **/546      tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;547      /**548       * Generic query549       **/550      [key: string]: QueryableStorageEntry<ApiType>;551    };552    parachainInfo: {553      parachainId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;554      /**555       * Generic query556       **/557      [key: string]: QueryableStorageEntry<ApiType>;558    };559    parachainSystem: {560      /**561       * The number of HRMP messages we observed in `on_initialize` and thus used that number for562       * announcing the weight of `on_initialize` and `on_finalize`.563       **/564      announcedHrmpMessagesPerCandidate: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;565      /**566       * The next authorized upgrade, if there is one.567       **/568      authorizedUpgrade: AugmentedQuery<ApiType, () => Observable<Option<H256>>, []> & QueryableStorageEntry<ApiType, []>;569      /**570       * A custom head data that should be returned as result of `validate_block`.571       * 572       * See [`Pallet::set_custom_validation_head_data`] for more information.573       **/574      customValidationHeadData: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;575      /**576       * Were the validation data set to notify the relay chain?577       **/578      didSetValidationCode: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;579      /**580       * The parachain host configuration that was obtained from the relay parent.581       * 582       * This field is meant to be updated each block with the validation data inherent. Therefore,583       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.584       * 585       * This data is also absent from the genesis.586       **/587      hostConfiguration: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV2AbridgedHostConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;588      /**589       * HRMP messages that were sent in a block.590       * 591       * This will be cleared in `on_initialize` of each new block.592       **/593      hrmpOutboundMessages: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotCorePrimitivesOutboundHrmpMessage>>, []> & QueryableStorageEntry<ApiType, []>;594      /**595       * HRMP watermark that was set in a block.596       * 597       * This will be cleared in `on_initialize` of each new block.598       **/599      hrmpWatermark: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;600      /**601       * The last downward message queue chain head we have observed.602       * 603       * This value is loaded before and saved after processing inbound downward messages carried604       * by the system inherent.605       **/606      lastDmqMqcHead: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;607      /**608       * The message queue chain heads we have observed per each channel incoming channel.609       * 610       * This value is loaded before and saved after processing inbound downward messages carried611       * by the system inherent.612       **/613      lastHrmpMqcHeads: AugmentedQuery<ApiType, () => Observable<BTreeMap<u32, H256>>, []> & QueryableStorageEntry<ApiType, []>;614      /**615       * The relay chain block number associated with the last parachain block.616       **/617      lastRelayChainBlockNumber: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;618      /**619       * Validation code that is set by the parachain and is to be communicated to collator and620       * consequently the relay-chain.621       * 622       * This will be cleared in `on_initialize` of each new block if no other pallet already set623       * the value.624       **/625      newValidationCode: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;626      /**627       * Upward messages that are still pending and not yet send to the relay chain.628       **/629      pendingUpwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;630      /**631       * In case of a scheduled upgrade, this storage field contains the validation code to be applied.632       * 633       * As soon as the relay chain gives us the go-ahead signal, we will overwrite the [`:code`][well_known_keys::CODE]634       * which will result the next block process with the new validation code. This concludes the upgrade process.635       * 636       * [well_known_keys::CODE]: sp_core::storage::well_known_keys::CODE637       **/638      pendingValidationCode: AugmentedQuery<ApiType, () => Observable<Bytes>, []> & QueryableStorageEntry<ApiType, []>;639      /**640       * Number of downward messages processed in a block.641       * 642       * This will be cleared in `on_initialize` of each new block.643       **/644      processedDownwardMessages: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;645      /**646       * The state proof for the last relay parent block.647       * 648       * This field is meant to be updated each block with the validation data inherent. Therefore,649       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.650       * 651       * This data is also absent from the genesis.652       **/653      relayStateProof: AugmentedQuery<ApiType, () => Observable<Option<SpTrieStorageProof>>, []> & QueryableStorageEntry<ApiType, []>;654      /**655       * The snapshot of some state related to messaging relevant to the current parachain as per656       * the relay parent.657       * 658       * This field is meant to be updated each block with the validation data inherent. Therefore,659       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.660       * 661       * This data is also absent from the genesis.662       **/663      relevantMessagingState: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot>>, []> & QueryableStorageEntry<ApiType, []>;664      /**665       * The weight we reserve at the beginning of the block for processing DMP messages. This666       * overrides the amount set in the Config trait.667       **/668      reservedDmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;669      /**670       * The weight we reserve at the beginning of the block for processing XCMP messages. This671       * overrides the amount set in the Config trait.672       **/673      reservedXcmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;674      /**675       * An option which indicates if the relay-chain restricts signalling a validation code upgrade.676       * In other words, if this is `Some` and [`NewValidationCode`] is `Some` then the produced677       * candidate will be invalid.678       * 679       * This storage item is a mirror of the corresponding value for the current parachain from the680       * relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is681       * set after the inherent.682       **/683      upgradeRestrictionSignal: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV2UpgradeRestriction>>, []> & QueryableStorageEntry<ApiType, []>;684      /**685       * Upward messages that were sent in a block.686       * 687       * This will be cleared in `on_initialize` of each new block.688       **/689      upwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;690      /**691       * The [`PersistedValidationData`] set for this block.692       * This value is expected to be set only once per block and it's never stored693       * in the trie.694       **/695      validationData: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV2PersistedValidationData>>, []> & QueryableStorageEntry<ApiType, []>;696      /**697       * Generic query698       **/699      [key: string]: QueryableStorageEntry<ApiType>;700    };701    polkadotXcm: {702      /**703       * The existing asset traps.704       * 705       * Key is the blake2 256 hash of (origin, versioned `MultiAssets`) pair. Value is the number of706       * times this pair has been trapped (usually just 1 if it exists at all).707       **/708      assetTraps: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<u32>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;709      /**710       * The current migration's stage, if any.711       **/712      currentMigration: AugmentedQuery<ApiType, () => Observable<Option<PalletXcmVersionMigrationStage>>, []> & QueryableStorageEntry<ApiType, []>;713      /**714       * Fungible assets which we know are locked on this chain.715       **/716      lockedFungibles: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<Vec<ITuple<[u128, XcmVersionedMultiLocation]>>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;717      /**718       * The ongoing queries.719       **/720      queries: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<PalletXcmQueryStatus>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;721      /**722       * The latest available query index.723       **/724      queryCounter: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;725      /**726       * Fungible assets which we know are locked on a remote chain.727       **/728      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]>;729      /**730       * Default version to encode XCM when latest version of destination is unknown. If `None`,731       * then the destinations whose XCM version is unknown are considered unreachable.732       **/733      safeXcmVersion: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;734      /**735       * The Latest versions that we know various locations support.736       **/737      supportedVersion: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => Observable<Option<u32>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedMultiLocation]>;738      /**739       * Destinations whose latest XCM version we would like to know. Duplicates not allowed, and740       * the `u32` counter is the number of times that a send to the destination has been attempted,741       * which is used as a prioritization.742       **/743      versionDiscoveryQueue: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[XcmVersionedMultiLocation, u32]>>>, []> & QueryableStorageEntry<ApiType, []>;744      /**745       * All locations that we have requested version notifications from.746       **/747      versionNotifiers: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: XcmVersionedMultiLocation | { V2: any } | { V3: any } | string | Uint8Array) => Observable<Option<u64>>, [u32, XcmVersionedMultiLocation]> & QueryableStorageEntry<ApiType, [u32, XcmVersionedMultiLocation]>;748      /**749       * The target locations that are subscribed to our version changes, as well as the most recent750       * of our versions we informed them of.751       **/752      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]>;753      /**754       * Generic query755       **/756      [key: string]: QueryableStorageEntry<ApiType>;757    };758    preimage: {759      preimageFor: AugmentedQuery<ApiType, (arg: ITuple<[H256, u32]> | [H256 | string | Uint8Array, u32 | AnyNumber | Uint8Array]) => Observable<Option<Bytes>>, [ITuple<[H256, u32]>]> & QueryableStorageEntry<ApiType, [ITuple<[H256, u32]>]>;760      /**761       * The request status of a given hash.762       **/763      statusFor: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Option<PalletPreimageRequestStatus>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;764      /**765       * Generic query766       **/767      [key: string]: QueryableStorageEntry<ApiType>;768    };769    refungible: {770      /**771       * Amount of tokens (not pieces) partially owned by an account within a collection.772       **/773      accountBalance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u32>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;774      /**775       * Allowance set by a token owner for another user to perform one of certain transactions on a number of pieces of a token.776       **/777      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]>;778      /**779       * Amount of token pieces owned by account.780       **/781      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]>;782      /**783       * Spender set by a wallet owner that could perform certain transactions on all tokens in the wallet.784       **/785      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]>;786      /**787       * Used to enumerate tokens owned by account.788       **/789      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]>;790      /**791       * Amount of pieces a refungible token is split into.792       **/793      tokenProperties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;794      /**795       * Amount of tokens burnt in a collection.796       **/797      tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;798      /**799       * Total amount of minted tokens in a collection.800       **/801      tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;802      /**803       * Total amount of pieces for token804       **/805      totalSupply: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;806      /**807       * Generic query808       **/809      [key: string]: QueryableStorageEntry<ApiType>;810    };811    session: {812      /**813       * Current index of the session.814       **/815      currentIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;816      /**817       * Indices of disabled validators.818       * 819       * The vec is always kept sorted so that we can find whether a given validator is820       * disabled using binary search. It gets cleared when `on_session_ending` returns821       * a new set of identities.822       **/823      disabledValidators: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;824      /**825       * The owner of a key. The key is the `KeyTypeId` + the encoded key.826       **/827      keyOwner: AugmentedQuery<ApiType, (arg: ITuple<[SpCoreCryptoKeyTypeId, Bytes]> | [SpCoreCryptoKeyTypeId | string | Uint8Array, Bytes | string | Uint8Array]) => Observable<Option<AccountId32>>, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]> & QueryableStorageEntry<ApiType, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]>;828      /**829       * The next session keys for a validator.830       **/831      nextKeys: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<OpalRuntimeRuntimeCommonSessionKeys>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;832      /**833       * True if the underlying economic identities or weighting behind the validators834       * has changed in the queued validator set.835       **/836      queuedChanged: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;837      /**838       * The queued keys for the next session. When the next session begins, these keys839       * will be used to determine the validator's session keys.840       **/841      queuedKeys: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[AccountId32, OpalRuntimeRuntimeCommonSessionKeys]>>>, []> & QueryableStorageEntry<ApiType, []>;842      /**843       * The current set of validators.844       **/845      validators: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;846      /**847       * Generic query848       **/849      [key: string]: QueryableStorageEntry<ApiType>;850    };851    sudo: {852      /**853       * The `AccountId` of the sudo key.854       **/855      key: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;856      /**857       * Generic query858       **/859      [key: string]: QueryableStorageEntry<ApiType>;860    };861    system: {862      /**863       * The full account information for a particular account ID.864       **/865      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<FrameSystemAccountInfo>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;866      /**867       * Total length (in bytes) for all extrinsics put together, for the current block.868       **/869      allExtrinsicsLen: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;870      /**871       * Map of block numbers to block hashes.872       **/873      blockHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<H256>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;874      /**875       * The current weight for the block.876       **/877      blockWeight: AugmentedQuery<ApiType, () => Observable<FrameSupportDispatchPerDispatchClassWeight>, []> & QueryableStorageEntry<ApiType, []>;878      /**879       * Digest of the current block, also part of the block header.880       **/881      digest: AugmentedQuery<ApiType, () => Observable<SpRuntimeDigest>, []> & QueryableStorageEntry<ApiType, []>;882      /**883       * The number of events in the `Events<T>` list.884       **/885      eventCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;886      /**887       * Events deposited for the current block.888       * 889       * NOTE: The item is unbound and should therefore never be read on chain.890       * It could otherwise inflate the PoV size of a block.891       * 892       * Events have a large in-memory size. Box the events to not go out-of-memory893       * just in case someone still reads them from within the runtime.894       **/895      events: AugmentedQuery<ApiType, () => Observable<Vec<FrameSystemEventRecord>>, []> & QueryableStorageEntry<ApiType, []>;896      /**897       * Mapping between a topic (represented by T::Hash) and a vector of indexes898       * of events in the `<Events<T>>` list.899       * 900       * All topic vectors have deterministic storage locations depending on the topic. This901       * allows light-clients to leverage the changes trie storage tracking mechanism and902       * in case of changes fetch the list of events of interest.903       * 904       * The value has the type `(T::BlockNumber, EventIndex)` because if we used only just905       * the `EventIndex` then in case if the topic has the same contents on the next block906       * no notification will be triggered thus the event might be lost.907       **/908      eventTopics: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Vec<ITuple<[u32, u32]>>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;909      /**910       * The execution phase of the block.911       **/912      executionPhase: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemPhase>>, []> & QueryableStorageEntry<ApiType, []>;913      /**914       * Total extrinsics count for the current block.915       **/916      extrinsicCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;917      /**918       * Extrinsics data for the current block (maps an extrinsic's index to its data).919       **/920      extrinsicData: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;921      /**922       * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.923       **/924      lastRuntimeUpgrade: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemLastRuntimeUpgradeInfo>>, []> & QueryableStorageEntry<ApiType, []>;925      /**926       * The current block number being processed. Set by `execute_block`.927       **/928      number: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;929      /**930       * Hash of the previous block.931       **/932      parentHash: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;933      /**934       * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False935       * (default) if not.936       **/937      upgradedToTripleRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;938      /**939       * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.940       **/941      upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;942      /**943       * Generic query944       **/945      [key: string]: QueryableStorageEntry<ApiType>;946    };947    testUtils: {948      enabled: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;949      testValue: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;950      /**951       * Generic query952       **/953      [key: string]: QueryableStorageEntry<ApiType>;954    };955    timestamp: {956      /**957       * Did the timestamp get updated in this block?958       **/959      didUpdate: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;960      /**961       * Current time for the current block.962       **/963      now: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;964      /**965       * Generic query966       **/967      [key: string]: QueryableStorageEntry<ApiType>;968    };969    tokens: {970      /**971       * The balance of a token type under an account.972       * 973       * NOTE: If the total is ever zero, decrease account ref account.974       * 975       * NOTE: This is only used in the case that this module is used to store976       * balances.977       **/978      accounts: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<OrmlTokensAccountData>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;979      /**980       * Any liquidity locks of a token type under an account.981       * NOTE: Should only be accessed when setting, changing and freeing a lock.982       **/983      locks: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Vec<OrmlTokensBalanceLock>>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;984      /**985       * Named reserves on some account balances.986       **/987      reserves: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Vec<OrmlTokensReserveData>>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;988      /**989       * The total issuance of a token type.990       **/991      totalIssuance: AugmentedQuery<ApiType, (arg: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<u128>, [PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [PalletForeignAssetsAssetIds]>;992      /**993       * Generic query994       **/995      [key: string]: QueryableStorageEntry<ApiType>;996    };997    transactionPayment: {998      nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;999      storageVersion: AugmentedQuery<ApiType, () => Observable<PalletTransactionPaymentReleases>, []> & QueryableStorageEntry<ApiType, []>;1000      /**1001       * Generic query1002       **/1003      [key: string]: QueryableStorageEntry<ApiType>;1004    };1005    treasury: {1006      /**1007       * Proposal indices that have been approved but not yet awarded.1008       **/1009      approvals: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;1010      /**1011       * The amount which has been reported as inactive to Currency.1012       **/1013      deactivated: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;1014      /**1015       * Number of proposals that have been made.1016       **/1017      proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;1018      /**1019       * Proposals that have been made.1020       **/1021      proposals: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletTreasuryProposal>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1022      /**1023       * Generic query1024       **/1025      [key: string]: QueryableStorageEntry<ApiType>;1026    };1027    unique: {1028      /**1029       * Used for migrations1030       **/1031      chainVersion: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;1032      /**1033       * (Collection id (controlled?2), who created (real))1034       * TODO: Off chain worker should remove from this map when collection gets removed1035       **/1036      createItemBasket: AugmentedQuery<ApiType, (arg: ITuple<[u32, AccountId32]> | [u32 | AnyNumber | Uint8Array, AccountId32 | string | Uint8Array]) => Observable<Option<u32>>, [ITuple<[u32, AccountId32]>]> & QueryableStorageEntry<ApiType, [ITuple<[u32, AccountId32]>]>;1037      /**1038       * Last sponsoring of fungible tokens approval in a collection1039       **/1040      fungibleApproveBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;1041      /**1042       * Collection id (controlled?2), owning user (real)1043       **/1044      fungibleTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;1045      /**1046       * Last sponsoring of NFT approval in a collection1047       **/1048      nftApproveBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1049      /**1050       * Collection id (controlled?2), token id (controlled?2)1051       **/1052      nftTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1053      /**1054       * Last sponsoring of RFT approval in a collection1055       **/1056      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]>;1057      /**1058       * Collection id (controlled?2), token id (controlled?2)1059       **/1060      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]>;1061      /**1062       * Last sponsoring of token property setting // todo:doc rephrase this and the following1063       **/1064      tokenPropertyBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1065      /**1066       * Variable metadata sponsoring1067       * Collection id (controlled?2), token id (controlled?2)1068       **/1069      variableMetaDataBasket: 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