git.delta.rocks / unique-network / refs/commits / 579977f0c7c7

--- /dev/null
+++ b/tests/src/interfaces/augment-api-consts.ts
@@ -0,0 +1,177 @@
+// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
+/* eslint-disable */
+
+import type { ApiTypes } from '@polkadot/api/types';
+import type { Vec, u128, u16, u32, u64, u8 } from '@polkadot/types';
+import type { Permill } from '@polkadot/types/interfaces/runtime';
+import type { FrameSupportPalletId, FrameSupportWeightsRuntimeDbWeight, FrameSupportWeightsWeightToFeeCoefficient, FrameSystemLimitsBlockLength, FrameSystemLimitsBlockWeights, SpVersionRuntimeVersion } from '@polkadot/types/lookup';
+import type { Codec } from '@polkadot/types/types';
+
+declare module '@polkadot/api/types/consts' {
+  export interface AugmentedConsts<ApiType> {
+    balances: {
+      /**
+       * The minimum amount required to keep an account open.
+       **/
+      existentialDeposit: u128 & AugmentedConst<ApiType>;
+      /**
+       * The maximum number of locks that should exist on an account.
+       * Not strictly enforced, but used for weight estimation.
+       **/
+      maxLocks: u32 & AugmentedConst<ApiType>;
+      /**
+       * The maximum number of named reserves that can exist on an account.
+       **/
+      maxReserves: u32 & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
+    };
+    common: {
+      collectionAdminsLimit: u32 & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
+    };
+    inflation: {
+      inflationBlockInterval: u32 & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
+    };
+    system: {
+      /**
+       * Maximum number of block number to block hash mappings to keep (oldest pruned first).
+       **/
+      blockHashCount: u32 & AugmentedConst<ApiType>;
+      /**
+       * The maximum length of a block (in bytes).
+       **/
+      blockLength: FrameSystemLimitsBlockLength & AugmentedConst<ApiType>;
+      /**
+       * Block & extrinsics weights: base values and limits.
+       **/
+      blockWeights: FrameSystemLimitsBlockWeights & AugmentedConst<ApiType>;
+      /**
+       * The weight of runtime database operations the runtime can invoke.
+       **/
+      dbWeight: FrameSupportWeightsRuntimeDbWeight & AugmentedConst<ApiType>;
+      /**
+       * The designated SS85 prefix of this chain.
+       * 
+       * This replaces the "ss58Format" property declared in the chain spec. Reason is
+       * that the runtime should know about the prefix in order to make use of it as
+       * an identifier of the chain.
+       **/
+      ss58Prefix: u16 & AugmentedConst<ApiType>;
+      /**
+       * Get the chain's current version.
+       **/
+      version: SpVersionRuntimeVersion & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
+    };
+    timestamp: {
+      /**
+       * The minimum period between blocks. Beware that this is different to the *expected*
+       * period that the block production apparatus provides. Your chosen consensus system will
+       * generally work with this to determine a sensible block time. e.g. For Aura, it will be
+       * double this period on default settings.
+       **/
+      minimumPeriod: u64 & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
+    };
+    transactionPayment: {
+      /**
+       * A fee mulitplier for `Operational` extrinsics to compute "virtual tip" to boost their
+       * `priority`
+       * 
+       * This value is multipled by the `final_fee` to obtain a "virtual tip" that is later
+       * added to a tip component in regular `priority` calculations.
+       * It means that a `Normal` transaction can front-run a similarly-sized `Operational`
+       * extrinsic (with no tip), by including a tip value greater than the virtual tip.
+       * 
+       * ```rust,ignore
+       * // For `Normal`
+       * let priority = priority_calc(tip);
+       * 
+       * // For `Operational`
+       * let virtual_tip = (inclusion_fee + tip) * OperationalFeeMultiplier;
+       * let priority = priority_calc(tip + virtual_tip);
+       * ```
+       * 
+       * Note that since we use `final_fee` the multiplier applies also to the regular `tip`
+       * sent with the transaction. So, not only does the transaction get a priority bump based
+       * on the `inclusion_fee`, but we also amplify the impact of tips applied to `Operational`
+       * transactions.
+       **/
+      operationalFeeMultiplier: u8 & AugmentedConst<ApiType>;
+      /**
+       * The fee to be paid for making a transaction; the per-byte portion.
+       **/
+      transactionByteFee: u128 & AugmentedConst<ApiType>;
+      /**
+       * The polynomial that is applied in order to derive fee from weight.
+       **/
+      weightToFee: Vec<FrameSupportWeightsWeightToFeeCoefficient> & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
+    };
+    treasury: {
+      /**
+       * Percentage of spare funds (if any) that are burnt per spend period.
+       **/
+      burn: Permill & AugmentedConst<ApiType>;
+      /**
+       * The maximum number of approvals that can wait in the spending queue.
+       **/
+      maxApprovals: u32 & AugmentedConst<ApiType>;
+      /**
+       * The treasury's pallet id, used for deriving its sovereign account ID.
+       **/
+      palletId: FrameSupportPalletId & AugmentedConst<ApiType>;
+      /**
+       * Fraction of a proposal's value that should be bonded in order to place the proposal.
+       * An accepted proposal gets these back. A rejected proposal does not.
+       **/
+      proposalBond: Permill & AugmentedConst<ApiType>;
+      /**
+       * Minimum amount of funds that should be placed in a deposit for making a proposal.
+       **/
+      proposalBondMinimum: u128 & AugmentedConst<ApiType>;
+      /**
+       * Period between successive spends.
+       **/
+      spendPeriod: u32 & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
+    };
+    vesting: {
+      maxVestingSchedules: u32 & AugmentedConst<ApiType>;
+      /**
+       * The minimum amount transferred to call `vested_transfer`.
+       **/
+      minVestedTransfer: u128 & AugmentedConst<ApiType>;
+      /**
+       * Generic const
+       **/
+      [key: string]: Codec;
+    };
+  }
+
+  export interface QueryableConsts<ApiType extends ApiTypes> extends AugmentedConsts<ApiType> {
+    [key: string]: QueryableModuleConsts;
+  }
+}

--- /dev/null
+++ b/tests/src/interfaces/augment-api-errors.ts
@@ -0,0 +1,528 @@
+// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
+/* eslint-disable */
+
+import type { ApiTypes } from '@polkadot/api/types';
+
+declare module '@polkadot/api/types/errors' {
+  export interface AugmentedErrors<ApiType> {
+    balances: {
+      /**
+       * Beneficiary account must pre-exist
+       **/
+      DeadAccount: AugmentedError<ApiType>;
+      /**
+       * Value too low to create account due to existential deposit
+       **/
+      ExistentialDeposit: AugmentedError<ApiType>;
+      /**
+       * A vesting schedule already exists for this account
+       **/
+      ExistingVestingSchedule: AugmentedError<ApiType>;
+      /**
+       * Balance too low to send value
+       **/
+      InsufficientBalance: AugmentedError<ApiType>;
+      /**
+       * Transfer/payment would kill account
+       **/
+      KeepAlive: AugmentedError<ApiType>;
+      /**
+       * Account liquidity restrictions prevent withdrawal
+       **/
+      LiquidityRestrictions: AugmentedError<ApiType>;
+      /**
+       * Number of named reserves exceed MaxReserves
+       **/
+      TooManyReserves: AugmentedError<ApiType>;
+      /**
+       * Vesting balance too high to send value
+       **/
+      VestingBalance: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    common: {
+      /**
+       * Account token limit exceeded per collection
+       **/
+      AccountTokenLimitExceeded: AugmentedError<ApiType>;
+      /**
+       * Can't transfer tokens to ethereum zero address
+       **/
+      AddressIsZero: AugmentedError<ApiType>;
+      /**
+       * Address is not in white list.
+       **/
+      AddressNotInAllowlist: AugmentedError<ApiType>;
+      /**
+       * Tried to approve more than owned
+       **/
+      CantApproveMoreThanOwned: AugmentedError<ApiType>;
+      /**
+       * Exceeded max admin amount
+       **/
+      CollectionAdminAmountExceeded: AugmentedError<ApiType>;
+      /**
+       * Collection description can not be longer than 255 char.
+       **/
+      CollectionDescriptionLimitExceeded: AugmentedError<ApiType>;
+      /**
+       * Collection name can not be longer than 63 char.
+       **/
+      CollectionNameLimitExceeded: AugmentedError<ApiType>;
+      /**
+       * This collection does not exist.
+       **/
+      CollectionNotFound: AugmentedError<ApiType>;
+      /**
+       * Collection token limit exceeded
+       **/
+      CollectionTokenLimitExceeded: AugmentedError<ApiType>;
+      /**
+       * Token prefix can not be longer than 15 char.
+       **/
+      CollectionTokenPrefixLimitExceeded: AugmentedError<ApiType>;
+      /**
+       * Metadata flag frozen
+       **/
+      MetadataFlagFrozen: AugmentedError<ApiType>;
+      /**
+       * Sender parameter and item owner must be equal.
+       **/
+      MustBeTokenOwner: AugmentedError<ApiType>;
+      /**
+       * No permission to perform action
+       **/
+      NoPermission: AugmentedError<ApiType>;
+      /**
+       * Collection is not in mint mode.
+       **/
+      PublicMintingNotAllowed: AugmentedError<ApiType>;
+      /**
+       * Item not exists.
+       **/
+      TokenNotFound: AugmentedError<ApiType>;
+      /**
+       * Requested value more than approved.
+       **/
+      TokenValueNotEnough: AugmentedError<ApiType>;
+      /**
+       * Item balance not enough.
+       **/
+      TokenValueTooLow: AugmentedError<ApiType>;
+      /**
+       * variable_data exceeded data limit.
+       **/
+      TokenVariableDataLimitExceeded: AugmentedError<ApiType>;
+      /**
+       * Total collections bound exceeded.
+       **/
+      TotalCollectionsLimitExceeded: AugmentedError<ApiType>;
+      /**
+       * Collection settings not allowing items transferring
+       **/
+      TransferNotAllowed: AugmentedError<ApiType>;
+      /**
+       * Target collection doesn't supports this operation
+       **/
+      UnsupportedOperation: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    cumulusXcm: {
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    dmpQueue: {
+      /**
+       * The amount of weight given is possibly not enough for executing the message.
+       **/
+      OverLimit: AugmentedError<ApiType>;
+      /**
+       * The message index given is unknown.
+       **/
+      Unknown: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    ethereum: {
+      /**
+       * Signature is invalid.
+       **/
+      InvalidSignature: AugmentedError<ApiType>;
+      /**
+       * Pre-log is present, therefore transact is not allowed.
+       **/
+      PreLogExists: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    evm: {
+      /**
+       * Not enough balance to perform action
+       **/
+      BalanceLow: AugmentedError<ApiType>;
+      /**
+       * Calculating total fee overflowed
+       **/
+      FeeOverflow: AugmentedError<ApiType>;
+      /**
+       * Gas price is too low.
+       **/
+      GasPriceTooLow: AugmentedError<ApiType>;
+      /**
+       * Nonce is invalid
+       **/
+      InvalidNonce: AugmentedError<ApiType>;
+      /**
+       * Calculating total payment overflowed
+       **/
+      PaymentOverflow: AugmentedError<ApiType>;
+      /**
+       * Withdraw fee failed
+       **/
+      WithdrawFailed: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    evmCoderSubstrate: {
+      OutOfFund: AugmentedError<ApiType>;
+      OutOfGas: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    evmContractHelpers: {
+      /**
+       * This method is only executable by owner
+       **/
+      NoPermission: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    evmMigration: {
+      AccountIsNotMigrating: AugmentedError<ApiType>;
+      AccountNotEmpty: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    fungible: {
+      /**
+       * Tried to set data for fungible item
+       **/
+      FungibleItemsHaveData: AugmentedError<ApiType>;
+      /**
+       * Not default id passed as TokenId argument
+       **/
+      FungibleItemsHaveNoId: AugmentedError<ApiType>;
+      /**
+       * Not Fungible item data used to mint in Fungible collection.
+       **/
+      NotFungibleDataUsedToMintFungibleCollectionToken: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    nft: {
+      /**
+       * Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.
+       **/
+      CollectionDecimalPointLimitExceeded: AugmentedError<ApiType>;
+      /**
+       * Collection limit bounds per collection exceeded
+       **/
+      CollectionLimitBoundsExceeded: AugmentedError<ApiType>;
+      /**
+       * This address is not set as sponsor, use setCollectionSponsor first.
+       **/
+      ConfirmUnsetSponsorFail: AugmentedError<ApiType>;
+      /**
+       * Length of items properties must be greater than 0.
+       **/
+      EmptyArgument: AugmentedError<ApiType>;
+      /**
+       * Tried to enable permissions which are only permitted to be disabled
+       **/
+      OwnerPermissionsCantBeReverted: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    nonfungible: {
+      /**
+       * Used amount > 1 with NFT
+       **/
+      NonfungibleItemsHaveNoAmount: AugmentedError<ApiType>;
+      /**
+       * Not Nonfungible item data used to mint in Nonfungible collection.
+       **/
+      NotNonfungibleDataUsedToMintFungibleCollectionToken: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    parachainSystem: {
+      /**
+       * The inherent which supplies the host configuration did not run this block
+       **/
+      HostConfigurationNotAvailable: AugmentedError<ApiType>;
+      /**
+       * No code upgrade has been authorized.
+       **/
+      NothingAuthorized: AugmentedError<ApiType>;
+      /**
+       * No validation function upgrade is currently scheduled.
+       **/
+      NotScheduled: AugmentedError<ApiType>;
+      /**
+       * Attempt to upgrade validation function while existing upgrade pending
+       **/
+      OverlappingUpgrades: AugmentedError<ApiType>;
+      /**
+       * Polkadot currently prohibits this parachain from upgrading its validation function
+       **/
+      ProhibitedByPolkadot: AugmentedError<ApiType>;
+      /**
+       * The supplied validation function has compiled into a blob larger than Polkadot is
+       * willing to run
+       **/
+      TooBig: AugmentedError<ApiType>;
+      /**
+       * The given code upgrade has not been authorized.
+       **/
+      Unauthorized: AugmentedError<ApiType>;
+      /**
+       * The inherent which supplies the validation data did not run this block
+       **/
+      ValidationDataNotAvailable: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    polkadotXcm: {
+      /**
+       * The location is invalid since it already has a subscription from us.
+       **/
+      AlreadySubscribed: AugmentedError<ApiType>;
+      /**
+       * The given location could not be used (e.g. because it cannot be expressed in the
+       * desired version of XCM).
+       **/
+      BadLocation: AugmentedError<ApiType>;
+      /**
+       * The version of the `Versioned` value used is not able to be interpreted.
+       **/
+      BadVersion: AugmentedError<ApiType>;
+      /**
+       * Could not re-anchor the assets to declare the fees for the destination chain.
+       **/
+      CannotReanchor: AugmentedError<ApiType>;
+      /**
+       * The destination `MultiLocation` provided cannot be inverted.
+       **/
+      DestinationNotInvertible: AugmentedError<ApiType>;
+      /**
+       * The assets to be sent are empty.
+       **/
+      Empty: AugmentedError<ApiType>;
+      /**
+       * The message execution fails the filter.
+       **/
+      Filtered: AugmentedError<ApiType>;
+      /**
+       * Origin is invalid for sending.
+       **/
+      InvalidOrigin: AugmentedError<ApiType>;
+      /**
+       * The referenced subscription could not be found.
+       **/
+      NoSubscription: AugmentedError<ApiType>;
+      /**
+       * There was some other issue (i.e. not to do with routing) in sending the message. Perhaps
+       * a lack of space for buffering the message.
+       **/
+      SendFailure: AugmentedError<ApiType>;
+      /**
+       * Too many assets have been attempted for transfer.
+       **/
+      TooManyAssets: AugmentedError<ApiType>;
+      /**
+       * The desired destination was unreachable, generally because there is a no way of routing
+       * to it.
+       **/
+      Unreachable: AugmentedError<ApiType>;
+      /**
+       * The message's weight could not be determined.
+       **/
+      UnweighableMessage: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    refungible: {
+      /**
+       * Not Refungible item data used to mint in Refungible collection.
+       **/
+      NotRefungibleDataUsedToMintFungibleCollectionToken: AugmentedError<ApiType>;
+      /**
+       * Maximum refungibility exceeded
+       **/
+      WrongRefungiblePieces: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    scheduler: {
+      /**
+       * Failed to schedule a call
+       **/
+      FailedToSchedule: AugmentedError<ApiType>;
+      /**
+       * Cannot find the scheduled call.
+       **/
+      NotFound: AugmentedError<ApiType>;
+      /**
+       * Reschedule failed because it does not change scheduled time.
+       **/
+      RescheduleNoChange: AugmentedError<ApiType>;
+      /**
+       * Given target block number is in the past.
+       **/
+      TargetBlockNumberInPast: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    sudo: {
+      /**
+       * Sender must be the Sudo account
+       **/
+      RequireSudo: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    system: {
+      /**
+       * Failed to extract the runtime version from the new runtime.
+       * 
+       * Either calling `Core_version` or decoding `RuntimeVersion` failed.
+       **/
+      FailedToExtractRuntimeVersion: AugmentedError<ApiType>;
+      /**
+       * The name of specification does not match between the current runtime
+       * and the new runtime.
+       **/
+      InvalidSpecName: AugmentedError<ApiType>;
+      /**
+       * Suicide called when the account has non-default composite data.
+       **/
+      NonDefaultComposite: AugmentedError<ApiType>;
+      /**
+       * There is a non-zero reference count preventing the account from being purged.
+       **/
+      NonZeroRefCount: AugmentedError<ApiType>;
+      /**
+       * The specification version is not allowed to decrease between the current runtime
+       * and the new runtime.
+       **/
+      SpecVersionNeedsToIncrease: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    treasury: {
+      /**
+       * Proposer's balance is too low.
+       **/
+      InsufficientProposersBalance: AugmentedError<ApiType>;
+      /**
+       * No proposal or bounty at that index.
+       **/
+      InvalidIndex: AugmentedError<ApiType>;
+      /**
+       * Too many approvals in the queue.
+       **/
+      TooManyApprovals: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    vesting: {
+      /**
+       * Amount being transferred is too low to create a vesting schedule.
+       **/
+      AmountLow: AugmentedError<ApiType>;
+      /**
+       * The account already has `MaxVestingSchedules` count of schedules and thus
+       * cannot add another one. Consider merging existing schedules in order to add another.
+       **/
+      AtMaxVestingSchedules: AugmentedError<ApiType>;
+      /**
+       * Failed to create a new schedule because some parameter was invalid.
+       **/
+      InvalidScheduleParams: AugmentedError<ApiType>;
+      /**
+       * The account given is not vesting.
+       **/
+      NotVesting: AugmentedError<ApiType>;
+      /**
+       * An index was out of bounds of the vesting schedules.
+       **/
+      ScheduleIndexOutOfBounds: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+    xcmpQueue: {
+      /**
+       * Bad XCM data.
+       **/
+      BadXcm: AugmentedError<ApiType>;
+      /**
+       * Bad XCM origin.
+       **/
+      BadXcmOrigin: AugmentedError<ApiType>;
+      /**
+       * Failed to send XCM message.
+       **/
+      FailedToSend: AugmentedError<ApiType>;
+      /**
+       * Generic error
+       **/
+      [key: string]: AugmentedError<ApiType>;
+    };
+  }
+
+  export interface DecoratedErrors<ApiType extends ApiTypes> extends AugmentedErrors<ApiType> {
+    [key: string]: ModuleErrors<ApiType>;
+  }
+}

--- /dev/null
+++ b/tests/src/interfaces/augment-api-events.ts
@@ -0,0 +1,544 @@
+// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
+/* eslint-disable */
+
+import type { EthereumLog, EvmCoreErrorExitReason } from './ethereum';
+import type { PalletCommonAccountBasicCrossAccountIdRepr } from './nft';
+import type { ApiTypes } from '@polkadot/api/types';
+import type { Bytes, Null, Option, Result, U256, U8aFixed, u128, u32, u64, u8 } from '@polkadot/types';
+import type { AccountId32, H160, H256 } from '@polkadot/types/interfaces/runtime';
+import type { FrameSupportTokensMiscBalanceStatus, FrameSupportWeightsDispatchInfo, SpRuntimeDispatchError, XcmV1MultiLocation, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation } from '@polkadot/types/lookup';
+import type { ITuple } from '@polkadot/types/types';
+
+declare module '@polkadot/api/types/events' {
+  export interface AugmentedEvents<ApiType> {
+    balances: {
+      /**
+       * A balance was set by root. \[who, free, reserved\]
+       **/
+      BalanceSet: AugmentedEvent<ApiType, [AccountId32, u128, u128]>;
+      /**
+       * Some amount was deposited into the account (e.g. for transaction fees). \[who,
+       * deposit\]
+       **/
+      Deposit: AugmentedEvent<ApiType, [AccountId32, u128]>;
+      /**
+       * An account was removed whose balance was non-zero but below ExistentialDeposit,
+       * resulting in an outright loss. \[account, balance\]
+       **/
+      DustLost: AugmentedEvent<ApiType, [AccountId32, u128]>;
+      /**
+       * An account was created with some free balance. \[account, free_balance\]
+       **/
+      Endowed: AugmentedEvent<ApiType, [AccountId32, u128]>;
+      /**
+       * Some balance was reserved (moved from free to reserved). \[who, value\]
+       **/
+      Reserved: AugmentedEvent<ApiType, [AccountId32, u128]>;
+      /**
+       * Some balance was moved from the reserve of the first account to the second account.
+       * Final argument indicates the destination balance type.
+       * \[from, to, balance, destination_status\]
+       **/
+      ReserveRepatriated: AugmentedEvent<ApiType, [AccountId32, AccountId32, u128, FrameSupportTokensMiscBalanceStatus]>;
+      /**
+       * Some amount was removed from the account (e.g. for misbehavior). \[who,
+       * amount_slashed\]
+       **/
+      Slashed: AugmentedEvent<ApiType, [AccountId32, u128]>;
+      /**
+       * Transfer succeeded. \[from, to, value\]
+       **/
+      Transfer: AugmentedEvent<ApiType, [AccountId32, AccountId32, u128]>;
+      /**
+       * Some balance was unreserved (moved from reserved to free). \[who, value\]
+       **/
+      Unreserved: AugmentedEvent<ApiType, [AccountId32, u128]>;
+      /**
+       * Some amount was withdrawn from the account (e.g. for transaction fees). \[who, value\]
+       **/
+      Withdraw: AugmentedEvent<ApiType, [AccountId32, u128]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+    common: {
+      /**
+       * * collection_id
+       * 
+       * * item_id
+       * 
+       * * sender
+       * 
+       * * spender
+       * 
+       * * amount
+       **/
+      Approved: AugmentedEvent<ApiType, [u32, u32, PalletCommonAccountBasicCrossAccountIdRepr, PalletCommonAccountBasicCrossAccountIdRepr, u128]>;
+      /**
+       * New collection was created
+       * 
+       * # Arguments
+       * 
+       * * collection_id: Globally unique identifier of newly created collection.
+       * 
+       * * mode: [CollectionMode] converted into u8.
+       * 
+       * * account_id: Collection owner.
+       **/
+      CollectionCreated: AugmentedEvent<ApiType, [u32, u8, AccountId32]>;
+      /**
+       * New item was created.
+       * 
+       * # Arguments
+       * 
+       * * collection_id: Id of the collection where item was created.
+       * 
+       * * item_id: Id of an item. Unique within the collection.
+       * 
+       * * recipient: Owner of newly created item
+       * 
+       * * amount: Always 1 for NFT
+       **/
+      ItemCreated: AugmentedEvent<ApiType, [u32, u32, PalletCommonAccountBasicCrossAccountIdRepr, u128]>;
+      /**
+       * Collection item was burned.
+       * 
+       * # Arguments
+       * 
+       * * collection_id.
+       * 
+       * * item_id: Identifier of burned NFT.
+       * 
+       * * owner: which user has destroyed its tokens
+       * 
+       * * amount: Always 1 for NFT
+       **/
+      ItemDestroyed: AugmentedEvent<ApiType, [u32, u32, PalletCommonAccountBasicCrossAccountIdRepr, u128]>;
+      /**
+       * Item was transferred
+       * 
+       * * collection_id: Id of collection to which item is belong
+       * 
+       * * item_id: Id of an item
+       * 
+       * * sender: Original owner of item
+       * 
+       * * recipient: New owner of item
+       * 
+       * * amount: Always 1 for NFT
+       **/
+      Transfer: AugmentedEvent<ApiType, [u32, u32, PalletCommonAccountBasicCrossAccountIdRepr, PalletCommonAccountBasicCrossAccountIdRepr, u128]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+    cumulusXcm: {
+      /**
+       * Downward message executed with the given outcome.
+       * \[ id, outcome \]
+       **/
+      ExecutedDownward: AugmentedEvent<ApiType, [U8aFixed, XcmV2TraitsOutcome]>;
+      /**
+       * Downward message is invalid XCM.
+       * \[ id \]
+       **/
+      InvalidFormat: AugmentedEvent<ApiType, [U8aFixed]>;
+      /**
+       * Downward message is unsupported version of XCM.
+       * \[ id \]
+       **/
+      UnsupportedVersion: AugmentedEvent<ApiType, [U8aFixed]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+    dmpQueue: {
+      /**
+       * Downward message executed with the given outcome.
+       * \[ id, outcome \]
+       **/
+      ExecutedDownward: AugmentedEvent<ApiType, [U8aFixed, XcmV2TraitsOutcome]>;
+      /**
+       * Downward message is invalid XCM.
+       * \[ id \]
+       **/
+      InvalidFormat: AugmentedEvent<ApiType, [U8aFixed]>;
+      /**
+       * Downward message is overweight and was placed in the overweight queue.
+       * \[ id, index, required \]
+       **/
+      OverweightEnqueued: AugmentedEvent<ApiType, [U8aFixed, u64, u64]>;
+      /**
+       * Downward message from the overweight queue was executed.
+       * \[ index, used \]
+       **/
+      OverweightServiced: AugmentedEvent<ApiType, [u64, u64]>;
+      /**
+       * Downward message is unsupported version of XCM.
+       * \[ id \]
+       **/
+      UnsupportedVersion: AugmentedEvent<ApiType, [U8aFixed]>;
+      /**
+       * The weight limit for handling downward messages was reached.
+       * \[ id, remaining, required \]
+       **/
+      WeightExhausted: AugmentedEvent<ApiType, [U8aFixed, u64, u64]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+    ethereum: {
+      /**
+       * An ethereum transaction was successfully executed. [from, to/contract_address, transaction_hash, exit_reason]
+       **/
+      Executed: AugmentedEvent<ApiType, [H160, H160, H256, EvmCoreErrorExitReason]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+    evm: {
+      /**
+       * A deposit has been made at a given address. \[sender, address, value\]
+       **/
+      BalanceDeposit: AugmentedEvent<ApiType, [AccountId32, H160, U256]>;
+      /**
+       * A withdrawal has been made from a given address. \[sender, address, value\]
+       **/
+      BalanceWithdraw: AugmentedEvent<ApiType, [AccountId32, H160, U256]>;
+      /**
+       * A contract has been created at given \[address\].
+       **/
+      Created: AugmentedEvent<ApiType, [H160]>;
+      /**
+       * A \[contract\] was attempted to be created, but the execution failed.
+       **/
+      CreatedFailed: AugmentedEvent<ApiType, [H160]>;
+      /**
+       * A \[contract\] has been executed successfully with states applied.
+       **/
+      Executed: AugmentedEvent<ApiType, [H160]>;
+      /**
+       * A \[contract\] has been executed with errors. States are reverted with only gas fees applied.
+       **/
+      ExecutedFailed: AugmentedEvent<ApiType, [H160]>;
+      /**
+       * Ethereum events from contracts.
+       **/
+      Log: AugmentedEvent<ApiType, [EthereumLog]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+    parachainSystem: {
+      /**
+       * Downward messages were processed using the given weight.
+       * \[ weight_used, result_mqc_head \]
+       **/
+      DownwardMessagesProcessed: AugmentedEvent<ApiType, [u64, H256]>;
+      /**
+       * Some downward messages have been received and will be processed.
+       * \[ count \]
+       **/
+      DownwardMessagesReceived: AugmentedEvent<ApiType, [u32]>;
+      /**
+       * An upgrade has been authorized.
+       **/
+      UpgradeAuthorized: AugmentedEvent<ApiType, [H256]>;
+      /**
+       * The validation function was applied as of the contained relay chain block number.
+       **/
+      ValidationFunctionApplied: AugmentedEvent<ApiType, [u32]>;
+      /**
+       * The relay-chain aborted the upgrade process.
+       **/
+      ValidationFunctionDiscarded: AugmentedEvent<ApiType, []>;
+      /**
+       * The validation function has been scheduled to apply.
+       **/
+      ValidationFunctionStored: AugmentedEvent<ApiType, []>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+    polkadotXcm: {
+      /**
+       * Some assets have been placed in an asset trap.
+       * 
+       * \[ hash, origin, assets \]
+       **/
+      AssetsTrapped: AugmentedEvent<ApiType, [H256, XcmV1MultiLocation, XcmVersionedMultiAssets]>;
+      /**
+       * Execution of an XCM message was attempted.
+       * 
+       * \[ outcome \]
+       **/
+      Attempted: AugmentedEvent<ApiType, [XcmV2TraitsOutcome]>;
+      /**
+       * Expected query response has been received but the origin location of the response does
+       * not match that expected. The query remains registered for a later, valid, response to
+       * be received and acted upon.
+       * 
+       * \[ origin location, id, expected location \]
+       **/
+      InvalidResponder: AugmentedEvent<ApiType, [XcmV1MultiLocation, u64, Option<XcmV1MultiLocation>]>;
+      /**
+       * Expected query response has been received but the expected origin location placed in
+       * storate by this runtime previously cannot be decoded. The query remains registered.
+       * 
+       * This is unexpected (since a location placed in storage in a previously executing
+       * runtime should be readable prior to query timeout) and dangerous since the possibly
+       * valid response will be dropped. Manual governance intervention is probably going to be
+       * needed.
+       * 
+       * \[ origin location, id \]
+       **/
+      InvalidResponderVersion: AugmentedEvent<ApiType, [XcmV1MultiLocation, u64]>;
+      /**
+       * Query response has been received and query is removed. The registered notification has
+       * been dispatched and executed successfully.
+       * 
+       * \[ id, pallet index, call index \]
+       **/
+      Notified: AugmentedEvent<ApiType, [u64, u8, u8]>;
+      /**
+       * Query response has been received and query is removed. The dispatch was unable to be
+       * decoded into a `Call`; this might be due to dispatch function having a signature which
+       * is not `(origin, QueryId, Response)`.
+       * 
+       * \[ id, pallet index, call index \]
+       **/
+      NotifyDecodeFailed: AugmentedEvent<ApiType, [u64, u8, u8]>;
+      /**
+       * Query response has been received and query is removed. There was a general error with
+       * dispatching the notification call.
+       * 
+       * \[ id, pallet index, call index \]
+       **/
+      NotifyDispatchError: AugmentedEvent<ApiType, [u64, u8, u8]>;
+      /**
+       * Query response has been received and query is removed. The registered notification could
+       * not be dispatched because the dispatch weight is greater than the maximum weight
+       * originally budgeted by this runtime for the query result.
+       * 
+       * \[ id, pallet index, call index, actual weight, max budgeted weight \]
+       **/
+      NotifyOverweight: AugmentedEvent<ApiType, [u64, u8, u8, u64, u64]>;
+      /**
+       * A given location which had a version change subscription was dropped owing to an error
+       * migrating the location to our new XCM format.
+       * 
+       * \[ location, query ID \]
+       **/
+      NotifyTargetMigrationFail: AugmentedEvent<ApiType, [XcmVersionedMultiLocation, u64]>;
+      /**
+       * A given location which had a version change subscription was dropped owing to an error
+       * sending the notification to it.
+       * 
+       * \[ location, query ID, error \]
+       **/
+      NotifyTargetSendFail: AugmentedEvent<ApiType, [XcmV1MultiLocation, u64, XcmV2TraitsError]>;
+      /**
+       * Query response has been received and is ready for taking with `take_response`. There is
+       * no registered notification call.
+       * 
+       * \[ id, response \]
+       **/
+      ResponseReady: AugmentedEvent<ApiType, [u64, XcmV2Response]>;
+      /**
+       * Received query response has been read and removed.
+       * 
+       * \[ id \]
+       **/
+      ResponseTaken: AugmentedEvent<ApiType, [u64]>;
+      /**
+       * A XCM message was sent.
+       * 
+       * \[ origin, destination, message \]
+       **/
+      Sent: AugmentedEvent<ApiType, [XcmV1MultiLocation, XcmV1MultiLocation, XcmV2Xcm]>;
+      /**
+       * The supported version of a location has been changed. This might be through an
+       * automatic notification or a manual intervention.
+       * 
+       * \[ location, XCM version \]
+       **/
+      SupportedVersionChanged: AugmentedEvent<ApiType, [XcmV1MultiLocation, u32]>;
+      /**
+       * Query response received which does not match a registered query. This may be because a
+       * matching query was never registered, it may be because it is a duplicate response, or
+       * because the query timed out.
+       * 
+       * \[ origin location, id \]
+       **/
+      UnexpectedResponse: AugmentedEvent<ApiType, [XcmV1MultiLocation, u64]>;
+      /**
+       * An XCM version change notification message has been attempted to be sent.
+       * 
+       * \[ destination, result \]
+       **/
+      VersionChangeNotified: AugmentedEvent<ApiType, [XcmV1MultiLocation, u32]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+    scheduler: {
+      /**
+       * Canceled some task. \[when, index\]
+       **/
+      Canceled: AugmentedEvent<ApiType, [u32, u32]>;
+      /**
+       * Dispatched some task. \[task, id, result\]
+       **/
+      Dispatched: AugmentedEvent<ApiType, [ITuple<[u32, u32]>, Option<Bytes>, Result<Null, SpRuntimeDispatchError>]>;
+      /**
+       * Scheduled some task. \[when, index\]
+       **/
+      Scheduled: AugmentedEvent<ApiType, [u32, u32]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+    sudo: {
+      /**
+       * The \[sudoer\] just switched identity; the old key is supplied.
+       **/
+      KeyChanged: AugmentedEvent<ApiType, [AccountId32]>;
+      /**
+       * A sudo just took place. \[result\]
+       **/
+      Sudid: AugmentedEvent<ApiType, [Result<Null, SpRuntimeDispatchError>]>;
+      /**
+       * A sudo just took place. \[result\]
+       **/
+      SudoAsDone: AugmentedEvent<ApiType, [Result<Null, SpRuntimeDispatchError>]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+    system: {
+      /**
+       * `:code` was updated.
+       **/
+      CodeUpdated: AugmentedEvent<ApiType, []>;
+      /**
+       * An extrinsic failed. \[error, info\]
+       **/
+      ExtrinsicFailed: AugmentedEvent<ApiType, [SpRuntimeDispatchError, FrameSupportWeightsDispatchInfo]>;
+      /**
+       * An extrinsic completed successfully. \[info\]
+       **/
+      ExtrinsicSuccess: AugmentedEvent<ApiType, [FrameSupportWeightsDispatchInfo]>;
+      /**
+       * An \[account\] was reaped.
+       **/
+      KilledAccount: AugmentedEvent<ApiType, [AccountId32]>;
+      /**
+       * A new \[account\] was created.
+       **/
+      NewAccount: AugmentedEvent<ApiType, [AccountId32]>;
+      /**
+       * On on-chain remark happened. \[origin, remark_hash\]
+       **/
+      Remarked: AugmentedEvent<ApiType, [AccountId32, H256]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+    treasury: {
+      /**
+       * Some funds have been allocated. \[proposal_index, award, beneficiary\]
+       **/
+      Awarded: AugmentedEvent<ApiType, [u32, u128, AccountId32]>;
+      /**
+       * Some of our funds have been burnt. \[burn\]
+       **/
+      Burnt: AugmentedEvent<ApiType, [u128]>;
+      /**
+       * Some funds have been deposited. \[deposit\]
+       **/
+      Deposit: AugmentedEvent<ApiType, [u128]>;
+      /**
+       * New proposal. \[proposal_index\]
+       **/
+      Proposed: AugmentedEvent<ApiType, [u32]>;
+      /**
+       * A proposal was rejected; funds were slashed. \[proposal_index, slashed\]
+       **/
+      Rejected: AugmentedEvent<ApiType, [u32, u128]>;
+      /**
+       * Spending has finished; this is the amount that rolls over until next spend.
+       * \[budget_remaining\]
+       **/
+      Rollover: AugmentedEvent<ApiType, [u128]>;
+      /**
+       * We have ended a spend period and will now allocate funds. \[budget_remaining\]
+       **/
+      Spending: AugmentedEvent<ApiType, [u128]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+    vesting: {
+      /**
+       * An \[account\] has become fully vested.
+       **/
+      VestingCompleted: AugmentedEvent<ApiType, [AccountId32]>;
+      /**
+       * The amount vested has been updated. This could indicate a change in funds available.
+       * The balance given is the amount which is left unvested (and thus locked).
+       * \[account, unvested\]
+       **/
+      VestingUpdated: AugmentedEvent<ApiType, [AccountId32, u128]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+    xcmpQueue: {
+      /**
+       * Bad XCM format used.
+       **/
+      BadFormat: AugmentedEvent<ApiType, [Option<H256>]>;
+      /**
+       * Bad XCM version used.
+       **/
+      BadVersion: AugmentedEvent<ApiType, [Option<H256>]>;
+      /**
+       * Some XCM failed.
+       **/
+      Fail: AugmentedEvent<ApiType, [Option<H256>, XcmV2TraitsError]>;
+      /**
+       * Some XCM was executed ok.
+       **/
+      Success: AugmentedEvent<ApiType, [Option<H256>]>;
+      /**
+       * An upward message was sent to the relay chain.
+       **/
+      UpwardMessageSent: AugmentedEvent<ApiType, [Option<H256>]>;
+      /**
+       * An HRMP message was sent to a sibling parachain.
+       **/
+      XcmpMessageSent: AugmentedEvent<ApiType, [Option<H256>]>;
+      /**
+       * Generic event
+       **/
+      [key: string]: AugmentedEvent<ApiType>;
+    };
+  }
+
+  export interface DecoratedEvents<ApiType extends ApiTypes> extends AugmentedEvents<ApiType> {
+    [key: string]: ModuleEvents<ApiType>;
+  }
+}

--- /dev/null
+++ b/tests/src/interfaces/augment-api-query.ts
@@ -0,0 +1,596 @@
+// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
+/* eslint-disable */
+
+import type { EthereumBlock, EthereumReceipt, EthereumTransactionLegacyTransaction, FpRpcTransactionStatus } from './ethereum';
+import type { NftDataStructsCollection, PalletCommonAccountBasicCrossAccountIdRepr, PalletNonfungibleItemData, PalletRefungibleItemData, PalletUnqSchedulerCallSpec, PalletUnqSchedulerReleases, PalletUnqSchedulerScheduledV2 } from './nft';
+import type { CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmpQueueInboundStatus, CumulusPalletXcmpQueueOutboundStatus, CumulusPalletXcmpQueueQueueConfigData, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV1AbridgedHostConfiguration, PolkadotPrimitivesV1PersistedValidationData } from './polkadot';
+import type { ApiTypes } from '@polkadot/api/types';
+import type { BTreeMap, Bytes, Option, U256, Vec, bool, u128, u16, u32, u64 } from '@polkadot/types';
+import type { AccountId32, H160, H256 } from '@polkadot/types/interfaces/runtime';
+import type { FrameSupportWeightsPerDispatchClassU64, FrameSystemAccountInfo, FrameSystemEventRecord, FrameSystemLastRuntimeUpgradeInfo, FrameSystemPhase, PalletBalancesAccountData, PalletBalancesBalanceLock, PalletBalancesReleases, PalletBalancesReserveData, PalletTransactionPaymentReleases, PalletTreasuryProposal, PalletVestingReleases, PalletVestingVestingInfo, PolkadotCorePrimitivesOutboundHrmpMessage, PolkadotPrimitivesV1UpgradeRestriction, SpRuntimeGenericDigest } from '@polkadot/types/lookup';
+import type { AnyNumber, ITuple, Observable } from '@polkadot/types/types';
+
+declare module '@polkadot/api/types/storage' {
+  export interface AugmentedQueries<ApiType> {
+    balances: {
+      /**
+       * The balance of an account.
+       * 
+       * NOTE: This is only used in the case that this pallet is used to store balances.
+       **/
+      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<PalletBalancesAccountData>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+      /**
+       * Any liquidity locks on some account balances.
+       * NOTE: Should only be accessed when setting, changing and freeing a lock.
+       **/
+      locks: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesBalanceLock>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+      /**
+       * Named reserves on some account balances.
+       **/
+      reserves: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Vec<PalletBalancesReserveData>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+      /**
+       * Storage version of the pallet.
+       * 
+       * This is set to v2.0.0 for new networks.
+       **/
+      storageVersion: AugmentedQuery<ApiType, () => Observable<PalletBalancesReleases>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The total units issued in the system.
+       **/
+      totalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    charging: {
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    common: {
+      adminAmount: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      /**
+       * Allowlisted collection users
+       **/
+      allowlist: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;
+      /**
+       * Collection info
+       **/
+      collectionById: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<NftDataStructsCollection>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      createdCollectionCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      destroyedCollectionCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * List of collection admins
+       **/
+      isAdmin: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<bool>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    dmpQueue: {
+      /**
+       * The configuration.
+       **/
+      configuration: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The overweight messages.
+       **/
+      overweight: AugmentedQuery<ApiType, (arg: u64 | AnyNumber | Uint8Array) => Observable<Option<ITuple<[u32, Bytes]>>>, [u64]> & QueryableStorageEntry<ApiType, [u64]>;
+      /**
+       * The page index.
+       **/
+      pageIndex: AugmentedQuery<ApiType, () => Observable<CumulusPalletDmpQueuePageIndexData>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The queue pages.
+       **/
+      pages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[u32, Bytes]>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    ethereum: {
+      blockHash: AugmentedQuery<ApiType, (arg: U256 | AnyNumber | Uint8Array) => Observable<H256>, [U256]> & QueryableStorageEntry<ApiType, [U256]>;
+      /**
+       * The current Ethereum block.
+       **/
+      currentBlock: AugmentedQuery<ApiType, () => Observable<Option<EthereumBlock>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The current Ethereum receipts.
+       **/
+      currentReceipts: AugmentedQuery<ApiType, () => Observable<Option<Vec<EthereumReceipt>>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The current transaction statuses.
+       **/
+      currentTransactionStatuses: AugmentedQuery<ApiType, () => Observable<Option<Vec<FpRpcTransactionStatus>>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Current building block's transactions and receipts.
+       **/
+      pending: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[EthereumTransactionLegacyTransaction, FpRpcTransactionStatus, EthereumReceipt]>>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    evm: {
+      accountCodes: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<Bytes>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;
+      accountStorages: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H256 | string | Uint8Array) => Observable<H256>, [H160, H256]> & QueryableStorageEntry<ApiType, [H160, H256]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    evmCoderSubstrate: {
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    evmContractHelpers: {
+      allowlist: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H160 | string | Uint8Array) => Observable<bool>, [H160, H160]> & QueryableStorageEntry<ApiType, [H160, H160]>;
+      allowlistEnabled: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;
+      owner: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<H160>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;
+      selfSponsoring: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;
+      sponsorBasket: AugmentedQuery<ApiType, (arg1: H160 | string | Uint8Array, arg2: H160 | string | Uint8Array) => Observable<Option<u32>>, [H160, H160]> & QueryableStorageEntry<ApiType, [H160, H160]>;
+      sponsoringRateLimit: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<u32>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    evmMigration: {
+      migrationPending: AugmentedQuery<ApiType, (arg: H160 | string | Uint8Array) => Observable<bool>, [H160]> & QueryableStorageEntry<ApiType, [H160]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    fungible: {
+      allowance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, arg3: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u128>, [u32, PalletCommonAccountBasicCrossAccountIdRepr, PalletCommonAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletCommonAccountBasicCrossAccountIdRepr, PalletCommonAccountBasicCrossAccountIdRepr]>;
+      balance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u128>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;
+      totalSupply: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    inflation: {
+      /**
+       * Current block inflation
+       **/
+      blockInflation: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * starting year total issuance
+       **/
+      startingYearTotalIssuance: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    nft: {
+      /**
+       * Used for migrations
+       **/
+      chainVersion: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * (Collection id (controlled?2), who created (real))
+       * TODO: Off chain worker should remove from this map when collection gets removed
+       **/
+      createItemBasket: AugmentedQuery<ApiType, (arg: ITuple<[u32, AccountId32]> | [u32 | AnyNumber | Uint8Array, AccountId32 | string | Uint8Array]) => Observable<u32>, [ITuple<[u32, AccountId32]>]> & QueryableStorageEntry<ApiType, [ITuple<[u32, AccountId32]>]>;
+      /**
+       * Collection id (controlled?2), owning user (real)
+       **/
+      fungibleTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: AccountId32 | string | Uint8Array) => Observable<u32>, [u32, AccountId32]> & QueryableStorageEntry<ApiType, [u32, AccountId32]>;
+      /**
+       * Collection id (controlled?2), token id (controlled?2)
+       **/
+      nftTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+      /**
+       * Collection id (controlled?2), token id (controlled?2)
+       **/
+      reFungibleTransferBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+      /**
+       * Variable metadata sponsoring
+       * Collection id (controlled?2), token id (controlled?2)
+       **/
+      variableMetaDataBasket: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<u32>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    nftPayment: {
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    nonfungible: {
+      accountBalance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u32>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;
+      allowance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletCommonAccountBasicCrossAccountIdRepr>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+      /**
+       * Used to enumerate tokens owned by account
+       **/
+      owned: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, arg3: u32 | AnyNumber | Uint8Array) => Observable<bool>, [u32, PalletCommonAccountBasicCrossAccountIdRepr, u32]> & QueryableStorageEntry<ApiType, [u32, PalletCommonAccountBasicCrossAccountIdRepr, u32]>;
+      tokenData: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletNonfungibleItemData>>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+      tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    parachainInfo: {
+      parachainId: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    parachainSystem: {
+      /**
+       * The number of HRMP messages we observed in `on_initialize` and thus used that number for
+       * announcing the weight of `on_initialize` and `on_finalize`.
+       **/
+      announcedHrmpMessagesPerCandidate: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The next authorized upgrade, if there is one.
+       **/
+      authorizedUpgrade: AugmentedQuery<ApiType, () => Observable<Option<H256>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Were the validation data set to notify the relay chain?
+       **/
+      didSetValidationCode: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The parachain host configuration that was obtained from the relay parent.
+       * 
+       * This field is meant to be updated each block with the validation data inherent. Therefore,
+       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.
+       * 
+       * This data is also absent from the genesis.
+       **/
+      hostConfiguration: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV1AbridgedHostConfiguration>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * HRMP messages that were sent in a block.
+       * 
+       * This will be cleared in `on_initialize` of each new block.
+       **/
+      hrmpOutboundMessages: AugmentedQuery<ApiType, () => Observable<Vec<PolkadotCorePrimitivesOutboundHrmpMessage>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * HRMP watermark that was set in a block.
+       * 
+       * This will be cleared in `on_initialize` of each new block.
+       **/
+      hrmpWatermark: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The last downward message queue chain head we have observed.
+       * 
+       * This value is loaded before and saved after processing inbound downward messages carried
+       * by the system inherent.
+       **/
+      lastDmqMqcHead: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The message queue chain heads we have observed per each channel incoming channel.
+       * 
+       * This value is loaded before and saved after processing inbound downward messages carried
+       * by the system inherent.
+       **/
+      lastHrmpMqcHeads: AugmentedQuery<ApiType, () => Observable<BTreeMap<u32, H256>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Validation code that is set by the parachain and is to be communicated to collator and
+       * consequently the relay-chain.
+       * 
+       * This will be cleared in `on_initialize` of each new block if no other pallet already set
+       * the value.
+       **/
+      newValidationCode: AugmentedQuery<ApiType, () => Observable<Option<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Upward messages that are still pending and not yet send to the relay chain.
+       **/
+      pendingUpwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * In case of a scheduled upgrade, this storage field contains the validation code to be applied.
+       * 
+       * As soon as the relay chain gives us the go-ahead signal, we will overwrite the [`:code`][well_known_keys::CODE]
+       * which will result the next block process with the new validation code. This concludes the upgrade process.
+       * 
+       * [well_known_keys::CODE]: sp_core::storage::well_known_keys::CODE
+       **/
+      pendingValidationCode: AugmentedQuery<ApiType, () => Observable<Bytes>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Number of downward messages processed in a block.
+       * 
+       * This will be cleared in `on_initialize` of each new block.
+       **/
+      processedDownwardMessages: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The snapshot of some state related to messaging relevant to the current parachain as per
+       * the relay parent.
+       * 
+       * This field is meant to be updated each block with the validation data inherent. Therefore,
+       * before processing of the inherent, e.g. in `on_initialize` this data may be stale.
+       * 
+       * This data is also absent from the genesis.
+       **/
+      relevantMessagingState: AugmentedQuery<ApiType, () => Observable<Option<CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The weight we reserve at the beginning of the block for processing DMP messages. This
+       * overrides the amount set in the Config trait.
+       **/
+      reservedDmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<u64>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The weight we reserve at the beginning of the block for processing XCMP messages. This
+       * overrides the amount set in the Config trait.
+       **/
+      reservedXcmpWeightOverride: AugmentedQuery<ApiType, () => Observable<Option<u64>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * An option which indicates if the relay-chain restricts signalling a validation code upgrade.
+       * In other words, if this is `Some` and [`NewValidationCode`] is `Some` then the produced
+       * candidate will be invalid.
+       * 
+       * This storage item is a mirror of the corresponding value for the current parachain from the
+       * relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is
+       * set after the inherent.
+       **/
+      upgradeRestrictionSignal: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV1UpgradeRestriction>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Upward messages that were sent in a block.
+       * 
+       * This will be cleared in `on_initialize` of each new block.
+       **/
+      upwardMessages: AugmentedQuery<ApiType, () => Observable<Vec<Bytes>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The [`PersistedValidationData`] set for this block.
+       * This value is expected to be set only once per block and it's never stored
+       * in the trie.
+       **/
+      validationData: AugmentedQuery<ApiType, () => Observable<Option<PolkadotPrimitivesV1PersistedValidationData>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    randomnessCollectiveFlip: {
+      /**
+       * Series of block headers from the last 81 blocks that acts as random seed material. This
+       * is arranged as a ring buffer with `block_number % 81` being the index into the `Vec` of
+       * the oldest hash.
+       **/
+      randomMaterial: AugmentedQuery<ApiType, () => Observable<Vec<H256>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    refungible: {
+      accountBalance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u32>, [u32, PalletCommonAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, PalletCommonAccountBasicCrossAccountIdRepr]>;
+      allowance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, arg4: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u128>, [u32, u32, PalletCommonAccountBasicCrossAccountIdRepr, PalletCommonAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, u32, PalletCommonAccountBasicCrossAccountIdRepr, PalletCommonAccountBasicCrossAccountIdRepr]>;
+      balance: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array, arg3: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array) => Observable<u128>, [u32, u32, PalletCommonAccountBasicCrossAccountIdRepr]> & QueryableStorageEntry<ApiType, [u32, u32, PalletCommonAccountBasicCrossAccountIdRepr]>;
+      /**
+       * Used to enumerate tokens owned by account
+       **/
+      owned: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, arg3: u32 | AnyNumber | Uint8Array) => Observable<bool>, [u32, PalletCommonAccountBasicCrossAccountIdRepr, u32]> & QueryableStorageEntry<ApiType, [u32, PalletCommonAccountBasicCrossAccountIdRepr, u32]>;
+      tokenData: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<PalletRefungibleItemData>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+      tokensBurnt: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      tokensMinted: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<u32>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      totalSupply: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<u128>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    scheduler: {
+      /**
+       * Items to be executed, indexed by the block number that they should be executed on.
+       **/
+      agenda: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<Option<PalletUnqSchedulerScheduledV2>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      /**
+       * Lookup from identity to the block number and index of the task.
+       **/
+      lookup: AugmentedQuery<ApiType, (arg: Bytes | string | Uint8Array) => Observable<Option<ITuple<[u32, u32]>>>, [Bytes]> & QueryableStorageEntry<ApiType, [Bytes]>;
+      specAgenda: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Vec<Option<PalletUnqSchedulerCallSpec>>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      /**
+       * Storage version of the pallet.
+       * 
+       * New networks start with last version.
+       **/
+      storageVersion: AugmentedQuery<ApiType, () => Observable<PalletUnqSchedulerReleases>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    sudo: {
+      /**
+       * The `AccountId` of the sudo key.
+       **/
+      key: AugmentedQuery<ApiType, () => Observable<AccountId32>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    system: {
+      /**
+       * The full account information for a particular account ID.
+       **/
+      account: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<FrameSystemAccountInfo>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+      /**
+       * Total length (in bytes) for all extrinsics put together, for the current block.
+       **/
+      allExtrinsicsLen: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Map of block numbers to block hashes.
+       **/
+      blockHash: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<H256>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      /**
+       * The current weight for the block.
+       **/
+      blockWeight: AugmentedQuery<ApiType, () => Observable<FrameSupportWeightsPerDispatchClassU64>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Digest of the current block, also part of the block header.
+       **/
+      digest: AugmentedQuery<ApiType, () => Observable<SpRuntimeGenericDigest>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The number of events in the `Events<T>` list.
+       **/
+      eventCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Events deposited for the current block.
+       * 
+       * NOTE: This storage item is explicitly unbounded since it is never intended to be read
+       * from within the runtime.
+       **/
+      events: AugmentedQuery<ApiType, () => Observable<Vec<FrameSystemEventRecord>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Mapping between a topic (represented by T::Hash) and a vector of indexes
+       * of events in the `<Events<T>>` list.
+       * 
+       * All topic vectors have deterministic storage locations depending on the topic. This
+       * allows light-clients to leverage the changes trie storage tracking mechanism and
+       * in case of changes fetch the list of events of interest.
+       * 
+       * The value has the type `(T::BlockNumber, EventIndex)` because if we used only just
+       * the `EventIndex` then in case if the topic has the same contents on the next block
+       * no notification will be triggered thus the event might be lost.
+       **/
+      eventTopics: AugmentedQuery<ApiType, (arg: H256 | string | Uint8Array) => Observable<Vec<ITuple<[u32, u32]>>>, [H256]> & QueryableStorageEntry<ApiType, [H256]>;
+      /**
+       * The execution phase of the block.
+       **/
+      executionPhase: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemPhase>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Total extrinsics count for the current block.
+       **/
+      extrinsicCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Extrinsics data for the current block (maps an extrinsic's index to its data).
+       **/
+      extrinsicData: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      /**
+       * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.
+       **/
+      lastRuntimeUpgrade: AugmentedQuery<ApiType, () => Observable<Option<FrameSystemLastRuntimeUpgradeInfo>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The current block number being processed. Set by `execute_block`.
+       **/
+      number: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Hash of the previous block.
+       **/
+      parentHash: AugmentedQuery<ApiType, () => Observable<H256>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False
+       * (default) if not.
+       **/
+      upgradedToTripleRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.
+       **/
+      upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    timestamp: {
+      /**
+       * Did the timestamp get updated in this block?
+       **/
+      didUpdate: AugmentedQuery<ApiType, () => Observable<bool>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Current time for the current block.
+       **/
+      now: AugmentedQuery<ApiType, () => Observable<u64>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    transactionPayment: {
+      nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<u128>, []> & QueryableStorageEntry<ApiType, []>;
+      storageVersion: AugmentedQuery<ApiType, () => Observable<PalletTransactionPaymentReleases>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    treasury: {
+      /**
+       * Proposal indices that have been approved but not yet awarded.
+       **/
+      approvals: AugmentedQuery<ApiType, () => Observable<Vec<u32>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Number of proposals that have been made.
+       **/
+      proposalCount: AugmentedQuery<ApiType, () => Observable<u32>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Proposals that have been made.
+       **/
+      proposals: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Option<PalletTreasuryProposal>>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    vesting: {
+      /**
+       * Storage version of the pallet.
+       * 
+       * New networks start with latest version, as determined by the genesis build.
+       **/
+      storageVersion: AugmentedQuery<ApiType, () => Observable<PalletVestingReleases>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Information regarding the vesting of a given account.
+       **/
+      vesting: AugmentedQuery<ApiType, (arg: AccountId32 | string | Uint8Array) => Observable<Option<Vec<PalletVestingVestingInfo>>>, [AccountId32]> & QueryableStorageEntry<ApiType, [AccountId32]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+    xcmpQueue: {
+      /**
+       * Inbound aggregate XCMP messages. It can only be one per ParaId/block.
+       **/
+      inboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u32]> & QueryableStorageEntry<ApiType, [u32, u32]>;
+      /**
+       * Status of the inbound XCMP channels.
+       **/
+      inboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, CumulusPalletXcmpQueueInboundStatus, Vec<ITuple<[u32, PolkadotParachainPrimitivesXcmpMessageFormat]>>]>>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The messages outbound in a given XCMP channel.
+       **/
+      outboundXcmpMessages: AugmentedQuery<ApiType, (arg1: u32 | AnyNumber | Uint8Array, arg2: u16 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32, u16]> & QueryableStorageEntry<ApiType, [u32, u16]>;
+      /**
+       * The non-empty XCMP channels in order of becoming non-empty, and the index of the first
+       * and last outbound message. If the two indices are equal, then it indicates an empty
+       * queue and there must be a non-`Ok` `OutboundStatus`. We assume queues grow no greater
+       * than 65535 items. Queue indices for normal messages begin at one; zero is reserved in
+       * case of the need to send a high-priority signal message this block.
+       * The bool is true if there is a signal message waiting to be sent.
+       **/
+      outboundXcmpStatus: AugmentedQuery<ApiType, () => Observable<Vec<ITuple<[u32, CumulusPalletXcmpQueueOutboundStatus, bool, u16, u16]>>>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * The configuration which controls the dynamics of the outbound queue.
+       **/
+      queueConfig: AugmentedQuery<ApiType, () => Observable<CumulusPalletXcmpQueueQueueConfigData>, []> & QueryableStorageEntry<ApiType, []>;
+      /**
+       * Any signal messages waiting to be sent.
+       **/
+      signalMessages: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]> & QueryableStorageEntry<ApiType, [u32]>;
+      /**
+       * Generic query
+       **/
+      [key: string]: QueryableStorageEntry<ApiType>;
+    };
+  }
+
+  export interface QueryableStorage<ApiType extends ApiTypes> extends AugmentedQueries<ApiType> {
+    [key: string]: QueryableModuleStorage<ApiType>;
+  }
+}

--- /dev/null
+++ b/tests/src/interfaces/augment-api-rpc.ts
@@ -0,0 +1,611 @@
+// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
+/* eslint-disable */
+
+import type { NftDataStructsCollectionId, NftDataStructsTokenId, PalletCommonAccountBasicCrossAccountIdRepr } from './nft';
+import type { Bytes, HashMap, Json, Metadata, Null, Option, StorageKey, Text, U256, U64, Vec, bool, u128, u32, u64 } from '@polkadot/types';
+import type { ExtrinsicOrHash, ExtrinsicStatus } from '@polkadot/types/interfaces/author';
+import type { EpochAuthorship } from '@polkadot/types/interfaces/babe';
+import type { BeefySignedCommitment } from '@polkadot/types/interfaces/beefy';
+import type { BlockHash } from '@polkadot/types/interfaces/chain';
+import type { PrefixedStorageKey } from '@polkadot/types/interfaces/childstate';
+import type { AuthorityId } from '@polkadot/types/interfaces/consensus';
+import type { ContractCallRequest, ContractExecResult, ContractInstantiateResult, InstantiateRequest } from '@polkadot/types/interfaces/contracts';
+import type { CreatedBlock } from '@polkadot/types/interfaces/engine';
+import type { EthAccount, EthCallRequest, EthFilter, EthFilterChanges, EthLog, EthReceipt, EthRichBlock, EthSubKind, EthSubParams, EthSyncStatus, EthTransaction, EthTransactionRequest, EthWork } from '@polkadot/types/interfaces/eth';
+import type { Extrinsic } from '@polkadot/types/interfaces/extrinsics';
+import type { EncodedFinalityProofs, JustificationNotification, ReportedRoundStates } from '@polkadot/types/interfaces/grandpa';
+import type { MmrLeafProof } from '@polkadot/types/interfaces/mmr';
+import type { StorageKind } from '@polkadot/types/interfaces/offchain';
+import type { FeeDetails, RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment';
+import type { RpcMethods } from '@polkadot/types/interfaces/rpc';
+import type { AccountId, BlockNumber, H160, H256, H64, Hash, Header, Index, Justification, KeyValue, SignedBlock, StorageData } from '@polkadot/types/interfaces/runtime';
+import type { ReadProof, RuntimeVersion, TraceBlockResponse } from '@polkadot/types/interfaces/state';
+import type { ApplyExtrinsicResult, ChainProperties, ChainType, Health, NetworkState, NodeRole, PeerInfo, SyncState } from '@polkadot/types/interfaces/system';
+import type { AnyNumber, Codec, IExtrinsic, Observable } from '@polkadot/types/types';
+
+declare module '@polkadot/rpc-core/types.jsonrpc' {
+  export interface RpcInterface {
+    author: {
+      /**
+       * Returns true if the keystore has private keys for the given public key and key type.
+       **/
+      hasKey: AugmentedRpc<(publicKey: Bytes | string | Uint8Array, keyType: Text | string) => Observable<bool>>;
+      /**
+       * Returns true if the keystore has private keys for the given session public keys.
+       **/
+      hasSessionKeys: AugmentedRpc<(sessionKeys: Bytes | string | Uint8Array) => Observable<bool>>;
+      /**
+       * Insert a key into the keystore.
+       **/
+      insertKey: AugmentedRpc<(keyType: Text | string, suri: Text | string, publicKey: Bytes | string | Uint8Array) => Observable<Bytes>>;
+      /**
+       * Returns all pending extrinsics, potentially grouped by sender
+       **/
+      pendingExtrinsics: AugmentedRpc<() => Observable<Vec<Extrinsic>>>;
+      /**
+       * Remove given extrinsic from the pool and temporarily ban it to prevent reimporting
+       **/
+      removeExtrinsic: AugmentedRpc<(bytesOrHash: Vec<ExtrinsicOrHash> | (ExtrinsicOrHash | { Hash: any } | { Extrinsic: any } | string | Uint8Array)[]) => Observable<Vec<Hash>>>;
+      /**
+       * Generate new session keys and returns the corresponding public keys
+       **/
+      rotateKeys: AugmentedRpc<() => Observable<Bytes>>;
+      /**
+       * Submit and subscribe to watch an extrinsic until unsubscribed
+       **/
+      submitAndWatchExtrinsic: AugmentedRpc<(extrinsic: IExtrinsic) => Observable<ExtrinsicStatus>>;
+      /**
+       * Submit a fully formatted extrinsic for block inclusion
+       **/
+      submitExtrinsic: AugmentedRpc<(extrinsic: IExtrinsic) => Observable<Hash>>;
+    };
+    babe: {
+      /**
+       * Returns data about which slots (primary or secondary) can be claimed in the current epoch with the keys in the keystore
+       **/
+      epochAuthorship: AugmentedRpc<() => Observable<HashMap<AuthorityId, EpochAuthorship>>>;
+    };
+    beefy: {
+      /**
+       * Returns the block most recently finalized by BEEFY, alongside side its justification.
+       **/
+      subscribeJustifications: AugmentedRpc<() => Observable<BeefySignedCommitment>>;
+    };
+    chain: {
+      /**
+       * Get header and body of a relay chain block
+       **/
+      getBlock: AugmentedRpc<(hash?: BlockHash | string | Uint8Array) => Observable<SignedBlock>>;
+      /**
+       * Get the block hash for a specific block
+       **/
+      getBlockHash: AugmentedRpc<(blockNumber?: BlockNumber | AnyNumber | Uint8Array) => Observable<BlockHash>>;
+      /**
+       * Get hash of the last finalized block in the canon chain
+       **/
+      getFinalizedHead: AugmentedRpc<() => Observable<BlockHash>>;
+      /**
+       * Retrieves the header for a specific block
+       **/
+      getHeader: AugmentedRpc<(hash?: BlockHash | string | Uint8Array) => Observable<Header>>;
+      /**
+       * Retrieves the newest header via subscription
+       **/
+      subscribeAllHeads: AugmentedRpc<() => Observable<Header>>;
+      /**
+       * Retrieves the best finalized header via subscription
+       **/
+      subscribeFinalizedHeads: AugmentedRpc<() => Observable<Header>>;
+      /**
+       * Retrieves the best header via subscription
+       **/
+      subscribeNewHeads: AugmentedRpc<() => Observable<Header>>;
+    };
+    childstate: {
+      /**
+       * Returns the keys with prefix from a child storage, leave empty to get all the keys
+       **/
+      getKeys: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, prefix: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
+      /**
+       * Returns the keys with prefix from a child storage with pagination support
+       **/
+      getKeysPaged: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, prefix: StorageKey | string | Uint8Array | any, count: u32 | AnyNumber | Uint8Array, startKey?: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
+      /**
+       * Returns a child storage entry at a specific block state
+       **/
+      getStorage: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Option<StorageData>>>;
+      /**
+       * Returns child storage entries for multiple keys at a specific block state
+       **/
+      getStorageEntries: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: Hash | string | Uint8Array) => Observable<Vec<Option<StorageData>>>>;
+      /**
+       * Returns the hash of a child storage entry at a block state
+       **/
+      getStorageHash: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Option<Hash>>>;
+      /**
+       * Returns the size of a child storage entry at a block state
+       **/
+      getStorageSize: AugmentedRpc<(childKey: PrefixedStorageKey | string | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: Hash | string | Uint8Array) => Observable<Option<u64>>>;
+    };
+    contracts: {
+      /**
+       * Executes a call to a contract
+       **/
+      call: AugmentedRpc<(callRequest: ContractCallRequest | { origin?: any; dest?: any; value?: any; gasLimit?: any; inputData?: any } | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<ContractExecResult>>;
+      /**
+       * Returns the value under a specified storage key in a contract
+       **/
+      getStorage: AugmentedRpc<(address: AccountId | string | Uint8Array, key: H256 | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<Option<Bytes>>>;
+      /**
+       * Instantiate a new contract
+       **/
+      instantiate: AugmentedRpc<(request: InstantiateRequest | { origin?: any; endowment?: any; gasLimit?: any; code?: any; data?: any; salt?: any } | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<ContractInstantiateResult>>;
+      /**
+       * Returns the projected time a given contract will be able to sustain paying its rent
+       **/
+      rentProjection: AugmentedRpc<(address: AccountId | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<Option<BlockNumber>>>;
+    };
+    engine: {
+      /**
+       * Instructs the manual-seal authorship task to create a new block
+       **/
+      createBlock: AugmentedRpc<(createEmpty: bool | boolean | Uint8Array, finalize: bool | boolean | Uint8Array, parentHash?: BlockHash | string | Uint8Array) => Observable<CreatedBlock>>;
+      /**
+       * Instructs the manual-seal authorship task to finalize a block
+       **/
+      finalizeBlock: AugmentedRpc<(hash: BlockHash | string | Uint8Array, justification?: Justification) => Observable<bool>>;
+    };
+    eth: {
+      /**
+       * Returns accounts list.
+       **/
+      accounts: AugmentedRpc<() => Observable<Vec<H160>>>;
+      /**
+       * Returns the blockNumber
+       **/
+      blockNumber: AugmentedRpc<() => Observable<U256>>;
+      /**
+       * Call contract, returning the output data.
+       **/
+      call: AugmentedRpc<(request: EthCallRequest | { from?: any; to?: any; gasPrice?: any; gas?: any; value?: any; data?: any; nonce?: any } | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<Bytes>>;
+      /**
+       * Returns the chain ID used for transaction signing at the current best block. None is returned if not available.
+       **/
+      chainId: AugmentedRpc<() => Observable<U64>>;
+      /**
+       * Returns block author.
+       **/
+      coinbase: AugmentedRpc<() => Observable<H160>>;
+      /**
+       * Estimate gas needed for execution of given contract.
+       **/
+      estimateGas: AugmentedRpc<(request: EthCallRequest | { from?: any; to?: any; gasPrice?: any; gas?: any; value?: any; data?: any; nonce?: any } | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;
+      /**
+       * Returns current gas price.
+       **/
+      gasPrice: AugmentedRpc<() => Observable<U256>>;
+      /**
+       * Returns balance of the given account.
+       **/
+      getBalance: AugmentedRpc<(address: H160 | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;
+      /**
+       * Returns block with given hash.
+       **/
+      getBlockByHash: AugmentedRpc<(hash: H256 | string | Uint8Array, full: bool | boolean | Uint8Array) => Observable<Option<EthRichBlock>>>;
+      /**
+       * Returns block with given number.
+       **/
+      getBlockByNumber: AugmentedRpc<(block: BlockNumber | AnyNumber | Uint8Array, full: bool | boolean | Uint8Array) => Observable<Option<EthRichBlock>>>;
+      /**
+       * Returns the number of transactions in a block with given hash.
+       **/
+      getBlockTransactionCountByHash: AugmentedRpc<(hash: H256 | string | Uint8Array) => Observable<U256>>;
+      /**
+       * Returns the number of transactions in a block with given block number.
+       **/
+      getBlockTransactionCountByNumber: AugmentedRpc<(block: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;
+      /**
+       * Returns the code at given address at given time (block number).
+       **/
+      getCode: AugmentedRpc<(address: H160 | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<Bytes>>;
+      /**
+       * Returns filter changes since last poll.
+       **/
+      getFilterChanges: AugmentedRpc<(index: U256 | AnyNumber | Uint8Array) => Observable<EthFilterChanges>>;
+      /**
+       * Returns all logs matching given filter (in a range 'from' - 'to').
+       **/
+      getFilterLogs: AugmentedRpc<(index: U256 | AnyNumber | Uint8Array) => Observable<Vec<EthLog>>>;
+      /**
+       * Returns logs matching given filter object.
+       **/
+      getLogs: AugmentedRpc<(filter: EthFilter | { fromBlock?: any; toBlock?: any; blockHash?: any; address?: any; topics?: any } | string | Uint8Array) => Observable<Vec<EthLog>>>;
+      /**
+       * Returns proof for account and storage.
+       **/
+      getProof: AugmentedRpc<(address: H160 | string | Uint8Array, storageKeys: Vec<H256> | (H256 | string | Uint8Array)[], number: BlockNumber | AnyNumber | Uint8Array) => Observable<EthAccount>>;
+      /**
+       * Returns content of the storage at given address.
+       **/
+      getStorageAt: AugmentedRpc<(address: H160 | string | Uint8Array, index: U256 | AnyNumber | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<H256>>;
+      /**
+       * Returns transaction at given block hash and index.
+       **/
+      getTransactionByBlockHashAndIndex: AugmentedRpc<(hash: H256 | string | Uint8Array, index: U256 | AnyNumber | Uint8Array) => Observable<EthTransaction>>;
+      /**
+       * Returns transaction by given block number and index.
+       **/
+      getTransactionByBlockNumberAndIndex: AugmentedRpc<(number: BlockNumber | AnyNumber | Uint8Array, index: U256 | AnyNumber | Uint8Array) => Observable<EthTransaction>>;
+      /**
+       * Get transaction by its hash.
+       **/
+      getTransactionByHash: AugmentedRpc<(hash: H256 | string | Uint8Array) => Observable<EthTransaction>>;
+      /**
+       * Returns the number of transactions sent from given address at given time (block number).
+       **/
+      getTransactionCount: AugmentedRpc<(hash: H256 | string | Uint8Array, number?: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;
+      /**
+       * Returns transaction receipt by transaction hash.
+       **/
+      getTransactionReceipt: AugmentedRpc<(hash: H256 | string | Uint8Array) => Observable<EthReceipt>>;
+      /**
+       * Returns an uncles at given block and index.
+       **/
+      getUncleByBlockHashAndIndex: AugmentedRpc<(hash: H256 | string | Uint8Array, index: U256 | AnyNumber | Uint8Array) => Observable<EthRichBlock>>;
+      /**
+       * Returns an uncles at given block and index.
+       **/
+      getUncleByBlockNumberAndIndex: AugmentedRpc<(number: BlockNumber | AnyNumber | Uint8Array, index: U256 | AnyNumber | Uint8Array) => Observable<EthRichBlock>>;
+      /**
+       * Returns the number of uncles in a block with given hash.
+       **/
+      getUncleCountByBlockHash: AugmentedRpc<(hash: H256 | string | Uint8Array) => Observable<U256>>;
+      /**
+       * Returns the number of uncles in a block with given block number.
+       **/
+      getUncleCountByBlockNumber: AugmentedRpc<(number: BlockNumber | AnyNumber | Uint8Array) => Observable<U256>>;
+      /**
+       * Returns the hash of the current block, the seedHash, and the boundary condition to be met.
+       **/
+      getWork: AugmentedRpc<() => Observable<EthWork>>;
+      /**
+       * Returns the number of hashes per second that the node is mining with.
+       **/
+      hashrate: AugmentedRpc<() => Observable<U256>>;
+      /**
+       * Returns true if client is actively mining new blocks.
+       **/
+      mining: AugmentedRpc<() => Observable<bool>>;
+      /**
+       * Returns id of new block filter.
+       **/
+      newBlockFilter: AugmentedRpc<() => Observable<U256>>;
+      /**
+       * Returns id of new filter.
+       **/
+      newFilter: AugmentedRpc<(filter: EthFilter | { fromBlock?: any; toBlock?: any; blockHash?: any; address?: any; topics?: any } | string | Uint8Array) => Observable<U256>>;
+      /**
+       * Returns id of new block filter.
+       **/
+      newPendingTransactionFilter: AugmentedRpc<() => Observable<U256>>;
+      /**
+       * Returns protocol version encoded as a string (quotes are necessary).
+       **/
+      protocolVersion: AugmentedRpc<() => Observable<u64>>;
+      /**
+       * Sends signed transaction, returning its hash.
+       **/
+      sendRawTransaction: AugmentedRpc<(bytes: Bytes | string | Uint8Array) => Observable<H256>>;
+      /**
+       * Sends transaction; will block waiting for signer to return the transaction hash
+       **/
+      sendTransaction: AugmentedRpc<(tx: EthTransactionRequest | { from?: any; to?: any; gasPrice?: any; gas?: any; value?: any; data?: any; nonce?: any } | string | Uint8Array) => Observable<H256>>;
+      /**
+       * Used for submitting mining hashrate.
+       **/
+      submitHashrate: AugmentedRpc<(index: U256 | AnyNumber | Uint8Array, hash: H256 | string | Uint8Array) => Observable<bool>>;
+      /**
+       * Used for submitting a proof-of-work solution.
+       **/
+      submitWork: AugmentedRpc<(nonce: H64 | string | Uint8Array, headerHash: H256 | string | Uint8Array, mixDigest: H256 | string | Uint8Array) => Observable<bool>>;
+      /**
+       * Subscribe to Eth subscription.
+       **/
+      subscribe: AugmentedRpc<(kind: EthSubKind | 'newHeads' | 'logs' | 'newPendingTransactions' | 'syncing' | number | Uint8Array, params?: EthSubParams | { None: any } | { Logs: any } | string | Uint8Array) => Observable<Null>>;
+      /**
+       * Returns an object with data about the sync status or false.
+       **/
+      syncing: AugmentedRpc<() => Observable<EthSyncStatus>>;
+      /**
+       * Uninstalls filter.
+       **/
+      uninstallFilter: AugmentedRpc<(index: U256 | AnyNumber | Uint8Array) => Observable<bool>>;
+    };
+    grandpa: {
+      /**
+       * Prove finality for the range (begin; end] hash.
+       **/
+      proveFinality: AugmentedRpc<(begin: BlockHash | string | Uint8Array, end: BlockHash | string | Uint8Array, authoritiesSetId?: u64 | AnyNumber | Uint8Array) => Observable<Option<EncodedFinalityProofs>>>;
+      /**
+       * Returns the state of the current best round state as well as the ongoing background rounds
+       **/
+      roundState: AugmentedRpc<() => Observable<ReportedRoundStates>>;
+      /**
+       * Subscribes to grandpa justifications
+       **/
+      subscribeJustifications: AugmentedRpc<() => Observable<JustificationNotification>>;
+    };
+    mmr: {
+      /**
+       * Generate MMR proof for given leaf index.
+       **/
+      generateProof: AugmentedRpc<(leafIndex: u64 | AnyNumber | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<MmrLeafProof>>;
+    };
+    net: {
+      /**
+       * Returns true if client is actively listening for network connections. Otherwise false.
+       **/
+      listening: AugmentedRpc<() => Observable<bool>>;
+      /**
+       * Returns number of peers connected to node.
+       **/
+      peerCount: AugmentedRpc<() => Observable<Text>>;
+      /**
+       * Returns protocol version.
+       **/
+      version: AugmentedRpc<() => Observable<Text>>;
+    };
+    nft: {
+      /**
+       * Get amount of different user tokens
+       **/
+      accountBalance: AugmentedRpc<(collection: NftDataStructsCollectionId | AnyNumber | Uint8Array, account: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, at?: Hash | string | Uint8Array) => Observable<u32>>;
+      /**
+       * Get tokens owned by account
+       **/
+      accountTokens: AugmentedRpc<(collection: NftDataStructsCollectionId | AnyNumber | Uint8Array, account: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<NftDataStructsTokenId>>>;
+      /**
+       * Get admin list
+       **/
+      adminlist: AugmentedRpc<(collection: NftDataStructsCollectionId | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<PalletCommonAccountBasicCrossAccountIdRepr>>>;
+      /**
+       * Get allowed amount
+       **/
+      allowance: AugmentedRpc<(collection: NftDataStructsCollectionId | AnyNumber | Uint8Array, sender: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, spender: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, tokenId: NftDataStructsTokenId | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<u128>>;
+      /**
+       * Get allowlist
+       **/
+      allowlist: AugmentedRpc<(collection: NftDataStructsCollectionId | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<PalletCommonAccountBasicCrossAccountIdRepr>>>;
+      /**
+       * Get amount of specific account token
+       **/
+      balance: AugmentedRpc<(collection: NftDataStructsCollectionId | AnyNumber | Uint8Array, account: PalletCommonAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, tokenId: NftDataStructsTokenId | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<u128>>;
+      /**
+       * Get tokens contained in collection
+       **/
+      collectionTokens: AugmentedRpc<(collection: NftDataStructsCollectionId | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Vec<NftDataStructsTokenId>>>;
+      /**
+       * Get token constant metadata
+       **/
+      constMetadata: AugmentedRpc<(collection: NftDataStructsCollectionId | AnyNumber | Uint8Array, tokenId: NftDataStructsTokenId | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Bytes>>;
+      /**
+       * Get last token id
+       **/
+      lastTokenId: AugmentedRpc<(collection: NftDataStructsCollectionId | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<NftDataStructsTokenId>>;
+      /**
+       * Check if token exists
+       **/
+      tokenExists: AugmentedRpc<(collection: NftDataStructsCollectionId | AnyNumber | Uint8Array, tokenId: NftDataStructsTokenId | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<bool>>;
+      /**
+       * Get token owner
+       **/
+      tokenOwner: AugmentedRpc<(collection: NftDataStructsCollectionId | AnyNumber | Uint8Array, tokenId: NftDataStructsTokenId | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<PalletCommonAccountBasicCrossAccountIdRepr>>;
+      /**
+       * Get token variable metadata
+       **/
+      variableMetadata: AugmentedRpc<(collection: NftDataStructsCollectionId | AnyNumber | Uint8Array, tokenId: NftDataStructsTokenId | AnyNumber | Uint8Array, at?: Hash | string | Uint8Array) => Observable<Bytes>>;
+    };
+    offchain: {
+      /**
+       * Get offchain local storage under given key and prefix
+       **/
+      localStorageGet: AugmentedRpc<(kind: StorageKind | 'PERSISTENT' | 'LOCAL' | number | Uint8Array, key: Bytes | string | Uint8Array) => Observable<Option<Bytes>>>;
+      /**
+       * Set offchain local storage under given key and prefix
+       **/
+      localStorageSet: AugmentedRpc<(kind: StorageKind | 'PERSISTENT' | 'LOCAL' | number | Uint8Array, key: Bytes | string | Uint8Array, value: Bytes | string | Uint8Array) => Observable<Null>>;
+    };
+    payment: {
+      /**
+       * Query the detailed fee of a given encoded extrinsic
+       **/
+      queryFeeDetails: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<FeeDetails>>;
+      /**
+       * Retrieves the fee information for an encoded extrinsic
+       **/
+      queryInfo: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<RuntimeDispatchInfo>>;
+    };
+    rpc: {
+      /**
+       * Retrieves the list of RPC methods that are exposed by the node
+       **/
+      methods: AugmentedRpc<() => Observable<RpcMethods>>;
+    };
+    state: {
+      /**
+       * Perform a call to a builtin on the chain
+       **/
+      call: AugmentedRpc<(method: Text | string, data: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<Bytes>>;
+      /**
+       * Retrieves the keys with prefix of a specific child storage
+       **/
+      getChildKeys: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
+      /**
+       * Returns proof of storage for child key entries at a specific block state.
+       **/
+      getChildReadProof: AugmentedRpc<(childStorageKey: PrefixedStorageKey | string | Uint8Array, keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: BlockHash | string | Uint8Array) => Observable<ReadProof>>;
+      /**
+       * Retrieves the child storage for a key
+       **/
+      getChildStorage: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<StorageData>>;
+      /**
+       * Retrieves the child storage hash
+       **/
+      getChildStorageHash: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Hash>>;
+      /**
+       * Retrieves the child storage size
+       **/
+      getChildStorageSize: AugmentedRpc<(childStorageKey: StorageKey | string | Uint8Array | any, childDefinition: StorageKey | string | Uint8Array | any, childType: u32 | AnyNumber | Uint8Array, key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<u64>>;
+      /**
+       * Retrieves the keys with a certain prefix
+       **/
+      getKeys: AugmentedRpc<(key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
+      /**
+       * Returns the keys with prefix with pagination support.
+       **/
+      getKeysPaged: AugmentedRpc<(key: StorageKey | string | Uint8Array | any, count: u32 | AnyNumber | Uint8Array, startKey?: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<StorageKey>>>;
+      /**
+       * Returns the runtime metadata
+       **/
+      getMetadata: AugmentedRpc<(at?: BlockHash | string | Uint8Array) => Observable<Metadata>>;
+      /**
+       * Returns the keys with prefix, leave empty to get all the keys (deprecated: Use getKeysPaged)
+       **/
+      getPairs: AugmentedRpc<(prefix: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Vec<KeyValue>>>;
+      /**
+       * Returns proof of storage entries at a specific block state
+       **/
+      getReadProof: AugmentedRpc<(keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: BlockHash | string | Uint8Array) => Observable<ReadProof>>;
+      /**
+       * Get the runtime version
+       **/
+      getRuntimeVersion: AugmentedRpc<(at?: BlockHash | string | Uint8Array) => Observable<RuntimeVersion>>;
+      /**
+       * Retrieves the storage for a key
+       **/
+      getStorage: AugmentedRpc<<T = Codec>(key: StorageKey | string | Uint8Array | any, block?: Hash | Uint8Array | string) => Observable<T>>;
+      /**
+       * Retrieves the storage hash
+       **/
+      getStorageHash: AugmentedRpc<(key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<Hash>>;
+      /**
+       * Retrieves the storage size
+       **/
+      getStorageSize: AugmentedRpc<(key: StorageKey | string | Uint8Array | any, at?: BlockHash | string | Uint8Array) => Observable<u64>>;
+      /**
+       * Query historical storage entries (by key) starting from a start block
+       **/
+      queryStorage: AugmentedRpc<<T = Codec[]>(keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], fromBlock?: Hash | Uint8Array | string, toBlock?: Hash | Uint8Array | string) => Observable<[Hash, T][]>>;
+      /**
+       * Query storage entries (by key) starting at block hash given as the second parameter
+       **/
+      queryStorageAt: AugmentedRpc<<T = Codec[]>(keys: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[], at?: Hash | Uint8Array | string) => Observable<T>>;
+      /**
+       * Retrieves the runtime version via subscription
+       **/
+      subscribeRuntimeVersion: AugmentedRpc<() => Observable<RuntimeVersion>>;
+      /**
+       * Subscribes to storage changes for the provided keys
+       **/
+      subscribeStorage: AugmentedRpc<<T = Codec[]>(keys?: Vec<StorageKey> | (StorageKey | string | Uint8Array | any)[]) => Observable<T>>;
+      /**
+       * Provides a way to trace the re-execution of a single block
+       **/
+      traceBlock: AugmentedRpc<(block: Hash | string | Uint8Array, targets: Option<Text> | null | object | string | Uint8Array, storageKeys: Option<Text> | null | object | string | Uint8Array) => Observable<TraceBlockResponse>>;
+    };
+    syncstate: {
+      /**
+       * Returns the json-serialized chainspec running the node, with a sync state.
+       **/
+      genSyncSpec: AugmentedRpc<(raw: bool | boolean | Uint8Array) => Observable<Json>>;
+    };
+    system: {
+      /**
+       * Retrieves the next accountIndex as available on the node
+       **/
+      accountNextIndex: AugmentedRpc<(accountId: AccountId | string | Uint8Array) => Observable<Index>>;
+      /**
+       * Adds the supplied directives to the current log filter
+       **/
+      addLogFilter: AugmentedRpc<(directives: Text | string) => Observable<Null>>;
+      /**
+       * Adds a reserved peer
+       **/
+      addReservedPeer: AugmentedRpc<(peer: Text | string) => Observable<Text>>;
+      /**
+       * Retrieves the chain
+       **/
+      chain: AugmentedRpc<() => Observable<Text>>;
+      /**
+       * Retrieves the chain type
+       **/
+      chainType: AugmentedRpc<() => Observable<ChainType>>;
+      /**
+       * Dry run an extrinsic at a given block
+       **/
+      dryRun: AugmentedRpc<(extrinsic: Bytes | string | Uint8Array, at?: BlockHash | string | Uint8Array) => Observable<ApplyExtrinsicResult>>;
+      /**
+       * Return health status of the node
+       **/
+      health: AugmentedRpc<() => Observable<Health>>;
+      /**
+       * The addresses include a trailing /p2p/ with the local PeerId, and are thus suitable to be passed to addReservedPeer or as a bootnode address for example
+       **/
+      localListenAddresses: AugmentedRpc<() => Observable<Vec<Text>>>;
+      /**
+       * Returns the base58-encoded PeerId of the node
+       **/
+      localPeerId: AugmentedRpc<() => Observable<Text>>;
+      /**
+       * Retrieves the node name
+       **/
+      name: AugmentedRpc<() => Observable<Text>>;
+      /**
+       * Returns current state of the network
+       **/
+      networkState: AugmentedRpc<() => Observable<NetworkState>>;
+      /**
+       * Returns the roles the node is running as
+       **/
+      nodeRoles: AugmentedRpc<() => Observable<Vec<NodeRole>>>;
+      /**
+       * Returns the currently connected peers
+       **/
+      peers: AugmentedRpc<() => Observable<Vec<PeerInfo>>>;
+      /**
+       * Get a custom set of properties as a JSON object, defined in the chain spec
+       **/
+      properties: AugmentedRpc<() => Observable<ChainProperties>>;
+      /**
+       * Remove a reserved peer
+       **/
+      removeReservedPeer: AugmentedRpc<(peerId: Text | string) => Observable<Text>>;
+      /**
+       * Returns the list of reserved peers
+       **/
+      reservedPeers: AugmentedRpc<() => Observable<Vec<Text>>>;
+      /**
+       * Resets the log filter to Substrate defaults
+       **/
+      resetLogFilter: AugmentedRpc<() => Observable<Null>>;
+      /**
+       * Returns the state of the syncing of the node
+       **/
+      syncState: AugmentedRpc<() => Observable<SyncState>>;
+      /**
+       * Retrieves the version of the node
+       **/
+      version: AugmentedRpc<() => Observable<Text>>;
+    };
+    web3: {
+      /**
+       * Returns current client version.
+       **/
+      clientVersion: AugmentedRpc<() => Observable<Text>>;
+      /**
+       * Returns sha3 of the given data
+       **/
+      sha3: AugmentedRpc<(data: Bytes | string | Uint8Array) => Observable<H256>>;
+    };
+  }
+}

no changes

--- /dev/null
+++ b/tests/src/interfaces/augment-api.ts
@@ -0,0 +1,10 @@
+// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
+/* eslint-disable */
+
+import '@polkadot/api/augment/rpc';
+import './augment-api-consts';
+import './augment-api-errors';
+import './augment-api-events';
+import './augment-api-query';
+import './augment-api-tx';
+import './augment-api-rpc';

--- /dev/null
+++ b/tests/src/interfaces/augment-types.ts
@@ -0,0 +1,1112 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { EthereumBlock, EthereumLog, EthereumReceipt, EthereumTransactionLegacyTransaction, EvmCoreErrorExitReason, FpRpcTransactionStatus } from './ethereum';
+import type { NftDataStructsAccessMode, NftDataStructsCollection, NftDataStructsCollectionId, NftDataStructsCollectionLimits, NftDataStructsCollectionMode, NftDataStructsCreateItemData, NftDataStructsMetaUpdatePermission, NftDataStructsSchemaVersion, NftDataStructsSponsorshipState, NftDataStructsTokenId, PalletCommonAccountBasicCrossAccountIdRepr, PalletNonfungibleItemData, PalletRefungibleItemData, PalletUnqSchedulerCallSpec, PalletUnqSchedulerReleases, PalletUnqSchedulerScheduledV2 } from './nft';
+import type { CumulusPalletDmpQueueConfigData, CumulusPalletDmpQueuePageIndexData, CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot, CumulusPalletXcmpQueueInboundStatus, CumulusPalletXcmpQueueOutboundStatus, CumulusPalletXcmpQueueQueueConfigData, CumulusPrimitivesParachainInherentParachainInherentData, PolkadotParachainPrimitivesXcmpMessageFormat, PolkadotPrimitivesV1AbridgedHostConfiguration, PolkadotPrimitivesV1PersistedValidationData } from './polkadot';
+import type { BitVec, Bool, Bytes, Data, I128, I16, I256, I32, I64, I8, Json, Null, Raw, StorageKey, Text, Type, U128, U16, U256, U32, U64, U8, USize, bool, i128, i16, i256, i32, i64, i8, u128, u16, u256, u32, u64, u8, usize } from '@polkadot/types';
+import type { AssetApproval, AssetApprovalKey, AssetBalance, AssetDestroyWitness, AssetDetails, AssetMetadata, TAssetBalance, TAssetDepositBalance } from '@polkadot/types/interfaces/assets';
+import type { BlockAttestations, IncludedBlocks, MoreAttestations } from '@polkadot/types/interfaces/attestations';
+import type { RawAuraPreDigest } from '@polkadot/types/interfaces/aura';
+import type { ExtrinsicOrHash, ExtrinsicStatus } from '@polkadot/types/interfaces/author';
+import type { UncleEntryItem } from '@polkadot/types/interfaces/authorship';
+import type { AllowedSlots, BabeAuthorityWeight, BabeBlockWeight, BabeEpochConfiguration, BabeEquivocationProof, BabeWeight, EpochAuthorship, MaybeRandomness, MaybeVrf, NextConfigDescriptor, NextConfigDescriptorV1, Randomness, RawBabePreDigest, RawBabePreDigestCompat, RawBabePreDigestPrimary, RawBabePreDigestPrimaryTo159, RawBabePreDigestSecondaryPlain, RawBabePreDigestSecondaryTo159, RawBabePreDigestSecondaryVRF, RawBabePreDigestTo159, SlotNumber, VrfData, VrfOutput, VrfProof } from '@polkadot/types/interfaces/babe';
+import type { AccountData, BalanceLock, BalanceLockTo212, BalanceStatus, Reasons, ReserveData, ReserveIdentifier, VestingSchedule, WithdrawReasons } from '@polkadot/types/interfaces/balances';
+import type { BeefyCommitment, BeefyId, BeefyNextAuthoritySet, BeefyPayload, BeefySignedCommitment, MmrRootHash, ValidatorSetId } from '@polkadot/types/interfaces/beefy';
+import type { BridgeMessageId, BridgedBlockHash, BridgedBlockNumber, BridgedHeader, CallOrigin, ChainId, DeliveredMessages, DispatchFeePayment, InboundLaneData, InboundRelayer, InitializationData, LaneId, MessageData, MessageKey, MessageNonce, MessagesDeliveryProofOf, MessagesProofOf, OperatingMode, OutboundLaneData, OutboundMessageFee, OutboundPayload, Parameter, RelayerId, UnrewardedRelayer, UnrewardedRelayersState } from '@polkadot/types/interfaces/bridges';
+import type { BlockHash } from '@polkadot/types/interfaces/chain';
+import type { PrefixedStorageKey } from '@polkadot/types/interfaces/childstate';
+import type { StatementKind } from '@polkadot/types/interfaces/claims';
+import type { CollectiveOrigin, MemberCount, ProposalIndex, Votes, VotesTo230 } from '@polkadot/types/interfaces/collective';
+import type { AuthorityId, RawVRFOutput } from '@polkadot/types/interfaces/consensus';
+import type { AliveContractInfo, CodeHash, ContractCallRequest, ContractExecResult, ContractExecResultErr, ContractExecResultErrModule, ContractExecResultOk, ContractExecResultResult, ContractExecResultSuccessTo255, ContractExecResultSuccessTo260, ContractExecResultTo255, ContractExecResultTo260, ContractExecResultTo267, ContractInfo, ContractInstantiateResult, ContractInstantiateResultTo267, ContractStorageKey, DeletedContract, ExecReturnValue, Gas, HostFnWeights, HostFnWeightsTo264, InstantiateRequest, InstantiateReturnValue, InstantiateReturnValueTo267, InstructionWeights, Limits, LimitsTo264, PrefabWasmModule, RentProjection, Schedule, ScheduleTo212, ScheduleTo258, ScheduleTo264, SeedOf, TombstoneContractInfo, TrieId } from '@polkadot/types/interfaces/contracts';
+import type { ContractConstructorSpec, ContractContractSpec, ContractCryptoHasher, ContractDiscriminant, ContractDisplayName, ContractEventParamSpec, ContractEventSpec, ContractLayoutArray, ContractLayoutCell, ContractLayoutEnum, ContractLayoutHash, ContractLayoutHashingStrategy, ContractLayoutKey, ContractLayoutStruct, ContractLayoutStructField, ContractMessageParamSpec, ContractMessageSpec, ContractMetadata, ContractMetadataLatest, ContractMetadataV0, ContractMetadataV1, ContractProject, ContractProjectContract, ContractProjectInfo, ContractProjectSource, ContractProjectV0, ContractSelector, ContractStorageLayout, ContractTypeSpec } from '@polkadot/types/interfaces/contractsAbi';
+import type { FundIndex, FundInfo, LastContribution, TrieIndex } from '@polkadot/types/interfaces/crowdloan';
+import type { ConfigData, MessageId, OverweightIndex, PageCounter, PageIndexData } from '@polkadot/types/interfaces/cumulus';
+import type { AccountVote, AccountVoteSplit, AccountVoteStandard, Conviction, Delegations, PreimageStatus, PreimageStatusAvailable, PriorLock, PropIndex, Proposal, ProxyState, ReferendumIndex, ReferendumInfo, ReferendumInfoFinished, ReferendumInfoTo239, ReferendumStatus, Tally, Voting, VotingDelegating, VotingDirect, VotingDirectVote } from '@polkadot/types/interfaces/democracy';
+import type { ApprovalFlag, DefunctVoter, Renouncing, SetIndex, Vote, VoteIndex, VoteThreshold, VoterInfo } from '@polkadot/types/interfaces/elections';
+import type { CreatedBlock, ImportedAux } from '@polkadot/types/interfaces/engine';
+import type { BlockV0, BlockV1, BlockV2, EIP1559Transaction, EIP2930Transaction, EthAccessList, EthAccessListItem, EthAccount, EthAddress, EthBlock, EthBloom, EthCallRequest, EthFilter, EthFilterAddress, EthFilterChanges, EthFilterTopic, EthFilterTopicEntry, EthFilterTopicInner, EthHeader, EthLog, EthReceipt, EthRichBlock, EthRichHeader, EthStorageProof, EthSubKind, EthSubParams, EthSubResult, EthSyncInfo, EthSyncStatus, EthTransaction, EthTransactionAction, EthTransactionCondition, EthTransactionRequest, EthTransactionSignature, EthTransactionStatus, EthWork, EthereumAccountId, EthereumAddress, EthereumLookupSource, EthereumSignature, LegacyTransaction, TransactionV0, TransactionV1, TransactionV2 } from '@polkadot/types/interfaces/eth';
+import type { EvmAccount, EvmLog, EvmVicinity, ExitError, ExitFatal, ExitReason, ExitRevert, ExitSucceed } from '@polkadot/types/interfaces/evm';
+import type { AnySignature, EcdsaSignature, Ed25519Signature, Era, Extrinsic, ExtrinsicEra, ExtrinsicPayload, ExtrinsicPayloadUnknown, ExtrinsicPayloadV4, ExtrinsicSignature, ExtrinsicSignatureV4, ExtrinsicUnknown, ExtrinsicV4, ImmortalEra, MortalEra, MultiSignature, Signature, SignerPayload, Sr25519Signature } from '@polkadot/types/interfaces/extrinsics';
+import type { AssetOptions, Owner, PermissionLatest, PermissionVersions, PermissionsV1 } from '@polkadot/types/interfaces/genericAsset';
+import type { ActiveGilt, ActiveGiltsTotal, ActiveIndex, GiltBid } from '@polkadot/types/interfaces/gilt';
+import type { AuthorityIndex, AuthorityList, AuthoritySet, AuthoritySetChange, AuthoritySetChanges, AuthorityWeight, DelayKind, DelayKindBest, EncodedFinalityProofs, ForkTreePendingChange, ForkTreePendingChangeNode, GrandpaCommit, GrandpaEquivocation, GrandpaEquivocationProof, GrandpaEquivocationValue, GrandpaJustification, GrandpaPrecommit, GrandpaPrevote, GrandpaSignedPrecommit, JustificationNotification, KeyOwnerProof, NextAuthority, PendingChange, PendingPause, PendingResume, Precommits, Prevotes, ReportedRoundStates, RoundState, SetId, StoredPendingChange, StoredState } from '@polkadot/types/interfaces/grandpa';
+import type { IdentityFields, IdentityInfo, IdentityInfoAdditional, IdentityInfoTo198, IdentityJudgement, RegistrarIndex, RegistrarInfo, Registration, RegistrationJudgement, RegistrationTo198 } from '@polkadot/types/interfaces/identity';
+import type { AuthIndex, AuthoritySignature, Heartbeat, HeartbeatTo244, OpaqueMultiaddr, OpaqueNetworkState, OpaquePeerId } from '@polkadot/types/interfaces/imOnline';
+import type { CallIndex, LotteryConfig } from '@polkadot/types/interfaces/lottery';
+import type { ErrorMetadataLatest, ErrorMetadataV10, ErrorMetadataV11, ErrorMetadataV12, ErrorMetadataV13, ErrorMetadataV14, ErrorMetadataV9, EventMetadataLatest, EventMetadataV10, EventMetadataV11, EventMetadataV12, EventMetadataV13, EventMetadataV14, EventMetadataV9, ExtrinsicMetadataLatest, ExtrinsicMetadataV11, ExtrinsicMetadataV12, ExtrinsicMetadataV13, ExtrinsicMetadataV14, FunctionArgumentMetadataLatest, FunctionArgumentMetadataV10, FunctionArgumentMetadataV11, FunctionArgumentMetadataV12, FunctionArgumentMetadataV13, FunctionArgumentMetadataV14, FunctionArgumentMetadataV9, FunctionMetadataLatest, FunctionMetadataV10, FunctionMetadataV11, FunctionMetadataV12, FunctionMetadataV13, FunctionMetadataV14, FunctionMetadataV9, MetadataAll, MetadataLatest, MetadataV10, MetadataV11, MetadataV12, MetadataV13, MetadataV14, MetadataV9, ModuleConstantMetadataV10, ModuleConstantMetadataV11, ModuleConstantMetadataV12, ModuleConstantMetadataV13, ModuleConstantMetadataV9, ModuleMetadataV10, ModuleMetadataV11, ModuleMetadataV12, ModuleMetadataV13, ModuleMetadataV9, PalletCallMetadataLatest, PalletCallMetadataV14, PalletConstantMetadataLatest, PalletConstantMetadataV14, PalletErrorMetadataLatest, PalletErrorMetadataV14, PalletEventMetadataLatest, PalletEventMetadataV14, PalletMetadataLatest, PalletMetadataV14, PalletStorageMetadataLatest, PalletStorageMetadataV14, PortableRegistry, PortableRegistryV14, PortableType, PortableTypeV14, SignedExtensionMetadataLatest, SignedExtensionMetadataV14, StorageEntryMetadataLatest, StorageEntryMetadataV10, StorageEntryMetadataV11, StorageEntryMetadataV12, StorageEntryMetadataV13, StorageEntryMetadataV14, StorageEntryMetadataV9, StorageEntryModifierLatest, StorageEntryModifierV10, StorageEntryModifierV11, StorageEntryModifierV12, StorageEntryModifierV13, StorageEntryModifierV14, StorageEntryModifierV9, StorageEntryTypeLatest, StorageEntryTypeV10, StorageEntryTypeV11, StorageEntryTypeV12, StorageEntryTypeV13, StorageEntryTypeV14, StorageEntryTypeV9, StorageHasher, StorageHasherV10, StorageHasherV11, StorageHasherV12, StorageHasherV13, StorageHasherV14, StorageHasherV9, StorageMetadataV10, StorageMetadataV11, StorageMetadataV12, StorageMetadataV13, StorageMetadataV9 } from '@polkadot/types/interfaces/metadata';
+import type { MmrLeafProof } from '@polkadot/types/interfaces/mmr';
+import type { StorageKind } from '@polkadot/types/interfaces/offchain';
+import type { DeferredOffenceOf, Kind, OffenceDetails, Offender, OpaqueTimeSlot, ReportIdOf, Reporter } from '@polkadot/types/interfaces/offences';
+import type { AbridgedCandidateReceipt, AbridgedHostConfiguration, AbridgedHrmpChannel, AssignmentId, AssignmentKind, AttestedCandidate, AuctionIndex, AuthorityDiscoveryId, AvailabilityBitfield, AvailabilityBitfieldRecord, BackedCandidate, Bidder, BufferedSessionChange, CandidateCommitments, CandidateDescriptor, CandidateHash, CandidateInfo, CandidatePendingAvailability, CandidateReceipt, CollatorId, CollatorSignature, CommittedCandidateReceipt, CoreAssignment, CoreIndex, CoreOccupied, DisputeLocation, DisputeResult, DisputeState, DisputeStatement, DisputeStatementSet, DoubleVoteReport, DownwardMessage, ExplicitDisputeStatement, GlobalValidationData, GlobalValidationSchedule, GroupIndex, HeadData, HostConfiguration, HrmpChannel, HrmpChannelId, HrmpOpenChannelRequest, InboundDownwardMessage, InboundHrmpMessage, InboundHrmpMessages, IncomingParachain, IncomingParachainDeploy, IncomingParachainFixed, InvalidDisputeStatementKind, LeasePeriod, LeasePeriodOf, LocalValidationData, MessageIngestionType, MessageQueueChain, MessagingStateSnapshot, MessagingStateSnapshotEgressEntry, MultiDisputeStatementSet, NewBidder, OutboundHrmpMessage, ParaGenesisArgs, ParaId, ParaInfo, ParaLifecycle, ParaPastCodeMeta, ParaScheduling, ParaValidatorIndex, ParachainDispatchOrigin, ParachainInherentData, ParachainProposal, ParachainsInherentData, ParathreadClaim, ParathreadClaimQueue, ParathreadEntry, PersistedValidationData, QueuedParathread, RegisteredParachainInfo, RelayBlockNumber, RelayChainBlockNumber, RelayChainHash, RelayHash, Remark, ReplacementTimes, Retriable, Scheduling, ServiceQuality, SessionInfo, SessionInfoValidatorGroup, SignedAvailabilityBitfield, SignedAvailabilityBitfields, SigningContext, SlotRange, Statement, SubId, SystemInherentData, TransientValidationData, UpgradeGoAhead, UpgradeRestriction, UpwardMessage, ValidDisputeStatementKind, ValidationCode, ValidationCodeHash, ValidationData, ValidationDataType, ValidationFunctionParams, ValidatorSignature, ValidityAttestation, VecInboundHrmpMessage, WinnersData, WinnersDataTuple, WinningData, WinningDataEntry } from '@polkadot/types/interfaces/parachains';
+import type { FeeDetails, InclusionFee, RuntimeDispatchInfo } from '@polkadot/types/interfaces/payment';
+import type { Approvals } from '@polkadot/types/interfaces/poll';
+import type { ProxyAnnouncement, ProxyDefinition, ProxyType } from '@polkadot/types/interfaces/proxy';
+import type { AccountStatus, AccountValidity } from '@polkadot/types/interfaces/purchase';
+import type { ActiveRecovery, RecoveryConfig } from '@polkadot/types/interfaces/recovery';
+import type { RpcMethods } from '@polkadot/types/interfaces/rpc';
+import type { AccountId, AccountId20, AccountId32, AccountIdOf, AccountIndex, Address, AssetId, Balance, BalanceOf, Block, BlockNumber, BlockNumberFor, BlockNumberOf, Call, CallHash, CallHashOf, ChangesTrieConfiguration, ChangesTrieSignal, CodecHash, Consensus, ConsensusEngineId, CrateVersion, Digest, DigestItem, EncodedJustification, ExtrinsicsWeight, Fixed128, Fixed64, FixedI128, FixedI64, FixedU128, FixedU64, H1024, H128, H160, H2048, H256, H32, H512, H64, Hash, Header, HeaderPartial, I32F32, Index, IndicesLookupSource, Justification, Justifications, KeyTypeId, KeyValue, LockIdentifier, LookupSource, LookupTarget, ModuleId, Moment, MultiAddress, MultiSigner, OpaqueCall, Origin, OriginCaller, PalletId, PalletVersion, PalletsOrigin, Pays, PerU16, Perbill, Percent, Permill, Perquintill, Phantom, PhantomData, PreRuntime, Releases, RuntimeDbWeight, Seal, SealV0, SignedBlock, SignedBlockWithJustification, SignedBlockWithJustifications, Slot, StorageData, StorageProof, TransactionInfo, TransactionPriority, TransactionStorageProof, U32F32, ValidatorId, ValidatorIdOf, Weight, WeightMultiplier } from '@polkadot/types/interfaces/runtime';
+import type { Si0Field, Si0LookupTypeId, Si0Path, Si0Type, Si0TypeDef, Si0TypeDefArray, Si0TypeDefBitSequence, Si0TypeDefCompact, Si0TypeDefComposite, Si0TypeDefPhantom, Si0TypeDefPrimitive, Si0TypeDefSequence, Si0TypeDefTuple, Si0TypeDefVariant, Si0TypeParameter, Si0Variant, Si1Field, Si1LookupTypeId, Si1Path, Si1Type, Si1TypeDef, Si1TypeDefArray, Si1TypeDefBitSequence, Si1TypeDefCompact, Si1TypeDefComposite, Si1TypeDefPrimitive, Si1TypeDefSequence, Si1TypeDefTuple, Si1TypeDefVariant, Si1TypeParameter, Si1Variant, SiField, SiLookupTypeId, SiPath, SiType, SiTypeDef, SiTypeDefArray, SiTypeDefBitSequence, SiTypeDefCompact, SiTypeDefComposite, SiTypeDefPrimitive, SiTypeDefSequence, SiTypeDefTuple, SiTypeDefVariant, SiTypeParameter, SiVariant } from '@polkadot/types/interfaces/scaleInfo';
+import type { Period, Priority, SchedulePeriod, SchedulePriority, Scheduled, ScheduledTo254, TaskAddress } from '@polkadot/types/interfaces/scheduler';
+import type { BeefyKey, FullIdentification, IdentificationTuple, Keys, MembershipProof, SessionIndex, SessionKeys1, SessionKeys10, SessionKeys10B, SessionKeys2, SessionKeys3, SessionKeys4, SessionKeys5, SessionKeys6, SessionKeys6B, SessionKeys7, SessionKeys7B, SessionKeys8, SessionKeys8B, SessionKeys9, SessionKeys9B, ValidatorCount } from '@polkadot/types/interfaces/session';
+import type { Bid, BidKind, SocietyJudgement, SocietyVote, StrikeCount, VouchingStatus } from '@polkadot/types/interfaces/society';
+import type { ActiveEraInfo, CompactAssignments, CompactAssignmentsTo257, CompactAssignmentsTo265, CompactAssignmentsWith16, CompactAssignmentsWith24, CompactScore, CompactScoreCompact, ElectionCompute, ElectionPhase, ElectionResult, ElectionScore, ElectionSize, ElectionStatus, EraIndex, EraPoints, EraRewardPoints, EraRewards, Exposure, ExtendedBalance, Forcing, IndividualExposure, KeyType, MomentOf, Nominations, NominatorIndex, NominatorIndexCompact, OffchainAccuracy, OffchainAccuracyCompact, PhragmenScore, Points, RawSolution, RawSolutionTo265, RawSolutionWith16, RawSolutionWith24, ReadySolution, RewardDestination, RewardPoint, RoundSnapshot, SeatHolder, SignedSubmission, SignedSubmissionOf, SignedSubmissionTo276, SlashJournalEntry, SlashingSpans, SlashingSpansTo204, SolutionOrSnapshotSize, SolutionSupport, SolutionSupports, SpanIndex, SpanRecord, StakingLedger, StakingLedgerTo223, StakingLedgerTo240, SubmissionIndicesOf, Supports, UnappliedSlash, UnappliedSlashOther, UnlockChunk, ValidatorIndex, ValidatorIndexCompact, ValidatorPrefs, ValidatorPrefsTo145, ValidatorPrefsTo196, ValidatorPrefsWithBlocked, ValidatorPrefsWithCommission, VoteWeight, Voter } from '@polkadot/types/interfaces/staking';
+import type { ApiId, BlockTrace, BlockTraceEvent, BlockTraceEventData, BlockTraceSpan, KeyValueOption, ReadProof, RuntimeVersion, RuntimeVersionApi, RuntimeVersionPartial, SpecVersion, StorageChangeSet, TraceBlockResponse, TraceError } from '@polkadot/types/interfaces/state';
+import type { WeightToFeeCoefficient } from '@polkadot/types/interfaces/support';
+import type { AccountInfo, AccountInfoWithDualRefCount, AccountInfoWithProviders, AccountInfoWithRefCount, AccountInfoWithRefCountU8, AccountInfoWithTripleRefCount, ApplyExtrinsicResult, ArithmeticError, BlockLength, BlockWeights, ChainProperties, ChainType, ConsumedWeight, DigestOf, DispatchClass, DispatchError, DispatchErrorModule, DispatchErrorTo198, DispatchInfo, DispatchInfoTo190, DispatchInfoTo244, DispatchOutcome, DispatchResult, DispatchResultOf, DispatchResultTo198, Event, EventId, EventIndex, EventRecord, Health, InvalidTransaction, Key, LastRuntimeUpgradeInfo, NetworkState, NetworkStatePeerset, NetworkStatePeersetInfo, NodeRole, NotConnectedPeer, Peer, PeerEndpoint, PeerEndpointAddr, PeerInfo, PeerPing, PerDispatchClassU32, PerDispatchClassWeight, PerDispatchClassWeightsPerClass, Phase, RawOrigin, RefCount, RefCountTo259, SyncState, SystemOrigin, TokenError, TransactionValidityError, UnknownTransaction, WeightPerClass } from '@polkadot/types/interfaces/system';
+import type { Bounty, BountyIndex, BountyStatus, BountyStatusActive, BountyStatusCuratorProposed, BountyStatusPendingPayout, OpenTip, OpenTipFinderTo225, OpenTipTip, OpenTipTo225, TreasuryProposal } from '@polkadot/types/interfaces/treasury';
+import type { Multiplier } from '@polkadot/types/interfaces/txpayment';
+import type { ClassDetails, ClassId, ClassMetadata, DepositBalance, DepositBalanceOf, DestroyWitness, InstanceDetails, InstanceId, InstanceMetadata } from '@polkadot/types/interfaces/uniques';
+import type { Multisig, Timepoint } from '@polkadot/types/interfaces/utility';
+import type { VestingInfo } from '@polkadot/types/interfaces/vesting';
+import type { AssetInstance, AssetInstanceV0, AssetInstanceV1, AssetInstanceV2, BodyId, BodyPart, DoubleEncodedCall, Fungibility, FungibilityV0, FungibilityV1, FungibilityV2, InboundStatus, InstructionV2, InteriorMultiLocation, Junction, JunctionV0, JunctionV1, JunctionV2, Junctions, JunctionsV1, JunctionsV2, MultiAsset, MultiAssetFilter, MultiAssetFilterV1, MultiAssetFilterV2, MultiAssetV0, MultiAssetV1, MultiAssetV2, MultiAssets, MultiAssetsV1, MultiAssetsV2, MultiLocation, MultiLocationV0, MultiLocationV1, MultiLocationV2, NetworkId, OriginKindV0, OriginKindV1, OriginKindV2, OutboundStatus, Outcome, QueryId, QueryStatus, QueueConfigData, Response, ResponseV0, ResponseV1, ResponseV2, ResponseV2Error, ResponseV2Result, VersionMigrationStage, VersionedMultiAsset, VersionedMultiAssets, VersionedMultiLocation, VersionedResponse, VersionedXcm, WeightLimitV2, WildFungibility, WildFungibilityV0, WildFungibilityV1, WildFungibilityV2, WildMultiAsset, WildMultiAssetV1, WildMultiAssetV2, Xcm, XcmAssetId, XcmError, XcmErrorV0, XcmErrorV1, XcmErrorV2, XcmOrder, XcmOrderV0, XcmOrderV1, XcmOrderV2, XcmOrigin, XcmOriginKind, XcmV0, XcmV1, XcmV2, XcmVersion, XcmpMessageFormat } from '@polkadot/types/interfaces/xcm';
+
+declare module '@polkadot/types/types/registry' {
+  export interface InterfaceTypes {
+    AbridgedCandidateReceipt: AbridgedCandidateReceipt;
+    AbridgedHostConfiguration: AbridgedHostConfiguration;
+    AbridgedHrmpChannel: AbridgedHrmpChannel;
+    AccountData: AccountData;
+    AccountId: AccountId;
+    AccountId20: AccountId20;
+    AccountId32: AccountId32;
+    AccountIdOf: AccountIdOf;
+    AccountIndex: AccountIndex;
+    AccountInfo: AccountInfo;
+    AccountInfoWithDualRefCount: AccountInfoWithDualRefCount;
+    AccountInfoWithProviders: AccountInfoWithProviders;
+    AccountInfoWithRefCount: AccountInfoWithRefCount;
+    AccountInfoWithRefCountU8: AccountInfoWithRefCountU8;
+    AccountInfoWithTripleRefCount: AccountInfoWithTripleRefCount;
+    AccountStatus: AccountStatus;
+    AccountValidity: AccountValidity;
+    AccountVote: AccountVote;
+    AccountVoteSplit: AccountVoteSplit;
+    AccountVoteStandard: AccountVoteStandard;
+    ActiveEraInfo: ActiveEraInfo;
+    ActiveGilt: ActiveGilt;
+    ActiveGiltsTotal: ActiveGiltsTotal;
+    ActiveIndex: ActiveIndex;
+    ActiveRecovery: ActiveRecovery;
+    Address: Address;
+    AliveContractInfo: AliveContractInfo;
+    AllowedSlots: AllowedSlots;
+    AnySignature: AnySignature;
+    ApiId: ApiId;
+    ApplyExtrinsicResult: ApplyExtrinsicResult;
+    ApprovalFlag: ApprovalFlag;
+    Approvals: Approvals;
+    ArithmeticError: ArithmeticError;
+    AssetApproval: AssetApproval;
+    AssetApprovalKey: AssetApprovalKey;
+    AssetBalance: AssetBalance;
+    AssetDestroyWitness: AssetDestroyWitness;
+    AssetDetails: AssetDetails;
+    AssetId: AssetId;
+    AssetInstance: AssetInstance;
+    AssetInstanceV0: AssetInstanceV0;
+    AssetInstanceV1: AssetInstanceV1;
+    AssetInstanceV2: AssetInstanceV2;
+    AssetMetadata: AssetMetadata;
+    AssetOptions: AssetOptions;
+    AssignmentId: AssignmentId;
+    AssignmentKind: AssignmentKind;
+    AttestedCandidate: AttestedCandidate;
+    AuctionIndex: AuctionIndex;
+    AuthIndex: AuthIndex;
+    AuthorityDiscoveryId: AuthorityDiscoveryId;
+    AuthorityId: AuthorityId;
+    AuthorityIndex: AuthorityIndex;
+    AuthorityList: AuthorityList;
+    AuthoritySet: AuthoritySet;
+    AuthoritySetChange: AuthoritySetChange;
+    AuthoritySetChanges: AuthoritySetChanges;
+    AuthoritySignature: AuthoritySignature;
+    AuthorityWeight: AuthorityWeight;
+    AvailabilityBitfield: AvailabilityBitfield;
+    AvailabilityBitfieldRecord: AvailabilityBitfieldRecord;
+    BabeAuthorityWeight: BabeAuthorityWeight;
+    BabeBlockWeight: BabeBlockWeight;
+    BabeEpochConfiguration: BabeEpochConfiguration;
+    BabeEquivocationProof: BabeEquivocationProof;
+    BabeWeight: BabeWeight;
+    BackedCandidate: BackedCandidate;
+    Balance: Balance;
+    BalanceLock: BalanceLock;
+    BalanceLockTo212: BalanceLockTo212;
+    BalanceOf: BalanceOf;
+    BalanceStatus: BalanceStatus;
+    BeefyCommitment: BeefyCommitment;
+    BeefyId: BeefyId;
+    BeefyKey: BeefyKey;
+    BeefyNextAuthoritySet: BeefyNextAuthoritySet;
+    BeefyPayload: BeefyPayload;
+    BeefySignedCommitment: BeefySignedCommitment;
+    Bid: Bid;
+    Bidder: Bidder;
+    BidKind: BidKind;
+    BitVec: BitVec;
+    Block: Block;
+    BlockAttestations: BlockAttestations;
+    BlockHash: BlockHash;
+    BlockLength: BlockLength;
+    BlockNumber: BlockNumber;
+    BlockNumberFor: BlockNumberFor;
+    BlockNumberOf: BlockNumberOf;
+    BlockTrace: BlockTrace;
+    BlockTraceEvent: BlockTraceEvent;
+    BlockTraceEventData: BlockTraceEventData;
+    BlockTraceSpan: BlockTraceSpan;
+    BlockV0: BlockV0;
+    BlockV1: BlockV1;
+    BlockV2: BlockV2;
+    BlockWeights: BlockWeights;
+    BodyId: BodyId;
+    BodyPart: BodyPart;
+    bool: bool;
+    Bool: Bool;
+    Bounty: Bounty;
+    BountyIndex: BountyIndex;
+    BountyStatus: BountyStatus;
+    BountyStatusActive: BountyStatusActive;
+    BountyStatusCuratorProposed: BountyStatusCuratorProposed;
+    BountyStatusPendingPayout: BountyStatusPendingPayout;
+    BridgedBlockHash: BridgedBlockHash;
+    BridgedBlockNumber: BridgedBlockNumber;
+    BridgedHeader: BridgedHeader;
+    BridgeMessageId: BridgeMessageId;
+    BufferedSessionChange: BufferedSessionChange;
+    Bytes: Bytes;
+    Call: Call;
+    CallHash: CallHash;
+    CallHashOf: CallHashOf;
+    CallIndex: CallIndex;
+    CallOrigin: CallOrigin;
+    CandidateCommitments: CandidateCommitments;
+    CandidateDescriptor: CandidateDescriptor;
+    CandidateHash: CandidateHash;
+    CandidateInfo: CandidateInfo;
+    CandidatePendingAvailability: CandidatePendingAvailability;
+    CandidateReceipt: CandidateReceipt;
+    ChainId: ChainId;
+    ChainProperties: ChainProperties;
+    ChainType: ChainType;
+    ChangesTrieConfiguration: ChangesTrieConfiguration;
+    ChangesTrieSignal: ChangesTrieSignal;
+    ClassDetails: ClassDetails;
+    ClassId: ClassId;
+    ClassMetadata: ClassMetadata;
+    CodecHash: CodecHash;
+    CodeHash: CodeHash;
+    CollatorId: CollatorId;
+    CollatorSignature: CollatorSignature;
+    CollectiveOrigin: CollectiveOrigin;
+    CommittedCandidateReceipt: CommittedCandidateReceipt;
+    CompactAssignments: CompactAssignments;
+    CompactAssignmentsTo257: CompactAssignmentsTo257;
+    CompactAssignmentsTo265: CompactAssignmentsTo265;
+    CompactAssignmentsWith16: CompactAssignmentsWith16;
+    CompactAssignmentsWith24: CompactAssignmentsWith24;
+    CompactScore: CompactScore;
+    CompactScoreCompact: CompactScoreCompact;
+    ConfigData: ConfigData;
+    Consensus: Consensus;
+    ConsensusEngineId: ConsensusEngineId;
+    ConsumedWeight: ConsumedWeight;
+    ContractCallRequest: ContractCallRequest;
+    ContractConstructorSpec: ContractConstructorSpec;
+    ContractContractSpec: ContractContractSpec;
+    ContractCryptoHasher: ContractCryptoHasher;
+    ContractDiscriminant: ContractDiscriminant;
+    ContractDisplayName: ContractDisplayName;
+    ContractEventParamSpec: ContractEventParamSpec;
+    ContractEventSpec: ContractEventSpec;
+    ContractExecResult: ContractExecResult;
+    ContractExecResultErr: ContractExecResultErr;
+    ContractExecResultErrModule: ContractExecResultErrModule;
+    ContractExecResultOk: ContractExecResultOk;
+    ContractExecResultResult: ContractExecResultResult;
+    ContractExecResultSuccessTo255: ContractExecResultSuccessTo255;
+    ContractExecResultSuccessTo260: ContractExecResultSuccessTo260;
+    ContractExecResultTo255: ContractExecResultTo255;
+    ContractExecResultTo260: ContractExecResultTo260;
+    ContractExecResultTo267: ContractExecResultTo267;
+    ContractInfo: ContractInfo;
+    ContractInstantiateResult: ContractInstantiateResult;
+    ContractInstantiateResultTo267: ContractInstantiateResultTo267;
+    ContractLayoutArray: ContractLayoutArray;
+    ContractLayoutCell: ContractLayoutCell;
+    ContractLayoutEnum: ContractLayoutEnum;
+    ContractLayoutHash: ContractLayoutHash;
+    ContractLayoutHashingStrategy: ContractLayoutHashingStrategy;
+    ContractLayoutKey: ContractLayoutKey;
+    ContractLayoutStruct: ContractLayoutStruct;
+    ContractLayoutStructField: ContractLayoutStructField;
+    ContractMessageParamSpec: ContractMessageParamSpec;
+    ContractMessageSpec: ContractMessageSpec;
+    ContractMetadata: ContractMetadata;
+    ContractMetadataLatest: ContractMetadataLatest;
+    ContractMetadataV0: ContractMetadataV0;
+    ContractMetadataV1: ContractMetadataV1;
+    ContractProject: ContractProject;
+    ContractProjectContract: ContractProjectContract;
+    ContractProjectInfo: ContractProjectInfo;
+    ContractProjectSource: ContractProjectSource;
+    ContractProjectV0: ContractProjectV0;
+    ContractSelector: ContractSelector;
+    ContractStorageKey: ContractStorageKey;
+    ContractStorageLayout: ContractStorageLayout;
+    ContractTypeSpec: ContractTypeSpec;
+    Conviction: Conviction;
+    CoreAssignment: CoreAssignment;
+    CoreIndex: CoreIndex;
+    CoreOccupied: CoreOccupied;
+    CrateVersion: CrateVersion;
+    CreatedBlock: CreatedBlock;
+    CumulusPalletDmpQueueConfigData: CumulusPalletDmpQueueConfigData;
+    CumulusPalletDmpQueuePageIndexData: CumulusPalletDmpQueuePageIndexData;
+    CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot: CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot;
+    CumulusPalletXcmpQueueInboundStatus: CumulusPalletXcmpQueueInboundStatus;
+    CumulusPalletXcmpQueueOutboundStatus: CumulusPalletXcmpQueueOutboundStatus;
+    CumulusPalletXcmpQueueQueueConfigData: CumulusPalletXcmpQueueQueueConfigData;
+    CumulusPrimitivesParachainInherentParachainInherentData: CumulusPrimitivesParachainInherentParachainInherentData;
+    Data: Data;
+    DeferredOffenceOf: DeferredOffenceOf;
+    DefunctVoter: DefunctVoter;
+    DelayKind: DelayKind;
+    DelayKindBest: DelayKindBest;
+    Delegations: Delegations;
+    DeletedContract: DeletedContract;
+    DeliveredMessages: DeliveredMessages;
+    DepositBalance: DepositBalance;
+    DepositBalanceOf: DepositBalanceOf;
+    DestroyWitness: DestroyWitness;
+    Digest: Digest;
+    DigestItem: DigestItem;
+    DigestOf: DigestOf;
+    DispatchClass: DispatchClass;
+    DispatchError: DispatchError;
+    DispatchErrorModule: DispatchErrorModule;
+    DispatchErrorTo198: DispatchErrorTo198;
+    DispatchFeePayment: DispatchFeePayment;
+    DispatchInfo: DispatchInfo;
+    DispatchInfoTo190: DispatchInfoTo190;
+    DispatchInfoTo244: DispatchInfoTo244;
+    DispatchOutcome: DispatchOutcome;
+    DispatchResult: DispatchResult;
+    DispatchResultOf: DispatchResultOf;
+    DispatchResultTo198: DispatchResultTo198;
+    DisputeLocation: DisputeLocation;
+    DisputeResult: DisputeResult;
+    DisputeState: DisputeState;
+    DisputeStatement: DisputeStatement;
+    DisputeStatementSet: DisputeStatementSet;
+    DoubleEncodedCall: DoubleEncodedCall;
+    DoubleVoteReport: DoubleVoteReport;
+    DownwardMessage: DownwardMessage;
+    EcdsaSignature: EcdsaSignature;
+    Ed25519Signature: Ed25519Signature;
+    EIP1559Transaction: EIP1559Transaction;
+    EIP2930Transaction: EIP2930Transaction;
+    ElectionCompute: ElectionCompute;
+    ElectionPhase: ElectionPhase;
+    ElectionResult: ElectionResult;
+    ElectionScore: ElectionScore;
+    ElectionSize: ElectionSize;
+    ElectionStatus: ElectionStatus;
+    EncodedFinalityProofs: EncodedFinalityProofs;
+    EncodedJustification: EncodedJustification;
+    EpochAuthorship: EpochAuthorship;
+    Era: Era;
+    EraIndex: EraIndex;
+    EraPoints: EraPoints;
+    EraRewardPoints: EraRewardPoints;
+    EraRewards: EraRewards;
+    ErrorMetadataLatest: ErrorMetadataLatest;
+    ErrorMetadataV10: ErrorMetadataV10;
+    ErrorMetadataV11: ErrorMetadataV11;
+    ErrorMetadataV12: ErrorMetadataV12;
+    ErrorMetadataV13: ErrorMetadataV13;
+    ErrorMetadataV14: ErrorMetadataV14;
+    ErrorMetadataV9: ErrorMetadataV9;
+    EthAccessList: EthAccessList;
+    EthAccessListItem: EthAccessListItem;
+    EthAccount: EthAccount;
+    EthAddress: EthAddress;
+    EthBlock: EthBlock;
+    EthBloom: EthBloom;
+    EthCallRequest: EthCallRequest;
+    EthereumAccountId: EthereumAccountId;
+    EthereumAddress: EthereumAddress;
+    EthereumBlock: EthereumBlock;
+    EthereumLog: EthereumLog;
+    EthereumLookupSource: EthereumLookupSource;
+    EthereumReceipt: EthereumReceipt;
+    EthereumSignature: EthereumSignature;
+    EthereumTransactionLegacyTransaction: EthereumTransactionLegacyTransaction;
+    EthFilter: EthFilter;
+    EthFilterAddress: EthFilterAddress;
+    EthFilterChanges: EthFilterChanges;
+    EthFilterTopic: EthFilterTopic;
+    EthFilterTopicEntry: EthFilterTopicEntry;
+    EthFilterTopicInner: EthFilterTopicInner;
+    EthHeader: EthHeader;
+    EthLog: EthLog;
+    EthReceipt: EthReceipt;
+    EthRichBlock: EthRichBlock;
+    EthRichHeader: EthRichHeader;
+    EthStorageProof: EthStorageProof;
+    EthSubKind: EthSubKind;
+    EthSubParams: EthSubParams;
+    EthSubResult: EthSubResult;
+    EthSyncInfo: EthSyncInfo;
+    EthSyncStatus: EthSyncStatus;
+    EthTransaction: EthTransaction;
+    EthTransactionAction: EthTransactionAction;
+    EthTransactionCondition: EthTransactionCondition;
+    EthTransactionRequest: EthTransactionRequest;
+    EthTransactionSignature: EthTransactionSignature;
+    EthTransactionStatus: EthTransactionStatus;
+    EthWork: EthWork;
+    Event: Event;
+    EventId: EventId;
+    EventIndex: EventIndex;
+    EventMetadataLatest: EventMetadataLatest;
+    EventMetadataV10: EventMetadataV10;
+    EventMetadataV11: EventMetadataV11;
+    EventMetadataV12: EventMetadataV12;
+    EventMetadataV13: EventMetadataV13;
+    EventMetadataV14: EventMetadataV14;
+    EventMetadataV9: EventMetadataV9;
+    EventRecord: EventRecord;
+    EvmAccount: EvmAccount;
+    EvmCoreErrorExitReason: EvmCoreErrorExitReason;
+    EvmLog: EvmLog;
+    EvmVicinity: EvmVicinity;
+    ExecReturnValue: ExecReturnValue;
+    ExitError: ExitError;
+    ExitFatal: ExitFatal;
+    ExitReason: ExitReason;
+    ExitRevert: ExitRevert;
+    ExitSucceed: ExitSucceed;
+    ExplicitDisputeStatement: ExplicitDisputeStatement;
+    Exposure: Exposure;
+    ExtendedBalance: ExtendedBalance;
+    Extrinsic: Extrinsic;
+    ExtrinsicEra: ExtrinsicEra;
+    ExtrinsicMetadataLatest: ExtrinsicMetadataLatest;
+    ExtrinsicMetadataV11: ExtrinsicMetadataV11;
+    ExtrinsicMetadataV12: ExtrinsicMetadataV12;
+    ExtrinsicMetadataV13: ExtrinsicMetadataV13;
+    ExtrinsicMetadataV14: ExtrinsicMetadataV14;
+    ExtrinsicOrHash: ExtrinsicOrHash;
+    ExtrinsicPayload: ExtrinsicPayload;
+    ExtrinsicPayloadUnknown: ExtrinsicPayloadUnknown;
+    ExtrinsicPayloadV4: ExtrinsicPayloadV4;
+    ExtrinsicSignature: ExtrinsicSignature;
+    ExtrinsicSignatureV4: ExtrinsicSignatureV4;
+    ExtrinsicStatus: ExtrinsicStatus;
+    ExtrinsicsWeight: ExtrinsicsWeight;
+    ExtrinsicUnknown: ExtrinsicUnknown;
+    ExtrinsicV4: ExtrinsicV4;
+    FeeDetails: FeeDetails;
+    Fixed128: Fixed128;
+    Fixed64: Fixed64;
+    FixedI128: FixedI128;
+    FixedI64: FixedI64;
+    FixedU128: FixedU128;
+    FixedU64: FixedU64;
+    Forcing: Forcing;
+    ForkTreePendingChange: ForkTreePendingChange;
+    ForkTreePendingChangeNode: ForkTreePendingChangeNode;
+    FpRpcTransactionStatus: FpRpcTransactionStatus;
+    FullIdentification: FullIdentification;
+    FunctionArgumentMetadataLatest: FunctionArgumentMetadataLatest;
+    FunctionArgumentMetadataV10: FunctionArgumentMetadataV10;
+    FunctionArgumentMetadataV11: FunctionArgumentMetadataV11;
+    FunctionArgumentMetadataV12: FunctionArgumentMetadataV12;
+    FunctionArgumentMetadataV13: FunctionArgumentMetadataV13;
+    FunctionArgumentMetadataV14: FunctionArgumentMetadataV14;
+    FunctionArgumentMetadataV9: FunctionArgumentMetadataV9;
+    FunctionMetadataLatest: FunctionMetadataLatest;
+    FunctionMetadataV10: FunctionMetadataV10;
+    FunctionMetadataV11: FunctionMetadataV11;
+    FunctionMetadataV12: FunctionMetadataV12;
+    FunctionMetadataV13: FunctionMetadataV13;
+    FunctionMetadataV14: FunctionMetadataV14;
+    FunctionMetadataV9: FunctionMetadataV9;
+    FundIndex: FundIndex;
+    FundInfo: FundInfo;
+    Fungibility: Fungibility;
+    FungibilityV0: FungibilityV0;
+    FungibilityV1: FungibilityV1;
+    FungibilityV2: FungibilityV2;
+    Gas: Gas;
+    GiltBid: GiltBid;
+    GlobalValidationData: GlobalValidationData;
+    GlobalValidationSchedule: GlobalValidationSchedule;
+    GrandpaCommit: GrandpaCommit;
+    GrandpaEquivocation: GrandpaEquivocation;
+    GrandpaEquivocationProof: GrandpaEquivocationProof;
+    GrandpaEquivocationValue: GrandpaEquivocationValue;
+    GrandpaJustification: GrandpaJustification;
+    GrandpaPrecommit: GrandpaPrecommit;
+    GrandpaPrevote: GrandpaPrevote;
+    GrandpaSignedPrecommit: GrandpaSignedPrecommit;
+    GroupIndex: GroupIndex;
+    H1024: H1024;
+    H128: H128;
+    H160: H160;
+    H2048: H2048;
+    H256: H256;
+    H32: H32;
+    H512: H512;
+    H64: H64;
+    Hash: Hash;
+    HeadData: HeadData;
+    Header: Header;
+    HeaderPartial: HeaderPartial;
+    Health: Health;
+    Heartbeat: Heartbeat;
+    HeartbeatTo244: HeartbeatTo244;
+    HostConfiguration: HostConfiguration;
+    HostFnWeights: HostFnWeights;
+    HostFnWeightsTo264: HostFnWeightsTo264;
+    HrmpChannel: HrmpChannel;
+    HrmpChannelId: HrmpChannelId;
+    HrmpOpenChannelRequest: HrmpOpenChannelRequest;
+    i128: i128;
+    I128: I128;
+    i16: i16;
+    I16: I16;
+    i256: i256;
+    I256: I256;
+    i32: i32;
+    I32: I32;
+    I32F32: I32F32;
+    i64: i64;
+    I64: I64;
+    i8: i8;
+    I8: I8;
+    IdentificationTuple: IdentificationTuple;
+    IdentityFields: IdentityFields;
+    IdentityInfo: IdentityInfo;
+    IdentityInfoAdditional: IdentityInfoAdditional;
+    IdentityInfoTo198: IdentityInfoTo198;
+    IdentityJudgement: IdentityJudgement;
+    ImmortalEra: ImmortalEra;
+    ImportedAux: ImportedAux;
+    InboundDownwardMessage: InboundDownwardMessage;
+    InboundHrmpMessage: InboundHrmpMessage;
+    InboundHrmpMessages: InboundHrmpMessages;
+    InboundLaneData: InboundLaneData;
+    InboundRelayer: InboundRelayer;
+    InboundStatus: InboundStatus;
+    IncludedBlocks: IncludedBlocks;
+    InclusionFee: InclusionFee;
+    IncomingParachain: IncomingParachain;
+    IncomingParachainDeploy: IncomingParachainDeploy;
+    IncomingParachainFixed: IncomingParachainFixed;
+    Index: Index;
+    IndicesLookupSource: IndicesLookupSource;
+    IndividualExposure: IndividualExposure;
+    InitializationData: InitializationData;
+    InstanceDetails: InstanceDetails;
+    InstanceId: InstanceId;
+    InstanceMetadata: InstanceMetadata;
+    InstantiateRequest: InstantiateRequest;
+    InstantiateReturnValue: InstantiateReturnValue;
+    InstantiateReturnValueTo267: InstantiateReturnValueTo267;
+    InstructionV2: InstructionV2;
+    InstructionWeights: InstructionWeights;
+    InteriorMultiLocation: InteriorMultiLocation;
+    InvalidDisputeStatementKind: InvalidDisputeStatementKind;
+    InvalidTransaction: InvalidTransaction;
+    Json: Json;
+    Junction: Junction;
+    Junctions: Junctions;
+    JunctionsV1: JunctionsV1;
+    JunctionsV2: JunctionsV2;
+    JunctionV0: JunctionV0;
+    JunctionV1: JunctionV1;
+    JunctionV2: JunctionV2;
+    Justification: Justification;
+    JustificationNotification: JustificationNotification;
+    Justifications: Justifications;
+    Key: Key;
+    KeyOwnerProof: KeyOwnerProof;
+    Keys: Keys;
+    KeyType: KeyType;
+    KeyTypeId: KeyTypeId;
+    KeyValue: KeyValue;
+    KeyValueOption: KeyValueOption;
+    Kind: Kind;
+    LaneId: LaneId;
+    LastContribution: LastContribution;
+    LastRuntimeUpgradeInfo: LastRuntimeUpgradeInfo;
+    LeasePeriod: LeasePeriod;
+    LeasePeriodOf: LeasePeriodOf;
+    LegacyTransaction: LegacyTransaction;
+    Limits: Limits;
+    LimitsTo264: LimitsTo264;
+    LocalValidationData: LocalValidationData;
+    LockIdentifier: LockIdentifier;
+    LookupSource: LookupSource;
+    LookupTarget: LookupTarget;
+    LotteryConfig: LotteryConfig;
+    MaybeRandomness: MaybeRandomness;
+    MaybeVrf: MaybeVrf;
+    MemberCount: MemberCount;
+    MembershipProof: MembershipProof;
+    MessageData: MessageData;
+    MessageId: MessageId;
+    MessageIngestionType: MessageIngestionType;
+    MessageKey: MessageKey;
+    MessageNonce: MessageNonce;
+    MessageQueueChain: MessageQueueChain;
+    MessagesDeliveryProofOf: MessagesDeliveryProofOf;
+    MessagesProofOf: MessagesProofOf;
+    MessagingStateSnapshot: MessagingStateSnapshot;
+    MessagingStateSnapshotEgressEntry: MessagingStateSnapshotEgressEntry;
+    MetadataAll: MetadataAll;
+    MetadataLatest: MetadataLatest;
+    MetadataV10: MetadataV10;
+    MetadataV11: MetadataV11;
+    MetadataV12: MetadataV12;
+    MetadataV13: MetadataV13;
+    MetadataV14: MetadataV14;
+    MetadataV9: MetadataV9;
+    MmrLeafProof: MmrLeafProof;
+    MmrRootHash: MmrRootHash;
+    ModuleConstantMetadataV10: ModuleConstantMetadataV10;
+    ModuleConstantMetadataV11: ModuleConstantMetadataV11;
+    ModuleConstantMetadataV12: ModuleConstantMetadataV12;
+    ModuleConstantMetadataV13: ModuleConstantMetadataV13;
+    ModuleConstantMetadataV9: ModuleConstantMetadataV9;
+    ModuleId: ModuleId;
+    ModuleMetadataV10: ModuleMetadataV10;
+    ModuleMetadataV11: ModuleMetadataV11;
+    ModuleMetadataV12: ModuleMetadataV12;
+    ModuleMetadataV13: ModuleMetadataV13;
+    ModuleMetadataV9: ModuleMetadataV9;
+    Moment: Moment;
+    MomentOf: MomentOf;
+    MoreAttestations: MoreAttestations;
+    MortalEra: MortalEra;
+    MultiAddress: MultiAddress;
+    MultiAsset: MultiAsset;
+    MultiAssetFilter: MultiAssetFilter;
+    MultiAssetFilterV1: MultiAssetFilterV1;
+    MultiAssetFilterV2: MultiAssetFilterV2;
+    MultiAssets: MultiAssets;
+    MultiAssetsV1: MultiAssetsV1;
+    MultiAssetsV2: MultiAssetsV2;
+    MultiAssetV0: MultiAssetV0;
+    MultiAssetV1: MultiAssetV1;
+    MultiAssetV2: MultiAssetV2;
+    MultiDisputeStatementSet: MultiDisputeStatementSet;
+    MultiLocation: MultiLocation;
+    MultiLocationV0: MultiLocationV0;
+    MultiLocationV1: MultiLocationV1;
+    MultiLocationV2: MultiLocationV2;
+    Multiplier: Multiplier;
+    Multisig: Multisig;
+    MultiSignature: MultiSignature;
+    MultiSigner: MultiSigner;
+    NetworkId: NetworkId;
+    NetworkState: NetworkState;
+    NetworkStatePeerset: NetworkStatePeerset;
+    NetworkStatePeersetInfo: NetworkStatePeersetInfo;
+    NewBidder: NewBidder;
+    NextAuthority: NextAuthority;
+    NextConfigDescriptor: NextConfigDescriptor;
+    NextConfigDescriptorV1: NextConfigDescriptorV1;
+    NftDataStructsAccessMode: NftDataStructsAccessMode;
+    NftDataStructsCollection: NftDataStructsCollection;
+    NftDataStructsCollectionId: NftDataStructsCollectionId;
+    NftDataStructsCollectionLimits: NftDataStructsCollectionLimits;
+    NftDataStructsCollectionMode: NftDataStructsCollectionMode;
+    NftDataStructsCreateItemData: NftDataStructsCreateItemData;
+    NftDataStructsMetaUpdatePermission: NftDataStructsMetaUpdatePermission;
+    NftDataStructsSchemaVersion: NftDataStructsSchemaVersion;
+    NftDataStructsSponsorshipState: NftDataStructsSponsorshipState;
+    NftDataStructsTokenId: NftDataStructsTokenId;
+    NodeRole: NodeRole;
+    Nominations: Nominations;
+    NominatorIndex: NominatorIndex;
+    NominatorIndexCompact: NominatorIndexCompact;
+    NotConnectedPeer: NotConnectedPeer;
+    Null: Null;
+    OffchainAccuracy: OffchainAccuracy;
+    OffchainAccuracyCompact: OffchainAccuracyCompact;
+    OffenceDetails: OffenceDetails;
+    Offender: Offender;
+    OpaqueCall: OpaqueCall;
+    OpaqueMultiaddr: OpaqueMultiaddr;
+    OpaqueNetworkState: OpaqueNetworkState;
+    OpaquePeerId: OpaquePeerId;
+    OpaqueTimeSlot: OpaqueTimeSlot;
+    OpenTip: OpenTip;
+    OpenTipFinderTo225: OpenTipFinderTo225;
+    OpenTipTip: OpenTipTip;
+    OpenTipTo225: OpenTipTo225;
+    OperatingMode: OperatingMode;
+    Origin: Origin;
+    OriginCaller: OriginCaller;
+    OriginKindV0: OriginKindV0;
+    OriginKindV1: OriginKindV1;
+    OriginKindV2: OriginKindV2;
+    OutboundHrmpMessage: OutboundHrmpMessage;
+    OutboundLaneData: OutboundLaneData;
+    OutboundMessageFee: OutboundMessageFee;
+    OutboundPayload: OutboundPayload;
+    OutboundStatus: OutboundStatus;
+    Outcome: Outcome;
+    OverweightIndex: OverweightIndex;
+    Owner: Owner;
+    PageCounter: PageCounter;
+    PageIndexData: PageIndexData;
+    PalletCallMetadataLatest: PalletCallMetadataLatest;
+    PalletCallMetadataV14: PalletCallMetadataV14;
+    PalletCommonAccountBasicCrossAccountIdRepr: PalletCommonAccountBasicCrossAccountIdRepr;
+    PalletConstantMetadataLatest: PalletConstantMetadataLatest;
+    PalletConstantMetadataV14: PalletConstantMetadataV14;
+    PalletErrorMetadataLatest: PalletErrorMetadataLatest;
+    PalletErrorMetadataV14: PalletErrorMetadataV14;
+    PalletEventMetadataLatest: PalletEventMetadataLatest;
+    PalletEventMetadataV14: PalletEventMetadataV14;
+    PalletId: PalletId;
+    PalletMetadataLatest: PalletMetadataLatest;
+    PalletMetadataV14: PalletMetadataV14;
+    PalletNonfungibleItemData: PalletNonfungibleItemData;
+    PalletRefungibleItemData: PalletRefungibleItemData;
+    PalletsOrigin: PalletsOrigin;
+    PalletStorageMetadataLatest: PalletStorageMetadataLatest;
+    PalletStorageMetadataV14: PalletStorageMetadataV14;
+    PalletUnqSchedulerCallSpec: PalletUnqSchedulerCallSpec;
+    PalletUnqSchedulerReleases: PalletUnqSchedulerReleases;
+    PalletUnqSchedulerScheduledV2: PalletUnqSchedulerScheduledV2;
+    PalletVersion: PalletVersion;
+    ParachainDispatchOrigin: ParachainDispatchOrigin;
+    ParachainInherentData: ParachainInherentData;
+    ParachainProposal: ParachainProposal;
+    ParachainsInherentData: ParachainsInherentData;
+    ParaGenesisArgs: ParaGenesisArgs;
+    ParaId: ParaId;
+    ParaInfo: ParaInfo;
+    ParaLifecycle: ParaLifecycle;
+    Parameter: Parameter;
+    ParaPastCodeMeta: ParaPastCodeMeta;
+    ParaScheduling: ParaScheduling;
+    ParathreadClaim: ParathreadClaim;
+    ParathreadClaimQueue: ParathreadClaimQueue;
+    ParathreadEntry: ParathreadEntry;
+    ParaValidatorIndex: ParaValidatorIndex;
+    Pays: Pays;
+    Peer: Peer;
+    PeerEndpoint: PeerEndpoint;
+    PeerEndpointAddr: PeerEndpointAddr;
+    PeerInfo: PeerInfo;
+    PeerPing: PeerPing;
+    PendingChange: PendingChange;
+    PendingPause: PendingPause;
+    PendingResume: PendingResume;
+    Perbill: Perbill;
+    Percent: Percent;
+    PerDispatchClassU32: PerDispatchClassU32;
+    PerDispatchClassWeight: PerDispatchClassWeight;
+    PerDispatchClassWeightsPerClass: PerDispatchClassWeightsPerClass;
+    Period: Period;
+    Permill: Permill;
+    PermissionLatest: PermissionLatest;
+    PermissionsV1: PermissionsV1;
+    PermissionVersions: PermissionVersions;
+    Perquintill: Perquintill;
+    PersistedValidationData: PersistedValidationData;
+    PerU16: PerU16;
+    Phantom: Phantom;
+    PhantomData: PhantomData;
+    Phase: Phase;
+    PhragmenScore: PhragmenScore;
+    Points: Points;
+    PolkadotParachainPrimitivesXcmpMessageFormat: PolkadotParachainPrimitivesXcmpMessageFormat;
+    PolkadotPrimitivesV1AbridgedHostConfiguration: PolkadotPrimitivesV1AbridgedHostConfiguration;
+    PolkadotPrimitivesV1PersistedValidationData: PolkadotPrimitivesV1PersistedValidationData;
+    PortableRegistry: PortableRegistry;
+    PortableRegistryV14: PortableRegistryV14;
+    PortableType: PortableType;
+    PortableTypeV14: PortableTypeV14;
+    Precommits: Precommits;
+    PrefabWasmModule: PrefabWasmModule;
+    PrefixedStorageKey: PrefixedStorageKey;
+    PreimageStatus: PreimageStatus;
+    PreimageStatusAvailable: PreimageStatusAvailable;
+    PreRuntime: PreRuntime;
+    Prevotes: Prevotes;
+    Priority: Priority;
+    PriorLock: PriorLock;
+    PropIndex: PropIndex;
+    Proposal: Proposal;
+    ProposalIndex: ProposalIndex;
+    ProxyAnnouncement: ProxyAnnouncement;
+    ProxyDefinition: ProxyDefinition;
+    ProxyState: ProxyState;
+    ProxyType: ProxyType;
+    QueryId: QueryId;
+    QueryStatus: QueryStatus;
+    QueueConfigData: QueueConfigData;
+    QueuedParathread: QueuedParathread;
+    Randomness: Randomness;
+    Raw: Raw;
+    RawAuraPreDigest: RawAuraPreDigest;
+    RawBabePreDigest: RawBabePreDigest;
+    RawBabePreDigestCompat: RawBabePreDigestCompat;
+    RawBabePreDigestPrimary: RawBabePreDigestPrimary;
+    RawBabePreDigestPrimaryTo159: RawBabePreDigestPrimaryTo159;
+    RawBabePreDigestSecondaryPlain: RawBabePreDigestSecondaryPlain;
+    RawBabePreDigestSecondaryTo159: RawBabePreDigestSecondaryTo159;
+    RawBabePreDigestSecondaryVRF: RawBabePreDigestSecondaryVRF;
+    RawBabePreDigestTo159: RawBabePreDigestTo159;
+    RawOrigin: RawOrigin;
+    RawSolution: RawSolution;
+    RawSolutionTo265: RawSolutionTo265;
+    RawSolutionWith16: RawSolutionWith16;
+    RawSolutionWith24: RawSolutionWith24;
+    RawVRFOutput: RawVRFOutput;
+    ReadProof: ReadProof;
+    ReadySolution: ReadySolution;
+    Reasons: Reasons;
+    RecoveryConfig: RecoveryConfig;
+    RefCount: RefCount;
+    RefCountTo259: RefCountTo259;
+    ReferendumIndex: ReferendumIndex;
+    ReferendumInfo: ReferendumInfo;
+    ReferendumInfoFinished: ReferendumInfoFinished;
+    ReferendumInfoTo239: ReferendumInfoTo239;
+    ReferendumStatus: ReferendumStatus;
+    RegisteredParachainInfo: RegisteredParachainInfo;
+    RegistrarIndex: RegistrarIndex;
+    RegistrarInfo: RegistrarInfo;
+    Registration: Registration;
+    RegistrationJudgement: RegistrationJudgement;
+    RegistrationTo198: RegistrationTo198;
+    RelayBlockNumber: RelayBlockNumber;
+    RelayChainBlockNumber: RelayChainBlockNumber;
+    RelayChainHash: RelayChainHash;
+    RelayerId: RelayerId;
+    RelayHash: RelayHash;
+    Releases: Releases;
+    Remark: Remark;
+    Renouncing: Renouncing;
+    RentProjection: RentProjection;
+    ReplacementTimes: ReplacementTimes;
+    ReportedRoundStates: ReportedRoundStates;
+    Reporter: Reporter;
+    ReportIdOf: ReportIdOf;
+    ReserveData: ReserveData;
+    ReserveIdentifier: ReserveIdentifier;
+    Response: Response;
+    ResponseV0: ResponseV0;
+    ResponseV1: ResponseV1;
+    ResponseV2: ResponseV2;
+    ResponseV2Error: ResponseV2Error;
+    ResponseV2Result: ResponseV2Result;
+    Retriable: Retriable;
+    RewardDestination: RewardDestination;
+    RewardPoint: RewardPoint;
+    RoundSnapshot: RoundSnapshot;
+    RoundState: RoundState;
+    RpcMethods: RpcMethods;
+    RuntimeDbWeight: RuntimeDbWeight;
+    RuntimeDispatchInfo: RuntimeDispatchInfo;
+    RuntimeVersion: RuntimeVersion;
+    RuntimeVersionApi: RuntimeVersionApi;
+    RuntimeVersionPartial: RuntimeVersionPartial;
+    Schedule: Schedule;
+    Scheduled: Scheduled;
+    ScheduledTo254: ScheduledTo254;
+    SchedulePeriod: SchedulePeriod;
+    SchedulePriority: SchedulePriority;
+    ScheduleTo212: ScheduleTo212;
+    ScheduleTo258: ScheduleTo258;
+    ScheduleTo264: ScheduleTo264;
+    Scheduling: Scheduling;
+    Seal: Seal;
+    SealV0: SealV0;
+    SeatHolder: SeatHolder;
+    SeedOf: SeedOf;
+    ServiceQuality: ServiceQuality;
+    SessionIndex: SessionIndex;
+    SessionInfo: SessionInfo;
+    SessionInfoValidatorGroup: SessionInfoValidatorGroup;
+    SessionKeys1: SessionKeys1;
+    SessionKeys10: SessionKeys10;
+    SessionKeys10B: SessionKeys10B;
+    SessionKeys2: SessionKeys2;
+    SessionKeys3: SessionKeys3;
+    SessionKeys4: SessionKeys4;
+    SessionKeys5: SessionKeys5;
+    SessionKeys6: SessionKeys6;
+    SessionKeys6B: SessionKeys6B;
+    SessionKeys7: SessionKeys7;
+    SessionKeys7B: SessionKeys7B;
+    SessionKeys8: SessionKeys8;
+    SessionKeys8B: SessionKeys8B;
+    SessionKeys9: SessionKeys9;
+    SessionKeys9B: SessionKeys9B;
+    SetId: SetId;
+    SetIndex: SetIndex;
+    Si0Field: Si0Field;
+    Si0LookupTypeId: Si0LookupTypeId;
+    Si0Path: Si0Path;
+    Si0Type: Si0Type;
+    Si0TypeDef: Si0TypeDef;
+    Si0TypeDefArray: Si0TypeDefArray;
+    Si0TypeDefBitSequence: Si0TypeDefBitSequence;
+    Si0TypeDefCompact: Si0TypeDefCompact;
+    Si0TypeDefComposite: Si0TypeDefComposite;
+    Si0TypeDefPhantom: Si0TypeDefPhantom;
+    Si0TypeDefPrimitive: Si0TypeDefPrimitive;
+    Si0TypeDefSequence: Si0TypeDefSequence;
+    Si0TypeDefTuple: Si0TypeDefTuple;
+    Si0TypeDefVariant: Si0TypeDefVariant;
+    Si0TypeParameter: Si0TypeParameter;
+    Si0Variant: Si0Variant;
+    Si1Field: Si1Field;
+    Si1LookupTypeId: Si1LookupTypeId;
+    Si1Path: Si1Path;
+    Si1Type: Si1Type;
+    Si1TypeDef: Si1TypeDef;
+    Si1TypeDefArray: Si1TypeDefArray;
+    Si1TypeDefBitSequence: Si1TypeDefBitSequence;
+    Si1TypeDefCompact: Si1TypeDefCompact;
+    Si1TypeDefComposite: Si1TypeDefComposite;
+    Si1TypeDefPrimitive: Si1TypeDefPrimitive;
+    Si1TypeDefSequence: Si1TypeDefSequence;
+    Si1TypeDefTuple: Si1TypeDefTuple;
+    Si1TypeDefVariant: Si1TypeDefVariant;
+    Si1TypeParameter: Si1TypeParameter;
+    Si1Variant: Si1Variant;
+    SiField: SiField;
+    Signature: Signature;
+    SignedAvailabilityBitfield: SignedAvailabilityBitfield;
+    SignedAvailabilityBitfields: SignedAvailabilityBitfields;
+    SignedBlock: SignedBlock;
+    SignedBlockWithJustification: SignedBlockWithJustification;
+    SignedBlockWithJustifications: SignedBlockWithJustifications;
+    SignedExtensionMetadataLatest: SignedExtensionMetadataLatest;
+    SignedExtensionMetadataV14: SignedExtensionMetadataV14;
+    SignedSubmission: SignedSubmission;
+    SignedSubmissionOf: SignedSubmissionOf;
+    SignedSubmissionTo276: SignedSubmissionTo276;
+    SignerPayload: SignerPayload;
+    SigningContext: SigningContext;
+    SiLookupTypeId: SiLookupTypeId;
+    SiPath: SiPath;
+    SiType: SiType;
+    SiTypeDef: SiTypeDef;
+    SiTypeDefArray: SiTypeDefArray;
+    SiTypeDefBitSequence: SiTypeDefBitSequence;
+    SiTypeDefCompact: SiTypeDefCompact;
+    SiTypeDefComposite: SiTypeDefComposite;
+    SiTypeDefPrimitive: SiTypeDefPrimitive;
+    SiTypeDefSequence: SiTypeDefSequence;
+    SiTypeDefTuple: SiTypeDefTuple;
+    SiTypeDefVariant: SiTypeDefVariant;
+    SiTypeParameter: SiTypeParameter;
+    SiVariant: SiVariant;
+    SlashingSpans: SlashingSpans;
+    SlashingSpansTo204: SlashingSpansTo204;
+    SlashJournalEntry: SlashJournalEntry;
+    Slot: Slot;
+    SlotNumber: SlotNumber;
+    SlotRange: SlotRange;
+    SocietyJudgement: SocietyJudgement;
+    SocietyVote: SocietyVote;
+    SolutionOrSnapshotSize: SolutionOrSnapshotSize;
+    SolutionSupport: SolutionSupport;
+    SolutionSupports: SolutionSupports;
+    SpanIndex: SpanIndex;
+    SpanRecord: SpanRecord;
+    SpecVersion: SpecVersion;
+    Sr25519Signature: Sr25519Signature;
+    StakingLedger: StakingLedger;
+    StakingLedgerTo223: StakingLedgerTo223;
+    StakingLedgerTo240: StakingLedgerTo240;
+    Statement: Statement;
+    StatementKind: StatementKind;
+    StorageChangeSet: StorageChangeSet;
+    StorageData: StorageData;
+    StorageEntryMetadataLatest: StorageEntryMetadataLatest;
+    StorageEntryMetadataV10: StorageEntryMetadataV10;
+    StorageEntryMetadataV11: StorageEntryMetadataV11;
+    StorageEntryMetadataV12: StorageEntryMetadataV12;
+    StorageEntryMetadataV13: StorageEntryMetadataV13;
+    StorageEntryMetadataV14: StorageEntryMetadataV14;
+    StorageEntryMetadataV9: StorageEntryMetadataV9;
+    StorageEntryModifierLatest: StorageEntryModifierLatest;
+    StorageEntryModifierV10: StorageEntryModifierV10;
+    StorageEntryModifierV11: StorageEntryModifierV11;
+    StorageEntryModifierV12: StorageEntryModifierV12;
+    StorageEntryModifierV13: StorageEntryModifierV13;
+    StorageEntryModifierV14: StorageEntryModifierV14;
+    StorageEntryModifierV9: StorageEntryModifierV9;
+    StorageEntryTypeLatest: StorageEntryTypeLatest;
+    StorageEntryTypeV10: StorageEntryTypeV10;
+    StorageEntryTypeV11: StorageEntryTypeV11;
+    StorageEntryTypeV12: StorageEntryTypeV12;
+    StorageEntryTypeV13: StorageEntryTypeV13;
+    StorageEntryTypeV14: StorageEntryTypeV14;
+    StorageEntryTypeV9: StorageEntryTypeV9;
+    StorageHasher: StorageHasher;
+    StorageHasherV10: StorageHasherV10;
+    StorageHasherV11: StorageHasherV11;
+    StorageHasherV12: StorageHasherV12;
+    StorageHasherV13: StorageHasherV13;
+    StorageHasherV14: StorageHasherV14;
+    StorageHasherV9: StorageHasherV9;
+    StorageKey: StorageKey;
+    StorageKind: StorageKind;
+    StorageMetadataV10: StorageMetadataV10;
+    StorageMetadataV11: StorageMetadataV11;
+    StorageMetadataV12: StorageMetadataV12;
+    StorageMetadataV13: StorageMetadataV13;
+    StorageMetadataV9: StorageMetadataV9;
+    StorageProof: StorageProof;
+    StoredPendingChange: StoredPendingChange;
+    StoredState: StoredState;
+    StrikeCount: StrikeCount;
+    SubId: SubId;
+    SubmissionIndicesOf: SubmissionIndicesOf;
+    Supports: Supports;
+    SyncState: SyncState;
+    SystemInherentData: SystemInherentData;
+    SystemOrigin: SystemOrigin;
+    Tally: Tally;
+    TaskAddress: TaskAddress;
+    TAssetBalance: TAssetBalance;
+    TAssetDepositBalance: TAssetDepositBalance;
+    Text: Text;
+    Timepoint: Timepoint;
+    TokenError: TokenError;
+    TombstoneContractInfo: TombstoneContractInfo;
+    TraceBlockResponse: TraceBlockResponse;
+    TraceError: TraceError;
+    TransactionInfo: TransactionInfo;
+    TransactionPriority: TransactionPriority;
+    TransactionStorageProof: TransactionStorageProof;
+    TransactionV0: TransactionV0;
+    TransactionV1: TransactionV1;
+    TransactionV2: TransactionV2;
+    TransactionValidityError: TransactionValidityError;
+    TransientValidationData: TransientValidationData;
+    TreasuryProposal: TreasuryProposal;
+    TrieId: TrieId;
+    TrieIndex: TrieIndex;
+    Type: Type;
+    u128: u128;
+    U128: U128;
+    u16: u16;
+    U16: U16;
+    u256: u256;
+    U256: U256;
+    u32: u32;
+    U32: U32;
+    U32F32: U32F32;
+    u64: u64;
+    U64: U64;
+    u8: u8;
+    U8: U8;
+    UnappliedSlash: UnappliedSlash;
+    UnappliedSlashOther: UnappliedSlashOther;
+    UncleEntryItem: UncleEntryItem;
+    UnknownTransaction: UnknownTransaction;
+    UnlockChunk: UnlockChunk;
+    UnrewardedRelayer: UnrewardedRelayer;
+    UnrewardedRelayersState: UnrewardedRelayersState;
+    UpgradeGoAhead: UpgradeGoAhead;
+    UpgradeRestriction: UpgradeRestriction;
+    UpwardMessage: UpwardMessage;
+    usize: usize;
+    USize: USize;
+    ValidationCode: ValidationCode;
+    ValidationCodeHash: ValidationCodeHash;
+    ValidationData: ValidationData;
+    ValidationDataType: ValidationDataType;
+    ValidationFunctionParams: ValidationFunctionParams;
+    ValidatorCount: ValidatorCount;
+    ValidatorId: ValidatorId;
+    ValidatorIdOf: ValidatorIdOf;
+    ValidatorIndex: ValidatorIndex;
+    ValidatorIndexCompact: ValidatorIndexCompact;
+    ValidatorPrefs: ValidatorPrefs;
+    ValidatorPrefsTo145: ValidatorPrefsTo145;
+    ValidatorPrefsTo196: ValidatorPrefsTo196;
+    ValidatorPrefsWithBlocked: ValidatorPrefsWithBlocked;
+    ValidatorPrefsWithCommission: ValidatorPrefsWithCommission;
+    ValidatorSetId: ValidatorSetId;
+    ValidatorSignature: ValidatorSignature;
+    ValidDisputeStatementKind: ValidDisputeStatementKind;
+    ValidityAttestation: ValidityAttestation;
+    VecInboundHrmpMessage: VecInboundHrmpMessage;
+    VersionedMultiAsset: VersionedMultiAsset;
+    VersionedMultiAssets: VersionedMultiAssets;
+    VersionedMultiLocation: VersionedMultiLocation;
+    VersionedResponse: VersionedResponse;
+    VersionedXcm: VersionedXcm;
+    VersionMigrationStage: VersionMigrationStage;
+    VestingInfo: VestingInfo;
+    VestingSchedule: VestingSchedule;
+    Vote: Vote;
+    VoteIndex: VoteIndex;
+    Voter: Voter;
+    VoterInfo: VoterInfo;
+    Votes: Votes;
+    VotesTo230: VotesTo230;
+    VoteThreshold: VoteThreshold;
+    VoteWeight: VoteWeight;
+    Voting: Voting;
+    VotingDelegating: VotingDelegating;
+    VotingDirect: VotingDirect;
+    VotingDirectVote: VotingDirectVote;
+    VouchingStatus: VouchingStatus;
+    VrfData: VrfData;
+    VrfOutput: VrfOutput;
+    VrfProof: VrfProof;
+    Weight: Weight;
+    WeightLimitV2: WeightLimitV2;
+    WeightMultiplier: WeightMultiplier;
+    WeightPerClass: WeightPerClass;
+    WeightToFeeCoefficient: WeightToFeeCoefficient;
+    WildFungibility: WildFungibility;
+    WildFungibilityV0: WildFungibilityV0;
+    WildFungibilityV1: WildFungibilityV1;
+    WildFungibilityV2: WildFungibilityV2;
+    WildMultiAsset: WildMultiAsset;
+    WildMultiAssetV1: WildMultiAssetV1;
+    WildMultiAssetV2: WildMultiAssetV2;
+    WinnersData: WinnersData;
+    WinnersDataTuple: WinnersDataTuple;
+    WinningData: WinningData;
+    WinningDataEntry: WinningDataEntry;
+    WithdrawReasons: WithdrawReasons;
+    Xcm: Xcm;
+    XcmAssetId: XcmAssetId;
+    XcmError: XcmError;
+    XcmErrorV0: XcmErrorV0;
+    XcmErrorV1: XcmErrorV1;
+    XcmErrorV2: XcmErrorV2;
+    XcmOrder: XcmOrder;
+    XcmOrderV0: XcmOrderV0;
+    XcmOrderV1: XcmOrderV1;
+    XcmOrderV2: XcmOrderV2;
+    XcmOrigin: XcmOrigin;
+    XcmOriginKind: XcmOriginKind;
+    XcmpMessageFormat: XcmpMessageFormat;
+    XcmV0: XcmV0;
+    XcmV1: XcmV1;
+    XcmV2: XcmV2;
+    XcmVersion: XcmVersion;
+  }
+}

--- /dev/null
+++ b/tests/src/interfaces/definitions.ts
@@ -0,0 +1,3 @@
+export {default as nft} from './nft/definitions';
+export {default as ethereum} from './ethereum/definitions';
+export {default as polkadot} from './polkadot/definitions';

--- /dev/null
+++ b/tests/src/interfaces/ethereum/definitions.ts
@@ -0,0 +1,16 @@
+function mkDummy(name: string) {
+  return {
+    ['dummy' + name]: 'u32',
+  };
+}
+
+export default {
+  types: {
+    EvmCoreErrorExitReason: mkDummy('ExitReason'),
+    EthereumLog: mkDummy('Log'),
+    EthereumTransactionLegacyTransaction: mkDummy('LegacyTx'),
+    EthereumBlock: mkDummy('EthBlock'),
+    EthereumReceipt: mkDummy('EthReceipt'),
+    FpRpcTransactionStatus: mkDummy('EthTxStatus'),
+  },
+};

--- /dev/null
+++ b/tests/src/interfaces/ethereum/index.ts
@@ -0,0 +1,4 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+export * from './types';

--- /dev/null
+++ b/tests/src/interfaces/ethereum/types.ts
@@ -0,0 +1,36 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { Struct, u32 } from '@polkadot/types';
+
+/** @name EthereumBlock */
+export interface EthereumBlock extends Struct {
+  readonly dummyEthBlock: u32;
+}
+
+/** @name EthereumLog */
+export interface EthereumLog extends Struct {
+  readonly dummyLog: u32;
+}
+
+/** @name EthereumReceipt */
+export interface EthereumReceipt extends Struct {
+  readonly dummyEthReceipt: u32;
+}
+
+/** @name EthereumTransactionLegacyTransaction */
+export interface EthereumTransactionLegacyTransaction extends Struct {
+  readonly dummyLegacyTx: u32;
+}
+
+/** @name EvmCoreErrorExitReason */
+export interface EvmCoreErrorExitReason extends Struct {
+  readonly dummyExitReason: u32;
+}
+
+/** @name FpRpcTransactionStatus */
+export interface FpRpcTransactionStatus extends Struct {
+  readonly dummyEthTxStatus: u32;
+}
+
+export type PHANTOM_ETHEREUM = 'ethereum';

--- /dev/null
+++ b/tests/src/interfaces/index.ts
@@ -0,0 +1,4 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+export * from './types';

--- /dev/null
+++ b/tests/src/interfaces/nft/definitions.ts
@@ -0,0 +1,102 @@
+function mkDummy(name: string) {
+  return {
+    ['dummy' + name]: 'u32',
+  };
+}
+
+type RpcParam = {
+  name: string;
+  type: string;
+  isOptional?: true;
+};
+
+const CROSS_ACCOUNT_ID_TYPE = 'PalletCommonAccountBasicCrossAccountIdRepr';
+const TOKEN_ID_TYPE = 'NftDataStructsTokenId';
+
+const collectionParam = {name: 'collection', type: 'NftDataStructsCollectionId'};
+const tokenParam = {name: 'tokenId', type: TOKEN_ID_TYPE};
+const crossAccountParam = (name = 'account') => ({name, type: CROSS_ACCOUNT_ID_TYPE});
+const atParam = {name: 'at', type: 'Hash', isOptional: true};
+
+const fun = (description: string, params: RpcParam[], type: string) => ({
+  description,
+  params: [...params, atParam],
+  type,
+});
+
+export default {
+  rpc: {
+    adminlist: fun('Get admin list', [collectionParam], 'Vec<PalletCommonAccountBasicCrossAccountIdRepr>'),
+    allowlist: fun('Get allowlist', [collectionParam], 'Vec<PalletCommonAccountBasicCrossAccountIdRepr>'),
+
+    accountTokens: fun('Get tokens owned by account', [collectionParam, crossAccountParam()], 'Vec<NftDataStructsTokenId>'),
+    collectionTokens: fun('Get tokens contained in collection', [collectionParam], 'Vec<NftDataStructsTokenId>'),
+
+    lastTokenId: fun('Get last token id', [collectionParam], TOKEN_ID_TYPE),
+    accountBalance: fun('Get amount of different user tokens', [collectionParam, crossAccountParam()], 'u32'),
+    balance: fun('Get amount of specific account token', [collectionParam, crossAccountParam(), tokenParam], 'u128'),
+    allowance: fun('Get allowed amount', [collectionParam, crossAccountParam('sender'), crossAccountParam('spender'), tokenParam], 'u128'),
+    tokenOwner: fun('Get token owner', [collectionParam, tokenParam], CROSS_ACCOUNT_ID_TYPE),
+    constMetadata: fun('Get token constant metadata', [collectionParam, tokenParam], 'Vec<u8>'),
+    variableMetadata: fun('Get token variable metadata', [collectionParam, tokenParam], 'Vec<u8>'),
+    tokenExists: fun('Check if token exists', [collectionParam, tokenParam], 'bool'),
+  },
+  types: {
+    PalletCommonAccountBasicCrossAccountIdRepr: {
+      _enum: {
+        Substrate: 'AccountId',
+        Ethereum: 'H160',
+      },
+    },
+    NftDataStructsCollection: {
+      owner: 'AccountId',
+      mode: 'NftDataStructsCollectionMode',
+      access: 'NftDataStructsAccessMode',
+      name: 'Vec<u16>',
+      description: 'Vec<u16>',
+      tokenPrefix: 'Vec<u8>',
+      mintMode: 'bool',
+      offchainSchema: 'Vec<u8>',
+      schemaVersion: 'NftDataStructsSchemaVersion',
+      sponsorship: 'NftDataStructsSponsorshipState',
+      limits: 'NftDataStructsCollectionLimits',
+      variableOnChainSchema: 'Vec<u8>',
+      constOnChainSchema: 'Vec<u8>',
+      metaUpdatePermission: 'NftDataStructsMetaUpdatePermission',
+    },
+    NftDataStructsCollectionId: 'u32',
+    NftDataStructsTokenId: 'u32',
+    PalletNonfungibleItemData: mkDummy('NftItemData'),
+    PalletRefungibleItemData: mkDummy('RftItemData'),
+    NftDataStructsCollectionMode: mkDummy('CollectionMode'),
+    NftDataStructsCreateItemData: mkDummy('CreateItemData'),
+    NftDataStructsCollectionLimits: {
+      accountTokenOwnershipLimit: 'Option<u32>',
+      sponsoredDataSize: 'Option<u32>',
+      sponsoredDataRateLimit: 'Option<u32>',
+      tokenLimit: 'Option<u32>',
+      sponsorTransferTimeout: 'Option<u32>',
+      ownerCanTransfer: 'Option<bool>',
+      ownerCanDestroy: 'Option<bool>',
+      transfersEnabled: 'Option<bool>',
+    },
+    NftDataStructsMetaUpdatePermission: {
+      _enum: ['ItemOwner', 'Admin', 'None'],
+    },
+    NftDataStructsSponsorshipState: {
+      _enum: {
+        Disabled: null,
+        Unconfirmed: 'AccountId',
+        Confirmed: 'AccountId',
+      },
+    },
+    NftDataStructsAccessMode: {
+      _enum: ['Normal', 'WhiteList'],
+    },
+    NftDataStructsSchemaVersion: mkDummy('SchemaVersion'),
+
+    PalletUnqSchedulerScheduledV2: mkDummy('ScheduledV2'),
+    PalletUnqSchedulerCallSpec: mkDummy('CallSpec'),
+    PalletUnqSchedulerReleases: mkDummy('Releases'),
+  },
+};

--- /dev/null
+++ b/tests/src/interfaces/nft/index.ts
@@ -0,0 +1,4 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+export * from './types';

--- /dev/null
+++ b/tests/src/interfaces/nft/types.ts
@@ -0,0 +1,113 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { Bytes, Enum, Option, Struct, Vec, bool, u16, u32 } from '@polkadot/types';
+import type { AccountId, H160 } from '@polkadot/types/interfaces/runtime';
+
+/** @name NftDataStructsAccessMode */
+export interface NftDataStructsAccessMode extends Enum {
+  readonly isNormal: boolean;
+  readonly isWhiteList: boolean;
+}
+
+/** @name NftDataStructsCollection */
+export interface NftDataStructsCollection extends Struct {
+  readonly owner: AccountId;
+  readonly mode: NftDataStructsCollectionMode;
+  readonly access: NftDataStructsAccessMode;
+  readonly name: Vec<u16>;
+  readonly description: Vec<u16>;
+  readonly tokenPrefix: Bytes;
+  readonly mintMode: bool;
+  readonly offchainSchema: Bytes;
+  readonly schemaVersion: NftDataStructsSchemaVersion;
+  readonly sponsorship: NftDataStructsSponsorshipState;
+  readonly limits: NftDataStructsCollectionLimits;
+  readonly variableOnChainSchema: Bytes;
+  readonly constOnChainSchema: Bytes;
+  readonly metaUpdatePermission: NftDataStructsMetaUpdatePermission;
+}
+
+/** @name NftDataStructsCollectionId */
+export interface NftDataStructsCollectionId extends u32 {}
+
+/** @name NftDataStructsCollectionLimits */
+export interface NftDataStructsCollectionLimits extends Struct {
+  readonly accountTokenOwnershipLimit: Option<u32>;
+  readonly sponsoredDataSize: Option<u32>;
+  readonly sponsoredDataRateLimit: Option<u32>;
+  readonly tokenLimit: Option<u32>;
+  readonly sponsorTransferTimeout: Option<u32>;
+  readonly ownerCanTransfer: Option<bool>;
+  readonly ownerCanDestroy: Option<bool>;
+  readonly transfersEnabled: Option<bool>;
+}
+
+/** @name NftDataStructsCollectionMode */
+export interface NftDataStructsCollectionMode extends Struct {
+  readonly dummyCollectionMode: u32;
+}
+
+/** @name NftDataStructsCreateItemData */
+export interface NftDataStructsCreateItemData extends Struct {
+  readonly dummyCreateItemData: u32;
+}
+
+/** @name NftDataStructsMetaUpdatePermission */
+export interface NftDataStructsMetaUpdatePermission extends Enum {
+  readonly isItemOwner: boolean;
+  readonly isAdmin: boolean;
+  readonly isNone: boolean;
+}
+
+/** @name NftDataStructsSchemaVersion */
+export interface NftDataStructsSchemaVersion extends Struct {
+  readonly dummySchemaVersion: u32;
+}
+
+/** @name NftDataStructsSponsorshipState */
+export interface NftDataStructsSponsorshipState extends Enum {
+  readonly isDisabled: boolean;
+  readonly isUnconfirmed: boolean;
+  readonly asUnconfirmed: AccountId;
+  readonly isConfirmed: boolean;
+  readonly asConfirmed: AccountId;
+}
+
+/** @name NftDataStructsTokenId */
+export interface NftDataStructsTokenId extends u32 {}
+
+/** @name PalletCommonAccountBasicCrossAccountIdRepr */
+export interface PalletCommonAccountBasicCrossAccountIdRepr extends Enum {
+  readonly isSubstrate: boolean;
+  readonly asSubstrate: AccountId;
+  readonly isEthereum: boolean;
+  readonly asEthereum: H160;
+}
+
+/** @name PalletNonfungibleItemData */
+export interface PalletNonfungibleItemData extends Struct {
+  readonly dummyNftItemData: u32;
+}
+
+/** @name PalletRefungibleItemData */
+export interface PalletRefungibleItemData extends Struct {
+  readonly dummyRftItemData: u32;
+}
+
+/** @name PalletUnqSchedulerCallSpec */
+export interface PalletUnqSchedulerCallSpec extends Struct {
+  readonly dummyCallSpec: u32;
+}
+
+/** @name PalletUnqSchedulerReleases */
+export interface PalletUnqSchedulerReleases extends Struct {
+  readonly dummyReleases: u32;
+}
+
+/** @name PalletUnqSchedulerScheduledV2 */
+export interface PalletUnqSchedulerScheduledV2 extends Struct {
+  readonly dummyScheduledV2: u32;
+}
+
+export type PHANTOM_NFT = 'nft';

--- /dev/null
+++ b/tests/src/interfaces/polkadot/definitions.ts
@@ -0,0 +1,20 @@
+function mkDummy(name: string) {
+  return {
+    ['dummy' + name]: 'u32',
+  };
+}
+
+export default {
+  types: {
+    CumulusPrimitivesParachainInherentParachainInherentData: mkDummy('ParachainInherentData'),
+    CumulusPalletDmpQueueConfigData: mkDummy('DmpQueueConfigData'),
+    CumulusPalletDmpQueuePageIndexData: mkDummy('DmpQueryPageIndexData'),
+    PolkadotPrimitivesV1AbridgedHostConfiguration: mkDummy('AbridgedHostConfiguration'),
+    CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot: mkDummy('CumulusStateSnapshot'),
+    PolkadotPrimitivesV1PersistedValidationData: mkDummy('PersistedValidationData'),
+    CumulusPalletXcmpQueueInboundStatus: mkDummy('CumulusInboundStatus'),
+    CumulusPalletXcmpQueueOutboundStatus: mkDummy('CumulusOutboundStatus'),
+    PolkadotParachainPrimitivesXcmpMessageFormat: mkDummy('XcmpMessageFormat'),
+    CumulusPalletXcmpQueueQueueConfigData: mkDummy('QueueConfigData'),
+  },
+};

--- /dev/null
+++ b/tests/src/interfaces/polkadot/index.ts
@@ -0,0 +1,4 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+export * from './types';

--- /dev/null
+++ b/tests/src/interfaces/polkadot/types.ts
@@ -0,0 +1,56 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { Struct, u32 } from '@polkadot/types';
+
+/** @name CumulusPalletDmpQueueConfigData */
+export interface CumulusPalletDmpQueueConfigData extends Struct {
+  readonly dummyDmpQueueConfigData: u32;
+}
+
+/** @name CumulusPalletDmpQueuePageIndexData */
+export interface CumulusPalletDmpQueuePageIndexData extends Struct {
+  readonly dummyDmpQueryPageIndexData: u32;
+}
+
+/** @name CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot */
+export interface CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot extends Struct {
+  readonly dummyCumulusStateSnapshot: u32;
+}
+
+/** @name CumulusPalletXcmpQueueInboundStatus */
+export interface CumulusPalletXcmpQueueInboundStatus extends Struct {
+  readonly dummyCumulusInboundStatus: u32;
+}
+
+/** @name CumulusPalletXcmpQueueOutboundStatus */
+export interface CumulusPalletXcmpQueueOutboundStatus extends Struct {
+  readonly dummyCumulusOutboundStatus: u32;
+}
+
+/** @name CumulusPalletXcmpQueueQueueConfigData */
+export interface CumulusPalletXcmpQueueQueueConfigData extends Struct {
+  readonly dummyQueueConfigData: u32;
+}
+
+/** @name CumulusPrimitivesParachainInherentParachainInherentData */
+export interface CumulusPrimitivesParachainInherentParachainInherentData extends Struct {
+  readonly dummyParachainInherentData: u32;
+}
+
+/** @name PolkadotParachainPrimitivesXcmpMessageFormat */
+export interface PolkadotParachainPrimitivesXcmpMessageFormat extends Struct {
+  readonly dummyXcmpMessageFormat: u32;
+}
+
+/** @name PolkadotPrimitivesV1AbridgedHostConfiguration */
+export interface PolkadotPrimitivesV1AbridgedHostConfiguration extends Struct {
+  readonly dummyAbridgedHostConfiguration: u32;
+}
+
+/** @name PolkadotPrimitivesV1PersistedValidationData */
+export interface PolkadotPrimitivesV1PersistedValidationData extends Struct {
+  readonly dummyPersistedValidationData: u32;
+}
+
+export type PHANTOM_POLKADOT = 'polkadot';

--- /dev/null
+++ b/tests/src/interfaces/types.ts
@@ -0,0 +1,6 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+export * from './nft/types';
+export * from './ethereum/types';
+export * from './polkadot/types';