git.delta.rocks / unique-network / refs/commits / 65e077c4f014

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, PalletAuthorshipUncleEntryItem, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReserveData, PalletConfigurationAppPromotionConfiguration, PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmContractHelpersSponsoringModeT, PalletForeignAssetsAssetIds, PalletForeignAssetsModuleAssetMetadata, PalletIdentityRegistrarInfo, PalletIdentityRegistration, PalletNonfungibleItemData, PalletTransactionPaymentReleases, PalletTreasuryProposal, PhantomTypeUpDataStructs, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV2AbridgedHostConfiguration, PolkadotPrimitivesV2PersistedValidationData, PolkadotPrimitivesV2UpgradeRestriction, SpCoreCryptoKeyTypeId, SpRuntimeDigest, SpTrieStorageProof, SpWeightsWeightV2Weight, UpDataStructsCollection, UpDataStructsCollectionStats, UpDataStructsProperties, UpDataStructsPropertiesMapPropertyPermission, UpDataStructsPropertyPermission, UpDataStructsPropertyScope, UpDataStructsSponsorshipStateBasicCrossAccountIdRepr, UpDataStructsTokenChild, XcmV1MultiLocation } 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       * Stores amount of stakes 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 amount of stakes for an `Account`.49       * 50       * * **Key** - Staker account.51       * * **Value** - Amount of stakes.52       **/53      stakesPerAccount: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u8>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;54      /**55       * Stores the total staked amount.56       **/57      totalStaked: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;58      /**59       * Generic query60       **/61      [key: string]: QueryableStorageEntry<ApiType>;62    };63    authorship: {64      /**65       * Author of current block.66       **/67      author: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;68      /**69       * Whether uncles were already set in this block.70       **/71      didSetUncles: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;72      /**73       * Uncles74       **/75      uncles: AugmentedQuery<ApiType, () => Observable<Vec<PalletAuthorshipUncleEntryItem>>, []> & QueryableStorageEntry<ApiType, []>;76      /**77       * Generic query78       **/79      [key: string]: QueryableStorageEntry<ApiType>;80    };81    balances: {82      /**83       * The Balances pallet example of storing the balance of an account.84       * 85       * # Example86       * 87       * ```nocompile88       * impl pallet_balances::Config for Runtime {89       * type AccountStore = StorageMapShim<Self::Account<Runtime>, frame_system::Provider<Runtime>, AccountId, Self::AccountData<Balance>>90       * }91       * ```92       * 93       * You can also store the balance of an account in the `System` pallet.94       * 95       * # Example96       * 97       * ```nocompile98       * impl pallet_balances::Config for Runtime {99       * type AccountStore = System100       * }101       * ```102       * 103       * But this comes with tradeoffs, storing account balances in the system pallet stores104       * `frame_system` data alongside the account data contrary to storing account balances in the105       * `Balances` pallet, which uses a `StorageMap` to store balances data only.106       * NOTE: This is only used in the case that this pallet is used to store balances.107       **/108      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletBalancesAccountData>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;109      /**110       * The total units of outstanding deactivated balance in the system.111       **/112      inactiveIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;113      /**114       * Any liquidity locks on some account balances.115       * NOTE: Should only be accessed when setting, changing and freeing a lock.116       **/117      locks: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesBalanceLock>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;118      /**119       * Named reserves on some account balances.120       **/121      reserves: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesReserveData>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;122      /**123       * The total units issued in the system.124       **/125      totalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;126      /**127       * Generic query128       **/129      [key: string]: QueryableStorageEntry<ApiType>;130    };131    charging: {132      /**133       * Generic query134       **/135      [key: string]: QueryableStorageEntry<ApiType>;136    };137    collatorSelection: {138      /**139       * The (community, limited) collation candidates.140       **/141      candidates: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;142      /**143       * The invulnerable, fixed collators.144       **/145      invulnerables: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;146      /**147       * Last block authored by collator.148       **/149      lastAuthoredBlock: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u32>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;150      /**151       * The (community) collation license holders.152       **/153      licenseDepositOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<u128>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;154      /**155       * Generic query156       **/157      [key: string]: QueryableStorageEntry<ApiType>;158    };159    common: {160      /**161       * Storage of the amount of collection admins.162       **/163      adminAmount: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;164      /**165       * Allowlisted collection users.166       **/167      allowlist: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;168      /**169       * Storage of collection info.170       **/171      collectionById: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<UpDataStructsCollection>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;172      /**173       * Storage of collection properties.174       **/175      collectionProperties: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;176      /**177       * Storage of token property permissions of a collection.178       **/179      collectionPropertyPermissions: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<BTreeMap<Bytes, UpDataStructsPropertyPermission>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;180      /**181       * Storage of the count of created collections. Essentially contains the last collection ID.182       **/183      createdCollectionCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;184      /**185       * Storage of the count of deleted collections.186       **/187      destroyedCollectionCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;188      /**189       * Not used by code, exists only to provide some types to metadata.190       **/191      dummyStorageValue: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[UpDataStructsCollectionStats, u32, u32, UpDataStructsTokenChild, PhantomTypeUpDataStructs]>>>, []> & QueryableStorageEntry<ApiType, []>;192      /**193       * List of collection admins.194       **/195      isAdmin: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;196      /**197       * Generic query198       **/199      [key: string]: QueryableStorageEntry<ApiType>;200    };201    configuration: {202      appPromomotionConfigurationOverride: AugmentedQuery<ApiType, () => Observable<PalletConfigurationAppPromotionConfiguration>, []> & QueryableStorageEntry<ApiType, []>;203      collatorSelectionDesiredCollatorsOverride: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;204      collatorSelectionKickThresholdOverride: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;205      collatorSelectionLicenseBondOverride: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;206      minGasPriceOverride: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;207      weightToFeeCoefficientOverride: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;208      xcmAllowedLocationsOverride: AugmentedQuery<ApiType, () => Observable<Option<Vec<XcmV1MultiLocation>>>, []> & QueryableStorageEntry<ApiType, []>;209      /**210       * Generic query211       **/212      [key: string]: QueryableStorageEntry<ApiType>;213    };214    dataManagement: {215      migrationPending: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;216      /**217       * Generic query218       **/219      [key: string]: QueryableStorageEntry<ApiType>;220    };221    dmpQueue: {222      /**223       * The configuration.224       **/225      configuration: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;226      /**227       * The overweight messages.228       **/229      overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;230      /**231       * The page index.232       **/233      pageIndex: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueuePageIndexData>, []> & QueryableStorageEntry<ApiType, []>;234      /**235       * The queue pages.236       **/237      pages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, Bytes]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;238      /**239       * Generic query240       **/241      [key: string]: QueryableStorageEntry<ApiType>;242    };243    ethereum: {244      blockHash: AugmentedQuery<ApiType, (arg: U256 | AnyNumber | Uint8Array) => Observable<H256>, [U256]> & QueryableStorageEntry<ApiType, [U256]>;245      /**246       * The current Ethereum block.247       **/248      currentBlock: AugmentedQuery<ApiType, () => Observable<Option<EthereumBlock>>, []> & QueryableStorageEntry<ApiType, []>;249      /**250       * The current Ethereum receipts.251       **/252      currentReceipts: AugmentedQuery<ApiType, () => Observable<Option<Vec<EthereumReceiptReceiptV3>>>, []> & QueryableStorageEntry<ApiType, []>;253      /**254       * The current transaction statuses.255       **/256      currentTransactionStatuses: AugmentedQuery<ApiType, () => Observable<Option<Vec<FpRpcTransactionStatus>>>, []> & QueryableStorageEntry<ApiType, []>;257      /**258       * Injected transactions should have unique nonce, here we store current259       **/260      injectedNonce: AugmentedQuery<ApiType, () => Observable<U256>, []> & QueryableStorageEntry<ApiType, []>;261      /**262       * Current building block's transactions and receipts.263       **/264      pending: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[EthereumTransactionTransactionV2, FpRpcTransactionStatus, EthereumReceiptReceiptV3]>>>, []> & QueryableStorageEntry<ApiType, []>;265      /**266       * Generic query267       **/268      [key: string]: QueryableStorageEntry<ApiType>;269    };270    evm: {271      accountCodes: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Bytes>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;272      accountStorages: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H256 | string | Uint8Array) => Observable<H256>, [H160, H256]> & QueryableStorageEntry<ApiType, [H160, H256]>;273      /**274       * Written on log, reset after transaction275       * Should be empty between transactions276       **/277      currentLogs: AugmentedQuery<ApiType, () => Observable<Vec<EthereumLog>>, []> & QueryableStorageEntry<ApiType, []>;278      /**279       * Generic query280       **/281      [key: string]: QueryableStorageEntry<ApiType>;282    };283    evmCoderSubstrate: {284      /**285       * Generic query286       **/287      [key: string]: QueryableStorageEntry<ApiType>;288    };289    evmContractHelpers: {290      /**291       * Storage for users that allowed for sponsorship.292       * 293       * ### Usage294       * Prefer to delete record from storage if user no more allowed for sponsorship.295       * 296       * * **Key1** - contract address.297       * * **Key2** - user that allowed for sponsorship.298       * * **Value** - allowance for sponsorship.299       **/300      allowlist: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H160 | string | Uint8Array) => Observable<bool>, [H160, H160]> & QueryableStorageEntry<ApiType, [H160, H160]>;301      /**302       * Storege for contracts with [`Allowlisted`](SponsoringModeT::Allowlisted) sponsoring mode.303       * 304       * ### Usage305       * Prefer to delete collection from storage if mode chaged to non `Allowlisted`, than set **Value** to **false**.306       * 307       * * **Key** - contract address.308       * * **Value** - is contract in [`Allowlisted`](SponsoringModeT::Allowlisted) mode.309       **/310      allowlistEnabled: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;311      /**312       * Store owner for contract.313       * 314       * * **Key** - contract address.315       * * **Value** - owner for contract.316       **/317      owner: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<H160>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;318      selfSponsoring: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;319      sponsorBasket: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H160 | string | Uint8Array) => Observable<Option<u32>>, [H160, H160]> & QueryableStorageEntry<ApiType, [H160, H160]>;320      /**321       * Store for contract sponsorship state.322       * 323       * * **Key** - contract address.324       * * **Value** - sponsorship state.325       **/326      sponsoring: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<UpDataStructsSponsorshipStateBasicCrossAccountIdRepr>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;327      /**328       * Storage for last sponsored block.329       * 330       * * **Key1** - contract address.331       * * **Key2** - sponsored user address.332       * * **Value** - last sponsored block number.333       **/334      sponsoringFeeLimit: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<BTreeMap<u32, U256>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;335      /**336       * Store for sponsoring mode.337       * 338       * ### Usage339       * Prefer to delete collection from storage if mode chaged to [`Disabled`](SponsoringModeT::Disabled).340       * 341       * * **Key** - contract address.342       * * **Value** - [`sponsoring mode`](SponsoringModeT).343       **/344      sponsoringMode: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Option<PalletEvmContractHelpersSponsoringModeT>>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;345      /**346       * Storage for sponsoring rate limit in blocks.347       * 348       * * **Key** - contract address.349       * * **Value** - amount of sponsored blocks.350       **/351      sponsoringRateLimit: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<u32>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;352      /**353       * Generic query354       **/355      [key: string]: QueryableStorageEntry<ApiType>;356    };357    foreignAssets: {358      /**359       * The storages for assets to fungible collection binding360       * 361       **/362      assetBinding: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;363      /**364       * The storages for AssetMetadatas.365       * 366       * AssetMetadatas: map AssetIds => Option<AssetMetadata>367       **/368      assetMetadatas: AugmentedQuery<ApiType, (arg: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Option<PalletForeignAssetsModuleAssetMetadata>>, [PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [PalletForeignAssetsAssetIds]>;369      /**370       * The storages for MultiLocations.371       * 372       * ForeignAssetLocations: map ForeignAssetId => Option<MultiLocation>373       **/374      foreignAssetLocations: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<XcmV1MultiLocation>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;375      /**376       * The storages for CurrencyIds.377       * 378       * LocationToCurrencyIds: map MultiLocation => Option<ForeignAssetId>379       **/380      locationToCurrencyIds: AugmentedQuery<ApiType, (arg: XcmV1MultiLocation | { parents?: any; interior?: any } | string | Uint8Array) => Observable<Option<u32>>, [XcmV1MultiLocation]> & QueryableStorageEntry<ApiType, [XcmV1MultiLocation]>;381      /**382       * Next available Foreign AssetId ID.383       * 384       * NextForeignAssetId: ForeignAssetId385       **/386      nextForeignAssetId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;387      /**388       * Generic query389       **/390      [key: string]: QueryableStorageEntry<ApiType>;391    };392    fungible: {393      /**394       * Storage for assets delegated to a limited extent to other users.395       **/396      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]>;397      /**398       * Amount of tokens owned by an account inside a collection.399       **/400      balance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u128>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;401      /**402       * Total amount of fungible tokens inside a collection.403       **/404      totalSupply: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;405      /**406       * Generic query407       **/408      [key: string]: QueryableStorageEntry<ApiType>;409    };410    identity: {411      /**412       * Information that is pertinent to identify the entity behind an account.413       * 414       * TWOX-NOTE: OK ― `AccountId` is a secure hash.415       **/416      identityOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<PalletIdentityRegistration>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;417      /**418       * The set of registrars. Not expected to get very big as can only be added through a419       * special origin (likely a council motion).420       * 421       * The index into this can be cast to `RegistrarIndex` to get a valid value.422       **/423      registrars: AugmentedQuery<ApiType, () => Observable<Vec<Option<PalletIdentityRegistrarInfo>>>, []> & QueryableStorageEntry<ApiType, []>;424      /**425       * Alternative "sub" identities of this account.426       * 427       * The first item is the deposit, the second is a vector of the accounts.428       * 429       * TWOX-NOTE: OK ― `AccountId` is a secure hash.430       **/431      subsOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<ITuple<[u128, Vec<AccountId32>]>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;432      /**433       * The super-identity of an alternative "sub" identity together with its name, within that434       * context. If the account is not some other account's sub-identity, then just `None`.435       **/436      superOf: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<ITuple<[AccountId32, Data]>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;437      /**438       * Generic query439       **/440      [key: string]: QueryableStorageEntry<ApiType>;441    };442    inflation: {443      /**444       * Current inflation for `InflationBlockInterval` number of blocks445       **/446      blockInflation: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;447      /**448       * Next target (relay) block when inflation will be applied449       **/450      nextInflationBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;451      /**452       * Next target (relay) block when inflation is recalculated453       **/454      nextRecalculationBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;455      /**456       * Relay block when inflation has started457       **/458      startBlock: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;459      /**460       * starting year total issuance461       **/462      startingYearTotalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;463      /**464       * Generic query465       **/466      [key: string]: QueryableStorageEntry<ApiType>;467    };468    maintenance: {469      enabled: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;470      /**471       * Generic query472       **/473      [key: string]: QueryableStorageEntry<ApiType>;474    };475    nonfungible: {476      /**477       * Amount of tokens owned by an account in a collection.478       **/479      accountBalance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u32>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;480      /**481       * Allowance set by a token owner for another user to perform one of certain transactions on a token.482       **/483      allowance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletEvmAccountBasicCrossAccountIdRepr>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;484      /**485       * Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.486       **/487      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]>;488      /**489       * Used to enumerate tokens owned by account.490       **/491      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]>;492      /**493       * Custom data of a token that is serialized to bytes,494       * primarily reserved for on-chain operations,495       * normally obscured from the external users.496       * 497       * Auxiliary properties are slightly different from498       * usual [`TokenProperties`] due to an unlimited number499       * and separately stored and written-to key-value pairs.500       * 501       * Currently used to store RMRK data.502       **/503      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]>;504      /**505       * Used to enumerate token's children.506       **/507      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]>]>;508      /**509       * Token data, used to partially describe a token.510       **/511      tokenData: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNonfungibleItemData>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;512      /**513       * Map of key-value pairs, describing the metadata of a token.514       **/515      tokenProperties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;516      /**517       * Amount of burnt tokens in a collection.518       **/519      tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;520      /**521       * Total amount of minted tokens in a collection.522       **/523      tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;524      /**525       * Generic query526       **/527      [key: string]: QueryableStorageEntry<ApiType>;528    };529    parachainInfo: {530      parachainId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;531      /**532       * Generic query533       **/534      [key: string]: QueryableStorageEntry<ApiType>;535    };536    parachainSystem: {537      /**538       * The number of HRMP messages we observed in `on_initialize` and thus used that number for539       * announcing the weight of `on_initialize` and `on_finalize`.540       **/541      announcedHrmpMessagesPerCandidate: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;542      /**543       * The next authorized upgrade, if there is one.544       **/545      authorizedUpgrade: AugmentedQuery<ApiType, () => Observable<Option<H256>>, []> & QueryableStorageEntry<ApiType, []>;546      /**547       * A custom head data that should be returned as result of `validate_block`.548       * 549       * See [`Pallet::set_custom_validation_head_data`] for more information.550       **/551      customValidationHeadData: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;552      /**553       * Were the validation data set to notify the relay chain?554       **/555      didSetValidationCode: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;556      /**557       * The parachain host configuration that was obtained from the relay parent.558       * 559       * This field is meant to be updated each block with the validation data inherent. Therefore,560       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.561       * 562       * This data is also absent from the genesis.563       **/564      hostConfiguration: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV2AbridgedHostConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;565      /**566       * HRMP messages that were sent in a block.567       * 568       * This will be cleared in `on_initialize` of each new block.569       **/570      hrmpOutboundMessages: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotCorePrimitivesOutboundHrmpMessage>>, []> & QueryableStorageEntry<ApiType, []>;571      /**572       * HRMP watermark that was set in a block.573       * 574       * This will be cleared in `on_initialize` of each new block.575       **/576      hrmpWatermark: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;577      /**578       * The last downward message queue chain head we have observed.579       * 580       * This value is loaded before and saved after processing inbound downward messages carried581       * by the system inherent.582       **/583      lastDmqMqcHead: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;584      /**585       * The message queue chain heads we have observed per each channel incoming channel.586       * 587       * This value is loaded before and saved after processing inbound downward messages carried588       * by the system inherent.589       **/590      lastHrmpMqcHeads: AugmentedQuery<ApiType, () => Observable<BTreeMap<u32, H256>>, []> & QueryableStorageEntry<ApiType, []>;591      /**592       * The relay chain block number associated with the last parachain block.593       **/594      lastRelayChainBlockNumber: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;595      /**596       * Validation code that is set by the parachain and is to be communicated to collator and597       * consequently the relay-chain.598       * 599       * This will be cleared in `on_initialize` of each new block if no other pallet already set600       * the value.601       **/602      newValidationCode: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;603      /**604       * Upward messages that are still pending and not yet send to the relay chain.605       **/606      pendingUpwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;607      /**608       * In case of a scheduled upgrade, this storage field contains the validation code to be applied.609       * 610       * As soon as the relay chain gives us the go-ahead signal, we will overwrite the [`:code`][well_known_keys::CODE]611       * which will result the next block process with the new validation code. This concludes the upgrade process.612       * 613       * [well_known_keys::CODE]: sp_core::storage::well_known_keys::CODE614       **/615      pendingValidationCode: AugmentedQuery<ApiType, () => Observable<Bytes>, []> & QueryableStorageEntry<ApiType, []>;616      /**617       * Number of downward messages processed in a block.618       * 619       * This will be cleared in `on_initialize` of each new block.620       **/621      processedDownwardMessages: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;622      /**623       * The state proof for the last relay parent block.624       * 625       * This field is meant to be updated each block with the validation data inherent. Therefore,626       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.627       * 628       * This data is also absent from the genesis.629       **/630      relayStateProof: AugmentedQuery<ApiType, () => Observable<Option<SpTrieStorageProof>>, []> & QueryableStorageEntry<ApiType, []>;631      /**632       * The snapshot of some state related to messaging relevant to the current parachain as per633       * the relay parent.634       * 635       * This field is meant to be updated each block with the validation data inherent. Therefore,636       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.637       * 638       * This data is also absent from the genesis.639       **/640      relevantMessagingState: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot>>, []> & QueryableStorageEntry<ApiType, []>;641      /**642       * The weight we reserve at the beginning of the block for processing DMP messages. This643       * overrides the amount set in the Config trait.644       **/645      reservedDmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;646      /**647       * The weight we reserve at the beginning of the block for processing XCMP messages. This648       * overrides the amount set in the Config trait.649       **/650      reservedXcmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<SpWeightsWeightV2Weight>>, []> & QueryableStorageEntry<ApiType, []>;651      /**652       * An option which indicates if the relay-chain restricts signalling a validation code upgrade.653       * In other words, if this is `Some` and [`NewValidationCode`] is `Some` then the produced654       * candidate will be invalid.655       * 656       * This storage item is a mirror of the corresponding value for the current parachain from the657       * relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is658       * set after the inherent.659       **/660      upgradeRestrictionSignal: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV2UpgradeRestriction>>, []> & QueryableStorageEntry<ApiType, []>;661      /**662       * Upward messages that were sent in a block.663       * 664       * This will be cleared in `on_initialize` of each new block.665       **/666      upwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;667      /**668       * The [`PersistedValidationData`] set for this block.669       * This value is expected to be set only once per block and it's never stored670       * in the trie.671       **/672      validationData: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV2PersistedValidationData>>, []> & QueryableStorageEntry<ApiType, []>;673      /**674       * Generic query675       **/676      [key: string]: QueryableStorageEntry<ApiType>;677    };678    randomnessCollectiveFlip: {679      /**680       * Series of block headers from the last 81 blocks that acts as random seed material. This681       * is arranged as a ring buffer with `block_number % 81` being the index into the `Vec` of682       * the oldest hash.683       **/684      randomMaterial: AugmentedQuery<ApiType, () => Observable<Vec<H256>>, []> & QueryableStorageEntry<ApiType, []>;685      /**686       * Generic query687       **/688      [key: string]: QueryableStorageEntry<ApiType>;689    };690    refungible: {691      /**692       * Amount of tokens (not pieces) partially owned by an account within a collection.693       **/694      accountBalance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u32>, [u32, PalletEvmAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletEvmAccountBasicCrossAccountIdRepr]>;695      /**696       * Allowance set by a token owner for another user to perform one of certain transactions on a number of pieces of a token.697       **/698      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]>;699      /**700       * Amount of token pieces owned by account.701       **/702      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]>;703      /**704       * Operator set by a wallet owner that could perform certain transactions on all tokens in the wallet.705       **/706      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]>;707      /**708       * Used to enumerate tokens owned by account.709       **/710      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]>;711      /**712       * Amount of pieces a refungible token is split into.713       **/714      tokenProperties: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<UpDataStructsProperties>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;715      /**716       * Amount of tokens burnt in a collection.717       **/718      tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;719      /**720       * Total amount of minted tokens in a collection.721       **/722      tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;723      /**724       * Total amount of pieces for token725       **/726      totalSupply: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;727      /**728       * Generic query729       **/730      [key: string]: QueryableStorageEntry<ApiType>;731    };732    rmrkCore: {733      /**734       * Latest yet-unused collection ID.735       **/736      collectionIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;737      /**738       * Mapping from RMRK collection ID to Unique's.739       **/740      uniqueCollectionId: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;741      /**742       * Generic query743       **/744      [key: string]: QueryableStorageEntry<ApiType>;745    };746    rmrkEquip: {747      /**748       * Checkmark that a Base has a Theme NFT named "default".749       **/750      baseHasDefaultTheme: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<bool>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;751      /**752       * Map of a Base ID and a Part ID to an NFT in the Base collection serving as the Part.753       **/754      inernalPartId: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;755      /**756       * Generic query757       **/758      [key: string]: QueryableStorageEntry<ApiType>;759    };760    session: {761      /**762       * Current index of the session.763       **/764      currentIndex: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;765      /**766       * Indices of disabled validators.767       * 768       * The vec is always kept sorted so that we can find whether a given validator is769       * disabled using binary search. It gets cleared when `on_session_ending` returns770       * a new set of identities.771       **/772      disabledValidators: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;773      /**774       * The owner of a key. The key is the `KeyTypeId` + the encoded key.775       **/776      keyOwner: AugmentedQuery<ApiType, (arg: ITuple<[SpCoreCryptoKeyTypeId, Bytes]> | [SpCoreCryptoKeyTypeId | string | Uint8Array, Bytes | string | Uint8Array]) => Observable<Option<AccountId32>>, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]> & QueryableStorageEntry<ApiType, [ITuple<[SpCoreCryptoKeyTypeId, Bytes]>]>;777      /**778       * The next session keys for a validator.779       **/780      nextKeys: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<OpalRuntimeRuntimeCommonSessionKeys>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;781      /**782       * True if the underlying economic identities or weighting behind the validators783       * has changed in the queued validator set.784       **/785      queuedChanged: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;786      /**787       * The queued keys for the next session. When the next session begins, these keys788       * will be used to determine the validator's session keys.789       **/790      queuedKeys: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[AccountId32, OpalRuntimeRuntimeCommonSessionKeys]>>>, []> & QueryableStorageEntry<ApiType, []>;791      /**792       * The current set of validators.793       **/794      validators: AugmentedQuery<ApiType, () => Observable<Vec<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;795      /**796       * Generic query797       **/798      [key: string]: QueryableStorageEntry<ApiType>;799    };800    structure: {801      /**802       * Generic query803       **/804      [key: string]: QueryableStorageEntry<ApiType>;805    };806    sudo: {807      /**808       * The `AccountId` of the sudo key.809       **/810      key: AugmentedQuery<ApiType, () => Observable<Option<AccountId32>>, []> & QueryableStorageEntry<ApiType, []>;811      /**812       * Generic query813       **/814      [key: string]: QueryableStorageEntry<ApiType>;815    };816    system: {817      /**818       * The full account information for a particular account ID.819       **/820      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<FrameSystemAccountInfo>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;821      /**822       * Total length (in bytes) for all extrinsics put together, for the current block.823       **/824      allExtrinsicsLen: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;825      /**826       * Map of block numbers to block hashes.827       **/828      blockHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<H256>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;829      /**830       * The current weight for the block.831       **/832      blockWeight: AugmentedQuery<ApiType, () => Observable<FrameSupportDispatchPerDispatchClassWeight>, []> & QueryableStorageEntry<ApiType, []>;833      /**834       * Digest of the current block, also part of the block header.835       **/836      digest: AugmentedQuery<ApiType, () => Observable<SpRuntimeDigest>, []> & QueryableStorageEntry<ApiType, []>;837      /**838       * The number of events in the `Events<T>` list.839       **/840      eventCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;841      /**842       * Events deposited for the current block.843       * 844       * NOTE: The item is unbound and should therefore never be read on chain.845       * It could otherwise inflate the PoV size of a block.846       * 847       * Events have a large in-memory size. Box the events to not go out-of-memory848       * just in case someone still reads them from within the runtime.849       **/850      events: AugmentedQuery<ApiType, () => Observable<Vec<FrameSystemEventRecord>>, []> & QueryableStorageEntry<ApiType, []>;851      /**852       * Mapping between a topic (represented by T::Hash) and a vector of indexes853       * of events in the `<Events<T>>` list.854       * 855       * All topic vectors have deterministic storage locations depending on the topic. This856       * allows light-clients to leverage the changes trie storage tracking mechanism and857       * in case of changes fetch the list of events of interest.858       * 859       * The value has the type `(T::BlockNumber, EventIndex)` because if we used only just860       * the `EventIndex` then in case if the topic has the same contents on the next block861       * no notification will be triggered thus the event might be lost.862       **/863      eventTopics: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Vec<ITuple<[u32, u32]>>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;864      /**865       * The execution phase of the block.866       **/867      executionPhase: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemPhase>>, []> & QueryableStorageEntry<ApiType, []>;868      /**869       * Total extrinsics count for the current block.870       **/871      extrinsicCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;872      /**873       * Extrinsics data for the current block (maps an extrinsic's index to its data).874       **/875      extrinsicData: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;876      /**877       * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.878       **/879      lastRuntimeUpgrade: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemLastRuntimeUpgradeInfo>>, []> & QueryableStorageEntry<ApiType, []>;880      /**881       * The current block number being processed. Set by `execute_block`.882       **/883      number: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;884      /**885       * Hash of the previous block.886       **/887      parentHash: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;888      /**889       * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False890       * (default) if not.891       **/892      upgradedToTripleRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;893      /**894       * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.895       **/896      upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;897      /**898       * Generic query899       **/900      [key: string]: QueryableStorageEntry<ApiType>;901    };902    testUtils: {903      enabled: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;904      testValue: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;905      /**906       * Generic query907       **/908      [key: string]: QueryableStorageEntry<ApiType>;909    };910    timestamp: {911      /**912       * Did the timestamp get updated in this block?913       **/914      didUpdate: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;915      /**916       * Current time for the current block.917       **/918      now: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;919      /**920       * Generic query921       **/922      [key: string]: QueryableStorageEntry<ApiType>;923    };924    tokens: {925      /**926       * The balance of a token type under an account.927       * 928       * NOTE: If the total is ever zero, decrease account ref account.929       * 930       * NOTE: This is only used in the case that this module is used to store931       * balances.932       **/933      accounts: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<OrmlTokensAccountData>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;934      /**935       * Any liquidity locks of a token type under an account.936       * NOTE: Should only be accessed when setting, changing and freeing a lock.937       **/938      locks: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Vec<OrmlTokensBalanceLock>>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;939      /**940       * Named reserves on some account balances.941       **/942      reserves: AugmentedQuery<ApiType, (arg1: AccountId32 | string | Uint8Array, arg2: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<Vec<OrmlTokensReserveData>>, [AccountId32, PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [AccountId32, PalletForeignAssetsAssetIds]>;943      /**944       * The total issuance of a token type.945       **/946      totalIssuance: AugmentedQuery<ApiType, (arg: PalletForeignAssetsAssetIds | { ForeignAssetId: any } | { NativeAssetId: any } | string | Uint8Array) => Observable<u128>, [PalletForeignAssetsAssetIds]> & QueryableStorageEntry<ApiType, [PalletForeignAssetsAssetIds]>;947      /**948       * Generic query949       **/950      [key: string]: QueryableStorageEntry<ApiType>;951    };952    transactionPayment: {953      nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;954      storageVersion: AugmentedQuery<ApiType, () => Observable<PalletTransactionPaymentReleases>, []> & QueryableStorageEntry<ApiType, []>;955      /**956       * Generic query957       **/958      [key: string]: QueryableStorageEntry<ApiType>;959    };960    treasury: {961      /**962       * Proposal indices that have been approved but not yet awarded.963       **/964      approvals: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;965      /**966       * The amount which has been reported as inactive to Currency.967       **/968      inactive: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;969      /**970       * Number of proposals that have been made.971       **/972      proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;973      /**974       * Proposals that have been made.975       **/976      proposals: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletTreasuryProposal>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;977      /**978       * Generic query979       **/980      [key: string]: QueryableStorageEntry<ApiType>;981    };982    unique: {983      /**984       * Used for migrations985       **/986      chainVersion: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;987      /**988       * (Collection id (controlled?2), who created (real))989       * TODO: Off chain worker should remove from this map when collection gets removed990       **/991      createItemBasket: AugmentedQuery<ApiType, (arg: ITuple<[u32, AccountId32]> | [u32 | AnyNumber | Uint8Array, AccountId32 | string | Uint8Array]) => Observable<Option<u32>>, [ITuple<[u32, AccountId32]>]> & QueryableStorageEntry<ApiType, [ITuple<[u32, AccountId32]>]>;992      /**993       * Last sponsoring of fungible tokens approval in a collection994       **/995      fungibleApproveBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;996      /**997       * Collection id (controlled?2), owning user (real)998       **/999      fungibleTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<Option<u32>>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;1000      /**1001       * Last sponsoring of NFT approval in a collection1002       **/1003      nftApproveBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1004      /**1005       * Collection id (controlled?2), token id (controlled?2)1006       **/1007      nftTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1008      /**1009       * Last sponsoring of RFT approval in a collection1010       **/1011      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]>;1012      /**1013       * Collection id (controlled?2), token id (controlled?2)1014       **/1015      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]>;1016      /**1017       * Last sponsoring of token property setting // todo:doc rephrase this and the following1018       **/1019      tokenPropertyBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1020      /**1021       * Variable metadata sponsoring1022       * Collection id (controlled?2), token id (controlled?2)1023       **/1024      variableMetaDataBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1025      /**1026       * Generic query1027       **/1028      [key: string]: QueryableStorageEntry<ApiType>;1029    };1030    vesting: {1031      /**1032       * Vesting schedules of an account.1033       * 1034       * VestingSchedules: map AccountId => Vec<VestingSchedule>1035       **/1036      vestingSchedules: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<OrmlVestingVestingSchedule>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;1037      /**1038       * Generic query1039       **/1040      [key: string]: QueryableStorageEntry<ApiType>;1041    };1042    xcmpQueue: {1043      /**1044       * Inbound aggregate XCMP messages. It can only be one per ParaId/block.1045       **/1046      inboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;1047      /**1048       * Status of the inbound XCMP channels.1049       **/1050      inboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueInboundChannelDetails>>, []> & QueryableStorageEntry<ApiType, []>;1051      /**1052       * The messages outbound in a given XCMP channel.1053       **/1054      outboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u16 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u16]> & QueryableStorageEntry<ApiType, [u32, u16]>;1055      /**1056       * The non-empty XCMP channels in order of becoming non-empty, and the index of the first1057       * and last outbound message. If the two indices are equal, then it indicates an empty1058       * queue and there must be a non-`Ok` `OutboundStatus`. We assume queues grow no greater1059       * than 65535 items. Queue indices for normal messages begin at one; zero is reserved in1060       * case of the need to send a high-priority signal message this block.1061       * The bool is true if there is a signal message waiting to be sent.1062       **/1063      outboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<CumulusPalletXcmpQueueOutboundChannelDetails>>, []> & QueryableStorageEntry<ApiType, []>;1064      /**1065       * The messages that exceeded max individual message weight budget.1066       * 1067       * These message stay in this storage map until they are manually dispatched via1068       * `service_overweight`.1069       **/1070      overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;1071      /**1072       * The number of overweight messages ever recorded in `Overweight`. Also doubles as the next1073       * available free overweight index.1074       **/1075      overweightCount: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;1076      /**1077       * The configuration which controls the dynamics of the outbound queue.1078       **/1079      queueConfig: AugmentedQuery<ApiType, () => Observable<CumulusPalletXcmpQueueQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;1080      /**1081       * Whether or not the XCMP queue is suspended from executing incoming XCMs or not.1082       **/1083      queueSuspended: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;1084      /**1085       * Any signal messages waiting to be sent.1086       **/1087      signalMessages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;1088      /**1089       * Generic query1090       **/1091      [key: string]: QueryableStorageEntry<ApiType>;1092    };1093  } // AugmentedQueries1094} // declare module