diff --git a/types-bundle/src/interfaces/augment-api-consts.ts b/types-bundle/src/interfaces/augment-api-consts.ts
new file mode 100644
index 0000000000000000000000000000000000000000..37713a682cc74dae572ae3e913845193740b0383
--- /dev/null
+++ b/types-bundle/src/interfaces/augment-api-consts.ts
@@ -0,0 +1,109 @@
+// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
+/* eslint-disable */
+
+import type { Vec, u16 } from '@polkadot/types';
+import type { Balance, BalanceOf, BlockNumber, Moment, Permill, RuntimeDbWeight } from '@polkadot/types/interfaces/runtime';
+import type { RuntimeVersion } from '@polkadot/types/interfaces/state';
+import type { WeightToFeeCoefficient } from '@polkadot/types/interfaces/support';
+import type { BlockLength, BlockWeights } from '@polkadot/types/interfaces/system';
+import type { ApiTypes } from '@polkadot/api/types';
+
+declare module '@polkadot/api/types/consts' {
+ export interface AugmentedConsts<ApiType> {
+ balances: {
+ /**
+ * The minimum amount required to keep an account open.
+ **/
+ existentialDeposit: Balance & AugmentedConst<ApiType>;
+ };
+ identity: {
+ /**
+ * Period during which the owner can confirm the new identity.
+ **/
+ confirmPeriod: BlockNumber & AugmentedConst<ApiType>;
+ /**
+ * Maximum period of inactivity, after this period, the identity is permanently deleted
+ **/
+ maxInactivityPeriod: BlockNumber & AugmentedConst<ApiType>;
+ /**
+ * Maximum period with no rights, after this period, the identity is permanently deleted
+ **/
+ maxNoRightPeriod: BlockNumber & AugmentedConst<ApiType>;
+ /**
+ * Period after which a non-validated identity is deleted
+ **/
+ validationPeriod: BlockNumber & AugmentedConst<ApiType>;
+ };
+ system: {
+ /**
+ * Maximum number of block number to block hash mappings to keep (oldest pruned first).
+ **/
+ blockHashCount: BlockNumber & AugmentedConst<ApiType>;
+ /**
+ * The maximum length of a block (in bytes).
+ **/
+ blockLength: BlockLength & AugmentedConst<ApiType>;
+ /**
+ * Block & extrinsics weights: base values and limits.
+ **/
+ blockWeights: BlockWeights & AugmentedConst<ApiType>;
+ /**
+ * The weight of runtime database operations the runtime can invoke.
+ **/
+ dbWeight: RuntimeDbWeight & 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: RuntimeVersion & AugmentedConst<ApiType>;
+ };
+ 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: Moment & AugmentedConst<ApiType>;
+ };
+ transactionPayment: {
+ /**
+ * The fee to be paid for making a transaction; the per-byte portion.
+ **/
+ transactionByteFee: BalanceOf & AugmentedConst<ApiType>;
+ /**
+ * The polynomial that is applied in order to derive fee from weight.
+ **/
+ weightToFee: Vec<WeightToFeeCoefficient> & AugmentedConst<ApiType>;
+ };
+ universalDividend: {
+ /**
+ * Square of the money growth rate per ud reevaluation period
+ **/
+ squareMoneyGrowthRate: Permill & AugmentedConst<ApiType>;
+ /**
+ * Universal dividend creation period
+ **/
+ udCreationPeriod: BlockNumber & AugmentedConst<ApiType>;
+ /**
+ * Universal dividend reevaluation period (in number of creation period)
+ **/
+ udReevalPeriod: BalanceOf & AugmentedConst<ApiType>;
+ /**
+ * Universal dividend reevaluation period in number of blocks
+ * Must be equal to UdReevalPeriod * UdCreationPeriod
+ **/
+ udReevalPeriodInBlocks: BlockNumber & AugmentedConst<ApiType>;
+ };
+ }
+
+ export interface QueryableConsts<ApiType extends ApiTypes> extends AugmentedConsts<ApiType> {
+ }
+}
diff --git a/types-bundle/src/interfaces/augment-api-errors.ts b/types-bundle/src/interfaces/augment-api-errors.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ca5944fe7196fc2827da10fa15b35a64d77c8e42
--- /dev/null
+++ b/types-bundle/src/interfaces/augment-api-errors.ts
@@ -0,0 +1,174 @@
+// 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>;
+ };
+ grandpa: {
+ /**
+ * Attempt to signal GRANDPA change with one already pending.
+ **/
+ ChangePending: AugmentedError<ApiType>;
+ /**
+ * A given equivocation report is valid but already previously reported.
+ **/
+ DuplicateOffenceReport: AugmentedError<ApiType>;
+ /**
+ * An equivocation proof provided as part of an equivocation report is invalid.
+ **/
+ InvalidEquivocationProof: AugmentedError<ApiType>;
+ /**
+ * A key ownership proof provided as part of an equivocation report is invalid.
+ **/
+ InvalidKeyOwnershipProof: AugmentedError<ApiType>;
+ /**
+ * Attempt to signal GRANDPA pause when the authority set isn't live
+ * (either paused or already pending pause).
+ **/
+ PauseFailed: AugmentedError<ApiType>;
+ /**
+ * Attempt to signal GRANDPA resume when the authority set isn't paused
+ * (either live or already pending resume).
+ **/
+ ResumeFailed: AugmentedError<ApiType>;
+ /**
+ * Cannot signal forced change so soon after last.
+ **/
+ TooSoon: AugmentedError<ApiType>;
+ };
+ identity: {
+ /**
+ * Identity already confirmed
+ **/
+ IdtyAlreadyConfirmed: AugmentedError<ApiType>;
+ /**
+ * Identity already exist
+ **/
+ IdtyAlreadyExist: AugmentedError<ApiType>;
+ /**
+ * Identity already validated
+ **/
+ IdtyAlreadyValidated: AugmentedError<ApiType>;
+ /**
+ * You are not allowed to create a new identity now
+ **/
+ IdtyCreationNotAllowed: AugmentedError<ApiType>;
+ /**
+ * Identity not confirmed by owner
+ **/
+ IdtyNotConfirmedByOwner: AugmentedError<ApiType>;
+ /**
+ * Identity not found
+ **/
+ IdtyNotFound: AugmentedError<ApiType>;
+ /**
+ * Identity not validated
+ **/
+ IdtyNotValidated: AugmentedError<ApiType>;
+ /**
+ * Identity not yet renewable
+ **/
+ IdtyNotYetRenewable: AugmentedError<ApiType>;
+ /**
+ * This operation requires to be the owner of the identity
+ **/
+ RequireToBeOwner: AugmentedError<ApiType>;
+ /**
+ * Right already added
+ **/
+ RightAlreadyAdded: AugmentedError<ApiType>;
+ /**
+ * Right not exist
+ **/
+ RightNotExist: AugmentedError<ApiType>;
+ };
+ strongCert: {
+ /**
+ * An identity must receive certifications before it can issue them.
+ **/
+ IdtyMustReceiveCertsBeforeCanIssue: AugmentedError<ApiType>;
+ /**
+ * This identity has already issued the maximum number of certifications
+ **/
+ IssuedTooManyCert: AugmentedError<ApiType>;
+ /**
+ * This identity has already issued a certification too recently
+ **/
+ NotRespectCertPeriod: AugmentedError<ApiType>;
+ /**
+ * This certification has already been issued or renewed recently
+ **/
+ NotRespectRenewablePeriod: AugmentedError<ApiType>;
+ };
+ sudo: {
+ /**
+ * Sender must be the Sudo account
+ **/
+ RequireSudo: 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>;
+ };
+ }
+
+ export interface DecoratedErrors<ApiType extends ApiTypes> extends AugmentedErrors<ApiType> {
+ }
+}
diff --git a/types-bundle/src/interfaces/augment-api-events.ts b/types-bundle/src/interfaces/augment-api-events.ts
new file mode 100644
index 0000000000000000000000000000000000000000..7fe58c6c65b3150f15215453f89710187c510d3c
--- /dev/null
+++ b/types-bundle/src/interfaces/augment-api-events.ts
@@ -0,0 +1,175 @@
+// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
+/* eslint-disable */
+
+import type { Option, bool, u32, u8 } from '@polkadot/types';
+import type { BalanceStatus } from '@polkadot/types/interfaces/balances';
+import type { AuthorityList } from '@polkadot/types/interfaces/grandpa';
+import type { AccountId, Balance, BalanceOf, Hash } from '@polkadot/types/interfaces/runtime';
+import type { DispatchError, DispatchInfo, DispatchResult } from '@polkadot/types/interfaces/system';
+import type { IdtyDid, IdtyIndex, IdtyRight } from './runtime';
+import type { ApiTypes } from '@polkadot/api/types';
+
+declare module '@polkadot/api/types/events' {
+ export interface AugmentedEvents<ApiType> {
+ balances: {
+ /**
+ * A balance was set by root. \[who, free, reserved\]
+ **/
+ BalanceSet: AugmentedEvent<ApiType, [AccountId, Balance, Balance]>;
+ /**
+ * Some amount was deposited (e.g. for transaction fees). \[who, deposit\]
+ **/
+ Deposit: AugmentedEvent<ApiType, [AccountId, Balance]>;
+ /**
+ * An account was removed whose balance was non-zero but below ExistentialDeposit,
+ * resulting in an outright loss. \[account, balance\]
+ **/
+ DustLost: AugmentedEvent<ApiType, [AccountId, Balance]>;
+ /**
+ * An account was created with some free balance. \[account, free_balance\]
+ **/
+ Endowed: AugmentedEvent<ApiType, [AccountId, Balance]>;
+ /**
+ * Some balance was reserved (moved from free to reserved). \[who, value\]
+ **/
+ Reserved: AugmentedEvent<ApiType, [AccountId, Balance]>;
+ /**
+ * 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, [AccountId, AccountId, Balance, BalanceStatus]>;
+ /**
+ * Transfer succeeded. \[from, to, value\]
+ **/
+ Transfer: AugmentedEvent<ApiType, [AccountId, AccountId, Balance]>;
+ /**
+ * Some balance was unreserved (moved from reserved to free). \[who, value\]
+ **/
+ Unreserved: AugmentedEvent<ApiType, [AccountId, Balance]>;
+ };
+ grandpa: {
+ /**
+ * New authority set has been applied. \[authority_set\]
+ **/
+ NewAuthorities: AugmentedEvent<ApiType, [AuthorityList]>;
+ /**
+ * Current authority set has been paused.
+ **/
+ Paused: AugmentedEvent<ApiType, []>;
+ /**
+ * Current authority set has been resumed.
+ **/
+ Resumed: AugmentedEvent<ApiType, []>;
+ };
+ identity: {
+ /**
+ * An identity has acquired a new right
+ * [idty, right]
+ **/
+ IdtyAcquireRight: AugmentedEvent<ApiType, [IdtyDid, IdtyRight]>;
+ /**
+ * An identity has been confirmed by it's owner
+ * [idty]
+ **/
+ IdtyConfirmed: AugmentedEvent<ApiType, [IdtyDid]>;
+ /**
+ * A new identity has been created
+ * [idty, owner_key]
+ **/
+ IdtyCreated: AugmentedEvent<ApiType, [IdtyDid, AccountId]>;
+ /**
+ * An identity lost a right
+ * [idty, righ]
+ **/
+ IdtyLostRight: AugmentedEvent<ApiType, [IdtyDid, IdtyRight]>;
+ /**
+ * An identity was renewed by it's owner
+ * [idty]
+ **/
+ IdtyRenewed: AugmentedEvent<ApiType, [IdtyDid]>;
+ /**
+ * An identity has modified a subkey associated with a right
+ * [idty_did, right, old_subkey_opt, new_subkey_opt]
+ **/
+ IdtySetRightSubKey: AugmentedEvent<ApiType, [IdtyDid, IdtyRight, Option<AccountId>, Option<AccountId>]>;
+ /**
+ * An identity has been validated
+ * [idty]
+ **/
+ IdtyValidated: AugmentedEvent<ApiType, [IdtyDid]>;
+ };
+ strongCert: {
+ /**
+ * New certification
+ * \[issuer, issuer_issued_count, receiver, receiver_received_count\]
+ **/
+ NewCert: AugmentedEvent<ApiType, [IdtyIndex, u8, IdtyIndex, u32]>;
+ /**
+ * Removed certification
+ * \[issuer, issuer_issued_count, receiver, receiver_received_count, expiration\]
+ **/
+ RemovedCert: AugmentedEvent<ApiType, [IdtyIndex, u8, IdtyIndex, u32, bool]>;
+ /**
+ * Renewed certification
+ * \[issuer, receiver\]
+ **/
+ RenewedCert: AugmentedEvent<ApiType, [IdtyIndex, IdtyIndex]>;
+ };
+ sudo: {
+ /**
+ * The \[sudoer\] just switched identity; the old key is supplied.
+ **/
+ KeyChanged: AugmentedEvent<ApiType, [AccountId]>;
+ /**
+ * A sudo just took place. \[result\]
+ **/
+ Sudid: AugmentedEvent<ApiType, [DispatchResult]>;
+ /**
+ * A sudo just took place. \[result\]
+ **/
+ SudoAsDone: AugmentedEvent<ApiType, [DispatchResult]>;
+ };
+ system: {
+ /**
+ * `:code` was updated.
+ **/
+ CodeUpdated: AugmentedEvent<ApiType, []>;
+ /**
+ * An extrinsic failed. \[error, info\]
+ **/
+ ExtrinsicFailed: AugmentedEvent<ApiType, [DispatchError, DispatchInfo]>;
+ /**
+ * An extrinsic completed successfully. \[info\]
+ **/
+ ExtrinsicSuccess: AugmentedEvent<ApiType, [DispatchInfo]>;
+ /**
+ * An \[account\] was reaped.
+ **/
+ KilledAccount: AugmentedEvent<ApiType, [AccountId]>;
+ /**
+ * A new \[account\] was created.
+ **/
+ NewAccount: AugmentedEvent<ApiType, [AccountId]>;
+ /**
+ * On on-chain remark happened. \[origin, remark_hash\]
+ **/
+ Remarked: AugmentedEvent<ApiType, [AccountId, Hash]>;
+ };
+ universalDividend: {
+ /**
+ * A new universal dividend is created
+ * [ud_amout, members_count]
+ **/
+ NewUdCreated: AugmentedEvent<ApiType, [BalanceOf, BalanceOf]>;
+ /**
+ * The universal dividend has been re-evaluated
+ * [new_ud_amount, monetary_mass, members_count]
+ **/
+ UdReevalued: AugmentedEvent<ApiType, [BalanceOf, BalanceOf, BalanceOf]>;
+ };
+ }
+
+ export interface DecoratedEvents<ApiType extends ApiTypes> extends AugmentedEvents<ApiType> {
+ }
+}
diff --git a/types-bundle/src/interfaces/augment-api-query.ts b/types-bundle/src/interfaces/augment-api-query.ts
new file mode 100644
index 0000000000000000000000000000000000000000..12c3073bc7b57cddb2ac0e166cade9b761896351
--- /dev/null
+++ b/types-bundle/src/interfaces/augment-api-query.ts
@@ -0,0 +1,247 @@
+// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
+/* eslint-disable */
+
+import type { Bytes, Option, Vec, bool, u32, u64 } from '@polkadot/types';
+import type { AnyNumber, ITuple, Observable } from '@polkadot/types/types';
+import type { AccountData, BalanceLock, ReserveData } from '@polkadot/types/interfaces/balances';
+import type { SetId, StoredPendingChange, StoredState } from '@polkadot/types/interfaces/grandpa';
+import type { AccountId, Balance, BalanceOf, BlockNumber, Hash, Moment, Releases } from '@polkadot/types/interfaces/runtime';
+import type { SessionIndex } from '@polkadot/types/interfaces/session';
+import type { AccountInfo, ConsumedWeight, DigestOf, EventIndex, EventRecord, LastRuntimeUpgradeInfo, Phase } from '@polkadot/types/interfaces/system';
+import type { Multiplier } from '@polkadot/types/interfaces/txpayment';
+import type { CertValue, IdtyCertMeta, IdtyDid, IdtyIndex, IdtyStatus, IdtyValue } from './runtime';
+import type { ApiTypes } from '@polkadot/api/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: AccountId | string | Uint8Array) => Observable<AccountData>, [AccountId]>;
+ /**
+ * Any liquidity locks on some account balances.
+ * NOTE: Should only be accessed when setting, changing and freeing a lock.
+ **/
+ locks: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Vec<BalanceLock>>, [AccountId]>;
+ /**
+ * Named reserves on some account balances.
+ **/
+ reserves: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<Vec<ReserveData>>, [AccountId]>;
+ /**
+ * Storage version of the pallet.
+ *
+ * This is set to v2.0.0 for new networks.
+ **/
+ storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>, []>;
+ /**
+ * The total units issued in the system.
+ **/
+ totalIssuance: AugmentedQuery<ApiType, () => Observable<Balance>, []>;
+ };
+ grandpa: {
+ /**
+ * The number of changes (both in terms of keys and underlying economic responsibilities)
+ * in the "set" of Grandpa validators from genesis.
+ **/
+ currentSetId: AugmentedQuery<ApiType, () => Observable<SetId>, []>;
+ /**
+ * next block number where we can force a change.
+ **/
+ nextForced: AugmentedQuery<ApiType, () => Observable<Option<BlockNumber>>, []>;
+ /**
+ * Pending change: (signaled at, scheduled change).
+ **/
+ pendingChange: AugmentedQuery<ApiType, () => Observable<Option<StoredPendingChange>>, []>;
+ /**
+ * A mapping from grandpa set ID to the index of the *most recent* session for which its
+ * members were responsible.
+ *
+ * TWOX-NOTE: `SetId` is not under user control.
+ **/
+ setIdSession: AugmentedQuery<ApiType, (arg: SetId | AnyNumber | Uint8Array) => Observable<Option<SessionIndex>>, [SetId]>;
+ /**
+ * `true` if we are currently stalled.
+ **/
+ stalled: AugmentedQuery<ApiType, () => Observable<Option<ITuple<[BlockNumber, BlockNumber]>>>, []>;
+ /**
+ * State of the current authority set.
+ **/
+ state: AugmentedQuery<ApiType, () => Observable<StoredState>, []>;
+ };
+ identity: {
+ /**
+ * Identities
+ **/
+ identities: AugmentedQuery<ApiType, (arg: IdtyIndex | AnyNumber | Uint8Array) => Observable<IdtyValue>, [IdtyIndex]>;
+ /**
+ * IdentitiesByDid
+ **/
+ identitiesByDid: AugmentedQuery<ApiType, (arg: IdtyDid | { hash?: any; planet?: any; latitude?: any; longitude?: any } | string | Uint8Array) => Observable<IdtyIndex>, [IdtyDid]>;
+ identitiesCount: AugmentedQuery<ApiType, () => Observable<u64>, []>;
+ /**
+ * Identities by expiration block
+ **/
+ identitiesExpireOn: AugmentedQuery<ApiType, (arg: BlockNumber | AnyNumber | Uint8Array) => Observable<Vec<IdtyIndex>>, [BlockNumber]>;
+ /**
+ * Identities by removed block
+ **/
+ identitiesRemovableOn: AugmentedQuery<ApiType, (arg: BlockNumber | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[IdtyIndex, IdtyStatus]>>>, [BlockNumber]>;
+ nextIdtyIndex: AugmentedQuery<ApiType, () => Observable<IdtyIndex>, []>;
+ /**
+ * Storage version of the pallet.
+ **/
+ storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>, []>;
+ };
+ 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<Hash>>, []>;
+ };
+ strongCert: {
+ storageCertsByIssuer: AugmentedQuery<ApiType, (arg1: IdtyIndex | AnyNumber | Uint8Array, arg2: IdtyIndex | AnyNumber | Uint8Array) => Observable<Option<CertValue>>, [IdtyIndex, IdtyIndex]>;
+ /**
+ * Certifications by receiver
+ **/
+ storageCertsByReceiver: AugmentedQuery<ApiType, (arg: IdtyIndex | AnyNumber | Uint8Array) => Observable<Vec<IdtyIndex>>, [IdtyIndex]>;
+ /**
+ * Certifications removable on
+ **/
+ storageCertsRemovableOn: AugmentedQuery<ApiType, (arg: BlockNumber | AnyNumber | Uint8Array) => Observable<Vec<ITuple<[IdtyIndex, IdtyIndex]>>>, [BlockNumber]>;
+ /**
+ * Certifications by issuer
+ **/
+ storageIdtyCertMeta: AugmentedQuery<ApiType, (arg: IdtyIndex | AnyNumber | Uint8Array) => Observable<IdtyCertMeta>, [IdtyIndex]>;
+ /**
+ * Storage version of the pallet.
+ **/
+ storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>, []>;
+ };
+ sudo: {
+ /**
+ * The `AccountId` of the sudo key.
+ **/
+ key: AugmentedQuery<ApiType, () => Observable<AccountId>, []>;
+ };
+ system: {
+ /**
+ * The full account information for a particular account ID.
+ **/
+ account: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<AccountInfo>, [AccountId]>;
+ /**
+ * Total length (in bytes) for all extrinsics put together, for the current block.
+ **/
+ allExtrinsicsLen: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []>;
+ /**
+ * Map of block numbers to block hashes.
+ **/
+ blockHash: AugmentedQuery<ApiType, (arg: BlockNumber | AnyNumber | Uint8Array) => Observable<Hash>, [BlockNumber]>;
+ /**
+ * The current weight for the block.
+ **/
+ blockWeight: AugmentedQuery<ApiType, () => Observable<ConsumedWeight>, []>;
+ /**
+ * Digest of the current block, also part of the block header.
+ **/
+ digest: AugmentedQuery<ApiType, () => Observable<DigestOf>, []>;
+ /**
+ * The number of events in the `Events<T>` list.
+ **/
+ eventCount: AugmentedQuery<ApiType, () => Observable<EventIndex>, []>;
+ /**
+ * Events deposited for the current block.
+ **/
+ events: AugmentedQuery<ApiType, () => Observable<Vec<EventRecord>>, []>;
+ /**
+ * 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: Hash | string | Uint8Array) => Observable<Vec<ITuple<[BlockNumber, EventIndex]>>>, [Hash]>;
+ /**
+ * The execution phase of the block.
+ **/
+ executionPhase: AugmentedQuery<ApiType, () => Observable<Option<Phase>>, []>;
+ /**
+ * Total extrinsics count for the current block.
+ **/
+ extrinsicCount: AugmentedQuery<ApiType, () => Observable<Option<u32>>, []>;
+ /**
+ * Extrinsics data for the current block (maps an extrinsic's index to its data).
+ **/
+ extrinsicData: AugmentedQuery<ApiType, (arg: u32 | AnyNumber | Uint8Array) => Observable<Bytes>, [u32]>;
+ /**
+ * Stores the `spec_version` and `spec_name` of when the last runtime upgrade happened.
+ **/
+ lastRuntimeUpgrade: AugmentedQuery<ApiType, () => Observable<Option<LastRuntimeUpgradeInfo>>, []>;
+ /**
+ * The current block number being processed. Set by `execute_block`.
+ **/
+ number: AugmentedQuery<ApiType, () => Observable<BlockNumber>, []>;
+ /**
+ * Hash of the previous block.
+ **/
+ parentHash: AugmentedQuery<ApiType, () => Observable<Hash>, []>;
+ /**
+ * True if we have upgraded so that AccountInfo contains three types of `RefCount`. False
+ * (default) if not.
+ **/
+ upgradedToTripleRefCount: AugmentedQuery<ApiType, () => Observable<bool>, []>;
+ /**
+ * True if we have upgraded so that `type RefCount` is `u32`. False (default) if not.
+ **/
+ upgradedToU32RefCount: AugmentedQuery<ApiType, () => Observable<bool>, []>;
+ };
+ timestamp: {
+ /**
+ * Did the timestamp get updated in this block?
+ **/
+ didUpdate: AugmentedQuery<ApiType, () => Observable<bool>, []>;
+ /**
+ * Current time for the current block.
+ **/
+ now: AugmentedQuery<ApiType, () => Observable<Moment>, []>;
+ };
+ transactionPayment: {
+ nextFeeMultiplier: AugmentedQuery<ApiType, () => Observable<Multiplier>, []>;
+ storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>, []>;
+ };
+ udAccountsStorage: {
+ /**
+ * Storage version of the pallet.
+ **/
+ storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>, []>;
+ udAccounts: AugmentedQuery<ApiType, (arg: AccountId | string | Uint8Array) => Observable<ITuple<[]>>, [AccountId]>;
+ udAccountsCounter: AugmentedQuery<ApiType, () => Observable<u64>, []>;
+ };
+ universalDividend: {
+ /**
+ * Last reevaluation
+ **/
+ currentUdStorage: AugmentedQuery<ApiType, () => Observable<BalanceOf>, []>;
+ /**
+ * Total quantity of money created by universal dividend (does not take into account the possible destruction of money)
+ **/
+ monetaryMassStorage: AugmentedQuery<ApiType, () => Observable<BalanceOf>, []>;
+ /**
+ * Storage version of the pallet.
+ **/
+ storageVersion: AugmentedQuery<ApiType, () => Observable<Releases>, []>;
+ };
+ }
+
+ export interface QueryableStorage<ApiType extends ApiTypes> extends AugmentedQueries<ApiType> {
+ }
+}
diff --git a/types-bundle/src/interfaces/augment-api-rpc.ts b/types-bundle/src/interfaces/augment-api-rpc.ts
new file mode 100644
index 0000000000000000000000000000000000000000..9405e6412a9b50aa9b77832a471b23b7764beaa5
--- /dev/null
+++ b/types-bundle/src/interfaces/augment-api-rpc.ts
@@ -0,0 +1,556 @@
+// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
+/* eslint-disable */
+
+import type { Bytes, HashMap, Json, Metadata, Null, Option, StorageKey, Text, U256, U64, Vec, bool, u32, u64 } from '@polkadot/types';
+import type { AnyNumber, Codec, IExtrinsic, Observable } from '@polkadot/types/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';
+
+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 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>>;
+ };
+ 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>>;
+ };
+ }
+}
diff --git a/types-bundle/src/interfaces/augment-api-tx.ts b/types-bundle/src/interfaces/augment-api-tx.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8cce21e1aedaa0bb0e92e54503329010aa0207fc
--- /dev/null
+++ b/types-bundle/src/interfaces/augment-api-tx.ts
@@ -0,0 +1,343 @@
+// Auto-generated via `yarn polkadot-types-from-chain`, do not edit
+/* eslint-disable */
+
+import type { Bytes, Compact, Option, Vec, bool, u32, u64 } from '@polkadot/types';
+import type { AnyNumber } from '@polkadot/types/types';
+import type { Extrinsic } from '@polkadot/types/interfaces/extrinsics';
+import type { GrandpaEquivocationProof, KeyOwnerProof } from '@polkadot/types/interfaces/grandpa';
+import type { AccountId, Balance, BlockNumber, Call, ChangesTrieConfiguration, KeyValue, LookupSource, Moment, Perbill, Weight } from '@polkadot/types/interfaces/runtime';
+import type { Key } from '@polkadot/types/interfaces/system';
+import type { IdtyDid, IdtyIndex, IdtyRight } from './runtime';
+import type { ApiTypes, SubmittableExtrinsic } from '@polkadot/api/types';
+
+declare module '@polkadot/api/types/submittable' {
+ export interface AugmentedSubmittables<ApiType> {
+ balances: {
+ /**
+ * Exactly as `transfer`, except the origin must be root and the source account may be
+ * specified.
+ * # <weight>
+ * - Same as transfer, but additional read and write because the source account is
+ * not assumed to be in the overlay.
+ * # </weight>
+ **/
+ forceTransfer: AugmentedSubmittable<(source: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, dest: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<Balance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, LookupSource, Compact<Balance>]>;
+ /**
+ * Set the balances of a given account.
+ *
+ * This will alter `FreeBalance` and `ReservedBalance` in storage. it will
+ * also decrease the total issuance of the system (`TotalIssuance`).
+ * If the new free or reserved balance is below the existential deposit,
+ * it will reset the account nonce (`frame_system::AccountNonce`).
+ *
+ * The dispatch origin for this call is `root`.
+ *
+ * # <weight>
+ * - Independent of the arguments.
+ * - Contains a limited number of reads and writes.
+ * ---------------------
+ * - Base Weight:
+ * - Creating: 27.56 µs
+ * - Killing: 35.11 µs
+ * - DB Weight: 1 Read, 1 Write to `who`
+ * # </weight>
+ **/
+ setBalance: AugmentedSubmittable<(who: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, newFree: Compact<Balance> | AnyNumber | Uint8Array, newReserved: Compact<Balance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Compact<Balance>, Compact<Balance>]>;
+ /**
+ * Transfer some liquid free balance to another account.
+ *
+ * `transfer` will set the `FreeBalance` of the sender and receiver.
+ * It will decrease the total issuance of the system by the `TransferFee`.
+ * If the sender's account is below the existential deposit as a result
+ * of the transfer, the account will be reaped.
+ *
+ * The dispatch origin for this call must be `Signed` by the transactor.
+ *
+ * # <weight>
+ * - Dependent on arguments but not critical, given proper implementations for
+ * input config types. See related functions below.
+ * - It contains a limited number of reads and writes internally and no complex computation.
+ *
+ * Related functions:
+ *
+ * - `ensure_can_withdraw` is always called internally but has a bounded complexity.
+ * - Transferring balances to accounts that did not exist before will cause
+ * `T::OnNewAccount::on_new_account` to be called.
+ * - Removing enough funds from an account will trigger `T::DustRemoval::on_unbalanced`.
+ * - `transfer_keep_alive` works the same way as `transfer`, but has an additional
+ * check that the transfer will not kill the origin account.
+ * ---------------------------------
+ * - Base Weight: 73.64 µs, worst case scenario (account created, account removed)
+ * - DB Weight: 1 Read and 1 Write to destination account
+ * - Origin account is already in memory, so no DB operations for them.
+ * # </weight>
+ **/
+ transfer: AugmentedSubmittable<(dest: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<Balance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Compact<Balance>]>;
+ /**
+ * Transfer the entire transferable balance from the caller account.
+ *
+ * NOTE: This function only attempts to transfer _transferable_ balances. This means that
+ * any locked, reserved, or existential deposits (when `keep_alive` is `true`), will not be
+ * transferred by this function. To ensure that this function results in a killed account,
+ * you might need to prepare the account by removing any reference counters, storage
+ * deposits, etc...
+ *
+ * The dispatch origin of this call must be Signed.
+ *
+ * - `dest`: The recipient of the transfer.
+ * - `keep_alive`: A boolean to determine if the `transfer_all` operation should send all
+ * of the funds the account has, causing the sender account to be killed (false), or
+ * transfer everything except at least the existential deposit, which will guarantee to
+ * keep the sender account alive (true).
+ * # <weight>
+ * - O(1). Just like transfer, but reading the user's transferable balance first.
+ * #</weight>
+ **/
+ transferAll: AugmentedSubmittable<(dest: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, keepAlive: bool | boolean | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, bool]>;
+ /**
+ * Same as the [`transfer`] call, but with a check that the transfer will not kill the
+ * origin account.
+ *
+ * 99% of the time you want [`transfer`] instead.
+ *
+ * [`transfer`]: struct.Pallet.html#method.transfer
+ * # <weight>
+ * - Cheaper than transfer because account cannot be killed.
+ * - Base Weight: 51.4 µs
+ * - DB Weight: 1 Read and 1 Write to dest (sender is in overlay already)
+ * #</weight>
+ **/
+ transferKeepAlive: AugmentedSubmittable<(dest: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, value: Compact<Balance> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Compact<Balance>]>;
+ };
+ grandpa: {
+ /**
+ * Note that the current authority set of the GRANDPA finality gadget has
+ * stalled. This will trigger a forced authority set change at the beginning
+ * of the next session, to be enacted `delay` blocks after that. The delay
+ * should be high enough to safely assume that the block signalling the
+ * forced change will not be re-orged (e.g. 1000 blocks). The GRANDPA voters
+ * will start the new authority set using the given finalized block as base.
+ * Only callable by root.
+ **/
+ noteStalled: AugmentedSubmittable<(delay: BlockNumber | AnyNumber | Uint8Array, bestFinalizedBlockNumber: BlockNumber | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [BlockNumber, BlockNumber]>;
+ /**
+ * Report voter equivocation/misbehavior. This method will verify the
+ * equivocation proof and validate the given key ownership proof
+ * against the extracted offender. If both are valid, the offence
+ * will be reported.
+ **/
+ reportEquivocation: AugmentedSubmittable<(equivocationProof: GrandpaEquivocationProof | { setId?: any; equivocation?: any } | string | Uint8Array, keyOwnerProof: KeyOwnerProof | { session?: any; trieNodes?: any; validatorCount?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [GrandpaEquivocationProof, KeyOwnerProof]>;
+ /**
+ * Report voter equivocation/misbehavior. This method will verify the
+ * equivocation proof and validate the given key ownership proof
+ * against the extracted offender. If both are valid, the offence
+ * will be reported.
+ *
+ * This extrinsic must be called unsigned and it is expected that only
+ * block authors will call it (validated in `ValidateUnsigned`), as such
+ * if the block author is defined it will be defined as the equivocation
+ * reporter.
+ **/
+ reportEquivocationUnsigned: AugmentedSubmittable<(equivocationProof: GrandpaEquivocationProof | { setId?: any; equivocation?: any } | string | Uint8Array, keyOwnerProof: KeyOwnerProof | { session?: any; trieNodes?: any; validatorCount?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [GrandpaEquivocationProof, KeyOwnerProof]>;
+ };
+ identity: {
+ addRight: AugmentedSubmittable<(idtyIndex: IdtyIndex | AnyNumber | Uint8Array, right: IdtyRight | 'CreateIdty' | 'LightCert' | 'StrongCert' | 'Ud' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [IdtyIndex, IdtyRight]>;
+ confirmIdentity: AugmentedSubmittable<(idtyDid: IdtyDid | { hash?: any; planet?: any; latitude?: any; longitude?: any } | string | Uint8Array, idtyIndex: IdtyIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [IdtyDid, IdtyIndex]>;
+ createIdentity: AugmentedSubmittable<(creator: IdtyIndex | AnyNumber | Uint8Array, idtyDid: IdtyDid | { hash?: any; planet?: any; latitude?: any; longitude?: any } | string | Uint8Array, ownerKey: AccountId | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [IdtyIndex, IdtyDid, AccountId]>;
+ delRight: AugmentedSubmittable<(idtyIndex: IdtyIndex | AnyNumber | Uint8Array, right: IdtyRight | 'CreateIdty' | 'LightCert' | 'StrongCert' | 'Ud' | number | Uint8Array) => SubmittableExtrinsic<ApiType>, [IdtyIndex, IdtyRight]>;
+ renewIdentity: AugmentedSubmittable<(idtyDid: IdtyDid | { hash?: any; planet?: any; latitude?: any; longitude?: any } | string | Uint8Array, idtyIndex: IdtyIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [IdtyDid, IdtyIndex]>;
+ setRightSubkey: AugmentedSubmittable<(idtyIndex: IdtyIndex | AnyNumber | Uint8Array, right: IdtyRight | 'CreateIdty' | 'LightCert' | 'StrongCert' | 'Ud' | number | Uint8Array, subkeyOpt: Option<AccountId> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [IdtyIndex, IdtyRight, Option<AccountId>]>;
+ validateIdentity: AugmentedSubmittable<(idtyIndex: IdtyIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [IdtyIndex]>;
+ validateIdentityAndAddRights: AugmentedSubmittable<(idtyIndex: IdtyIndex | AnyNumber | Uint8Array, rights: Vec<IdtyRight> | (IdtyRight | 'CreateIdty' | 'LightCert' | 'StrongCert' | 'Ud' | number | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [IdtyIndex, Vec<IdtyRight>]>;
+ };
+ strongCert: {
+ addCert: AugmentedSubmittable<(issuer: IdtyIndex | AnyNumber | Uint8Array, receiver: IdtyIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [IdtyIndex, IdtyIndex]>;
+ delCert: AugmentedSubmittable<(issuer: IdtyIndex | AnyNumber | Uint8Array, receiver: IdtyIndex | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [IdtyIndex, IdtyIndex]>;
+ };
+ sudo: {
+ /**
+ * Authenticates the current sudo key and sets the given AccountId (`new`) as the new sudo key.
+ *
+ * The dispatch origin for this call must be _Signed_.
+ *
+ * # <weight>
+ * - O(1).
+ * - Limited storage reads.
+ * - One DB change.
+ * # </weight>
+ **/
+ setKey: AugmentedSubmittable<(updated: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource]>;
+ /**
+ * Authenticates the sudo key and dispatches a function call with `Root` origin.
+ *
+ * The dispatch origin for this call must be _Signed_.
+ *
+ * # <weight>
+ * - O(1).
+ * - Limited storage reads.
+ * - One DB write (event).
+ * - Weight of derivative `call` execution + 10,000.
+ * # </weight>
+ **/
+ sudo: AugmentedSubmittable<(call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call]>;
+ /**
+ * Authenticates the sudo key and dispatches a function call with `Signed` origin from
+ * a given account.
+ *
+ * The dispatch origin for this call must be _Signed_.
+ *
+ * # <weight>
+ * - O(1).
+ * - Limited storage reads.
+ * - One DB write (event).
+ * - Weight of derivative `call` execution + 10,000.
+ * # </weight>
+ **/
+ sudoAs: AugmentedSubmittable<(who: LookupSource | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array, call: Call | { callIndex?: any; args?: any } | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [LookupSource, Call]>;
+ /**
+ * Authenticates the sudo key and dispatches a function call with `Root` origin.
+ * This function does not check the weight of the call, and instead allows the
+ * Sudo user to specify the weight of the call.
+ *
+ * The dispatch origin for this call must be _Signed_.
+ *
+ * # <weight>
+ * - O(1).
+ * - The weight of this call is defined by the caller.
+ * # </weight>
+ **/
+ sudoUncheckedWeight: AugmentedSubmittable<(call: Call | { callIndex?: any; args?: any } | string | Uint8Array, weight: Weight | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Call, Weight]>;
+ };
+ system: {
+ /**
+ * A dispatch that will fill the block weight up to the given ratio.
+ **/
+ fillBlock: AugmentedSubmittable<(ratio: Perbill | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Perbill]>;
+ /**
+ * Kill all storage items with a key that starts with the given prefix.
+ *
+ * **NOTE:** We rely on the Root origin to provide us the number of subkeys under
+ * the prefix we are removing to accurately calculate the weight of this function.
+ *
+ * # <weight>
+ * - `O(P)` where `P` amount of keys with prefix `prefix`
+ * - `P` storage deletions.
+ * - Base Weight: 0.834 * P µs
+ * - Writes: Number of subkeys + 1
+ * # </weight>
+ **/
+ killPrefix: AugmentedSubmittable<(prefix: Key | string | Uint8Array, subkeys: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Key, u32]>;
+ /**
+ * Kill some items from storage.
+ *
+ * # <weight>
+ * - `O(IK)` where `I` length of `keys` and `K` length of one key
+ * - `I` storage deletions.
+ * - Base Weight: .378 * i µs
+ * - Writes: Number of items
+ * # </weight>
+ **/
+ killStorage: AugmentedSubmittable<(keys: Vec<Key> | (Key | string | Uint8Array)[]) => SubmittableExtrinsic<ApiType>, [Vec<Key>]>;
+ /**
+ * Make some on-chain remark.
+ *
+ * # <weight>
+ * - `O(1)`
+ * # </weight>
+ **/
+ remark: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
+ /**
+ * Make some on-chain remark and emit event.
+ *
+ * # <weight>
+ * - `O(b)` where b is the length of the remark.
+ * - 1 event.
+ * # </weight>
+ **/
+ remarkWithEvent: AugmentedSubmittable<(remark: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
+ /**
+ * Set the new changes trie configuration.
+ *
+ * # <weight>
+ * - `O(1)`
+ * - 1 storage write or delete (codec `O(1)`).
+ * - 1 call to `deposit_log`: Uses `append` API, so O(1)
+ * - Base Weight: 7.218 µs
+ * - DB Weight:
+ * - Writes: Changes Trie, System Digest
+ * # </weight>
+ **/
+ setChangesTrieConfig: AugmentedSubmittable<(changesTrieConfig: Option<ChangesTrieConfiguration> | null | object | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Option<ChangesTrieConfiguration>]>;
+ /**
+ * Set the new runtime code.
+ *
+ * # <weight>
+ * - `O(C + S)` where `C` length of `code` and `S` complexity of `can_set_code`
+ * - 1 storage write (codec `O(C)`).
+ * - 1 call to `can_set_code`: `O(S)` (calls `sp_io::misc::runtime_version` which is expensive).
+ * - 1 event.
+ * The weight of this function is dependent on the runtime, but generally this is very expensive.
+ * We will treat this as a full block.
+ * # </weight>
+ **/
+ setCode: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
+ /**
+ * Set the new runtime code without doing any checks of the given `code`.
+ *
+ * # <weight>
+ * - `O(C)` where `C` length of `code`
+ * - 1 storage write (codec `O(C)`).
+ * - 1 event.
+ * The weight of this function is dependent on the runtime. We will treat this as a full block.
+ * # </weight>
+ **/
+ setCodeWithoutChecks: AugmentedSubmittable<(code: Bytes | string | Uint8Array) => SubmittableExtrinsic<ApiType>, [Bytes]>;
+ /**
+ * Set the number of pages in the WebAssembly environment's heap.
+ *
+ * # <weight>
+ * - `O(1)`
+ * - 1 storage write.
+ * - Base Weight: 1.405 µs
+ * - 1 write to HEAP_PAGES
+ * # </weight>
+ **/
+ setHeapPages: AugmentedSubmittable<(pages: u64 | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [u64]>;
+ /**
+ * Set some items of storage.
+ *
+ * # <weight>
+ * - `O(I)` where `I` length of `items`
+ * - `I` storage writes (`O(1)`).
+ * - Base Weight: 0.568 * i µs
+ * - Writes: Number of items
+ * # </weight>
+ **/
+ setStorage: AugmentedSubmittable<(items: Vec<KeyValue> | (KeyValue)[]) => SubmittableExtrinsic<ApiType>, [Vec<KeyValue>]>;
+ };
+ timestamp: {
+ /**
+ * Set the current time.
+ *
+ * This call should be invoked exactly once per block. It will panic at the finalization
+ * phase, if this call hasn't been invoked by that time.
+ *
+ * The timestamp should be greater than the previous one by the amount specified by
+ * `MinimumPeriod`.
+ *
+ * The dispatch origin for this call must be `Inherent`.
+ *
+ * # <weight>
+ * - `O(1)` (Note that implementations of `OnTimestampSet` must also be `O(1)`)
+ * - 1 storage read and 1 storage mutation (codec `O(1)`). (because of `DidUpdate::take` in `on_finalize`)
+ * - 1 event handler `on_timestamp_set`. Must be `O(1)`.
+ * # </weight>
+ **/
+ set: AugmentedSubmittable<(now: Compact<Moment> | AnyNumber | Uint8Array) => SubmittableExtrinsic<ApiType>, [Compact<Moment>]>;
+ };
+ }
+
+ export interface SubmittableExtrinsics<ApiType extends ApiTypes> extends AugmentedSubmittables<ApiType> {
+ (extrinsic: Call | Extrinsic | Uint8Array | string): SubmittableExtrinsic<ApiType>;
+ }
+}
diff --git a/types-bundle/src/interfaces/augment-api.ts b/types-bundle/src/interfaces/augment-api.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c283f4fa448d31b8bed3dd34ad3dac1eccd61b40
--- /dev/null
+++ b/types-bundle/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';
diff --git a/types-bundle/src/interfaces/augment-types.ts b/types-bundle/src/interfaces/augment-types.ts
new file mode 100644
index 0000000000000000000000000000000000000000..837baee16f30590ad603143b6c9796e8e2ff2652
--- /dev/null
+++ b/types-bundle/src/interfaces/augment-types.ts
@@ -0,0 +1,2644 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { BitVec, Bool, Bytes, Compact, Data, I128, I16, I256, I32, I64, I8, Json, Null, Option, Raw, StorageKey, Text, Type, U128, U16, U256, U32, U64, U8, USize, Vec, 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 { BridgedBlockHash, BridgedBlockNumber, BridgedHeader, InitializationData } from '@polkadot/types/interfaces/bridges';
+import type { BlockHash } from '@polkadot/types/interfaces/chain';
+import type { PrefixedStorageKey } from '@polkadot/types/interfaces/childstate';
+import type { EthereumAddress, 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, ContractStorageKey, DeletedContract, ExecReturnValue, Gas, HostFnWeights, HostFnWeightsTo264, InstantiateRequest, InstantiateReturnValue, 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, ContractProject, ContractProjectContract, ContractProjectSource, 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 { EthAccount, 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, EthereumLookupSource, EthereumSignature } 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, 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, IdentityJudgement, RegistrarIndex, RegistrarInfo, Registration, RegistrationJudgement } 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, ErrorMetadataV9, EventMetadataLatest, EventMetadataV10, EventMetadataV11, EventMetadataV12, EventMetadataV13, EventMetadataV9, ExtrinsicMetadataLatest, ExtrinsicMetadataV11, ExtrinsicMetadataV12, ExtrinsicMetadataV13, ExtrinsicMetadataV14, FunctionArgumentMetadataLatest, FunctionArgumentMetadataV10, FunctionArgumentMetadataV11, FunctionArgumentMetadataV12, FunctionArgumentMetadataV13, FunctionArgumentMetadataV9, FunctionMetadataLatest, FunctionMetadataV10, FunctionMetadataV11, FunctionMetadataV12, FunctionMetadataV13, FunctionMetadataV9, MetadataAll, MetadataLatest, MetadataV10, MetadataV11, MetadataV12, MetadataV13, MetadataV14, MetadataV9, ModuleConstantMetadataLatest, ModuleConstantMetadataV10, ModuleConstantMetadataV11, ModuleConstantMetadataV12, ModuleConstantMetadataV13, ModuleConstantMetadataV9, ModuleMetadataLatest, ModuleMetadataV10, ModuleMetadataV11, ModuleMetadataV12, ModuleMetadataV13, ModuleMetadataV9, PalletCallMetadataLatest, PalletCallMetadataV14, PalletConstantMetadataLatest, PalletConstantMetadataV14, PalletErrorMetadataLatest, PalletErrorMetadataV14, PalletEventMetadataLatest, PalletEventMetadataV14, PalletMetadataLatest, PalletMetadataV14, PalletStorageMetadataLatest, PalletStorageMetadataV14, PortableRegistry, PortableType, 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, StorageMetadataLatest, 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, 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, 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 { Si0Field, Si0LookupTypeId, Si0Path, Si0Type, Si0TypeDef, Si0TypeDefArray, Si0TypeDefBitSequence, Si0TypeDefCompact, Si0TypeDefComposite, Si0TypeDefPhantom, Si0TypeDefPrimitive, Si0TypeDefSequence, Si0TypeDefTuple, Si0TypeDefVariant, Si0TypeParameter, Si0Variant, 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, 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, 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 { AccountId32Junction, AccountIndex64Junction, AccountKey20Junction, AssetInstance, BodyId, BodyPart, BodyPartAtLeastProportion, BodyPartFraction, BodyPartMoreThanProportion, DoubleEncodedCall, InboundStatus, Junction, MultiAsset, MultiAssetAbstractFungible, MultiAssetAbstractNonFungible, MultiAssetConcreteFungible, MultiAssetConcreteNonFungible, MultiLocation, NetworkId, OutboundStatus, Outcome, PluralityJunction, QueueConfigData, VersionedMultiAsset, VersionedMultiLocation, VersionedXcm, Xcm, XcmAssetEffects, XcmError, XcmHrmpChannelAccepted, XcmHrmpChannelClosing, XcmHrmpNewChannelOpenRequest, XcmOrder, XcmOrderBuyExecution, XcmOrderDepositAsset, XcmOrderDepositReserveAsset, XcmOrderExchangeAsset, XcmOrderInitiateReserveWithdraw, XcmOrderInitiateTeleport, XcmOrderQueryHolding, XcmOrigin, XcmOriginKind, XcmQueryResponse, XcmRelayedFrom, XcmReserveAssetDeposit, XcmResponse, XcmTeleportAsset, XcmTransact, XcmTransferAsset, XcmTransferReserveAsset, XcmWithdrawAsset, XcmpMessageFormat } from '@polkadot/types/interfaces/xcm';
+import type { Balance, CertValue, IdtyCertMeta, IdtyData, IdtyDid, IdtyIndex, IdtyRight, IdtyStatus, IdtyValue, Planet } from './runtime';
+
+declare module '@polkadot/types/types/registry' {
+ export interface InterfaceTypes {
+ 'Compact<ActiveIndex>': Compact<ActiveIndex>;
+ 'Compact<ApprovalFlag>': Compact<ApprovalFlag>;
+ 'Compact<AuctionIndex>': Compact<AuctionIndex>;
+ 'Compact<AuthIndex>': Compact<AuthIndex>;
+ 'Compact<AuthorityIndex>': Compact<AuthorityIndex>;
+ 'Compact<AuthorityWeight>': Compact<AuthorityWeight>;
+ 'Compact<BabeAuthorityWeight>': Compact<BabeAuthorityWeight>;
+ 'Compact<BabeBlockWeight>': Compact<BabeBlockWeight>;
+ 'Compact<BabeWeight>': Compact<BabeWeight>;
+ 'Compact<Balance>': Compact<Balance>;
+ 'Compact<BountyIndex>': Compact<BountyIndex>;
+ 'Compact<BridgedBlockNumber>': Compact<BridgedBlockNumber>;
+ 'Compact<ClassId>': Compact<ClassId>;
+ 'Compact<ContractDiscriminant>': Compact<ContractDiscriminant>;
+ 'Compact<CoreIndex>': Compact<CoreIndex>;
+ 'Compact<DepositBalance>': Compact<DepositBalance>;
+ 'Compact<DepositBalanceOf>': Compact<DepositBalanceOf>;
+ 'Compact<EraIndex>': Compact<EraIndex>;
+ 'Compact<EventIndex>': Compact<EventIndex>;
+ 'Compact<ExtendedBalance>': Compact<ExtendedBalance>;
+ 'Compact<FundIndex>': Compact<FundIndex>;
+ 'Compact<Gas>': Compact<Gas>;
+ 'Compact<GroupIndex>': Compact<GroupIndex>;
+ 'Compact<IdtyIndex>': Compact<IdtyIndex>;
+ 'Compact<InstanceId>': Compact<InstanceId>;
+ 'Compact<LeasePeriod>': Compact<LeasePeriod>;
+ 'Compact<LeasePeriodOf>': Compact<LeasePeriodOf>;
+ 'Compact<MemberCount>': Compact<MemberCount>;
+ 'Compact<MomentOf>': Compact<MomentOf>;
+ 'Compact<NominatorIndex>': Compact<NominatorIndex>;
+ 'Compact<OffchainAccuracy>': Compact<OffchainAccuracy>;
+ 'Compact<OverweightIndex>': Compact<OverweightIndex>;
+ 'Compact<PageCounter>': Compact<PageCounter>;
+ 'Compact<ParaId>': Compact<ParaId>;
+ 'Compact<ParaValidatorIndex>': Compact<ParaValidatorIndex>;
+ 'Compact<Points>': Compact<Points>;
+ 'Compact<Priority>': Compact<Priority>;
+ 'Compact<PropIndex>': Compact<PropIndex>;
+ 'Compact<ProposalIndex>': Compact<ProposalIndex>;
+ 'Compact<RefCount>': Compact<RefCount>;
+ 'Compact<RefCountTo259>': Compact<RefCountTo259>;
+ 'Compact<ReferendumIndex>': Compact<ReferendumIndex>;
+ 'Compact<RegistrarIndex>': Compact<RegistrarIndex>;
+ 'Compact<RelayBlockNumber>': Compact<RelayBlockNumber>;
+ 'Compact<RelayChainBlockNumber>': Compact<RelayChainBlockNumber>;
+ 'Compact<RewardPoint>': Compact<RewardPoint>;
+ 'Compact<SchedulePriority>': Compact<SchedulePriority>;
+ 'Compact<SessionIndex>': Compact<SessionIndex>;
+ 'Compact<SetId>': Compact<SetId>;
+ 'Compact<SetIndex>': Compact<SetIndex>;
+ 'Compact<Si0LookupTypeId>': Compact<Si0LookupTypeId>;
+ 'Compact<SlotNumber>': Compact<SlotNumber>;
+ 'Compact<SpanIndex>': Compact<SpanIndex>;
+ 'Compact<StrikeCount>': Compact<StrikeCount>;
+ 'Compact<SubId>': Compact<SubId>;
+ 'Compact<TAssetBalance>': Compact<TAssetBalance>;
+ 'Compact<TAssetDepositBalance>': Compact<TAssetDepositBalance>;
+ 'Compact<TrieIndex>': Compact<TrieIndex>;
+ 'Compact<u128>': Compact<u128>;
+ 'Compact<U128>': Compact<U128>;
+ 'Compact<u16>': Compact<u16>;
+ 'Compact<U16>': Compact<U16>;
+ 'Compact<u256>': Compact<u256>;
+ 'Compact<U256>': Compact<U256>;
+ 'Compact<u32>': Compact<u32>;
+ 'Compact<U32>': Compact<U32>;
+ 'Compact<u64>': Compact<u64>;
+ 'Compact<U64>': Compact<U64>;
+ 'Compact<u8>': Compact<u8>;
+ 'Compact<U8>': Compact<U8>;
+ 'Compact<usize>': Compact<usize>;
+ 'Compact<USize>': Compact<USize>;
+ 'Compact<ValidatorCount>': Compact<ValidatorCount>;
+ 'Compact<ValidatorIndex>': Compact<ValidatorIndex>;
+ 'Compact<ValidatorSetId>': Compact<ValidatorSetId>;
+ 'Compact<VoteIndex>': Compact<VoteIndex>;
+ 'Compact<VoteWeight>': Compact<VoteWeight>;
+ 'Option<AbridgedCandidateReceipt>': Option<AbridgedCandidateReceipt>;
+ 'Option<AbridgedHostConfiguration>': Option<AbridgedHostConfiguration>;
+ 'Option<AbridgedHrmpChannel>': Option<AbridgedHrmpChannel>;
+ 'Option<AccountData>': Option<AccountData>;
+ 'Option<AccountId32Junction>': Option<AccountId32Junction>;
+ 'Option<AccountIndex64Junction>': Option<AccountIndex64Junction>;
+ 'Option<AccountInfo>': Option<AccountInfo>;
+ 'Option<AccountInfoWithDualRefCount>': Option<AccountInfoWithDualRefCount>;
+ 'Option<AccountInfoWithProviders>': Option<AccountInfoWithProviders>;
+ 'Option<AccountInfoWithRefCount>': Option<AccountInfoWithRefCount>;
+ 'Option<AccountInfoWithRefCountU8>': Option<AccountInfoWithRefCountU8>;
+ 'Option<AccountInfoWithTripleRefCount>': Option<AccountInfoWithTripleRefCount>;
+ 'Option<AccountKey20Junction>': Option<AccountKey20Junction>;
+ 'Option<AccountStatus>': Option<AccountStatus>;
+ 'Option<AccountValidity>': Option<AccountValidity>;
+ 'Option<AccountVote>': Option<AccountVote>;
+ 'Option<AccountVoteSplit>': Option<AccountVoteSplit>;
+ 'Option<AccountVoteStandard>': Option<AccountVoteStandard>;
+ 'Option<ActiveEraInfo>': Option<ActiveEraInfo>;
+ 'Option<ActiveGilt>': Option<ActiveGilt>;
+ 'Option<ActiveGiltsTotal>': Option<ActiveGiltsTotal>;
+ 'Option<ActiveIndex>': Option<ActiveIndex>;
+ 'Option<ActiveRecovery>': Option<ActiveRecovery>;
+ 'Option<AliveContractInfo>': Option<AliveContractInfo>;
+ 'Option<AllowedSlots>': Option<AllowedSlots>;
+ 'Option<AnySignature>': Option<AnySignature>;
+ 'Option<ApiId>': Option<ApiId>;
+ 'Option<ApplyExtrinsicResult>': Option<ApplyExtrinsicResult>;
+ 'Option<ApprovalFlag>': Option<ApprovalFlag>;
+ 'Option<Approvals>': Option<Approvals>;
+ 'Option<ArithmeticError>': Option<ArithmeticError>;
+ 'Option<AssetApproval>': Option<AssetApproval>;
+ 'Option<AssetApprovalKey>': Option<AssetApprovalKey>;
+ 'Option<AssetBalance>': Option<AssetBalance>;
+ 'Option<AssetDestroyWitness>': Option<AssetDestroyWitness>;
+ 'Option<AssetDetails>': Option<AssetDetails>;
+ 'Option<AssetInstance>': Option<AssetInstance>;
+ 'Option<AssetMetadata>': Option<AssetMetadata>;
+ 'Option<AssetOptions>': Option<AssetOptions>;
+ 'Option<AssignmentId>': Option<AssignmentId>;
+ 'Option<AssignmentKind>': Option<AssignmentKind>;
+ 'Option<AttestedCandidate>': Option<AttestedCandidate>;
+ 'Option<AuctionIndex>': Option<AuctionIndex>;
+ 'Option<AuthIndex>': Option<AuthIndex>;
+ 'Option<AuthorityDiscoveryId>': Option<AuthorityDiscoveryId>;
+ 'Option<AuthorityId>': Option<AuthorityId>;
+ 'Option<AuthorityIndex>': Option<AuthorityIndex>;
+ 'Option<AuthorityList>': Option<AuthorityList>;
+ 'Option<AuthoritySet>': Option<AuthoritySet>;
+ 'Option<AuthoritySetChange>': Option<AuthoritySetChange>;
+ 'Option<AuthoritySetChanges>': Option<AuthoritySetChanges>;
+ 'Option<AuthoritySignature>': Option<AuthoritySignature>;
+ 'Option<AuthorityWeight>': Option<AuthorityWeight>;
+ 'Option<AvailabilityBitfield>': Option<AvailabilityBitfield>;
+ 'Option<AvailabilityBitfieldRecord>': Option<AvailabilityBitfieldRecord>;
+ 'Option<BabeAuthorityWeight>': Option<BabeAuthorityWeight>;
+ 'Option<BabeBlockWeight>': Option<BabeBlockWeight>;
+ 'Option<BabeEpochConfiguration>': Option<BabeEpochConfiguration>;
+ 'Option<BabeEquivocationProof>': Option<BabeEquivocationProof>;
+ 'Option<BabeWeight>': Option<BabeWeight>;
+ 'Option<BackedCandidate>': Option<BackedCandidate>;
+ 'Option<Balance>': Option<Balance>;
+ 'Option<BalanceLock>': Option<BalanceLock>;
+ 'Option<BalanceLockTo212>': Option<BalanceLockTo212>;
+ 'Option<BalanceStatus>': Option<BalanceStatus>;
+ 'Option<BeefyCommitment>': Option<BeefyCommitment>;
+ 'Option<BeefyId>': Option<BeefyId>;
+ 'Option<BeefyKey>': Option<BeefyKey>;
+ 'Option<BeefyNextAuthoritySet>': Option<BeefyNextAuthoritySet>;
+ 'Option<BeefyPayload>': Option<BeefyPayload>;
+ 'Option<BeefySignedCommitment>': Option<BeefySignedCommitment>;
+ 'Option<Bid>': Option<Bid>;
+ 'Option<Bidder>': Option<Bidder>;
+ 'Option<BidKind>': Option<BidKind>;
+ 'Option<BitVec>': Option<BitVec>;
+ 'Option<BlockAttestations>': Option<BlockAttestations>;
+ 'Option<BlockHash>': Option<BlockHash>;
+ 'Option<BlockLength>': Option<BlockLength>;
+ 'Option<BlockTrace>': Option<BlockTrace>;
+ 'Option<BlockTraceEvent>': Option<BlockTraceEvent>;
+ 'Option<BlockTraceEventData>': Option<BlockTraceEventData>;
+ 'Option<BlockTraceSpan>': Option<BlockTraceSpan>;
+ 'Option<BlockWeights>': Option<BlockWeights>;
+ 'Option<BodyId>': Option<BodyId>;
+ 'Option<BodyPart>': Option<BodyPart>;
+ 'Option<BodyPartAtLeastProportion>': Option<BodyPartAtLeastProportion>;
+ 'Option<BodyPartFraction>': Option<BodyPartFraction>;
+ 'Option<BodyPartMoreThanProportion>': Option<BodyPartMoreThanProportion>;
+ 'Option<bool>': Option<bool>;
+ 'Option<Bool>': Option<Bool>;
+ 'Option<Bounty>': Option<Bounty>;
+ 'Option<BountyIndex>': Option<BountyIndex>;
+ 'Option<BountyStatus>': Option<BountyStatus>;
+ 'Option<BountyStatusActive>': Option<BountyStatusActive>;
+ 'Option<BountyStatusCuratorProposed>': Option<BountyStatusCuratorProposed>;
+ 'Option<BountyStatusPendingPayout>': Option<BountyStatusPendingPayout>;
+ 'Option<BridgedBlockHash>': Option<BridgedBlockHash>;
+ 'Option<BridgedBlockNumber>': Option<BridgedBlockNumber>;
+ 'Option<BridgedHeader>': Option<BridgedHeader>;
+ 'Option<BufferedSessionChange>': Option<BufferedSessionChange>;
+ 'Option<Bytes>': Option<Bytes>;
+ 'Option<CallIndex>': Option<CallIndex>;
+ 'Option<CandidateCommitments>': Option<CandidateCommitments>;
+ 'Option<CandidateDescriptor>': Option<CandidateDescriptor>;
+ 'Option<CandidateHash>': Option<CandidateHash>;
+ 'Option<CandidateInfo>': Option<CandidateInfo>;
+ 'Option<CandidatePendingAvailability>': Option<CandidatePendingAvailability>;
+ 'Option<CandidateReceipt>': Option<CandidateReceipt>;
+ 'Option<CertValue>': Option<CertValue>;
+ 'Option<ChainProperties>': Option<ChainProperties>;
+ 'Option<ChainType>': Option<ChainType>;
+ 'Option<ClassDetails>': Option<ClassDetails>;
+ 'Option<ClassId>': Option<ClassId>;
+ 'Option<ClassMetadata>': Option<ClassMetadata>;
+ 'Option<CodeHash>': Option<CodeHash>;
+ 'Option<CollatorId>': Option<CollatorId>;
+ 'Option<CollatorSignature>': Option<CollatorSignature>;
+ 'Option<CollectiveOrigin>': Option<CollectiveOrigin>;
+ 'Option<CommittedCandidateReceipt>': Option<CommittedCandidateReceipt>;
+ 'Option<CompactAssignments>': Option<CompactAssignments>;
+ 'Option<CompactAssignmentsTo257>': Option<CompactAssignmentsTo257>;
+ 'Option<CompactAssignmentsTo265>': Option<CompactAssignmentsTo265>;
+ 'Option<CompactAssignmentsWith16>': Option<CompactAssignmentsWith16>;
+ 'Option<CompactAssignmentsWith24>': Option<CompactAssignmentsWith24>;
+ 'Option<CompactScore>': Option<CompactScore>;
+ 'Option<CompactScoreCompact>': Option<CompactScoreCompact>;
+ 'Option<ConfigData>': Option<ConfigData>;
+ 'Option<ConsumedWeight>': Option<ConsumedWeight>;
+ 'Option<ContractCallRequest>': Option<ContractCallRequest>;
+ 'Option<ContractConstructorSpec>': Option<ContractConstructorSpec>;
+ 'Option<ContractContractSpec>': Option<ContractContractSpec>;
+ 'Option<ContractCryptoHasher>': Option<ContractCryptoHasher>;
+ 'Option<ContractDiscriminant>': Option<ContractDiscriminant>;
+ 'Option<ContractDisplayName>': Option<ContractDisplayName>;
+ 'Option<ContractEventParamSpec>': Option<ContractEventParamSpec>;
+ 'Option<ContractEventSpec>': Option<ContractEventSpec>;
+ 'Option<ContractExecResult>': Option<ContractExecResult>;
+ 'Option<ContractExecResultErr>': Option<ContractExecResultErr>;
+ 'Option<ContractExecResultErrModule>': Option<ContractExecResultErrModule>;
+ 'Option<ContractExecResultOk>': Option<ContractExecResultOk>;
+ 'Option<ContractExecResultResult>': Option<ContractExecResultResult>;
+ 'Option<ContractExecResultSuccessTo255>': Option<ContractExecResultSuccessTo255>;
+ 'Option<ContractExecResultSuccessTo260>': Option<ContractExecResultSuccessTo260>;
+ 'Option<ContractExecResultTo255>': Option<ContractExecResultTo255>;
+ 'Option<ContractExecResultTo260>': Option<ContractExecResultTo260>;
+ 'Option<ContractExecResultTo267>': Option<ContractExecResultTo267>;
+ 'Option<ContractInfo>': Option<ContractInfo>;
+ 'Option<ContractInstantiateResult>': Option<ContractInstantiateResult>;
+ 'Option<ContractLayoutArray>': Option<ContractLayoutArray>;
+ 'Option<ContractLayoutCell>': Option<ContractLayoutCell>;
+ 'Option<ContractLayoutEnum>': Option<ContractLayoutEnum>;
+ 'Option<ContractLayoutHash>': Option<ContractLayoutHash>;
+ 'Option<ContractLayoutHashingStrategy>': Option<ContractLayoutHashingStrategy>;
+ 'Option<ContractLayoutKey>': Option<ContractLayoutKey>;
+ 'Option<ContractLayoutStruct>': Option<ContractLayoutStruct>;
+ 'Option<ContractLayoutStructField>': Option<ContractLayoutStructField>;
+ 'Option<ContractMessageParamSpec>': Option<ContractMessageParamSpec>;
+ 'Option<ContractMessageSpec>': Option<ContractMessageSpec>;
+ 'Option<ContractProject>': Option<ContractProject>;
+ 'Option<ContractProjectContract>': Option<ContractProjectContract>;
+ 'Option<ContractProjectSource>': Option<ContractProjectSource>;
+ 'Option<ContractSelector>': Option<ContractSelector>;
+ 'Option<ContractStorageKey>': Option<ContractStorageKey>;
+ 'Option<ContractStorageLayout>': Option<ContractStorageLayout>;
+ 'Option<ContractTypeSpec>': Option<ContractTypeSpec>;
+ 'Option<Conviction>': Option<Conviction>;
+ 'Option<CoreAssignment>': Option<CoreAssignment>;
+ 'Option<CoreIndex>': Option<CoreIndex>;
+ 'Option<CoreOccupied>': Option<CoreOccupied>;
+ 'Option<CreatedBlock>': Option<CreatedBlock>;
+ 'Option<Data>': Option<Data>;
+ 'Option<DeferredOffenceOf>': Option<DeferredOffenceOf>;
+ 'Option<DefunctVoter>': Option<DefunctVoter>;
+ 'Option<DelayKind>': Option<DelayKind>;
+ 'Option<DelayKindBest>': Option<DelayKindBest>;
+ 'Option<Delegations>': Option<Delegations>;
+ 'Option<DeletedContract>': Option<DeletedContract>;
+ 'Option<DepositBalance>': Option<DepositBalance>;
+ 'Option<DepositBalanceOf>': Option<DepositBalanceOf>;
+ 'Option<DestroyWitness>': Option<DestroyWitness>;
+ 'Option<DigestOf>': Option<DigestOf>;
+ 'Option<DispatchClass>': Option<DispatchClass>;
+ 'Option<DispatchError>': Option<DispatchError>;
+ 'Option<DispatchErrorModule>': Option<DispatchErrorModule>;
+ 'Option<DispatchErrorTo198>': Option<DispatchErrorTo198>;
+ 'Option<DispatchInfo>': Option<DispatchInfo>;
+ 'Option<DispatchInfoTo190>': Option<DispatchInfoTo190>;
+ 'Option<DispatchInfoTo244>': Option<DispatchInfoTo244>;
+ 'Option<DispatchOutcome>': Option<DispatchOutcome>;
+ 'Option<DispatchResult>': Option<DispatchResult>;
+ 'Option<DispatchResultOf>': Option<DispatchResultOf>;
+ 'Option<DispatchResultTo198>': Option<DispatchResultTo198>;
+ 'Option<DisputeStatement>': Option<DisputeStatement>;
+ 'Option<DisputeStatementSet>': Option<DisputeStatementSet>;
+ 'Option<DoubleEncodedCall>': Option<DoubleEncodedCall>;
+ 'Option<DoubleVoteReport>': Option<DoubleVoteReport>;
+ 'Option<DownwardMessage>': Option<DownwardMessage>;
+ 'Option<EcdsaSignature>': Option<EcdsaSignature>;
+ 'Option<Ed25519Signature>': Option<Ed25519Signature>;
+ 'Option<ElectionCompute>': Option<ElectionCompute>;
+ 'Option<ElectionPhase>': Option<ElectionPhase>;
+ 'Option<ElectionResult>': Option<ElectionResult>;
+ 'Option<ElectionScore>': Option<ElectionScore>;
+ 'Option<ElectionSize>': Option<ElectionSize>;
+ 'Option<ElectionStatus>': Option<ElectionStatus>;
+ 'Option<EncodedFinalityProofs>': Option<EncodedFinalityProofs>;
+ 'Option<EpochAuthorship>': Option<EpochAuthorship>;
+ 'Option<EraIndex>': Option<EraIndex>;
+ 'Option<EraPoints>': Option<EraPoints>;
+ 'Option<EraRewardPoints>': Option<EraRewardPoints>;
+ 'Option<EraRewards>': Option<EraRewards>;
+ 'Option<ErrorMetadataLatest>': Option<ErrorMetadataLatest>;
+ 'Option<ErrorMetadataV10>': Option<ErrorMetadataV10>;
+ 'Option<ErrorMetadataV11>': Option<ErrorMetadataV11>;
+ 'Option<ErrorMetadataV12>': Option<ErrorMetadataV12>;
+ 'Option<ErrorMetadataV13>': Option<ErrorMetadataV13>;
+ 'Option<ErrorMetadataV9>': Option<ErrorMetadataV9>;
+ 'Option<EthAccount>': Option<EthAccount>;
+ 'Option<EthBlock>': Option<EthBlock>;
+ 'Option<EthBloom>': Option<EthBloom>;
+ 'Option<EthCallRequest>': Option<EthCallRequest>;
+ 'Option<EthereumAccountId>': Option<EthereumAccountId>;
+ 'Option<EthereumAddress>': Option<EthereumAddress>;
+ 'Option<EthereumLookupSource>': Option<EthereumLookupSource>;
+ 'Option<EthereumSignature>': Option<EthereumSignature>;
+ 'Option<EthFilter>': Option<EthFilter>;
+ 'Option<EthFilterAddress>': Option<EthFilterAddress>;
+ 'Option<EthFilterChanges>': Option<EthFilterChanges>;
+ 'Option<EthFilterTopic>': Option<EthFilterTopic>;
+ 'Option<EthFilterTopicEntry>': Option<EthFilterTopicEntry>;
+ 'Option<EthFilterTopicInner>': Option<EthFilterTopicInner>;
+ 'Option<EthHeader>': Option<EthHeader>;
+ 'Option<EthLog>': Option<EthLog>;
+ 'Option<EthReceipt>': Option<EthReceipt>;
+ 'Option<EthRichBlock>': Option<EthRichBlock>;
+ 'Option<EthRichHeader>': Option<EthRichHeader>;
+ 'Option<EthStorageProof>': Option<EthStorageProof>;
+ 'Option<EthSubKind>': Option<EthSubKind>;
+ 'Option<EthSubParams>': Option<EthSubParams>;
+ 'Option<EthSubResult>': Option<EthSubResult>;
+ 'Option<EthSyncInfo>': Option<EthSyncInfo>;
+ 'Option<EthSyncStatus>': Option<EthSyncStatus>;
+ 'Option<EthTransaction>': Option<EthTransaction>;
+ 'Option<EthTransactionAction>': Option<EthTransactionAction>;
+ 'Option<EthTransactionCondition>': Option<EthTransactionCondition>;
+ 'Option<EthTransactionRequest>': Option<EthTransactionRequest>;
+ 'Option<EthTransactionSignature>': Option<EthTransactionSignature>;
+ 'Option<EthTransactionStatus>': Option<EthTransactionStatus>;
+ 'Option<EthWork>': Option<EthWork>;
+ 'Option<Event>': Option<Event>;
+ 'Option<EventId>': Option<EventId>;
+ 'Option<EventIndex>': Option<EventIndex>;
+ 'Option<EventMetadataLatest>': Option<EventMetadataLatest>;
+ 'Option<EventMetadataV10>': Option<EventMetadataV10>;
+ 'Option<EventMetadataV11>': Option<EventMetadataV11>;
+ 'Option<EventMetadataV12>': Option<EventMetadataV12>;
+ 'Option<EventMetadataV13>': Option<EventMetadataV13>;
+ 'Option<EventMetadataV9>': Option<EventMetadataV9>;
+ 'Option<EventRecord>': Option<EventRecord>;
+ 'Option<EvmAccount>': Option<EvmAccount>;
+ 'Option<EvmLog>': Option<EvmLog>;
+ 'Option<EvmVicinity>': Option<EvmVicinity>;
+ 'Option<ExecReturnValue>': Option<ExecReturnValue>;
+ 'Option<ExitError>': Option<ExitError>;
+ 'Option<ExitFatal>': Option<ExitFatal>;
+ 'Option<ExitReason>': Option<ExitReason>;
+ 'Option<ExitRevert>': Option<ExitRevert>;
+ 'Option<ExitSucceed>': Option<ExitSucceed>;
+ 'Option<ExplicitDisputeStatement>': Option<ExplicitDisputeStatement>;
+ 'Option<Exposure>': Option<Exposure>;
+ 'Option<ExtendedBalance>': Option<ExtendedBalance>;
+ 'Option<Extrinsic>': Option<Extrinsic>;
+ 'Option<ExtrinsicEra>': Option<ExtrinsicEra>;
+ 'Option<ExtrinsicMetadataLatest>': Option<ExtrinsicMetadataLatest>;
+ 'Option<ExtrinsicMetadataV11>': Option<ExtrinsicMetadataV11>;
+ 'Option<ExtrinsicMetadataV12>': Option<ExtrinsicMetadataV12>;
+ 'Option<ExtrinsicMetadataV13>': Option<ExtrinsicMetadataV13>;
+ 'Option<ExtrinsicMetadataV14>': Option<ExtrinsicMetadataV14>;
+ 'Option<ExtrinsicOrHash>': Option<ExtrinsicOrHash>;
+ 'Option<ExtrinsicPayload>': Option<ExtrinsicPayload>;
+ 'Option<ExtrinsicPayloadUnknown>': Option<ExtrinsicPayloadUnknown>;
+ 'Option<ExtrinsicPayloadV4>': Option<ExtrinsicPayloadV4>;
+ 'Option<ExtrinsicSignature>': Option<ExtrinsicSignature>;
+ 'Option<ExtrinsicSignatureV4>': Option<ExtrinsicSignatureV4>;
+ 'Option<ExtrinsicStatus>': Option<ExtrinsicStatus>;
+ 'Option<ExtrinsicUnknown>': Option<ExtrinsicUnknown>;
+ 'Option<ExtrinsicV4>': Option<ExtrinsicV4>;
+ 'Option<FeeDetails>': Option<FeeDetails>;
+ 'Option<Forcing>': Option<Forcing>;
+ 'Option<ForkTreePendingChange>': Option<ForkTreePendingChange>;
+ 'Option<ForkTreePendingChangeNode>': Option<ForkTreePendingChangeNode>;
+ 'Option<FullIdentification>': Option<FullIdentification>;
+ 'Option<FunctionArgumentMetadataLatest>': Option<FunctionArgumentMetadataLatest>;
+ 'Option<FunctionArgumentMetadataV10>': Option<FunctionArgumentMetadataV10>;
+ 'Option<FunctionArgumentMetadataV11>': Option<FunctionArgumentMetadataV11>;
+ 'Option<FunctionArgumentMetadataV12>': Option<FunctionArgumentMetadataV12>;
+ 'Option<FunctionArgumentMetadataV13>': Option<FunctionArgumentMetadataV13>;
+ 'Option<FunctionArgumentMetadataV9>': Option<FunctionArgumentMetadataV9>;
+ 'Option<FunctionMetadataLatest>': Option<FunctionMetadataLatest>;
+ 'Option<FunctionMetadataV10>': Option<FunctionMetadataV10>;
+ 'Option<FunctionMetadataV11>': Option<FunctionMetadataV11>;
+ 'Option<FunctionMetadataV12>': Option<FunctionMetadataV12>;
+ 'Option<FunctionMetadataV13>': Option<FunctionMetadataV13>;
+ 'Option<FunctionMetadataV9>': Option<FunctionMetadataV9>;
+ 'Option<FundIndex>': Option<FundIndex>;
+ 'Option<FundInfo>': Option<FundInfo>;
+ 'Option<Gas>': Option<Gas>;
+ 'Option<GiltBid>': Option<GiltBid>;
+ 'Option<GlobalValidationData>': Option<GlobalValidationData>;
+ 'Option<GlobalValidationSchedule>': Option<GlobalValidationSchedule>;
+ 'Option<GrandpaCommit>': Option<GrandpaCommit>;
+ 'Option<GrandpaEquivocation>': Option<GrandpaEquivocation>;
+ 'Option<GrandpaEquivocationProof>': Option<GrandpaEquivocationProof>;
+ 'Option<GrandpaEquivocationValue>': Option<GrandpaEquivocationValue>;
+ 'Option<GrandpaJustification>': Option<GrandpaJustification>;
+ 'Option<GrandpaPrecommit>': Option<GrandpaPrecommit>;
+ 'Option<GrandpaPrevote>': Option<GrandpaPrevote>;
+ 'Option<GrandpaSignedPrecommit>': Option<GrandpaSignedPrecommit>;
+ 'Option<GroupIndex>': Option<GroupIndex>;
+ 'Option<HeadData>': Option<HeadData>;
+ 'Option<Health>': Option<Health>;
+ 'Option<Heartbeat>': Option<Heartbeat>;
+ 'Option<HeartbeatTo244>': Option<HeartbeatTo244>;
+ 'Option<HostConfiguration>': Option<HostConfiguration>;
+ 'Option<HostFnWeights>': Option<HostFnWeights>;
+ 'Option<HostFnWeightsTo264>': Option<HostFnWeightsTo264>;
+ 'Option<HrmpChannel>': Option<HrmpChannel>;
+ 'Option<HrmpChannelId>': Option<HrmpChannelId>;
+ 'Option<HrmpOpenChannelRequest>': Option<HrmpOpenChannelRequest>;
+ 'Option<i128>': Option<i128>;
+ 'Option<I128>': Option<I128>;
+ 'Option<i16>': Option<i16>;
+ 'Option<I16>': Option<I16>;
+ 'Option<i256>': Option<i256>;
+ 'Option<I256>': Option<I256>;
+ 'Option<i32>': Option<i32>;
+ 'Option<I32>': Option<I32>;
+ 'Option<i64>': Option<i64>;
+ 'Option<I64>': Option<I64>;
+ 'Option<i8>': Option<i8>;
+ 'Option<I8>': Option<I8>;
+ 'Option<IdentificationTuple>': Option<IdentificationTuple>;
+ 'Option<IdentityFields>': Option<IdentityFields>;
+ 'Option<IdentityInfo>': Option<IdentityInfo>;
+ 'Option<IdentityInfoAdditional>': Option<IdentityInfoAdditional>;
+ 'Option<IdentityJudgement>': Option<IdentityJudgement>;
+ 'Option<IdtyCertMeta>': Option<IdtyCertMeta>;
+ 'Option<IdtyData>': Option<IdtyData>;
+ 'Option<IdtyDid>': Option<IdtyDid>;
+ 'Option<IdtyIndex>': Option<IdtyIndex>;
+ 'Option<IdtyRight>': Option<IdtyRight>;
+ 'Option<IdtyStatus>': Option<IdtyStatus>;
+ 'Option<IdtyValue>': Option<IdtyValue>;
+ 'Option<ImmortalEra>': Option<ImmortalEra>;
+ 'Option<ImportedAux>': Option<ImportedAux>;
+ 'Option<InboundDownwardMessage>': Option<InboundDownwardMessage>;
+ 'Option<InboundHrmpMessage>': Option<InboundHrmpMessage>;
+ 'Option<InboundHrmpMessages>': Option<InboundHrmpMessages>;
+ 'Option<InboundStatus>': Option<InboundStatus>;
+ 'Option<IncludedBlocks>': Option<IncludedBlocks>;
+ 'Option<InclusionFee>': Option<InclusionFee>;
+ 'Option<IncomingParachain>': Option<IncomingParachain>;
+ 'Option<IncomingParachainDeploy>': Option<IncomingParachainDeploy>;
+ 'Option<IncomingParachainFixed>': Option<IncomingParachainFixed>;
+ 'Option<IndividualExposure>': Option<IndividualExposure>;
+ 'Option<InitializationData>': Option<InitializationData>;
+ 'Option<InstanceDetails>': Option<InstanceDetails>;
+ 'Option<InstanceId>': Option<InstanceId>;
+ 'Option<InstanceMetadata>': Option<InstanceMetadata>;
+ 'Option<InstantiateRequest>': Option<InstantiateRequest>;
+ 'Option<InstantiateReturnValue>': Option<InstantiateReturnValue>;
+ 'Option<InstructionWeights>': Option<InstructionWeights>;
+ 'Option<InvalidDisputeStatementKind>': Option<InvalidDisputeStatementKind>;
+ 'Option<InvalidTransaction>': Option<InvalidTransaction>;
+ 'Option<Json>': Option<Json>;
+ 'Option<Junction>': Option<Junction>;
+ 'Option<JustificationNotification>': Option<JustificationNotification>;
+ 'Option<Key>': Option<Key>;
+ 'Option<KeyOwnerProof>': Option<KeyOwnerProof>;
+ 'Option<Keys>': Option<Keys>;
+ 'Option<KeyType>': Option<KeyType>;
+ 'Option<KeyValueOption>': Option<KeyValueOption>;
+ 'Option<Kind>': Option<Kind>;
+ 'Option<LastContribution>': Option<LastContribution>;
+ 'Option<LastRuntimeUpgradeInfo>': Option<LastRuntimeUpgradeInfo>;
+ 'Option<LeasePeriod>': Option<LeasePeriod>;
+ 'Option<LeasePeriodOf>': Option<LeasePeriodOf>;
+ 'Option<Limits>': Option<Limits>;
+ 'Option<LimitsTo264>': Option<LimitsTo264>;
+ 'Option<LocalValidationData>': Option<LocalValidationData>;
+ 'Option<LotteryConfig>': Option<LotteryConfig>;
+ 'Option<MaybeRandomness>': Option<MaybeRandomness>;
+ 'Option<MaybeVrf>': Option<MaybeVrf>;
+ 'Option<MemberCount>': Option<MemberCount>;
+ 'Option<MembershipProof>': Option<MembershipProof>;
+ 'Option<MessageId>': Option<MessageId>;
+ 'Option<MessageIngestionType>': Option<MessageIngestionType>;
+ 'Option<MessageQueueChain>': Option<MessageQueueChain>;
+ 'Option<MessagingStateSnapshot>': Option<MessagingStateSnapshot>;
+ 'Option<MessagingStateSnapshotEgressEntry>': Option<MessagingStateSnapshotEgressEntry>;
+ 'Option<MetadataAll>': Option<MetadataAll>;
+ 'Option<MetadataLatest>': Option<MetadataLatest>;
+ 'Option<MetadataV10>': Option<MetadataV10>;
+ 'Option<MetadataV11>': Option<MetadataV11>;
+ 'Option<MetadataV12>': Option<MetadataV12>;
+ 'Option<MetadataV13>': Option<MetadataV13>;
+ 'Option<MetadataV14>': Option<MetadataV14>;
+ 'Option<MetadataV9>': Option<MetadataV9>;
+ 'Option<MmrLeafProof>': Option<MmrLeafProof>;
+ 'Option<MmrRootHash>': Option<MmrRootHash>;
+ 'Option<ModuleConstantMetadataLatest>': Option<ModuleConstantMetadataLatest>;
+ 'Option<ModuleConstantMetadataV10>': Option<ModuleConstantMetadataV10>;
+ 'Option<ModuleConstantMetadataV11>': Option<ModuleConstantMetadataV11>;
+ 'Option<ModuleConstantMetadataV12>': Option<ModuleConstantMetadataV12>;
+ 'Option<ModuleConstantMetadataV13>': Option<ModuleConstantMetadataV13>;
+ 'Option<ModuleConstantMetadataV9>': Option<ModuleConstantMetadataV9>;
+ 'Option<ModuleMetadataLatest>': Option<ModuleMetadataLatest>;
+ 'Option<ModuleMetadataV10>': Option<ModuleMetadataV10>;
+ 'Option<ModuleMetadataV11>': Option<ModuleMetadataV11>;
+ 'Option<ModuleMetadataV12>': Option<ModuleMetadataV12>;
+ 'Option<ModuleMetadataV13>': Option<ModuleMetadataV13>;
+ 'Option<ModuleMetadataV9>': Option<ModuleMetadataV9>;
+ 'Option<MomentOf>': Option<MomentOf>;
+ 'Option<MoreAttestations>': Option<MoreAttestations>;
+ 'Option<MortalEra>': Option<MortalEra>;
+ 'Option<MultiAsset>': Option<MultiAsset>;
+ 'Option<MultiAssetAbstractFungible>': Option<MultiAssetAbstractFungible>;
+ 'Option<MultiAssetAbstractNonFungible>': Option<MultiAssetAbstractNonFungible>;
+ 'Option<MultiAssetConcreteFungible>': Option<MultiAssetConcreteFungible>;
+ 'Option<MultiAssetConcreteNonFungible>': Option<MultiAssetConcreteNonFungible>;
+ 'Option<MultiDisputeStatementSet>': Option<MultiDisputeStatementSet>;
+ 'Option<MultiLocation>': Option<MultiLocation>;
+ 'Option<Multiplier>': Option<Multiplier>;
+ 'Option<Multisig>': Option<Multisig>;
+ 'Option<MultiSignature>': Option<MultiSignature>;
+ 'Option<NetworkId>': Option<NetworkId>;
+ 'Option<NetworkState>': Option<NetworkState>;
+ 'Option<NetworkStatePeerset>': Option<NetworkStatePeerset>;
+ 'Option<NetworkStatePeersetInfo>': Option<NetworkStatePeersetInfo>;
+ 'Option<NewBidder>': Option<NewBidder>;
+ 'Option<NextAuthority>': Option<NextAuthority>;
+ 'Option<NextConfigDescriptor>': Option<NextConfigDescriptor>;
+ 'Option<NextConfigDescriptorV1>': Option<NextConfigDescriptorV1>;
+ 'Option<NodeRole>': Option<NodeRole>;
+ 'Option<Nominations>': Option<Nominations>;
+ 'Option<NominatorIndex>': Option<NominatorIndex>;
+ 'Option<NominatorIndexCompact>': Option<NominatorIndexCompact>;
+ 'Option<NotConnectedPeer>': Option<NotConnectedPeer>;
+ 'Option<Null>': Option<Null>;
+ 'Option<OffchainAccuracy>': Option<OffchainAccuracy>;
+ 'Option<OffchainAccuracyCompact>': Option<OffchainAccuracyCompact>;
+ 'Option<OffenceDetails>': Option<OffenceDetails>;
+ 'Option<Offender>': Option<Offender>;
+ 'Option<OpaqueMultiaddr>': Option<OpaqueMultiaddr>;
+ 'Option<OpaqueNetworkState>': Option<OpaqueNetworkState>;
+ 'Option<OpaquePeerId>': Option<OpaquePeerId>;
+ 'Option<OpaqueTimeSlot>': Option<OpaqueTimeSlot>;
+ 'Option<OpenTip>': Option<OpenTip>;
+ 'Option<OpenTipFinderTo225>': Option<OpenTipFinderTo225>;
+ 'Option<OpenTipTip>': Option<OpenTipTip>;
+ 'Option<OpenTipTo225>': Option<OpenTipTo225>;
+ 'Option<OutboundHrmpMessage>': Option<OutboundHrmpMessage>;
+ 'Option<OutboundStatus>': Option<OutboundStatus>;
+ 'Option<Outcome>': Option<Outcome>;
+ 'Option<OverweightIndex>': Option<OverweightIndex>;
+ 'Option<Owner>': Option<Owner>;
+ 'Option<PageCounter>': Option<PageCounter>;
+ 'Option<PageIndexData>': Option<PageIndexData>;
+ 'Option<PalletCallMetadataLatest>': Option<PalletCallMetadataLatest>;
+ 'Option<PalletCallMetadataV14>': Option<PalletCallMetadataV14>;
+ 'Option<PalletConstantMetadataLatest>': Option<PalletConstantMetadataLatest>;
+ 'Option<PalletConstantMetadataV14>': Option<PalletConstantMetadataV14>;
+ 'Option<PalletErrorMetadataLatest>': Option<PalletErrorMetadataLatest>;
+ 'Option<PalletErrorMetadataV14>': Option<PalletErrorMetadataV14>;
+ 'Option<PalletEventMetadataLatest>': Option<PalletEventMetadataLatest>;
+ 'Option<PalletEventMetadataV14>': Option<PalletEventMetadataV14>;
+ 'Option<PalletMetadataLatest>': Option<PalletMetadataLatest>;
+ 'Option<PalletMetadataV14>': Option<PalletMetadataV14>;
+ 'Option<PalletStorageMetadataLatest>': Option<PalletStorageMetadataLatest>;
+ 'Option<PalletStorageMetadataV14>': Option<PalletStorageMetadataV14>;
+ 'Option<ParachainDispatchOrigin>': Option<ParachainDispatchOrigin>;
+ 'Option<ParachainInherentData>': Option<ParachainInherentData>;
+ 'Option<ParachainProposal>': Option<ParachainProposal>;
+ 'Option<ParachainsInherentData>': Option<ParachainsInherentData>;
+ 'Option<ParaGenesisArgs>': Option<ParaGenesisArgs>;
+ 'Option<ParaId>': Option<ParaId>;
+ 'Option<ParaInfo>': Option<ParaInfo>;
+ 'Option<ParaLifecycle>': Option<ParaLifecycle>;
+ 'Option<ParaPastCodeMeta>': Option<ParaPastCodeMeta>;
+ 'Option<ParaScheduling>': Option<ParaScheduling>;
+ 'Option<ParathreadClaim>': Option<ParathreadClaim>;
+ 'Option<ParathreadClaimQueue>': Option<ParathreadClaimQueue>;
+ 'Option<ParathreadEntry>': Option<ParathreadEntry>;
+ 'Option<ParaValidatorIndex>': Option<ParaValidatorIndex>;
+ 'Option<Peer>': Option<Peer>;
+ 'Option<PeerEndpoint>': Option<PeerEndpoint>;
+ 'Option<PeerEndpointAddr>': Option<PeerEndpointAddr>;
+ 'Option<PeerInfo>': Option<PeerInfo>;
+ 'Option<PeerPing>': Option<PeerPing>;
+ 'Option<PendingChange>': Option<PendingChange>;
+ 'Option<PendingPause>': Option<PendingPause>;
+ 'Option<PendingResume>': Option<PendingResume>;
+ 'Option<PerDispatchClassU32>': Option<PerDispatchClassU32>;
+ 'Option<PerDispatchClassWeight>': Option<PerDispatchClassWeight>;
+ 'Option<PerDispatchClassWeightsPerClass>': Option<PerDispatchClassWeightsPerClass>;
+ 'Option<Period>': Option<Period>;
+ 'Option<PermissionLatest>': Option<PermissionLatest>;
+ 'Option<PermissionsV1>': Option<PermissionsV1>;
+ 'Option<PermissionVersions>': Option<PermissionVersions>;
+ 'Option<PersistedValidationData>': Option<PersistedValidationData>;
+ 'Option<Phase>': Option<Phase>;
+ 'Option<PhragmenScore>': Option<PhragmenScore>;
+ 'Option<Planet>': Option<Planet>;
+ 'Option<PluralityJunction>': Option<PluralityJunction>;
+ 'Option<Points>': Option<Points>;
+ 'Option<PortableRegistry>': Option<PortableRegistry>;
+ 'Option<PortableType>': Option<PortableType>;
+ 'Option<Precommits>': Option<Precommits>;
+ 'Option<PrefabWasmModule>': Option<PrefabWasmModule>;
+ 'Option<PrefixedStorageKey>': Option<PrefixedStorageKey>;
+ 'Option<PreimageStatus>': Option<PreimageStatus>;
+ 'Option<PreimageStatusAvailable>': Option<PreimageStatusAvailable>;
+ 'Option<Prevotes>': Option<Prevotes>;
+ 'Option<Priority>': Option<Priority>;
+ 'Option<PriorLock>': Option<PriorLock>;
+ 'Option<PropIndex>': Option<PropIndex>;
+ 'Option<Proposal>': Option<Proposal>;
+ 'Option<ProposalIndex>': Option<ProposalIndex>;
+ 'Option<ProxyAnnouncement>': Option<ProxyAnnouncement>;
+ 'Option<ProxyDefinition>': Option<ProxyDefinition>;
+ 'Option<ProxyState>': Option<ProxyState>;
+ 'Option<ProxyType>': Option<ProxyType>;
+ 'Option<QueueConfigData>': Option<QueueConfigData>;
+ 'Option<QueuedParathread>': Option<QueuedParathread>;
+ 'Option<Randomness>': Option<Randomness>;
+ 'Option<Raw>': Option<Raw>;
+ 'Option<RawAuraPreDigest>': Option<RawAuraPreDigest>;
+ 'Option<RawBabePreDigest>': Option<RawBabePreDigest>;
+ 'Option<RawBabePreDigestCompat>': Option<RawBabePreDigestCompat>;
+ 'Option<RawBabePreDigestPrimary>': Option<RawBabePreDigestPrimary>;
+ 'Option<RawBabePreDigestPrimaryTo159>': Option<RawBabePreDigestPrimaryTo159>;
+ 'Option<RawBabePreDigestSecondaryPlain>': Option<RawBabePreDigestSecondaryPlain>;
+ 'Option<RawBabePreDigestSecondaryTo159>': Option<RawBabePreDigestSecondaryTo159>;
+ 'Option<RawBabePreDigestSecondaryVRF>': Option<RawBabePreDigestSecondaryVRF>;
+ 'Option<RawBabePreDigestTo159>': Option<RawBabePreDigestTo159>;
+ 'Option<RawOrigin>': Option<RawOrigin>;
+ 'Option<RawSolution>': Option<RawSolution>;
+ 'Option<RawSolutionTo265>': Option<RawSolutionTo265>;
+ 'Option<RawSolutionWith16>': Option<RawSolutionWith16>;
+ 'Option<RawSolutionWith24>': Option<RawSolutionWith24>;
+ 'Option<RawVRFOutput>': Option<RawVRFOutput>;
+ 'Option<ReadProof>': Option<ReadProof>;
+ 'Option<ReadySolution>': Option<ReadySolution>;
+ 'Option<Reasons>': Option<Reasons>;
+ 'Option<RecoveryConfig>': Option<RecoveryConfig>;
+ 'Option<RefCount>': Option<RefCount>;
+ 'Option<RefCountTo259>': Option<RefCountTo259>;
+ 'Option<ReferendumIndex>': Option<ReferendumIndex>;
+ 'Option<ReferendumInfo>': Option<ReferendumInfo>;
+ 'Option<ReferendumInfoFinished>': Option<ReferendumInfoFinished>;
+ 'Option<ReferendumInfoTo239>': Option<ReferendumInfoTo239>;
+ 'Option<ReferendumStatus>': Option<ReferendumStatus>;
+ 'Option<RegisteredParachainInfo>': Option<RegisteredParachainInfo>;
+ 'Option<RegistrarIndex>': Option<RegistrarIndex>;
+ 'Option<RegistrarInfo>': Option<RegistrarInfo>;
+ 'Option<Registration>': Option<Registration>;
+ 'Option<RegistrationJudgement>': Option<RegistrationJudgement>;
+ 'Option<RelayBlockNumber>': Option<RelayBlockNumber>;
+ 'Option<RelayChainBlockNumber>': Option<RelayChainBlockNumber>;
+ 'Option<RelayChainHash>': Option<RelayChainHash>;
+ 'Option<RelayHash>': Option<RelayHash>;
+ 'Option<Remark>': Option<Remark>;
+ 'Option<Renouncing>': Option<Renouncing>;
+ 'Option<RentProjection>': Option<RentProjection>;
+ 'Option<ReplacementTimes>': Option<ReplacementTimes>;
+ 'Option<ReportedRoundStates>': Option<ReportedRoundStates>;
+ 'Option<Reporter>': Option<Reporter>;
+ 'Option<ReportIdOf>': Option<ReportIdOf>;
+ 'Option<ReserveData>': Option<ReserveData>;
+ 'Option<ReserveIdentifier>': Option<ReserveIdentifier>;
+ 'Option<Retriable>': Option<Retriable>;
+ 'Option<RewardDestination>': Option<RewardDestination>;
+ 'Option<RewardPoint>': Option<RewardPoint>;
+ 'Option<RoundSnapshot>': Option<RoundSnapshot>;
+ 'Option<RoundState>': Option<RoundState>;
+ 'Option<RpcMethods>': Option<RpcMethods>;
+ 'Option<RuntimeDispatchInfo>': Option<RuntimeDispatchInfo>;
+ 'Option<RuntimeVersion>': Option<RuntimeVersion>;
+ 'Option<RuntimeVersionApi>': Option<RuntimeVersionApi>;
+ 'Option<RuntimeVersionPartial>': Option<RuntimeVersionPartial>;
+ 'Option<Schedule>': Option<Schedule>;
+ 'Option<Scheduled>': Option<Scheduled>;
+ 'Option<ScheduledTo254>': Option<ScheduledTo254>;
+ 'Option<SchedulePeriod>': Option<SchedulePeriod>;
+ 'Option<SchedulePriority>': Option<SchedulePriority>;
+ 'Option<ScheduleTo212>': Option<ScheduleTo212>;
+ 'Option<ScheduleTo258>': Option<ScheduleTo258>;
+ 'Option<ScheduleTo264>': Option<ScheduleTo264>;
+ 'Option<Scheduling>': Option<Scheduling>;
+ 'Option<SeatHolder>': Option<SeatHolder>;
+ 'Option<SeedOf>': Option<SeedOf>;
+ 'Option<ServiceQuality>': Option<ServiceQuality>;
+ 'Option<SessionIndex>': Option<SessionIndex>;
+ 'Option<SessionInfo>': Option<SessionInfo>;
+ 'Option<SessionInfoValidatorGroup>': Option<SessionInfoValidatorGroup>;
+ 'Option<SessionKeys1>': Option<SessionKeys1>;
+ 'Option<SessionKeys10>': Option<SessionKeys10>;
+ 'Option<SessionKeys10B>': Option<SessionKeys10B>;
+ 'Option<SessionKeys2>': Option<SessionKeys2>;
+ 'Option<SessionKeys3>': Option<SessionKeys3>;
+ 'Option<SessionKeys4>': Option<SessionKeys4>;
+ 'Option<SessionKeys5>': Option<SessionKeys5>;
+ 'Option<SessionKeys6>': Option<SessionKeys6>;
+ 'Option<SessionKeys6B>': Option<SessionKeys6B>;
+ 'Option<SessionKeys7>': Option<SessionKeys7>;
+ 'Option<SessionKeys7B>': Option<SessionKeys7B>;
+ 'Option<SessionKeys8>': Option<SessionKeys8>;
+ 'Option<SessionKeys8B>': Option<SessionKeys8B>;
+ 'Option<SessionKeys9>': Option<SessionKeys9>;
+ 'Option<SessionKeys9B>': Option<SessionKeys9B>;
+ 'Option<SetId>': Option<SetId>;
+ 'Option<SetIndex>': Option<SetIndex>;
+ 'Option<Si0Field>': Option<Si0Field>;
+ 'Option<Si0LookupTypeId>': Option<Si0LookupTypeId>;
+ 'Option<Si0Path>': Option<Si0Path>;
+ 'Option<Si0Type>': Option<Si0Type>;
+ 'Option<Si0TypeDef>': Option<Si0TypeDef>;
+ 'Option<Si0TypeDefArray>': Option<Si0TypeDefArray>;
+ 'Option<Si0TypeDefBitSequence>': Option<Si0TypeDefBitSequence>;
+ 'Option<Si0TypeDefCompact>': Option<Si0TypeDefCompact>;
+ 'Option<Si0TypeDefComposite>': Option<Si0TypeDefComposite>;
+ 'Option<Si0TypeDefPhantom>': Option<Si0TypeDefPhantom>;
+ 'Option<Si0TypeDefPrimitive>': Option<Si0TypeDefPrimitive>;
+ 'Option<Si0TypeDefSequence>': Option<Si0TypeDefSequence>;
+ 'Option<Si0TypeDefTuple>': Option<Si0TypeDefTuple>;
+ 'Option<Si0TypeDefVariant>': Option<Si0TypeDefVariant>;
+ 'Option<Si0TypeParameter>': Option<Si0TypeParameter>;
+ 'Option<Si0Variant>': Option<Si0Variant>;
+ 'Option<SiField>': Option<SiField>;
+ 'Option<Signature>': Option<Signature>;
+ 'Option<SignedAvailabilityBitfield>': Option<SignedAvailabilityBitfield>;
+ 'Option<SignedAvailabilityBitfields>': Option<SignedAvailabilityBitfields>;
+ 'Option<SignedExtensionMetadataLatest>': Option<SignedExtensionMetadataLatest>;
+ 'Option<SignedExtensionMetadataV14>': Option<SignedExtensionMetadataV14>;
+ 'Option<SignedSubmission>': Option<SignedSubmission>;
+ 'Option<SignedSubmissionOf>': Option<SignedSubmissionOf>;
+ 'Option<SignerPayload>': Option<SignerPayload>;
+ 'Option<SigningContext>': Option<SigningContext>;
+ 'Option<SiLookupTypeId>': Option<SiLookupTypeId>;
+ 'Option<SiPath>': Option<SiPath>;
+ 'Option<SiType>': Option<SiType>;
+ 'Option<SiTypeDef>': Option<SiTypeDef>;
+ 'Option<SiTypeDefArray>': Option<SiTypeDefArray>;
+ 'Option<SiTypeDefBitSequence>': Option<SiTypeDefBitSequence>;
+ 'Option<SiTypeDefCompact>': Option<SiTypeDefCompact>;
+ 'Option<SiTypeDefComposite>': Option<SiTypeDefComposite>;
+ 'Option<SiTypeDefPrimitive>': Option<SiTypeDefPrimitive>;
+ 'Option<SiTypeDefSequence>': Option<SiTypeDefSequence>;
+ 'Option<SiTypeDefTuple>': Option<SiTypeDefTuple>;
+ 'Option<SiTypeDefVariant>': Option<SiTypeDefVariant>;
+ 'Option<SiTypeParameter>': Option<SiTypeParameter>;
+ 'Option<SiVariant>': Option<SiVariant>;
+ 'Option<SlashingSpans>': Option<SlashingSpans>;
+ 'Option<SlashingSpansTo204>': Option<SlashingSpansTo204>;
+ 'Option<SlashJournalEntry>': Option<SlashJournalEntry>;
+ 'Option<SlotNumber>': Option<SlotNumber>;
+ 'Option<SlotRange>': Option<SlotRange>;
+ 'Option<SocietyJudgement>': Option<SocietyJudgement>;
+ 'Option<SocietyVote>': Option<SocietyVote>;
+ 'Option<SolutionOrSnapshotSize>': Option<SolutionOrSnapshotSize>;
+ 'Option<SolutionSupport>': Option<SolutionSupport>;
+ 'Option<SolutionSupports>': Option<SolutionSupports>;
+ 'Option<SpanIndex>': Option<SpanIndex>;
+ 'Option<SpanRecord>': Option<SpanRecord>;
+ 'Option<Sr25519Signature>': Option<Sr25519Signature>;
+ 'Option<StakingLedger>': Option<StakingLedger>;
+ 'Option<StakingLedgerTo223>': Option<StakingLedgerTo223>;
+ 'Option<StakingLedgerTo240>': Option<StakingLedgerTo240>;
+ 'Option<Statement>': Option<Statement>;
+ 'Option<StatementKind>': Option<StatementKind>;
+ 'Option<StorageChangeSet>': Option<StorageChangeSet>;
+ 'Option<StorageEntryMetadataLatest>': Option<StorageEntryMetadataLatest>;
+ 'Option<StorageEntryMetadataV10>': Option<StorageEntryMetadataV10>;
+ 'Option<StorageEntryMetadataV11>': Option<StorageEntryMetadataV11>;
+ 'Option<StorageEntryMetadataV12>': Option<StorageEntryMetadataV12>;
+ 'Option<StorageEntryMetadataV13>': Option<StorageEntryMetadataV13>;
+ 'Option<StorageEntryMetadataV14>': Option<StorageEntryMetadataV14>;
+ 'Option<StorageEntryMetadataV9>': Option<StorageEntryMetadataV9>;
+ 'Option<StorageEntryModifierLatest>': Option<StorageEntryModifierLatest>;
+ 'Option<StorageEntryModifierV10>': Option<StorageEntryModifierV10>;
+ 'Option<StorageEntryModifierV11>': Option<StorageEntryModifierV11>;
+ 'Option<StorageEntryModifierV12>': Option<StorageEntryModifierV12>;
+ 'Option<StorageEntryModifierV13>': Option<StorageEntryModifierV13>;
+ 'Option<StorageEntryModifierV14>': Option<StorageEntryModifierV14>;
+ 'Option<StorageEntryModifierV9>': Option<StorageEntryModifierV9>;
+ 'Option<StorageEntryTypeLatest>': Option<StorageEntryTypeLatest>;
+ 'Option<StorageEntryTypeV10>': Option<StorageEntryTypeV10>;
+ 'Option<StorageEntryTypeV11>': Option<StorageEntryTypeV11>;
+ 'Option<StorageEntryTypeV12>': Option<StorageEntryTypeV12>;
+ 'Option<StorageEntryTypeV13>': Option<StorageEntryTypeV13>;
+ 'Option<StorageEntryTypeV14>': Option<StorageEntryTypeV14>;
+ 'Option<StorageEntryTypeV9>': Option<StorageEntryTypeV9>;
+ 'Option<StorageHasher>': Option<StorageHasher>;
+ 'Option<StorageHasherV10>': Option<StorageHasherV10>;
+ 'Option<StorageHasherV11>': Option<StorageHasherV11>;
+ 'Option<StorageHasherV12>': Option<StorageHasherV12>;
+ 'Option<StorageHasherV13>': Option<StorageHasherV13>;
+ 'Option<StorageHasherV14>': Option<StorageHasherV14>;
+ 'Option<StorageHasherV9>': Option<StorageHasherV9>;
+ 'Option<StorageKey>': Option<StorageKey>;
+ 'Option<StorageKind>': Option<StorageKind>;
+ 'Option<StorageMetadataLatest>': Option<StorageMetadataLatest>;
+ 'Option<StorageMetadataV10>': Option<StorageMetadataV10>;
+ 'Option<StorageMetadataV11>': Option<StorageMetadataV11>;
+ 'Option<StorageMetadataV12>': Option<StorageMetadataV12>;
+ 'Option<StorageMetadataV13>': Option<StorageMetadataV13>;
+ 'Option<StorageMetadataV9>': Option<StorageMetadataV9>;
+ 'Option<StoredPendingChange>': Option<StoredPendingChange>;
+ 'Option<StoredState>': Option<StoredState>;
+ 'Option<StrikeCount>': Option<StrikeCount>;
+ 'Option<SubId>': Option<SubId>;
+ 'Option<SubmissionIndicesOf>': Option<SubmissionIndicesOf>;
+ 'Option<Supports>': Option<Supports>;
+ 'Option<SyncState>': Option<SyncState>;
+ 'Option<SystemInherentData>': Option<SystemInherentData>;
+ 'Option<SystemOrigin>': Option<SystemOrigin>;
+ 'Option<Tally>': Option<Tally>;
+ 'Option<TaskAddress>': Option<TaskAddress>;
+ 'Option<TAssetBalance>': Option<TAssetBalance>;
+ 'Option<TAssetDepositBalance>': Option<TAssetDepositBalance>;
+ 'Option<Text>': Option<Text>;
+ 'Option<Timepoint>': Option<Timepoint>;
+ 'Option<TokenError>': Option<TokenError>;
+ 'Option<TombstoneContractInfo>': Option<TombstoneContractInfo>;
+ 'Option<TraceBlockResponse>': Option<TraceBlockResponse>;
+ 'Option<TraceError>': Option<TraceError>;
+ 'Option<TransactionValidityError>': Option<TransactionValidityError>;
+ 'Option<TransientValidationData>': Option<TransientValidationData>;
+ 'Option<TreasuryProposal>': Option<TreasuryProposal>;
+ 'Option<TrieId>': Option<TrieId>;
+ 'Option<TrieIndex>': Option<TrieIndex>;
+ 'Option<Type>': Option<Type>;
+ 'Option<u128>': Option<u128>;
+ 'Option<U128>': Option<U128>;
+ 'Option<u16>': Option<u16>;
+ 'Option<U16>': Option<U16>;
+ 'Option<u256>': Option<u256>;
+ 'Option<U256>': Option<U256>;
+ 'Option<u32>': Option<u32>;
+ 'Option<U32>': Option<U32>;
+ 'Option<u64>': Option<u64>;
+ 'Option<U64>': Option<U64>;
+ 'Option<u8>': Option<u8>;
+ 'Option<U8>': Option<U8>;
+ 'Option<UnappliedSlash>': Option<UnappliedSlash>;
+ 'Option<UnappliedSlashOther>': Option<UnappliedSlashOther>;
+ 'Option<UncleEntryItem>': Option<UncleEntryItem>;
+ 'Option<UnknownTransaction>': Option<UnknownTransaction>;
+ 'Option<UnlockChunk>': Option<UnlockChunk>;
+ 'Option<UpwardMessage>': Option<UpwardMessage>;
+ 'Option<usize>': Option<usize>;
+ 'Option<USize>': Option<USize>;
+ 'Option<ValidationCode>': Option<ValidationCode>;
+ 'Option<ValidationCodeHash>': Option<ValidationCodeHash>;
+ 'Option<ValidationData>': Option<ValidationData>;
+ 'Option<ValidationDataType>': Option<ValidationDataType>;
+ 'Option<ValidationFunctionParams>': Option<ValidationFunctionParams>;
+ 'Option<ValidatorCount>': Option<ValidatorCount>;
+ 'Option<ValidatorIndex>': Option<ValidatorIndex>;
+ 'Option<ValidatorIndexCompact>': Option<ValidatorIndexCompact>;
+ 'Option<ValidatorPrefs>': Option<ValidatorPrefs>;
+ 'Option<ValidatorPrefsTo145>': Option<ValidatorPrefsTo145>;
+ 'Option<ValidatorPrefsTo196>': Option<ValidatorPrefsTo196>;
+ 'Option<ValidatorPrefsWithBlocked>': Option<ValidatorPrefsWithBlocked>;
+ 'Option<ValidatorPrefsWithCommission>': Option<ValidatorPrefsWithCommission>;
+ 'Option<ValidatorSetId>': Option<ValidatorSetId>;
+ 'Option<ValidatorSignature>': Option<ValidatorSignature>;
+ 'Option<ValidDisputeStatementKind>': Option<ValidDisputeStatementKind>;
+ 'Option<ValidityAttestation>': Option<ValidityAttestation>;
+ 'Option<VecInboundHrmpMessage>': Option<VecInboundHrmpMessage>;
+ 'Option<VersionedMultiAsset>': Option<VersionedMultiAsset>;
+ 'Option<VersionedMultiLocation>': Option<VersionedMultiLocation>;
+ 'Option<VersionedXcm>': Option<VersionedXcm>;
+ 'Option<VestingInfo>': Option<VestingInfo>;
+ 'Option<VestingSchedule>': Option<VestingSchedule>;
+ 'Option<Vote>': Option<Vote>;
+ 'Option<VoteIndex>': Option<VoteIndex>;
+ 'Option<Voter>': Option<Voter>;
+ 'Option<VoterInfo>': Option<VoterInfo>;
+ 'Option<Votes>': Option<Votes>;
+ 'Option<VotesTo230>': Option<VotesTo230>;
+ 'Option<VoteThreshold>': Option<VoteThreshold>;
+ 'Option<VoteWeight>': Option<VoteWeight>;
+ 'Option<Voting>': Option<Voting>;
+ 'Option<VotingDelegating>': Option<VotingDelegating>;
+ 'Option<VotingDirect>': Option<VotingDirect>;
+ 'Option<VotingDirectVote>': Option<VotingDirectVote>;
+ 'Option<VouchingStatus>': Option<VouchingStatus>;
+ 'Option<VrfData>': Option<VrfData>;
+ 'Option<VrfOutput>': Option<VrfOutput>;
+ 'Option<VrfProof>': Option<VrfProof>;
+ 'Option<WeightPerClass>': Option<WeightPerClass>;
+ 'Option<WeightToFeeCoefficient>': Option<WeightToFeeCoefficient>;
+ 'Option<WinnersData>': Option<WinnersData>;
+ 'Option<WinnersDataTuple>': Option<WinnersDataTuple>;
+ 'Option<WinningData>': Option<WinningData>;
+ 'Option<WinningDataEntry>': Option<WinningDataEntry>;
+ 'Option<WithdrawReasons>': Option<WithdrawReasons>;
+ 'Option<Xcm>': Option<Xcm>;
+ 'Option<XcmAssetEffects>': Option<XcmAssetEffects>;
+ 'Option<XcmError>': Option<XcmError>;
+ 'Option<XcmHrmpChannelAccepted>': Option<XcmHrmpChannelAccepted>;
+ 'Option<XcmHrmpChannelClosing>': Option<XcmHrmpChannelClosing>;
+ 'Option<XcmHrmpNewChannelOpenRequest>': Option<XcmHrmpNewChannelOpenRequest>;
+ 'Option<XcmOrder>': Option<XcmOrder>;
+ 'Option<XcmOrderBuyExecution>': Option<XcmOrderBuyExecution>;
+ 'Option<XcmOrderDepositAsset>': Option<XcmOrderDepositAsset>;
+ 'Option<XcmOrderDepositReserveAsset>': Option<XcmOrderDepositReserveAsset>;
+ 'Option<XcmOrderExchangeAsset>': Option<XcmOrderExchangeAsset>;
+ 'Option<XcmOrderInitiateReserveWithdraw>': Option<XcmOrderInitiateReserveWithdraw>;
+ 'Option<XcmOrderInitiateTeleport>': Option<XcmOrderInitiateTeleport>;
+ 'Option<XcmOrderQueryHolding>': Option<XcmOrderQueryHolding>;
+ 'Option<XcmOrigin>': Option<XcmOrigin>;
+ 'Option<XcmOriginKind>': Option<XcmOriginKind>;
+ 'Option<XcmpMessageFormat>': Option<XcmpMessageFormat>;
+ 'Option<XcmQueryResponse>': Option<XcmQueryResponse>;
+ 'Option<XcmRelayedFrom>': Option<XcmRelayedFrom>;
+ 'Option<XcmReserveAssetDeposit>': Option<XcmReserveAssetDeposit>;
+ 'Option<XcmResponse>': Option<XcmResponse>;
+ 'Option<XcmTeleportAsset>': Option<XcmTeleportAsset>;
+ 'Option<XcmTransact>': Option<XcmTransact>;
+ 'Option<XcmTransferAsset>': Option<XcmTransferAsset>;
+ 'Option<XcmTransferReserveAsset>': Option<XcmTransferReserveAsset>;
+ 'Option<XcmWithdrawAsset>': Option<XcmWithdrawAsset>;
+ 'Vec<AbridgedCandidateReceipt>': Vec<AbridgedCandidateReceipt>;
+ 'Vec<AbridgedHostConfiguration>': Vec<AbridgedHostConfiguration>;
+ 'Vec<AbridgedHrmpChannel>': Vec<AbridgedHrmpChannel>;
+ 'Vec<AccountData>': Vec<AccountData>;
+ 'Vec<AccountId32Junction>': Vec<AccountId32Junction>;
+ 'Vec<AccountIndex64Junction>': Vec<AccountIndex64Junction>;
+ 'Vec<AccountInfo>': Vec<AccountInfo>;
+ 'Vec<AccountInfoWithDualRefCount>': Vec<AccountInfoWithDualRefCount>;
+ 'Vec<AccountInfoWithProviders>': Vec<AccountInfoWithProviders>;
+ 'Vec<AccountInfoWithRefCount>': Vec<AccountInfoWithRefCount>;
+ 'Vec<AccountInfoWithRefCountU8>': Vec<AccountInfoWithRefCountU8>;
+ 'Vec<AccountInfoWithTripleRefCount>': Vec<AccountInfoWithTripleRefCount>;
+ 'Vec<AccountKey20Junction>': Vec<AccountKey20Junction>;
+ 'Vec<AccountStatus>': Vec<AccountStatus>;
+ 'Vec<AccountValidity>': Vec<AccountValidity>;
+ 'Vec<AccountVote>': Vec<AccountVote>;
+ 'Vec<AccountVoteSplit>': Vec<AccountVoteSplit>;
+ 'Vec<AccountVoteStandard>': Vec<AccountVoteStandard>;
+ 'Vec<ActiveEraInfo>': Vec<ActiveEraInfo>;
+ 'Vec<ActiveGilt>': Vec<ActiveGilt>;
+ 'Vec<ActiveGiltsTotal>': Vec<ActiveGiltsTotal>;
+ 'Vec<ActiveIndex>': Vec<ActiveIndex>;
+ 'Vec<ActiveRecovery>': Vec<ActiveRecovery>;
+ 'Vec<AliveContractInfo>': Vec<AliveContractInfo>;
+ 'Vec<AllowedSlots>': Vec<AllowedSlots>;
+ 'Vec<AnySignature>': Vec<AnySignature>;
+ 'Vec<ApiId>': Vec<ApiId>;
+ 'Vec<ApplyExtrinsicResult>': Vec<ApplyExtrinsicResult>;
+ 'Vec<ApprovalFlag>': Vec<ApprovalFlag>;
+ 'Vec<Approvals>': Vec<Approvals>;
+ 'Vec<ArithmeticError>': Vec<ArithmeticError>;
+ 'Vec<AssetApproval>': Vec<AssetApproval>;
+ 'Vec<AssetApprovalKey>': Vec<AssetApprovalKey>;
+ 'Vec<AssetBalance>': Vec<AssetBalance>;
+ 'Vec<AssetDestroyWitness>': Vec<AssetDestroyWitness>;
+ 'Vec<AssetDetails>': Vec<AssetDetails>;
+ 'Vec<AssetInstance>': Vec<AssetInstance>;
+ 'Vec<AssetMetadata>': Vec<AssetMetadata>;
+ 'Vec<AssetOptions>': Vec<AssetOptions>;
+ 'Vec<AssignmentId>': Vec<AssignmentId>;
+ 'Vec<AssignmentKind>': Vec<AssignmentKind>;
+ 'Vec<AttestedCandidate>': Vec<AttestedCandidate>;
+ 'Vec<AuctionIndex>': Vec<AuctionIndex>;
+ 'Vec<AuthIndex>': Vec<AuthIndex>;
+ 'Vec<AuthorityDiscoveryId>': Vec<AuthorityDiscoveryId>;
+ 'Vec<AuthorityId>': Vec<AuthorityId>;
+ 'Vec<AuthorityIndex>': Vec<AuthorityIndex>;
+ 'Vec<AuthorityList>': Vec<AuthorityList>;
+ 'Vec<AuthoritySet>': Vec<AuthoritySet>;
+ 'Vec<AuthoritySetChange>': Vec<AuthoritySetChange>;
+ 'Vec<AuthoritySetChanges>': Vec<AuthoritySetChanges>;
+ 'Vec<AuthoritySignature>': Vec<AuthoritySignature>;
+ 'Vec<AuthorityWeight>': Vec<AuthorityWeight>;
+ 'Vec<AvailabilityBitfield>': Vec<AvailabilityBitfield>;
+ 'Vec<AvailabilityBitfieldRecord>': Vec<AvailabilityBitfieldRecord>;
+ 'Vec<BabeAuthorityWeight>': Vec<BabeAuthorityWeight>;
+ 'Vec<BabeBlockWeight>': Vec<BabeBlockWeight>;
+ 'Vec<BabeEpochConfiguration>': Vec<BabeEpochConfiguration>;
+ 'Vec<BabeEquivocationProof>': Vec<BabeEquivocationProof>;
+ 'Vec<BabeWeight>': Vec<BabeWeight>;
+ 'Vec<BackedCandidate>': Vec<BackedCandidate>;
+ 'Vec<Balance>': Vec<Balance>;
+ 'Vec<BalanceLock>': Vec<BalanceLock>;
+ 'Vec<BalanceLockTo212>': Vec<BalanceLockTo212>;
+ 'Vec<BalanceStatus>': Vec<BalanceStatus>;
+ 'Vec<BeefyCommitment>': Vec<BeefyCommitment>;
+ 'Vec<BeefyId>': Vec<BeefyId>;
+ 'Vec<BeefyKey>': Vec<BeefyKey>;
+ 'Vec<BeefyNextAuthoritySet>': Vec<BeefyNextAuthoritySet>;
+ 'Vec<BeefyPayload>': Vec<BeefyPayload>;
+ 'Vec<BeefySignedCommitment>': Vec<BeefySignedCommitment>;
+ 'Vec<Bid>': Vec<Bid>;
+ 'Vec<Bidder>': Vec<Bidder>;
+ 'Vec<BidKind>': Vec<BidKind>;
+ 'Vec<BitVec>': Vec<BitVec>;
+ 'Vec<BlockAttestations>': Vec<BlockAttestations>;
+ 'Vec<BlockHash>': Vec<BlockHash>;
+ 'Vec<BlockLength>': Vec<BlockLength>;
+ 'Vec<BlockTrace>': Vec<BlockTrace>;
+ 'Vec<BlockTraceEvent>': Vec<BlockTraceEvent>;
+ 'Vec<BlockTraceEventData>': Vec<BlockTraceEventData>;
+ 'Vec<BlockTraceSpan>': Vec<BlockTraceSpan>;
+ 'Vec<BlockWeights>': Vec<BlockWeights>;
+ 'Vec<BodyId>': Vec<BodyId>;
+ 'Vec<BodyPart>': Vec<BodyPart>;
+ 'Vec<BodyPartAtLeastProportion>': Vec<BodyPartAtLeastProportion>;
+ 'Vec<BodyPartFraction>': Vec<BodyPartFraction>;
+ 'Vec<BodyPartMoreThanProportion>': Vec<BodyPartMoreThanProportion>;
+ 'Vec<bool>': Vec<bool>;
+ 'Vec<Bool>': Vec<Bool>;
+ 'Vec<Bounty>': Vec<Bounty>;
+ 'Vec<BountyIndex>': Vec<BountyIndex>;
+ 'Vec<BountyStatus>': Vec<BountyStatus>;
+ 'Vec<BountyStatusActive>': Vec<BountyStatusActive>;
+ 'Vec<BountyStatusCuratorProposed>': Vec<BountyStatusCuratorProposed>;
+ 'Vec<BountyStatusPendingPayout>': Vec<BountyStatusPendingPayout>;
+ 'Vec<BridgedBlockHash>': Vec<BridgedBlockHash>;
+ 'Vec<BridgedBlockNumber>': Vec<BridgedBlockNumber>;
+ 'Vec<BridgedHeader>': Vec<BridgedHeader>;
+ 'Vec<BufferedSessionChange>': Vec<BufferedSessionChange>;
+ 'Vec<Bytes>': Vec<Bytes>;
+ 'Vec<CallIndex>': Vec<CallIndex>;
+ 'Vec<CandidateCommitments>': Vec<CandidateCommitments>;
+ 'Vec<CandidateDescriptor>': Vec<CandidateDescriptor>;
+ 'Vec<CandidateHash>': Vec<CandidateHash>;
+ 'Vec<CandidateInfo>': Vec<CandidateInfo>;
+ 'Vec<CandidatePendingAvailability>': Vec<CandidatePendingAvailability>;
+ 'Vec<CandidateReceipt>': Vec<CandidateReceipt>;
+ 'Vec<CertValue>': Vec<CertValue>;
+ 'Vec<ChainProperties>': Vec<ChainProperties>;
+ 'Vec<ChainType>': Vec<ChainType>;
+ 'Vec<ClassDetails>': Vec<ClassDetails>;
+ 'Vec<ClassId>': Vec<ClassId>;
+ 'Vec<ClassMetadata>': Vec<ClassMetadata>;
+ 'Vec<CodeHash>': Vec<CodeHash>;
+ 'Vec<CollatorId>': Vec<CollatorId>;
+ 'Vec<CollatorSignature>': Vec<CollatorSignature>;
+ 'Vec<CollectiveOrigin>': Vec<CollectiveOrigin>;
+ 'Vec<CommittedCandidateReceipt>': Vec<CommittedCandidateReceipt>;
+ 'Vec<CompactAssignments>': Vec<CompactAssignments>;
+ 'Vec<CompactAssignmentsTo257>': Vec<CompactAssignmentsTo257>;
+ 'Vec<CompactAssignmentsTo265>': Vec<CompactAssignmentsTo265>;
+ 'Vec<CompactAssignmentsWith16>': Vec<CompactAssignmentsWith16>;
+ 'Vec<CompactAssignmentsWith24>': Vec<CompactAssignmentsWith24>;
+ 'Vec<CompactScore>': Vec<CompactScore>;
+ 'Vec<CompactScoreCompact>': Vec<CompactScoreCompact>;
+ 'Vec<ConfigData>': Vec<ConfigData>;
+ 'Vec<ConsumedWeight>': Vec<ConsumedWeight>;
+ 'Vec<ContractCallRequest>': Vec<ContractCallRequest>;
+ 'Vec<ContractConstructorSpec>': Vec<ContractConstructorSpec>;
+ 'Vec<ContractContractSpec>': Vec<ContractContractSpec>;
+ 'Vec<ContractCryptoHasher>': Vec<ContractCryptoHasher>;
+ 'Vec<ContractDiscriminant>': Vec<ContractDiscriminant>;
+ 'Vec<ContractDisplayName>': Vec<ContractDisplayName>;
+ 'Vec<ContractEventParamSpec>': Vec<ContractEventParamSpec>;
+ 'Vec<ContractEventSpec>': Vec<ContractEventSpec>;
+ 'Vec<ContractExecResult>': Vec<ContractExecResult>;
+ 'Vec<ContractExecResultErr>': Vec<ContractExecResultErr>;
+ 'Vec<ContractExecResultErrModule>': Vec<ContractExecResultErrModule>;
+ 'Vec<ContractExecResultOk>': Vec<ContractExecResultOk>;
+ 'Vec<ContractExecResultResult>': Vec<ContractExecResultResult>;
+ 'Vec<ContractExecResultSuccessTo255>': Vec<ContractExecResultSuccessTo255>;
+ 'Vec<ContractExecResultSuccessTo260>': Vec<ContractExecResultSuccessTo260>;
+ 'Vec<ContractExecResultTo255>': Vec<ContractExecResultTo255>;
+ 'Vec<ContractExecResultTo260>': Vec<ContractExecResultTo260>;
+ 'Vec<ContractExecResultTo267>': Vec<ContractExecResultTo267>;
+ 'Vec<ContractInfo>': Vec<ContractInfo>;
+ 'Vec<ContractInstantiateResult>': Vec<ContractInstantiateResult>;
+ 'Vec<ContractLayoutArray>': Vec<ContractLayoutArray>;
+ 'Vec<ContractLayoutCell>': Vec<ContractLayoutCell>;
+ 'Vec<ContractLayoutEnum>': Vec<ContractLayoutEnum>;
+ 'Vec<ContractLayoutHash>': Vec<ContractLayoutHash>;
+ 'Vec<ContractLayoutHashingStrategy>': Vec<ContractLayoutHashingStrategy>;
+ 'Vec<ContractLayoutKey>': Vec<ContractLayoutKey>;
+ 'Vec<ContractLayoutStruct>': Vec<ContractLayoutStruct>;
+ 'Vec<ContractLayoutStructField>': Vec<ContractLayoutStructField>;
+ 'Vec<ContractMessageParamSpec>': Vec<ContractMessageParamSpec>;
+ 'Vec<ContractMessageSpec>': Vec<ContractMessageSpec>;
+ 'Vec<ContractProject>': Vec<ContractProject>;
+ 'Vec<ContractProjectContract>': Vec<ContractProjectContract>;
+ 'Vec<ContractProjectSource>': Vec<ContractProjectSource>;
+ 'Vec<ContractSelector>': Vec<ContractSelector>;
+ 'Vec<ContractStorageKey>': Vec<ContractStorageKey>;
+ 'Vec<ContractStorageLayout>': Vec<ContractStorageLayout>;
+ 'Vec<ContractTypeSpec>': Vec<ContractTypeSpec>;
+ 'Vec<Conviction>': Vec<Conviction>;
+ 'Vec<CoreAssignment>': Vec<CoreAssignment>;
+ 'Vec<CoreIndex>': Vec<CoreIndex>;
+ 'Vec<CoreOccupied>': Vec<CoreOccupied>;
+ 'Vec<CreatedBlock>': Vec<CreatedBlock>;
+ 'Vec<Data>': Vec<Data>;
+ 'Vec<DeferredOffenceOf>': Vec<DeferredOffenceOf>;
+ 'Vec<DefunctVoter>': Vec<DefunctVoter>;
+ 'Vec<DelayKind>': Vec<DelayKind>;
+ 'Vec<DelayKindBest>': Vec<DelayKindBest>;
+ 'Vec<Delegations>': Vec<Delegations>;
+ 'Vec<DeletedContract>': Vec<DeletedContract>;
+ 'Vec<DepositBalance>': Vec<DepositBalance>;
+ 'Vec<DepositBalanceOf>': Vec<DepositBalanceOf>;
+ 'Vec<DestroyWitness>': Vec<DestroyWitness>;
+ 'Vec<DigestOf>': Vec<DigestOf>;
+ 'Vec<DispatchClass>': Vec<DispatchClass>;
+ 'Vec<DispatchError>': Vec<DispatchError>;
+ 'Vec<DispatchErrorModule>': Vec<DispatchErrorModule>;
+ 'Vec<DispatchErrorTo198>': Vec<DispatchErrorTo198>;
+ 'Vec<DispatchInfo>': Vec<DispatchInfo>;
+ 'Vec<DispatchInfoTo190>': Vec<DispatchInfoTo190>;
+ 'Vec<DispatchInfoTo244>': Vec<DispatchInfoTo244>;
+ 'Vec<DispatchOutcome>': Vec<DispatchOutcome>;
+ 'Vec<DispatchResult>': Vec<DispatchResult>;
+ 'Vec<DispatchResultOf>': Vec<DispatchResultOf>;
+ 'Vec<DispatchResultTo198>': Vec<DispatchResultTo198>;
+ 'Vec<DisputeStatement>': Vec<DisputeStatement>;
+ 'Vec<DisputeStatementSet>': Vec<DisputeStatementSet>;
+ 'Vec<DoubleEncodedCall>': Vec<DoubleEncodedCall>;
+ 'Vec<DoubleVoteReport>': Vec<DoubleVoteReport>;
+ 'Vec<DownwardMessage>': Vec<DownwardMessage>;
+ 'Vec<EcdsaSignature>': Vec<EcdsaSignature>;
+ 'Vec<Ed25519Signature>': Vec<Ed25519Signature>;
+ 'Vec<ElectionCompute>': Vec<ElectionCompute>;
+ 'Vec<ElectionPhase>': Vec<ElectionPhase>;
+ 'Vec<ElectionResult>': Vec<ElectionResult>;
+ 'Vec<ElectionScore>': Vec<ElectionScore>;
+ 'Vec<ElectionSize>': Vec<ElectionSize>;
+ 'Vec<ElectionStatus>': Vec<ElectionStatus>;
+ 'Vec<EncodedFinalityProofs>': Vec<EncodedFinalityProofs>;
+ 'Vec<EpochAuthorship>': Vec<EpochAuthorship>;
+ 'Vec<EraIndex>': Vec<EraIndex>;
+ 'Vec<EraPoints>': Vec<EraPoints>;
+ 'Vec<EraRewardPoints>': Vec<EraRewardPoints>;
+ 'Vec<EraRewards>': Vec<EraRewards>;
+ 'Vec<ErrorMetadataLatest>': Vec<ErrorMetadataLatest>;
+ 'Vec<ErrorMetadataV10>': Vec<ErrorMetadataV10>;
+ 'Vec<ErrorMetadataV11>': Vec<ErrorMetadataV11>;
+ 'Vec<ErrorMetadataV12>': Vec<ErrorMetadataV12>;
+ 'Vec<ErrorMetadataV13>': Vec<ErrorMetadataV13>;
+ 'Vec<ErrorMetadataV9>': Vec<ErrorMetadataV9>;
+ 'Vec<EthAccount>': Vec<EthAccount>;
+ 'Vec<EthBlock>': Vec<EthBlock>;
+ 'Vec<EthBloom>': Vec<EthBloom>;
+ 'Vec<EthCallRequest>': Vec<EthCallRequest>;
+ 'Vec<EthereumAccountId>': Vec<EthereumAccountId>;
+ 'Vec<EthereumAddress>': Vec<EthereumAddress>;
+ 'Vec<EthereumLookupSource>': Vec<EthereumLookupSource>;
+ 'Vec<EthereumSignature>': Vec<EthereumSignature>;
+ 'Vec<EthFilter>': Vec<EthFilter>;
+ 'Vec<EthFilterAddress>': Vec<EthFilterAddress>;
+ 'Vec<EthFilterChanges>': Vec<EthFilterChanges>;
+ 'Vec<EthFilterTopic>': Vec<EthFilterTopic>;
+ 'Vec<EthFilterTopicEntry>': Vec<EthFilterTopicEntry>;
+ 'Vec<EthFilterTopicInner>': Vec<EthFilterTopicInner>;
+ 'Vec<EthHeader>': Vec<EthHeader>;
+ 'Vec<EthLog>': Vec<EthLog>;
+ 'Vec<EthReceipt>': Vec<EthReceipt>;
+ 'Vec<EthRichBlock>': Vec<EthRichBlock>;
+ 'Vec<EthRichHeader>': Vec<EthRichHeader>;
+ 'Vec<EthStorageProof>': Vec<EthStorageProof>;
+ 'Vec<EthSubKind>': Vec<EthSubKind>;
+ 'Vec<EthSubParams>': Vec<EthSubParams>;
+ 'Vec<EthSubResult>': Vec<EthSubResult>;
+ 'Vec<EthSyncInfo>': Vec<EthSyncInfo>;
+ 'Vec<EthSyncStatus>': Vec<EthSyncStatus>;
+ 'Vec<EthTransaction>': Vec<EthTransaction>;
+ 'Vec<EthTransactionAction>': Vec<EthTransactionAction>;
+ 'Vec<EthTransactionCondition>': Vec<EthTransactionCondition>;
+ 'Vec<EthTransactionRequest>': Vec<EthTransactionRequest>;
+ 'Vec<EthTransactionSignature>': Vec<EthTransactionSignature>;
+ 'Vec<EthTransactionStatus>': Vec<EthTransactionStatus>;
+ 'Vec<EthWork>': Vec<EthWork>;
+ 'Vec<Event>': Vec<Event>;
+ 'Vec<EventId>': Vec<EventId>;
+ 'Vec<EventIndex>': Vec<EventIndex>;
+ 'Vec<EventMetadataLatest>': Vec<EventMetadataLatest>;
+ 'Vec<EventMetadataV10>': Vec<EventMetadataV10>;
+ 'Vec<EventMetadataV11>': Vec<EventMetadataV11>;
+ 'Vec<EventMetadataV12>': Vec<EventMetadataV12>;
+ 'Vec<EventMetadataV13>': Vec<EventMetadataV13>;
+ 'Vec<EventMetadataV9>': Vec<EventMetadataV9>;
+ 'Vec<EventRecord>': Vec<EventRecord>;
+ 'Vec<EvmAccount>': Vec<EvmAccount>;
+ 'Vec<EvmLog>': Vec<EvmLog>;
+ 'Vec<EvmVicinity>': Vec<EvmVicinity>;
+ 'Vec<ExecReturnValue>': Vec<ExecReturnValue>;
+ 'Vec<ExitError>': Vec<ExitError>;
+ 'Vec<ExitFatal>': Vec<ExitFatal>;
+ 'Vec<ExitReason>': Vec<ExitReason>;
+ 'Vec<ExitRevert>': Vec<ExitRevert>;
+ 'Vec<ExitSucceed>': Vec<ExitSucceed>;
+ 'Vec<ExplicitDisputeStatement>': Vec<ExplicitDisputeStatement>;
+ 'Vec<Exposure>': Vec<Exposure>;
+ 'Vec<ExtendedBalance>': Vec<ExtendedBalance>;
+ 'Vec<Extrinsic>': Vec<Extrinsic>;
+ 'Vec<ExtrinsicEra>': Vec<ExtrinsicEra>;
+ 'Vec<ExtrinsicMetadataLatest>': Vec<ExtrinsicMetadataLatest>;
+ 'Vec<ExtrinsicMetadataV11>': Vec<ExtrinsicMetadataV11>;
+ 'Vec<ExtrinsicMetadataV12>': Vec<ExtrinsicMetadataV12>;
+ 'Vec<ExtrinsicMetadataV13>': Vec<ExtrinsicMetadataV13>;
+ 'Vec<ExtrinsicMetadataV14>': Vec<ExtrinsicMetadataV14>;
+ 'Vec<ExtrinsicOrHash>': Vec<ExtrinsicOrHash>;
+ 'Vec<ExtrinsicPayload>': Vec<ExtrinsicPayload>;
+ 'Vec<ExtrinsicPayloadUnknown>': Vec<ExtrinsicPayloadUnknown>;
+ 'Vec<ExtrinsicPayloadV4>': Vec<ExtrinsicPayloadV4>;
+ 'Vec<ExtrinsicSignature>': Vec<ExtrinsicSignature>;
+ 'Vec<ExtrinsicSignatureV4>': Vec<ExtrinsicSignatureV4>;
+ 'Vec<ExtrinsicStatus>': Vec<ExtrinsicStatus>;
+ 'Vec<ExtrinsicUnknown>': Vec<ExtrinsicUnknown>;
+ 'Vec<ExtrinsicV4>': Vec<ExtrinsicV4>;
+ 'Vec<FeeDetails>': Vec<FeeDetails>;
+ 'Vec<Forcing>': Vec<Forcing>;
+ 'Vec<ForkTreePendingChange>': Vec<ForkTreePendingChange>;
+ 'Vec<ForkTreePendingChangeNode>': Vec<ForkTreePendingChangeNode>;
+ 'Vec<FullIdentification>': Vec<FullIdentification>;
+ 'Vec<FunctionArgumentMetadataLatest>': Vec<FunctionArgumentMetadataLatest>;
+ 'Vec<FunctionArgumentMetadataV10>': Vec<FunctionArgumentMetadataV10>;
+ 'Vec<FunctionArgumentMetadataV11>': Vec<FunctionArgumentMetadataV11>;
+ 'Vec<FunctionArgumentMetadataV12>': Vec<FunctionArgumentMetadataV12>;
+ 'Vec<FunctionArgumentMetadataV13>': Vec<FunctionArgumentMetadataV13>;
+ 'Vec<FunctionArgumentMetadataV9>': Vec<FunctionArgumentMetadataV9>;
+ 'Vec<FunctionMetadataLatest>': Vec<FunctionMetadataLatest>;
+ 'Vec<FunctionMetadataV10>': Vec<FunctionMetadataV10>;
+ 'Vec<FunctionMetadataV11>': Vec<FunctionMetadataV11>;
+ 'Vec<FunctionMetadataV12>': Vec<FunctionMetadataV12>;
+ 'Vec<FunctionMetadataV13>': Vec<FunctionMetadataV13>;
+ 'Vec<FunctionMetadataV9>': Vec<FunctionMetadataV9>;
+ 'Vec<FundIndex>': Vec<FundIndex>;
+ 'Vec<FundInfo>': Vec<FundInfo>;
+ 'Vec<Gas>': Vec<Gas>;
+ 'Vec<GiltBid>': Vec<GiltBid>;
+ 'Vec<GlobalValidationData>': Vec<GlobalValidationData>;
+ 'Vec<GlobalValidationSchedule>': Vec<GlobalValidationSchedule>;
+ 'Vec<GrandpaCommit>': Vec<GrandpaCommit>;
+ 'Vec<GrandpaEquivocation>': Vec<GrandpaEquivocation>;
+ 'Vec<GrandpaEquivocationProof>': Vec<GrandpaEquivocationProof>;
+ 'Vec<GrandpaEquivocationValue>': Vec<GrandpaEquivocationValue>;
+ 'Vec<GrandpaJustification>': Vec<GrandpaJustification>;
+ 'Vec<GrandpaPrecommit>': Vec<GrandpaPrecommit>;
+ 'Vec<GrandpaPrevote>': Vec<GrandpaPrevote>;
+ 'Vec<GrandpaSignedPrecommit>': Vec<GrandpaSignedPrecommit>;
+ 'Vec<GroupIndex>': Vec<GroupIndex>;
+ 'Vec<HeadData>': Vec<HeadData>;
+ 'Vec<Health>': Vec<Health>;
+ 'Vec<Heartbeat>': Vec<Heartbeat>;
+ 'Vec<HeartbeatTo244>': Vec<HeartbeatTo244>;
+ 'Vec<HostConfiguration>': Vec<HostConfiguration>;
+ 'Vec<HostFnWeights>': Vec<HostFnWeights>;
+ 'Vec<HostFnWeightsTo264>': Vec<HostFnWeightsTo264>;
+ 'Vec<HrmpChannel>': Vec<HrmpChannel>;
+ 'Vec<HrmpChannelId>': Vec<HrmpChannelId>;
+ 'Vec<HrmpOpenChannelRequest>': Vec<HrmpOpenChannelRequest>;
+ 'Vec<i128>': Vec<i128>;
+ 'Vec<I128>': Vec<I128>;
+ 'Vec<i16>': Vec<i16>;
+ 'Vec<I16>': Vec<I16>;
+ 'Vec<i256>': Vec<i256>;
+ 'Vec<I256>': Vec<I256>;
+ 'Vec<i32>': Vec<i32>;
+ 'Vec<I32>': Vec<I32>;
+ 'Vec<i64>': Vec<i64>;
+ 'Vec<I64>': Vec<I64>;
+ 'Vec<i8>': Vec<i8>;
+ 'Vec<I8>': Vec<I8>;
+ 'Vec<IdentificationTuple>': Vec<IdentificationTuple>;
+ 'Vec<IdentityFields>': Vec<IdentityFields>;
+ 'Vec<IdentityInfo>': Vec<IdentityInfo>;
+ 'Vec<IdentityInfoAdditional>': Vec<IdentityInfoAdditional>;
+ 'Vec<IdentityJudgement>': Vec<IdentityJudgement>;
+ 'Vec<IdtyCertMeta>': Vec<IdtyCertMeta>;
+ 'Vec<IdtyData>': Vec<IdtyData>;
+ 'Vec<IdtyDid>': Vec<IdtyDid>;
+ 'Vec<IdtyIndex>': Vec<IdtyIndex>;
+ 'Vec<IdtyRight>': Vec<IdtyRight>;
+ 'Vec<IdtyStatus>': Vec<IdtyStatus>;
+ 'Vec<IdtyValue>': Vec<IdtyValue>;
+ 'Vec<ImmortalEra>': Vec<ImmortalEra>;
+ 'Vec<ImportedAux>': Vec<ImportedAux>;
+ 'Vec<InboundDownwardMessage>': Vec<InboundDownwardMessage>;
+ 'Vec<InboundHrmpMessage>': Vec<InboundHrmpMessage>;
+ 'Vec<InboundHrmpMessages>': Vec<InboundHrmpMessages>;
+ 'Vec<InboundStatus>': Vec<InboundStatus>;
+ 'Vec<IncludedBlocks>': Vec<IncludedBlocks>;
+ 'Vec<InclusionFee>': Vec<InclusionFee>;
+ 'Vec<IncomingParachain>': Vec<IncomingParachain>;
+ 'Vec<IncomingParachainDeploy>': Vec<IncomingParachainDeploy>;
+ 'Vec<IncomingParachainFixed>': Vec<IncomingParachainFixed>;
+ 'Vec<IndividualExposure>': Vec<IndividualExposure>;
+ 'Vec<InitializationData>': Vec<InitializationData>;
+ 'Vec<InstanceDetails>': Vec<InstanceDetails>;
+ 'Vec<InstanceId>': Vec<InstanceId>;
+ 'Vec<InstanceMetadata>': Vec<InstanceMetadata>;
+ 'Vec<InstantiateRequest>': Vec<InstantiateRequest>;
+ 'Vec<InstantiateReturnValue>': Vec<InstantiateReturnValue>;
+ 'Vec<InstructionWeights>': Vec<InstructionWeights>;
+ 'Vec<InvalidDisputeStatementKind>': Vec<InvalidDisputeStatementKind>;
+ 'Vec<InvalidTransaction>': Vec<InvalidTransaction>;
+ 'Vec<Json>': Vec<Json>;
+ 'Vec<Junction>': Vec<Junction>;
+ 'Vec<JustificationNotification>': Vec<JustificationNotification>;
+ 'Vec<Key>': Vec<Key>;
+ 'Vec<KeyOwnerProof>': Vec<KeyOwnerProof>;
+ 'Vec<Keys>': Vec<Keys>;
+ 'Vec<KeyType>': Vec<KeyType>;
+ 'Vec<KeyValueOption>': Vec<KeyValueOption>;
+ 'Vec<Kind>': Vec<Kind>;
+ 'Vec<LastContribution>': Vec<LastContribution>;
+ 'Vec<LastRuntimeUpgradeInfo>': Vec<LastRuntimeUpgradeInfo>;
+ 'Vec<LeasePeriod>': Vec<LeasePeriod>;
+ 'Vec<LeasePeriodOf>': Vec<LeasePeriodOf>;
+ 'Vec<Limits>': Vec<Limits>;
+ 'Vec<LimitsTo264>': Vec<LimitsTo264>;
+ 'Vec<LocalValidationData>': Vec<LocalValidationData>;
+ 'Vec<LotteryConfig>': Vec<LotteryConfig>;
+ 'Vec<MaybeRandomness>': Vec<MaybeRandomness>;
+ 'Vec<MaybeVrf>': Vec<MaybeVrf>;
+ 'Vec<MemberCount>': Vec<MemberCount>;
+ 'Vec<MembershipProof>': Vec<MembershipProof>;
+ 'Vec<MessageId>': Vec<MessageId>;
+ 'Vec<MessageIngestionType>': Vec<MessageIngestionType>;
+ 'Vec<MessageQueueChain>': Vec<MessageQueueChain>;
+ 'Vec<MessagingStateSnapshot>': Vec<MessagingStateSnapshot>;
+ 'Vec<MessagingStateSnapshotEgressEntry>': Vec<MessagingStateSnapshotEgressEntry>;
+ 'Vec<MetadataAll>': Vec<MetadataAll>;
+ 'Vec<MetadataLatest>': Vec<MetadataLatest>;
+ 'Vec<MetadataV10>': Vec<MetadataV10>;
+ 'Vec<MetadataV11>': Vec<MetadataV11>;
+ 'Vec<MetadataV12>': Vec<MetadataV12>;
+ 'Vec<MetadataV13>': Vec<MetadataV13>;
+ 'Vec<MetadataV14>': Vec<MetadataV14>;
+ 'Vec<MetadataV9>': Vec<MetadataV9>;
+ 'Vec<MmrLeafProof>': Vec<MmrLeafProof>;
+ 'Vec<MmrRootHash>': Vec<MmrRootHash>;
+ 'Vec<ModuleConstantMetadataLatest>': Vec<ModuleConstantMetadataLatest>;
+ 'Vec<ModuleConstantMetadataV10>': Vec<ModuleConstantMetadataV10>;
+ 'Vec<ModuleConstantMetadataV11>': Vec<ModuleConstantMetadataV11>;
+ 'Vec<ModuleConstantMetadataV12>': Vec<ModuleConstantMetadataV12>;
+ 'Vec<ModuleConstantMetadataV13>': Vec<ModuleConstantMetadataV13>;
+ 'Vec<ModuleConstantMetadataV9>': Vec<ModuleConstantMetadataV9>;
+ 'Vec<ModuleMetadataLatest>': Vec<ModuleMetadataLatest>;
+ 'Vec<ModuleMetadataV10>': Vec<ModuleMetadataV10>;
+ 'Vec<ModuleMetadataV11>': Vec<ModuleMetadataV11>;
+ 'Vec<ModuleMetadataV12>': Vec<ModuleMetadataV12>;
+ 'Vec<ModuleMetadataV13>': Vec<ModuleMetadataV13>;
+ 'Vec<ModuleMetadataV9>': Vec<ModuleMetadataV9>;
+ 'Vec<MomentOf>': Vec<MomentOf>;
+ 'Vec<MoreAttestations>': Vec<MoreAttestations>;
+ 'Vec<MortalEra>': Vec<MortalEra>;
+ 'Vec<MultiAsset>': Vec<MultiAsset>;
+ 'Vec<MultiAssetAbstractFungible>': Vec<MultiAssetAbstractFungible>;
+ 'Vec<MultiAssetAbstractNonFungible>': Vec<MultiAssetAbstractNonFungible>;
+ 'Vec<MultiAssetConcreteFungible>': Vec<MultiAssetConcreteFungible>;
+ 'Vec<MultiAssetConcreteNonFungible>': Vec<MultiAssetConcreteNonFungible>;
+ 'Vec<MultiDisputeStatementSet>': Vec<MultiDisputeStatementSet>;
+ 'Vec<MultiLocation>': Vec<MultiLocation>;
+ 'Vec<Multiplier>': Vec<Multiplier>;
+ 'Vec<Multisig>': Vec<Multisig>;
+ 'Vec<MultiSignature>': Vec<MultiSignature>;
+ 'Vec<NetworkId>': Vec<NetworkId>;
+ 'Vec<NetworkState>': Vec<NetworkState>;
+ 'Vec<NetworkStatePeerset>': Vec<NetworkStatePeerset>;
+ 'Vec<NetworkStatePeersetInfo>': Vec<NetworkStatePeersetInfo>;
+ 'Vec<NewBidder>': Vec<NewBidder>;
+ 'Vec<NextAuthority>': Vec<NextAuthority>;
+ 'Vec<NextConfigDescriptor>': Vec<NextConfigDescriptor>;
+ 'Vec<NextConfigDescriptorV1>': Vec<NextConfigDescriptorV1>;
+ 'Vec<NodeRole>': Vec<NodeRole>;
+ 'Vec<Nominations>': Vec<Nominations>;
+ 'Vec<NominatorIndex>': Vec<NominatorIndex>;
+ 'Vec<NominatorIndexCompact>': Vec<NominatorIndexCompact>;
+ 'Vec<NotConnectedPeer>': Vec<NotConnectedPeer>;
+ 'Vec<Null>': Vec<Null>;
+ 'Vec<OffchainAccuracy>': Vec<OffchainAccuracy>;
+ 'Vec<OffchainAccuracyCompact>': Vec<OffchainAccuracyCompact>;
+ 'Vec<OffenceDetails>': Vec<OffenceDetails>;
+ 'Vec<Offender>': Vec<Offender>;
+ 'Vec<OpaqueMultiaddr>': Vec<OpaqueMultiaddr>;
+ 'Vec<OpaqueNetworkState>': Vec<OpaqueNetworkState>;
+ 'Vec<OpaquePeerId>': Vec<OpaquePeerId>;
+ 'Vec<OpaqueTimeSlot>': Vec<OpaqueTimeSlot>;
+ 'Vec<OpenTip>': Vec<OpenTip>;
+ 'Vec<OpenTipFinderTo225>': Vec<OpenTipFinderTo225>;
+ 'Vec<OpenTipTip>': Vec<OpenTipTip>;
+ 'Vec<OpenTipTo225>': Vec<OpenTipTo225>;
+ 'Vec<OutboundHrmpMessage>': Vec<OutboundHrmpMessage>;
+ 'Vec<OutboundStatus>': Vec<OutboundStatus>;
+ 'Vec<Outcome>': Vec<Outcome>;
+ 'Vec<OverweightIndex>': Vec<OverweightIndex>;
+ 'Vec<Owner>': Vec<Owner>;
+ 'Vec<PageCounter>': Vec<PageCounter>;
+ 'Vec<PageIndexData>': Vec<PageIndexData>;
+ 'Vec<PalletCallMetadataLatest>': Vec<PalletCallMetadataLatest>;
+ 'Vec<PalletCallMetadataV14>': Vec<PalletCallMetadataV14>;
+ 'Vec<PalletConstantMetadataLatest>': Vec<PalletConstantMetadataLatest>;
+ 'Vec<PalletConstantMetadataV14>': Vec<PalletConstantMetadataV14>;
+ 'Vec<PalletErrorMetadataLatest>': Vec<PalletErrorMetadataLatest>;
+ 'Vec<PalletErrorMetadataV14>': Vec<PalletErrorMetadataV14>;
+ 'Vec<PalletEventMetadataLatest>': Vec<PalletEventMetadataLatest>;
+ 'Vec<PalletEventMetadataV14>': Vec<PalletEventMetadataV14>;
+ 'Vec<PalletMetadataLatest>': Vec<PalletMetadataLatest>;
+ 'Vec<PalletMetadataV14>': Vec<PalletMetadataV14>;
+ 'Vec<PalletStorageMetadataLatest>': Vec<PalletStorageMetadataLatest>;
+ 'Vec<PalletStorageMetadataV14>': Vec<PalletStorageMetadataV14>;
+ 'Vec<ParachainDispatchOrigin>': Vec<ParachainDispatchOrigin>;
+ 'Vec<ParachainInherentData>': Vec<ParachainInherentData>;
+ 'Vec<ParachainProposal>': Vec<ParachainProposal>;
+ 'Vec<ParachainsInherentData>': Vec<ParachainsInherentData>;
+ 'Vec<ParaGenesisArgs>': Vec<ParaGenesisArgs>;
+ 'Vec<ParaId>': Vec<ParaId>;
+ 'Vec<ParaInfo>': Vec<ParaInfo>;
+ 'Vec<ParaLifecycle>': Vec<ParaLifecycle>;
+ 'Vec<ParaPastCodeMeta>': Vec<ParaPastCodeMeta>;
+ 'Vec<ParaScheduling>': Vec<ParaScheduling>;
+ 'Vec<ParathreadClaim>': Vec<ParathreadClaim>;
+ 'Vec<ParathreadClaimQueue>': Vec<ParathreadClaimQueue>;
+ 'Vec<ParathreadEntry>': Vec<ParathreadEntry>;
+ 'Vec<ParaValidatorIndex>': Vec<ParaValidatorIndex>;
+ 'Vec<Peer>': Vec<Peer>;
+ 'Vec<PeerEndpoint>': Vec<PeerEndpoint>;
+ 'Vec<PeerEndpointAddr>': Vec<PeerEndpointAddr>;
+ 'Vec<PeerInfo>': Vec<PeerInfo>;
+ 'Vec<PeerPing>': Vec<PeerPing>;
+ 'Vec<PendingChange>': Vec<PendingChange>;
+ 'Vec<PendingPause>': Vec<PendingPause>;
+ 'Vec<PendingResume>': Vec<PendingResume>;
+ 'Vec<PerDispatchClassU32>': Vec<PerDispatchClassU32>;
+ 'Vec<PerDispatchClassWeight>': Vec<PerDispatchClassWeight>;
+ 'Vec<PerDispatchClassWeightsPerClass>': Vec<PerDispatchClassWeightsPerClass>;
+ 'Vec<Period>': Vec<Period>;
+ 'Vec<PermissionLatest>': Vec<PermissionLatest>;
+ 'Vec<PermissionsV1>': Vec<PermissionsV1>;
+ 'Vec<PermissionVersions>': Vec<PermissionVersions>;
+ 'Vec<PersistedValidationData>': Vec<PersistedValidationData>;
+ 'Vec<Phase>': Vec<Phase>;
+ 'Vec<PhragmenScore>': Vec<PhragmenScore>;
+ 'Vec<Planet>': Vec<Planet>;
+ 'Vec<PluralityJunction>': Vec<PluralityJunction>;
+ 'Vec<Points>': Vec<Points>;
+ 'Vec<PortableRegistry>': Vec<PortableRegistry>;
+ 'Vec<PortableType>': Vec<PortableType>;
+ 'Vec<Precommits>': Vec<Precommits>;
+ 'Vec<PrefabWasmModule>': Vec<PrefabWasmModule>;
+ 'Vec<PrefixedStorageKey>': Vec<PrefixedStorageKey>;
+ 'Vec<PreimageStatus>': Vec<PreimageStatus>;
+ 'Vec<PreimageStatusAvailable>': Vec<PreimageStatusAvailable>;
+ 'Vec<Prevotes>': Vec<Prevotes>;
+ 'Vec<Priority>': Vec<Priority>;
+ 'Vec<PriorLock>': Vec<PriorLock>;
+ 'Vec<PropIndex>': Vec<PropIndex>;
+ 'Vec<Proposal>': Vec<Proposal>;
+ 'Vec<ProposalIndex>': Vec<ProposalIndex>;
+ 'Vec<ProxyAnnouncement>': Vec<ProxyAnnouncement>;
+ 'Vec<ProxyDefinition>': Vec<ProxyDefinition>;
+ 'Vec<ProxyState>': Vec<ProxyState>;
+ 'Vec<ProxyType>': Vec<ProxyType>;
+ 'Vec<QueueConfigData>': Vec<QueueConfigData>;
+ 'Vec<QueuedParathread>': Vec<QueuedParathread>;
+ 'Vec<Randomness>': Vec<Randomness>;
+ 'Vec<Raw>': Vec<Raw>;
+ 'Vec<RawAuraPreDigest>': Vec<RawAuraPreDigest>;
+ 'Vec<RawBabePreDigest>': Vec<RawBabePreDigest>;
+ 'Vec<RawBabePreDigestCompat>': Vec<RawBabePreDigestCompat>;
+ 'Vec<RawBabePreDigestPrimary>': Vec<RawBabePreDigestPrimary>;
+ 'Vec<RawBabePreDigestPrimaryTo159>': Vec<RawBabePreDigestPrimaryTo159>;
+ 'Vec<RawBabePreDigestSecondaryPlain>': Vec<RawBabePreDigestSecondaryPlain>;
+ 'Vec<RawBabePreDigestSecondaryTo159>': Vec<RawBabePreDigestSecondaryTo159>;
+ 'Vec<RawBabePreDigestSecondaryVRF>': Vec<RawBabePreDigestSecondaryVRF>;
+ 'Vec<RawBabePreDigestTo159>': Vec<RawBabePreDigestTo159>;
+ 'Vec<RawOrigin>': Vec<RawOrigin>;
+ 'Vec<RawSolution>': Vec<RawSolution>;
+ 'Vec<RawSolutionTo265>': Vec<RawSolutionTo265>;
+ 'Vec<RawSolutionWith16>': Vec<RawSolutionWith16>;
+ 'Vec<RawSolutionWith24>': Vec<RawSolutionWith24>;
+ 'Vec<RawVRFOutput>': Vec<RawVRFOutput>;
+ 'Vec<ReadProof>': Vec<ReadProof>;
+ 'Vec<ReadySolution>': Vec<ReadySolution>;
+ 'Vec<Reasons>': Vec<Reasons>;
+ 'Vec<RecoveryConfig>': Vec<RecoveryConfig>;
+ 'Vec<RefCount>': Vec<RefCount>;
+ 'Vec<RefCountTo259>': Vec<RefCountTo259>;
+ 'Vec<ReferendumIndex>': Vec<ReferendumIndex>;
+ 'Vec<ReferendumInfo>': Vec<ReferendumInfo>;
+ 'Vec<ReferendumInfoFinished>': Vec<ReferendumInfoFinished>;
+ 'Vec<ReferendumInfoTo239>': Vec<ReferendumInfoTo239>;
+ 'Vec<ReferendumStatus>': Vec<ReferendumStatus>;
+ 'Vec<RegisteredParachainInfo>': Vec<RegisteredParachainInfo>;
+ 'Vec<RegistrarIndex>': Vec<RegistrarIndex>;
+ 'Vec<RegistrarInfo>': Vec<RegistrarInfo>;
+ 'Vec<Registration>': Vec<Registration>;
+ 'Vec<RegistrationJudgement>': Vec<RegistrationJudgement>;
+ 'Vec<RelayBlockNumber>': Vec<RelayBlockNumber>;
+ 'Vec<RelayChainBlockNumber>': Vec<RelayChainBlockNumber>;
+ 'Vec<RelayChainHash>': Vec<RelayChainHash>;
+ 'Vec<RelayHash>': Vec<RelayHash>;
+ 'Vec<Remark>': Vec<Remark>;
+ 'Vec<Renouncing>': Vec<Renouncing>;
+ 'Vec<RentProjection>': Vec<RentProjection>;
+ 'Vec<ReplacementTimes>': Vec<ReplacementTimes>;
+ 'Vec<ReportedRoundStates>': Vec<ReportedRoundStates>;
+ 'Vec<Reporter>': Vec<Reporter>;
+ 'Vec<ReportIdOf>': Vec<ReportIdOf>;
+ 'Vec<ReserveData>': Vec<ReserveData>;
+ 'Vec<ReserveIdentifier>': Vec<ReserveIdentifier>;
+ 'Vec<Retriable>': Vec<Retriable>;
+ 'Vec<RewardDestination>': Vec<RewardDestination>;
+ 'Vec<RewardPoint>': Vec<RewardPoint>;
+ 'Vec<RoundSnapshot>': Vec<RoundSnapshot>;
+ 'Vec<RoundState>': Vec<RoundState>;
+ 'Vec<RpcMethods>': Vec<RpcMethods>;
+ 'Vec<RuntimeDispatchInfo>': Vec<RuntimeDispatchInfo>;
+ 'Vec<RuntimeVersion>': Vec<RuntimeVersion>;
+ 'Vec<RuntimeVersionApi>': Vec<RuntimeVersionApi>;
+ 'Vec<RuntimeVersionPartial>': Vec<RuntimeVersionPartial>;
+ 'Vec<Schedule>': Vec<Schedule>;
+ 'Vec<Scheduled>': Vec<Scheduled>;
+ 'Vec<ScheduledTo254>': Vec<ScheduledTo254>;
+ 'Vec<SchedulePeriod>': Vec<SchedulePeriod>;
+ 'Vec<SchedulePriority>': Vec<SchedulePriority>;
+ 'Vec<ScheduleTo212>': Vec<ScheduleTo212>;
+ 'Vec<ScheduleTo258>': Vec<ScheduleTo258>;
+ 'Vec<ScheduleTo264>': Vec<ScheduleTo264>;
+ 'Vec<Scheduling>': Vec<Scheduling>;
+ 'Vec<SeatHolder>': Vec<SeatHolder>;
+ 'Vec<SeedOf>': Vec<SeedOf>;
+ 'Vec<ServiceQuality>': Vec<ServiceQuality>;
+ 'Vec<SessionIndex>': Vec<SessionIndex>;
+ 'Vec<SessionInfo>': Vec<SessionInfo>;
+ 'Vec<SessionInfoValidatorGroup>': Vec<SessionInfoValidatorGroup>;
+ 'Vec<SessionKeys1>': Vec<SessionKeys1>;
+ 'Vec<SessionKeys10>': Vec<SessionKeys10>;
+ 'Vec<SessionKeys10B>': Vec<SessionKeys10B>;
+ 'Vec<SessionKeys2>': Vec<SessionKeys2>;
+ 'Vec<SessionKeys3>': Vec<SessionKeys3>;
+ 'Vec<SessionKeys4>': Vec<SessionKeys4>;
+ 'Vec<SessionKeys5>': Vec<SessionKeys5>;
+ 'Vec<SessionKeys6>': Vec<SessionKeys6>;
+ 'Vec<SessionKeys6B>': Vec<SessionKeys6B>;
+ 'Vec<SessionKeys7>': Vec<SessionKeys7>;
+ 'Vec<SessionKeys7B>': Vec<SessionKeys7B>;
+ 'Vec<SessionKeys8>': Vec<SessionKeys8>;
+ 'Vec<SessionKeys8B>': Vec<SessionKeys8B>;
+ 'Vec<SessionKeys9>': Vec<SessionKeys9>;
+ 'Vec<SessionKeys9B>': Vec<SessionKeys9B>;
+ 'Vec<SetId>': Vec<SetId>;
+ 'Vec<SetIndex>': Vec<SetIndex>;
+ 'Vec<Si0Field>': Vec<Si0Field>;
+ 'Vec<Si0LookupTypeId>': Vec<Si0LookupTypeId>;
+ 'Vec<Si0Path>': Vec<Si0Path>;
+ 'Vec<Si0Type>': Vec<Si0Type>;
+ 'Vec<Si0TypeDef>': Vec<Si0TypeDef>;
+ 'Vec<Si0TypeDefArray>': Vec<Si0TypeDefArray>;
+ 'Vec<Si0TypeDefBitSequence>': Vec<Si0TypeDefBitSequence>;
+ 'Vec<Si0TypeDefCompact>': Vec<Si0TypeDefCompact>;
+ 'Vec<Si0TypeDefComposite>': Vec<Si0TypeDefComposite>;
+ 'Vec<Si0TypeDefPhantom>': Vec<Si0TypeDefPhantom>;
+ 'Vec<Si0TypeDefPrimitive>': Vec<Si0TypeDefPrimitive>;
+ 'Vec<Si0TypeDefSequence>': Vec<Si0TypeDefSequence>;
+ 'Vec<Si0TypeDefTuple>': Vec<Si0TypeDefTuple>;
+ 'Vec<Si0TypeDefVariant>': Vec<Si0TypeDefVariant>;
+ 'Vec<Si0TypeParameter>': Vec<Si0TypeParameter>;
+ 'Vec<Si0Variant>': Vec<Si0Variant>;
+ 'Vec<SiField>': Vec<SiField>;
+ 'Vec<Signature>': Vec<Signature>;
+ 'Vec<SignedAvailabilityBitfield>': Vec<SignedAvailabilityBitfield>;
+ 'Vec<SignedAvailabilityBitfields>': Vec<SignedAvailabilityBitfields>;
+ 'Vec<SignedExtensionMetadataLatest>': Vec<SignedExtensionMetadataLatest>;
+ 'Vec<SignedExtensionMetadataV14>': Vec<SignedExtensionMetadataV14>;
+ 'Vec<SignedSubmission>': Vec<SignedSubmission>;
+ 'Vec<SignedSubmissionOf>': Vec<SignedSubmissionOf>;
+ 'Vec<SignerPayload>': Vec<SignerPayload>;
+ 'Vec<SigningContext>': Vec<SigningContext>;
+ 'Vec<SiLookupTypeId>': Vec<SiLookupTypeId>;
+ 'Vec<SiPath>': Vec<SiPath>;
+ 'Vec<SiType>': Vec<SiType>;
+ 'Vec<SiTypeDef>': Vec<SiTypeDef>;
+ 'Vec<SiTypeDefArray>': Vec<SiTypeDefArray>;
+ 'Vec<SiTypeDefBitSequence>': Vec<SiTypeDefBitSequence>;
+ 'Vec<SiTypeDefCompact>': Vec<SiTypeDefCompact>;
+ 'Vec<SiTypeDefComposite>': Vec<SiTypeDefComposite>;
+ 'Vec<SiTypeDefPrimitive>': Vec<SiTypeDefPrimitive>;
+ 'Vec<SiTypeDefSequence>': Vec<SiTypeDefSequence>;
+ 'Vec<SiTypeDefTuple>': Vec<SiTypeDefTuple>;
+ 'Vec<SiTypeDefVariant>': Vec<SiTypeDefVariant>;
+ 'Vec<SiTypeParameter>': Vec<SiTypeParameter>;
+ 'Vec<SiVariant>': Vec<SiVariant>;
+ 'Vec<SlashingSpans>': Vec<SlashingSpans>;
+ 'Vec<SlashingSpansTo204>': Vec<SlashingSpansTo204>;
+ 'Vec<SlashJournalEntry>': Vec<SlashJournalEntry>;
+ 'Vec<SlotNumber>': Vec<SlotNumber>;
+ 'Vec<SlotRange>': Vec<SlotRange>;
+ 'Vec<SocietyJudgement>': Vec<SocietyJudgement>;
+ 'Vec<SocietyVote>': Vec<SocietyVote>;
+ 'Vec<SolutionOrSnapshotSize>': Vec<SolutionOrSnapshotSize>;
+ 'Vec<SolutionSupport>': Vec<SolutionSupport>;
+ 'Vec<SolutionSupports>': Vec<SolutionSupports>;
+ 'Vec<SpanIndex>': Vec<SpanIndex>;
+ 'Vec<SpanRecord>': Vec<SpanRecord>;
+ 'Vec<Sr25519Signature>': Vec<Sr25519Signature>;
+ 'Vec<StakingLedger>': Vec<StakingLedger>;
+ 'Vec<StakingLedgerTo223>': Vec<StakingLedgerTo223>;
+ 'Vec<StakingLedgerTo240>': Vec<StakingLedgerTo240>;
+ 'Vec<Statement>': Vec<Statement>;
+ 'Vec<StatementKind>': Vec<StatementKind>;
+ 'Vec<StorageChangeSet>': Vec<StorageChangeSet>;
+ 'Vec<StorageEntryMetadataLatest>': Vec<StorageEntryMetadataLatest>;
+ 'Vec<StorageEntryMetadataV10>': Vec<StorageEntryMetadataV10>;
+ 'Vec<StorageEntryMetadataV11>': Vec<StorageEntryMetadataV11>;
+ 'Vec<StorageEntryMetadataV12>': Vec<StorageEntryMetadataV12>;
+ 'Vec<StorageEntryMetadataV13>': Vec<StorageEntryMetadataV13>;
+ 'Vec<StorageEntryMetadataV14>': Vec<StorageEntryMetadataV14>;
+ 'Vec<StorageEntryMetadataV9>': Vec<StorageEntryMetadataV9>;
+ 'Vec<StorageEntryModifierLatest>': Vec<StorageEntryModifierLatest>;
+ 'Vec<StorageEntryModifierV10>': Vec<StorageEntryModifierV10>;
+ 'Vec<StorageEntryModifierV11>': Vec<StorageEntryModifierV11>;
+ 'Vec<StorageEntryModifierV12>': Vec<StorageEntryModifierV12>;
+ 'Vec<StorageEntryModifierV13>': Vec<StorageEntryModifierV13>;
+ 'Vec<StorageEntryModifierV14>': Vec<StorageEntryModifierV14>;
+ 'Vec<StorageEntryModifierV9>': Vec<StorageEntryModifierV9>;
+ 'Vec<StorageEntryTypeLatest>': Vec<StorageEntryTypeLatest>;
+ 'Vec<StorageEntryTypeV10>': Vec<StorageEntryTypeV10>;
+ 'Vec<StorageEntryTypeV11>': Vec<StorageEntryTypeV11>;
+ 'Vec<StorageEntryTypeV12>': Vec<StorageEntryTypeV12>;
+ 'Vec<StorageEntryTypeV13>': Vec<StorageEntryTypeV13>;
+ 'Vec<StorageEntryTypeV14>': Vec<StorageEntryTypeV14>;
+ 'Vec<StorageEntryTypeV9>': Vec<StorageEntryTypeV9>;
+ 'Vec<StorageHasher>': Vec<StorageHasher>;
+ 'Vec<StorageHasherV10>': Vec<StorageHasherV10>;
+ 'Vec<StorageHasherV11>': Vec<StorageHasherV11>;
+ 'Vec<StorageHasherV12>': Vec<StorageHasherV12>;
+ 'Vec<StorageHasherV13>': Vec<StorageHasherV13>;
+ 'Vec<StorageHasherV14>': Vec<StorageHasherV14>;
+ 'Vec<StorageHasherV9>': Vec<StorageHasherV9>;
+ 'Vec<StorageKey>': Vec<StorageKey>;
+ 'Vec<StorageKind>': Vec<StorageKind>;
+ 'Vec<StorageMetadataLatest>': Vec<StorageMetadataLatest>;
+ 'Vec<StorageMetadataV10>': Vec<StorageMetadataV10>;
+ 'Vec<StorageMetadataV11>': Vec<StorageMetadataV11>;
+ 'Vec<StorageMetadataV12>': Vec<StorageMetadataV12>;
+ 'Vec<StorageMetadataV13>': Vec<StorageMetadataV13>;
+ 'Vec<StorageMetadataV9>': Vec<StorageMetadataV9>;
+ 'Vec<StoredPendingChange>': Vec<StoredPendingChange>;
+ 'Vec<StoredState>': Vec<StoredState>;
+ 'Vec<StrikeCount>': Vec<StrikeCount>;
+ 'Vec<SubId>': Vec<SubId>;
+ 'Vec<SubmissionIndicesOf>': Vec<SubmissionIndicesOf>;
+ 'Vec<Supports>': Vec<Supports>;
+ 'Vec<SyncState>': Vec<SyncState>;
+ 'Vec<SystemInherentData>': Vec<SystemInherentData>;
+ 'Vec<SystemOrigin>': Vec<SystemOrigin>;
+ 'Vec<Tally>': Vec<Tally>;
+ 'Vec<TaskAddress>': Vec<TaskAddress>;
+ 'Vec<TAssetBalance>': Vec<TAssetBalance>;
+ 'Vec<TAssetDepositBalance>': Vec<TAssetDepositBalance>;
+ 'Vec<Text>': Vec<Text>;
+ 'Vec<Timepoint>': Vec<Timepoint>;
+ 'Vec<TokenError>': Vec<TokenError>;
+ 'Vec<TombstoneContractInfo>': Vec<TombstoneContractInfo>;
+ 'Vec<TraceBlockResponse>': Vec<TraceBlockResponse>;
+ 'Vec<TraceError>': Vec<TraceError>;
+ 'Vec<TransactionValidityError>': Vec<TransactionValidityError>;
+ 'Vec<TransientValidationData>': Vec<TransientValidationData>;
+ 'Vec<TreasuryProposal>': Vec<TreasuryProposal>;
+ 'Vec<TrieId>': Vec<TrieId>;
+ 'Vec<TrieIndex>': Vec<TrieIndex>;
+ 'Vec<Type>': Vec<Type>;
+ 'Vec<u128>': Vec<u128>;
+ 'Vec<U128>': Vec<U128>;
+ 'Vec<u16>': Vec<u16>;
+ 'Vec<U16>': Vec<U16>;
+ 'Vec<u256>': Vec<u256>;
+ 'Vec<U256>': Vec<U256>;
+ 'Vec<u32>': Vec<u32>;
+ 'Vec<U32>': Vec<U32>;
+ 'Vec<u64>': Vec<u64>;
+ 'Vec<U64>': Vec<U64>;
+ 'Vec<u8>': Vec<u8>;
+ 'Vec<U8>': Vec<U8>;
+ 'Vec<UnappliedSlash>': Vec<UnappliedSlash>;
+ 'Vec<UnappliedSlashOther>': Vec<UnappliedSlashOther>;
+ 'Vec<UncleEntryItem>': Vec<UncleEntryItem>;
+ 'Vec<UnknownTransaction>': Vec<UnknownTransaction>;
+ 'Vec<UnlockChunk>': Vec<UnlockChunk>;
+ 'Vec<UpwardMessage>': Vec<UpwardMessage>;
+ 'Vec<usize>': Vec<usize>;
+ 'Vec<USize>': Vec<USize>;
+ 'Vec<ValidationCode>': Vec<ValidationCode>;
+ 'Vec<ValidationCodeHash>': Vec<ValidationCodeHash>;
+ 'Vec<ValidationData>': Vec<ValidationData>;
+ 'Vec<ValidationDataType>': Vec<ValidationDataType>;
+ 'Vec<ValidationFunctionParams>': Vec<ValidationFunctionParams>;
+ 'Vec<ValidatorCount>': Vec<ValidatorCount>;
+ 'Vec<ValidatorIndex>': Vec<ValidatorIndex>;
+ 'Vec<ValidatorIndexCompact>': Vec<ValidatorIndexCompact>;
+ 'Vec<ValidatorPrefs>': Vec<ValidatorPrefs>;
+ 'Vec<ValidatorPrefsTo145>': Vec<ValidatorPrefsTo145>;
+ 'Vec<ValidatorPrefsTo196>': Vec<ValidatorPrefsTo196>;
+ 'Vec<ValidatorPrefsWithBlocked>': Vec<ValidatorPrefsWithBlocked>;
+ 'Vec<ValidatorPrefsWithCommission>': Vec<ValidatorPrefsWithCommission>;
+ 'Vec<ValidatorSetId>': Vec<ValidatorSetId>;
+ 'Vec<ValidatorSignature>': Vec<ValidatorSignature>;
+ 'Vec<ValidDisputeStatementKind>': Vec<ValidDisputeStatementKind>;
+ 'Vec<ValidityAttestation>': Vec<ValidityAttestation>;
+ 'Vec<VecInboundHrmpMessage>': Vec<VecInboundHrmpMessage>;
+ 'Vec<VersionedMultiAsset>': Vec<VersionedMultiAsset>;
+ 'Vec<VersionedMultiLocation>': Vec<VersionedMultiLocation>;
+ 'Vec<VersionedXcm>': Vec<VersionedXcm>;
+ 'Vec<VestingInfo>': Vec<VestingInfo>;
+ 'Vec<VestingSchedule>': Vec<VestingSchedule>;
+ 'Vec<Vote>': Vec<Vote>;
+ 'Vec<VoteIndex>': Vec<VoteIndex>;
+ 'Vec<Voter>': Vec<Voter>;
+ 'Vec<VoterInfo>': Vec<VoterInfo>;
+ 'Vec<Votes>': Vec<Votes>;
+ 'Vec<VotesTo230>': Vec<VotesTo230>;
+ 'Vec<VoteThreshold>': Vec<VoteThreshold>;
+ 'Vec<VoteWeight>': Vec<VoteWeight>;
+ 'Vec<Voting>': Vec<Voting>;
+ 'Vec<VotingDelegating>': Vec<VotingDelegating>;
+ 'Vec<VotingDirect>': Vec<VotingDirect>;
+ 'Vec<VotingDirectVote>': Vec<VotingDirectVote>;
+ 'Vec<VouchingStatus>': Vec<VouchingStatus>;
+ 'Vec<VrfData>': Vec<VrfData>;
+ 'Vec<VrfOutput>': Vec<VrfOutput>;
+ 'Vec<VrfProof>': Vec<VrfProof>;
+ 'Vec<WeightPerClass>': Vec<WeightPerClass>;
+ 'Vec<WeightToFeeCoefficient>': Vec<WeightToFeeCoefficient>;
+ 'Vec<WinnersData>': Vec<WinnersData>;
+ 'Vec<WinnersDataTuple>': Vec<WinnersDataTuple>;
+ 'Vec<WinningData>': Vec<WinningData>;
+ 'Vec<WinningDataEntry>': Vec<WinningDataEntry>;
+ 'Vec<WithdrawReasons>': Vec<WithdrawReasons>;
+ 'Vec<Xcm>': Vec<Xcm>;
+ 'Vec<XcmAssetEffects>': Vec<XcmAssetEffects>;
+ 'Vec<XcmError>': Vec<XcmError>;
+ 'Vec<XcmHrmpChannelAccepted>': Vec<XcmHrmpChannelAccepted>;
+ 'Vec<XcmHrmpChannelClosing>': Vec<XcmHrmpChannelClosing>;
+ 'Vec<XcmHrmpNewChannelOpenRequest>': Vec<XcmHrmpNewChannelOpenRequest>;
+ 'Vec<XcmOrder>': Vec<XcmOrder>;
+ 'Vec<XcmOrderBuyExecution>': Vec<XcmOrderBuyExecution>;
+ 'Vec<XcmOrderDepositAsset>': Vec<XcmOrderDepositAsset>;
+ 'Vec<XcmOrderDepositReserveAsset>': Vec<XcmOrderDepositReserveAsset>;
+ 'Vec<XcmOrderExchangeAsset>': Vec<XcmOrderExchangeAsset>;
+ 'Vec<XcmOrderInitiateReserveWithdraw>': Vec<XcmOrderInitiateReserveWithdraw>;
+ 'Vec<XcmOrderInitiateTeleport>': Vec<XcmOrderInitiateTeleport>;
+ 'Vec<XcmOrderQueryHolding>': Vec<XcmOrderQueryHolding>;
+ 'Vec<XcmOrigin>': Vec<XcmOrigin>;
+ 'Vec<XcmOriginKind>': Vec<XcmOriginKind>;
+ 'Vec<XcmpMessageFormat>': Vec<XcmpMessageFormat>;
+ 'Vec<XcmQueryResponse>': Vec<XcmQueryResponse>;
+ 'Vec<XcmRelayedFrom>': Vec<XcmRelayedFrom>;
+ 'Vec<XcmReserveAssetDeposit>': Vec<XcmReserveAssetDeposit>;
+ 'Vec<XcmResponse>': Vec<XcmResponse>;
+ 'Vec<XcmTeleportAsset>': Vec<XcmTeleportAsset>;
+ 'Vec<XcmTransact>': Vec<XcmTransact>;
+ 'Vec<XcmTransferAsset>': Vec<XcmTransferAsset>;
+ 'Vec<XcmTransferReserveAsset>': Vec<XcmTransferReserveAsset>;
+ 'Vec<XcmWithdrawAsset>': Vec<XcmWithdrawAsset>;
+ AbridgedCandidateReceipt: AbridgedCandidateReceipt;
+ AbridgedHostConfiguration: AbridgedHostConfiguration;
+ AbridgedHrmpChannel: AbridgedHrmpChannel;
+ AccountData: AccountData;
+ AccountId32Junction: AccountId32Junction;
+ AccountIndex64Junction: AccountIndex64Junction;
+ AccountInfo: AccountInfo;
+ AccountInfoWithDualRefCount: AccountInfoWithDualRefCount;
+ AccountInfoWithProviders: AccountInfoWithProviders;
+ AccountInfoWithRefCount: AccountInfoWithRefCount;
+ AccountInfoWithRefCountU8: AccountInfoWithRefCountU8;
+ AccountInfoWithTripleRefCount: AccountInfoWithTripleRefCount;
+ AccountKey20Junction: AccountKey20Junction;
+ AccountStatus: AccountStatus;
+ AccountValidity: AccountValidity;
+ AccountVote: AccountVote;
+ AccountVoteSplit: AccountVoteSplit;
+ AccountVoteStandard: AccountVoteStandard;
+ ActiveEraInfo: ActiveEraInfo;
+ ActiveGilt: ActiveGilt;
+ ActiveGiltsTotal: ActiveGiltsTotal;
+ ActiveIndex: ActiveIndex;
+ ActiveRecovery: ActiveRecovery;
+ 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;
+ AssetInstance: AssetInstance;
+ 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;
+ BalanceStatus: BalanceStatus;
+ BeefyCommitment: BeefyCommitment;
+ BeefyId: BeefyId;
+ BeefyKey: BeefyKey;
+ BeefyNextAuthoritySet: BeefyNextAuthoritySet;
+ BeefyPayload: BeefyPayload;
+ BeefySignedCommitment: BeefySignedCommitment;
+ Bid: Bid;
+ Bidder: Bidder;
+ BidKind: BidKind;
+ BitVec: BitVec;
+ BlockAttestations: BlockAttestations;
+ BlockHash: BlockHash;
+ BlockLength: BlockLength;
+ BlockTrace: BlockTrace;
+ BlockTraceEvent: BlockTraceEvent;
+ BlockTraceEventData: BlockTraceEventData;
+ BlockTraceSpan: BlockTraceSpan;
+ BlockWeights: BlockWeights;
+ BodyId: BodyId;
+ BodyPart: BodyPart;
+ BodyPartAtLeastProportion: BodyPartAtLeastProportion;
+ BodyPartFraction: BodyPartFraction;
+ BodyPartMoreThanProportion: BodyPartMoreThanProportion;
+ bool: bool;
+ Bool: Bool;
+ Bounty: Bounty;
+ BountyIndex: BountyIndex;
+ BountyStatus: BountyStatus;
+ BountyStatusActive: BountyStatusActive;
+ BountyStatusCuratorProposed: BountyStatusCuratorProposed;
+ BountyStatusPendingPayout: BountyStatusPendingPayout;
+ BridgedBlockHash: BridgedBlockHash;
+ BridgedBlockNumber: BridgedBlockNumber;
+ BridgedHeader: BridgedHeader;
+ BufferedSessionChange: BufferedSessionChange;
+ Bytes: Bytes;
+ CallIndex: CallIndex;
+ CandidateCommitments: CandidateCommitments;
+ CandidateDescriptor: CandidateDescriptor;
+ CandidateHash: CandidateHash;
+ CandidateInfo: CandidateInfo;
+ CandidatePendingAvailability: CandidatePendingAvailability;
+ CandidateReceipt: CandidateReceipt;
+ CertValue: CertValue;
+ ChainProperties: ChainProperties;
+ ChainType: ChainType;
+ ClassDetails: ClassDetails;
+ ClassId: ClassId;
+ ClassMetadata: ClassMetadata;
+ 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;
+ 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;
+ ContractLayoutArray: ContractLayoutArray;
+ ContractLayoutCell: ContractLayoutCell;
+ ContractLayoutEnum: ContractLayoutEnum;
+ ContractLayoutHash: ContractLayoutHash;
+ ContractLayoutHashingStrategy: ContractLayoutHashingStrategy;
+ ContractLayoutKey: ContractLayoutKey;
+ ContractLayoutStruct: ContractLayoutStruct;
+ ContractLayoutStructField: ContractLayoutStructField;
+ ContractMessageParamSpec: ContractMessageParamSpec;
+ ContractMessageSpec: ContractMessageSpec;
+ ContractProject: ContractProject;
+ ContractProjectContract: ContractProjectContract;
+ ContractProjectSource: ContractProjectSource;
+ ContractSelector: ContractSelector;
+ ContractStorageKey: ContractStorageKey;
+ ContractStorageLayout: ContractStorageLayout;
+ ContractTypeSpec: ContractTypeSpec;
+ Conviction: Conviction;
+ CoreAssignment: CoreAssignment;
+ CoreIndex: CoreIndex;
+ CoreOccupied: CoreOccupied;
+ CreatedBlock: CreatedBlock;
+ Data: Data;
+ DeferredOffenceOf: DeferredOffenceOf;
+ DefunctVoter: DefunctVoter;
+ DelayKind: DelayKind;
+ DelayKindBest: DelayKindBest;
+ Delegations: Delegations;
+ DeletedContract: DeletedContract;
+ DepositBalance: DepositBalance;
+ DepositBalanceOf: DepositBalanceOf;
+ DestroyWitness: DestroyWitness;
+ DigestOf: DigestOf;
+ DispatchClass: DispatchClass;
+ DispatchError: DispatchError;
+ DispatchErrorModule: DispatchErrorModule;
+ DispatchErrorTo198: DispatchErrorTo198;
+ DispatchInfo: DispatchInfo;
+ DispatchInfoTo190: DispatchInfoTo190;
+ DispatchInfoTo244: DispatchInfoTo244;
+ DispatchOutcome: DispatchOutcome;
+ DispatchResult: DispatchResult;
+ DispatchResultOf: DispatchResultOf;
+ DispatchResultTo198: DispatchResultTo198;
+ DisputeStatement: DisputeStatement;
+ DisputeStatementSet: DisputeStatementSet;
+ DoubleEncodedCall: DoubleEncodedCall;
+ DoubleVoteReport: DoubleVoteReport;
+ DownwardMessage: DownwardMessage;
+ EcdsaSignature: EcdsaSignature;
+ Ed25519Signature: Ed25519Signature;
+ ElectionCompute: ElectionCompute;
+ ElectionPhase: ElectionPhase;
+ ElectionResult: ElectionResult;
+ ElectionScore: ElectionScore;
+ ElectionSize: ElectionSize;
+ ElectionStatus: ElectionStatus;
+ EncodedFinalityProofs: EncodedFinalityProofs;
+ EpochAuthorship: EpochAuthorship;
+ EraIndex: EraIndex;
+ EraPoints: EraPoints;
+ EraRewardPoints: EraRewardPoints;
+ EraRewards: EraRewards;
+ ErrorMetadataLatest: ErrorMetadataLatest;
+ ErrorMetadataV10: ErrorMetadataV10;
+ ErrorMetadataV11: ErrorMetadataV11;
+ ErrorMetadataV12: ErrorMetadataV12;
+ ErrorMetadataV13: ErrorMetadataV13;
+ ErrorMetadataV9: ErrorMetadataV9;
+ EthAccount: EthAccount;
+ EthBlock: EthBlock;
+ EthBloom: EthBloom;
+ EthCallRequest: EthCallRequest;
+ EthereumAccountId: EthereumAccountId;
+ EthereumAddress: EthereumAddress;
+ EthereumLookupSource: EthereumLookupSource;
+ EthereumSignature: EthereumSignature;
+ 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;
+ EventMetadataV9: EventMetadataV9;
+ EventRecord: EventRecord;
+ EvmAccount: EvmAccount;
+ 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;
+ ExtrinsicUnknown: ExtrinsicUnknown;
+ ExtrinsicV4: ExtrinsicV4;
+ FeeDetails: FeeDetails;
+ Forcing: Forcing;
+ ForkTreePendingChange: ForkTreePendingChange;
+ ForkTreePendingChangeNode: ForkTreePendingChangeNode;
+ FullIdentification: FullIdentification;
+ FunctionArgumentMetadataLatest: FunctionArgumentMetadataLatest;
+ FunctionArgumentMetadataV10: FunctionArgumentMetadataV10;
+ FunctionArgumentMetadataV11: FunctionArgumentMetadataV11;
+ FunctionArgumentMetadataV12: FunctionArgumentMetadataV12;
+ FunctionArgumentMetadataV13: FunctionArgumentMetadataV13;
+ FunctionArgumentMetadataV9: FunctionArgumentMetadataV9;
+ FunctionMetadataLatest: FunctionMetadataLatest;
+ FunctionMetadataV10: FunctionMetadataV10;
+ FunctionMetadataV11: FunctionMetadataV11;
+ FunctionMetadataV12: FunctionMetadataV12;
+ FunctionMetadataV13: FunctionMetadataV13;
+ FunctionMetadataV9: FunctionMetadataV9;
+ FundIndex: FundIndex;
+ FundInfo: FundInfo;
+ 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;
+ HeadData: HeadData;
+ 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;
+ i64: i64;
+ I64: I64;
+ i8: i8;
+ I8: I8;
+ IdentificationTuple: IdentificationTuple;
+ IdentityFields: IdentityFields;
+ IdentityInfo: IdentityInfo;
+ IdentityInfoAdditional: IdentityInfoAdditional;
+ IdentityJudgement: IdentityJudgement;
+ IdtyCertMeta: IdtyCertMeta;
+ IdtyData: IdtyData;
+ IdtyDid: IdtyDid;
+ IdtyIndex: IdtyIndex;
+ IdtyRight: IdtyRight;
+ IdtyStatus: IdtyStatus;
+ IdtyValue: IdtyValue;
+ ImmortalEra: ImmortalEra;
+ ImportedAux: ImportedAux;
+ InboundDownwardMessage: InboundDownwardMessage;
+ InboundHrmpMessage: InboundHrmpMessage;
+ InboundHrmpMessages: InboundHrmpMessages;
+ InboundStatus: InboundStatus;
+ IncludedBlocks: IncludedBlocks;
+ InclusionFee: InclusionFee;
+ IncomingParachain: IncomingParachain;
+ IncomingParachainDeploy: IncomingParachainDeploy;
+ IncomingParachainFixed: IncomingParachainFixed;
+ IndividualExposure: IndividualExposure;
+ InitializationData: InitializationData;
+ InstanceDetails: InstanceDetails;
+ InstanceId: InstanceId;
+ InstanceMetadata: InstanceMetadata;
+ InstantiateRequest: InstantiateRequest;
+ InstantiateReturnValue: InstantiateReturnValue;
+ InstructionWeights: InstructionWeights;
+ InvalidDisputeStatementKind: InvalidDisputeStatementKind;
+ InvalidTransaction: InvalidTransaction;
+ Json: Json;
+ Junction: Junction;
+ JustificationNotification: JustificationNotification;
+ Key: Key;
+ KeyOwnerProof: KeyOwnerProof;
+ Keys: Keys;
+ KeyType: KeyType;
+ KeyValueOption: KeyValueOption;
+ Kind: Kind;
+ LastContribution: LastContribution;
+ LastRuntimeUpgradeInfo: LastRuntimeUpgradeInfo;
+ LeasePeriod: LeasePeriod;
+ LeasePeriodOf: LeasePeriodOf;
+ Limits: Limits;
+ LimitsTo264: LimitsTo264;
+ LocalValidationData: LocalValidationData;
+ LotteryConfig: LotteryConfig;
+ MaybeRandomness: MaybeRandomness;
+ MaybeVrf: MaybeVrf;
+ MemberCount: MemberCount;
+ MembershipProof: MembershipProof;
+ MessageId: MessageId;
+ MessageIngestionType: MessageIngestionType;
+ MessageQueueChain: MessageQueueChain;
+ MessagingStateSnapshot: MessagingStateSnapshot;
+ MessagingStateSnapshotEgressEntry: MessagingStateSnapshotEgressEntry;
+ MetadataAll: MetadataAll;
+ MetadataLatest: MetadataLatest;
+ MetadataV10: MetadataV10;
+ MetadataV11: MetadataV11;
+ MetadataV12: MetadataV12;
+ MetadataV13: MetadataV13;
+ MetadataV14: MetadataV14;
+ MetadataV9: MetadataV9;
+ MmrLeafProof: MmrLeafProof;
+ MmrRootHash: MmrRootHash;
+ ModuleConstantMetadataLatest: ModuleConstantMetadataLatest;
+ ModuleConstantMetadataV10: ModuleConstantMetadataV10;
+ ModuleConstantMetadataV11: ModuleConstantMetadataV11;
+ ModuleConstantMetadataV12: ModuleConstantMetadataV12;
+ ModuleConstantMetadataV13: ModuleConstantMetadataV13;
+ ModuleConstantMetadataV9: ModuleConstantMetadataV9;
+ ModuleMetadataLatest: ModuleMetadataLatest;
+ ModuleMetadataV10: ModuleMetadataV10;
+ ModuleMetadataV11: ModuleMetadataV11;
+ ModuleMetadataV12: ModuleMetadataV12;
+ ModuleMetadataV13: ModuleMetadataV13;
+ ModuleMetadataV9: ModuleMetadataV9;
+ MomentOf: MomentOf;
+ MoreAttestations: MoreAttestations;
+ MortalEra: MortalEra;
+ MultiAsset: MultiAsset;
+ MultiAssetAbstractFungible: MultiAssetAbstractFungible;
+ MultiAssetAbstractNonFungible: MultiAssetAbstractNonFungible;
+ MultiAssetConcreteFungible: MultiAssetConcreteFungible;
+ MultiAssetConcreteNonFungible: MultiAssetConcreteNonFungible;
+ MultiDisputeStatementSet: MultiDisputeStatementSet;
+ MultiLocation: MultiLocation;
+ Multiplier: Multiplier;
+ Multisig: Multisig;
+ MultiSignature: MultiSignature;
+ NetworkId: NetworkId;
+ NetworkState: NetworkState;
+ NetworkStatePeerset: NetworkStatePeerset;
+ NetworkStatePeersetInfo: NetworkStatePeersetInfo;
+ NewBidder: NewBidder;
+ NextAuthority: NextAuthority;
+ NextConfigDescriptor: NextConfigDescriptor;
+ NextConfigDescriptorV1: NextConfigDescriptorV1;
+ NodeRole: NodeRole;
+ Nominations: Nominations;
+ NominatorIndex: NominatorIndex;
+ NominatorIndexCompact: NominatorIndexCompact;
+ NotConnectedPeer: NotConnectedPeer;
+ Null: Null;
+ OffchainAccuracy: OffchainAccuracy;
+ OffchainAccuracyCompact: OffchainAccuracyCompact;
+ OffenceDetails: OffenceDetails;
+ Offender: Offender;
+ OpaqueMultiaddr: OpaqueMultiaddr;
+ OpaqueNetworkState: OpaqueNetworkState;
+ OpaquePeerId: OpaquePeerId;
+ OpaqueTimeSlot: OpaqueTimeSlot;
+ OpenTip: OpenTip;
+ OpenTipFinderTo225: OpenTipFinderTo225;
+ OpenTipTip: OpenTipTip;
+ OpenTipTo225: OpenTipTo225;
+ OutboundHrmpMessage: OutboundHrmpMessage;
+ OutboundStatus: OutboundStatus;
+ Outcome: Outcome;
+ OverweightIndex: OverweightIndex;
+ Owner: Owner;
+ PageCounter: PageCounter;
+ PageIndexData: PageIndexData;
+ PalletCallMetadataLatest: PalletCallMetadataLatest;
+ PalletCallMetadataV14: PalletCallMetadataV14;
+ PalletConstantMetadataLatest: PalletConstantMetadataLatest;
+ PalletConstantMetadataV14: PalletConstantMetadataV14;
+ PalletErrorMetadataLatest: PalletErrorMetadataLatest;
+ PalletErrorMetadataV14: PalletErrorMetadataV14;
+ PalletEventMetadataLatest: PalletEventMetadataLatest;
+ PalletEventMetadataV14: PalletEventMetadataV14;
+ PalletMetadataLatest: PalletMetadataLatest;
+ PalletMetadataV14: PalletMetadataV14;
+ PalletStorageMetadataLatest: PalletStorageMetadataLatest;
+ PalletStorageMetadataV14: PalletStorageMetadataV14;
+ ParachainDispatchOrigin: ParachainDispatchOrigin;
+ ParachainInherentData: ParachainInherentData;
+ ParachainProposal: ParachainProposal;
+ ParachainsInherentData: ParachainsInherentData;
+ ParaGenesisArgs: ParaGenesisArgs;
+ ParaId: ParaId;
+ ParaInfo: ParaInfo;
+ ParaLifecycle: ParaLifecycle;
+ ParaPastCodeMeta: ParaPastCodeMeta;
+ ParaScheduling: ParaScheduling;
+ ParathreadClaim: ParathreadClaim;
+ ParathreadClaimQueue: ParathreadClaimQueue;
+ ParathreadEntry: ParathreadEntry;
+ ParaValidatorIndex: ParaValidatorIndex;
+ Peer: Peer;
+ PeerEndpoint: PeerEndpoint;
+ PeerEndpointAddr: PeerEndpointAddr;
+ PeerInfo: PeerInfo;
+ PeerPing: PeerPing;
+ PendingChange: PendingChange;
+ PendingPause: PendingPause;
+ PendingResume: PendingResume;
+ PerDispatchClassU32: PerDispatchClassU32;
+ PerDispatchClassWeight: PerDispatchClassWeight;
+ PerDispatchClassWeightsPerClass: PerDispatchClassWeightsPerClass;
+ Period: Period;
+ PermissionLatest: PermissionLatest;
+ PermissionsV1: PermissionsV1;
+ PermissionVersions: PermissionVersions;
+ PersistedValidationData: PersistedValidationData;
+ Phase: Phase;
+ PhragmenScore: PhragmenScore;
+ Planet: Planet;
+ PluralityJunction: PluralityJunction;
+ Points: Points;
+ PortableRegistry: PortableRegistry;
+ PortableType: PortableType;
+ Precommits: Precommits;
+ PrefabWasmModule: PrefabWasmModule;
+ PrefixedStorageKey: PrefixedStorageKey;
+ PreimageStatus: PreimageStatus;
+ PreimageStatusAvailable: PreimageStatusAvailable;
+ Prevotes: Prevotes;
+ Priority: Priority;
+ PriorLock: PriorLock;
+ PropIndex: PropIndex;
+ Proposal: Proposal;
+ ProposalIndex: ProposalIndex;
+ ProxyAnnouncement: ProxyAnnouncement;
+ ProxyDefinition: ProxyDefinition;
+ ProxyState: ProxyState;
+ ProxyType: ProxyType;
+ 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;
+ RelayBlockNumber: RelayBlockNumber;
+ RelayChainBlockNumber: RelayChainBlockNumber;
+ RelayChainHash: RelayChainHash;
+ RelayHash: RelayHash;
+ Remark: Remark;
+ Renouncing: Renouncing;
+ RentProjection: RentProjection;
+ ReplacementTimes: ReplacementTimes;
+ ReportedRoundStates: ReportedRoundStates;
+ Reporter: Reporter;
+ ReportIdOf: ReportIdOf;
+ ReserveData: ReserveData;
+ ReserveIdentifier: ReserveIdentifier;
+ Retriable: Retriable;
+ RewardDestination: RewardDestination;
+ RewardPoint: RewardPoint;
+ RoundSnapshot: RoundSnapshot;
+ RoundState: RoundState;
+ RpcMethods: RpcMethods;
+ 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;
+ 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;
+ SiField: SiField;
+ Signature: Signature;
+ SignedAvailabilityBitfield: SignedAvailabilityBitfield;
+ SignedAvailabilityBitfields: SignedAvailabilityBitfields;
+ SignedExtensionMetadataLatest: SignedExtensionMetadataLatest;
+ SignedExtensionMetadataV14: SignedExtensionMetadataV14;
+ SignedSubmission: SignedSubmission;
+ SignedSubmissionOf: SignedSubmissionOf;
+ 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;
+ SlotNumber: SlotNumber;
+ SlotRange: SlotRange;
+ SocietyJudgement: SocietyJudgement;
+ SocietyVote: SocietyVote;
+ SolutionOrSnapshotSize: SolutionOrSnapshotSize;
+ SolutionSupport: SolutionSupport;
+ SolutionSupports: SolutionSupports;
+ SpanIndex: SpanIndex;
+ SpanRecord: SpanRecord;
+ Sr25519Signature: Sr25519Signature;
+ StakingLedger: StakingLedger;
+ StakingLedgerTo223: StakingLedgerTo223;
+ StakingLedgerTo240: StakingLedgerTo240;
+ Statement: Statement;
+ StatementKind: StatementKind;
+ StorageChangeSet: StorageChangeSet;
+ 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;
+ StorageMetadataLatest: StorageMetadataLatest;
+ StorageMetadataV10: StorageMetadataV10;
+ StorageMetadataV11: StorageMetadataV11;
+ StorageMetadataV12: StorageMetadataV12;
+ StorageMetadataV13: StorageMetadataV13;
+ StorageMetadataV9: StorageMetadataV9;
+ 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;
+ 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;
+ u64: u64;
+ U64: U64;
+ u8: u8;
+ U8: U8;
+ UnappliedSlash: UnappliedSlash;
+ UnappliedSlashOther: UnappliedSlashOther;
+ UncleEntryItem: UncleEntryItem;
+ UnknownTransaction: UnknownTransaction;
+ UnlockChunk: UnlockChunk;
+ UpwardMessage: UpwardMessage;
+ usize: usize;
+ USize: USize;
+ ValidationCode: ValidationCode;
+ ValidationCodeHash: ValidationCodeHash;
+ ValidationData: ValidationData;
+ ValidationDataType: ValidationDataType;
+ ValidationFunctionParams: ValidationFunctionParams;
+ ValidatorCount: ValidatorCount;
+ 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;
+ VersionedMultiLocation: VersionedMultiLocation;
+ VersionedXcm: VersionedXcm;
+ 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;
+ WeightPerClass: WeightPerClass;
+ WeightToFeeCoefficient: WeightToFeeCoefficient;
+ WinnersData: WinnersData;
+ WinnersDataTuple: WinnersDataTuple;
+ WinningData: WinningData;
+ WinningDataEntry: WinningDataEntry;
+ WithdrawReasons: WithdrawReasons;
+ Xcm: Xcm;
+ XcmAssetEffects: XcmAssetEffects;
+ XcmError: XcmError;
+ XcmHrmpChannelAccepted: XcmHrmpChannelAccepted;
+ XcmHrmpChannelClosing: XcmHrmpChannelClosing;
+ XcmHrmpNewChannelOpenRequest: XcmHrmpNewChannelOpenRequest;
+ XcmOrder: XcmOrder;
+ XcmOrderBuyExecution: XcmOrderBuyExecution;
+ XcmOrderDepositAsset: XcmOrderDepositAsset;
+ XcmOrderDepositReserveAsset: XcmOrderDepositReserveAsset;
+ XcmOrderExchangeAsset: XcmOrderExchangeAsset;
+ XcmOrderInitiateReserveWithdraw: XcmOrderInitiateReserveWithdraw;
+ XcmOrderInitiateTeleport: XcmOrderInitiateTeleport;
+ XcmOrderQueryHolding: XcmOrderQueryHolding;
+ XcmOrigin: XcmOrigin;
+ XcmOriginKind: XcmOriginKind;
+ XcmpMessageFormat: XcmpMessageFormat;
+ XcmQueryResponse: XcmQueryResponse;
+ XcmRelayedFrom: XcmRelayedFrom;
+ XcmReserveAssetDeposit: XcmReserveAssetDeposit;
+ XcmResponse: XcmResponse;
+ XcmTeleportAsset: XcmTeleportAsset;
+ XcmTransact: XcmTransact;
+ XcmTransferAsset: XcmTransferAsset;
+ XcmTransferReserveAsset: XcmTransferReserveAsset;
+ XcmWithdrawAsset: XcmWithdrawAsset;
+ }
+}
diff --git a/types-bundle/src/interfaces/index.ts b/types-bundle/src/interfaces/index.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2d307291c395445022764d85d9f991f6588c36a0
--- /dev/null
+++ b/types-bundle/src/interfaces/index.ts
@@ -0,0 +1,4 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+export * from './types';
diff --git a/types-bundle/src/interfaces/runtime/index.ts b/types-bundle/src/interfaces/runtime/index.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2d307291c395445022764d85d9f991f6588c36a0
--- /dev/null
+++ b/types-bundle/src/interfaces/runtime/index.ts
@@ -0,0 +1,4 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+export * from './types';
diff --git a/types-bundle/src/interfaces/runtime/types.ts b/types-bundle/src/interfaces/runtime/types.ts
new file mode 100644
index 0000000000000000000000000000000000000000..320fb33897991d6c7f31180edfe5c90651f1c98a
--- /dev/null
+++ b/types-bundle/src/interfaces/runtime/types.ts
@@ -0,0 +1,72 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+import type { Enum, Option, Struct, U8aFixed, Vec, u32, u64, u8 } from '@polkadot/types';
+import { AccountId, BlockNumber } from '@polkadot/types/interfaces';
+import type { ITuple } from '@polkadot/types/types';
+
+/** @name Balance */
+export interface Balance extends u64 {}
+
+/** @name CertValue */
+export interface CertValue extends Struct {
+ readonly chainable_on: BlockNumber;
+ readonly removable_on: BlockNumber;
+}
+
+/** @name IdtyCertMeta */
+export interface IdtyCertMeta extends Struct {
+ readonly issued_count: u8;
+ readonly next_issuable_on: BlockNumber;
+ readonly received_count: u32;
+}
+
+/** @name IdtyData */
+export interface IdtyData extends Struct {
+ readonly can_create_on: BlockNumber;
+}
+
+/** @name IdtyDid */
+export interface IdtyDid extends Struct {
+ readonly hash: U8aFixed;
+ readonly planet: Planet;
+ readonly latitude: u32;
+ readonly longitude: u32;
+}
+
+/** @name IdtyIndex */
+export interface IdtyIndex extends u64 {}
+
+/** @name IdtyRight */
+export interface IdtyRight extends Enum {
+ readonly isCreateIdty: boolean;
+ readonly isLightCert: boolean;
+ readonly isStrongCert: boolean;
+ readonly isUd: boolean;
+}
+
+/** @name IdtyStatus */
+export interface IdtyStatus extends Enum {
+ readonly isCreated: boolean;
+ readonly isConfirmedByOwner: boolean;
+ readonly isValidated: boolean;
+}
+
+/** @name IdtyValue */
+export interface IdtyValue extends Struct {
+ readonly did: IdtyDid;
+ readonly expire_on: BlockNumber;
+ readonly owner_key: AccountId;
+ readonly removable_on: BlockNumber;
+ readonly renewable_on: BlockNumber;
+ readonly rights: Vec<ITuple<[IdtyRight, Option<AccountId>]>>;
+ readonly status: IdtyStatus;
+ readonly data: IdtyData;
+}
+
+/** @name Planet */
+export interface Planet extends Enum {
+ readonly isEarth: boolean;
+}
+
+export type PHANTOM_RUNTIME = 'runtime';
diff --git a/types-bundle/src/interfaces/types.ts b/types-bundle/src/interfaces/types.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8cc21cbfcdb10ad2a38101a3b1457f82c49512a4
--- /dev/null
+++ b/types-bundle/src/interfaces/types.ts
@@ -0,0 +1,4 @@
+// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
+/* eslint-disable */
+
+export * from './runtime/types';
diff --git a/types-bundle/yarn.lock b/types-bundle/yarn.lock
new file mode 100644
index 0000000000000000000000000000000000000000..d9a1e7e9046d8541c79cabd32ce97759ca874076
--- /dev/null
+++ b/types-bundle/yarn.lock
@@ -0,0 +1,1289 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@babel/code-frame@^7.14.5":
+ version "7.14.5"
+ resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.14.5.tgz#23b08d740e83f49c5e59945fbf1b43e80bbf4edb"
+ integrity sha512-9pzDqyc6OLDaqe+zbACgFkb6fKMNG6CObKpnYXChRsvYGyEdc7CA2BaqeOM+vOtCS5ndmJicPJhKAwYRI6UfFw==
+ dependencies:
+ "@babel/highlight" "^7.14.5"
+
+"@babel/compat-data@^7.14.5":
+ version "7.14.7"
+ resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.14.7.tgz#7b047d7a3a89a67d2258dc61f604f098f1bc7e08"
+ integrity sha512-nS6dZaISCXJ3+518CWiBfEr//gHyMO02uDxBkXTKZDN5POruCnOZ1N4YBRZDCabwF8nZMWBpRxIicmXtBs+fvw==
+
+"@babel/core@^7.14.6":
+ version "7.14.8"
+ resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.14.8.tgz#20cdf7c84b5d86d83fac8710a8bc605a7ba3f010"
+ integrity sha512-/AtaeEhT6ErpDhInbXmjHcUQXH0L0TEgscfcxk1qbOvLuKCa5aZT0SOOtDKFY96/CLROwbLSKyFor6idgNaU4Q==
+ dependencies:
+ "@babel/code-frame" "^7.14.5"
+ "@babel/generator" "^7.14.8"
+ "@babel/helper-compilation-targets" "^7.14.5"
+ "@babel/helper-module-transforms" "^7.14.8"
+ "@babel/helpers" "^7.14.8"
+ "@babel/parser" "^7.14.8"
+ "@babel/template" "^7.14.5"
+ "@babel/traverse" "^7.14.8"
+ "@babel/types" "^7.14.8"
+ convert-source-map "^1.7.0"
+ debug "^4.1.0"
+ gensync "^1.0.0-beta.2"
+ json5 "^2.1.2"
+ semver "^6.3.0"
+ source-map "^0.5.0"
+
+"@babel/generator@^7.14.8":
+ version "7.14.8"
+ resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.14.8.tgz#bf86fd6af96cf3b74395a8ca409515f89423e070"
+ integrity sha512-cYDUpvIzhBVnMzRoY1fkSEhK/HmwEVwlyULYgn/tMQYd6Obag3ylCjONle3gdErfXBW61SVTlR9QR7uWlgeIkg==
+ dependencies:
+ "@babel/types" "^7.14.8"
+ jsesc "^2.5.1"
+ source-map "^0.5.0"
+
+"@babel/helper-compilation-targets@^7.14.5":
+ version "7.14.5"
+ resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.14.5.tgz#7a99c5d0967911e972fe2c3411f7d5b498498ecf"
+ integrity sha512-v+QtZqXEiOnpO6EYvlImB6zCD2Lel06RzOPzmkz/D/XgQiUu3C/Jb1LOqSt/AIA34TYi/Q+KlT8vTQrgdxkbLw==
+ dependencies:
+ "@babel/compat-data" "^7.14.5"
+ "@babel/helper-validator-option" "^7.14.5"
+ browserslist "^4.16.6"
+ semver "^6.3.0"
+
+"@babel/helper-function-name@^7.14.5":
+ version "7.14.5"
+ resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.14.5.tgz#89e2c474972f15d8e233b52ee8c480e2cfcd50c4"
+ integrity sha512-Gjna0AsXWfFvrAuX+VKcN/aNNWonizBj39yGwUzVDVTlMYJMK2Wp6xdpy72mfArFq5uK+NOuexfzZlzI1z9+AQ==
+ dependencies:
+ "@babel/helper-get-function-arity" "^7.14.5"
+ "@babel/template" "^7.14.5"
+ "@babel/types" "^7.14.5"
+
+"@babel/helper-get-function-arity@^7.14.5":
+ version "7.14.5"
+ resolved "https://registry.yarnpkg.com/@babel/helper-get-function-arity/-/helper-get-function-arity-7.14.5.tgz#25fbfa579b0937eee1f3b805ece4ce398c431815"
+ integrity sha512-I1Db4Shst5lewOM4V+ZKJzQ0JGGaZ6VY1jYvMghRjqs6DWgxLCIyFt30GlnKkfUeFLpJt2vzbMVEXVSXlIFYUg==
+ dependencies:
+ "@babel/types" "^7.14.5"
+
+"@babel/helper-hoist-variables@^7.14.5":
+ version "7.14.5"
+ resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.14.5.tgz#e0dd27c33a78e577d7c8884916a3e7ef1f7c7f8d"
+ integrity sha512-R1PXiz31Uc0Vxy4OEOm07x0oSjKAdPPCh3tPivn/Eo8cvz6gveAeuyUUPB21Hoiif0uoPQSSdhIPS3352nvdyQ==
+ dependencies:
+ "@babel/types" "^7.14.5"
+
+"@babel/helper-member-expression-to-functions@^7.14.5":
+ version "7.14.7"
+ resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.14.7.tgz#97e56244beb94211fe277bd818e3a329c66f7970"
+ integrity sha512-TMUt4xKxJn6ccjcOW7c4hlwyJArizskAhoSTOCkA0uZ+KghIaci0Qg9R043kUMWI9mtQfgny+NQ5QATnZ+paaA==
+ dependencies:
+ "@babel/types" "^7.14.5"
+
+"@babel/helper-module-imports@^7.14.5":
+ version "7.14.5"
+ resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.14.5.tgz#6d1a44df6a38c957aa7c312da076429f11b422f3"
+ integrity sha512-SwrNHu5QWS84XlHwGYPDtCxcA0hrSlL2yhWYLgeOc0w7ccOl2qv4s/nARI0aYZW+bSwAL5CukeXA47B/1NKcnQ==
+ dependencies:
+ "@babel/types" "^7.14.5"
+
+"@babel/helper-module-transforms@^7.14.8":
+ version "7.14.8"
+ resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.14.8.tgz#d4279f7e3fd5f4d5d342d833af36d4dd87d7dc49"
+ integrity sha512-RyE+NFOjXn5A9YU1dkpeBaduagTlZ0+fccnIcAGbv1KGUlReBj7utF7oEth8IdIBQPcux0DDgW5MFBH2xu9KcA==
+ dependencies:
+ "@babel/helper-module-imports" "^7.14.5"
+ "@babel/helper-replace-supers" "^7.14.5"
+ "@babel/helper-simple-access" "^7.14.8"
+ "@babel/helper-split-export-declaration" "^7.14.5"
+ "@babel/helper-validator-identifier" "^7.14.8"
+ "@babel/template" "^7.14.5"
+ "@babel/traverse" "^7.14.8"
+ "@babel/types" "^7.14.8"
+
+"@babel/helper-optimise-call-expression@^7.14.5":
+ version "7.14.5"
+ resolved "https://registry.yarnpkg.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.14.5.tgz#f27395a8619e0665b3f0364cddb41c25d71b499c"
+ integrity sha512-IqiLIrODUOdnPU9/F8ib1Fx2ohlgDhxnIDU7OEVi+kAbEZcyiF7BLU8W6PfvPi9LzztjS7kcbzbmL7oG8kD6VA==
+ dependencies:
+ "@babel/types" "^7.14.5"
+
+"@babel/helper-replace-supers@^7.14.5":
+ version "7.14.5"
+ resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.14.5.tgz#0ecc0b03c41cd567b4024ea016134c28414abb94"
+ integrity sha512-3i1Qe9/8x/hCHINujn+iuHy+mMRLoc77b2nI9TB0zjH1hvn9qGlXjWlggdwUcju36PkPCy/lpM7LLUdcTyH4Ow==
+ dependencies:
+ "@babel/helper-member-expression-to-functions" "^7.14.5"
+ "@babel/helper-optimise-call-expression" "^7.14.5"
+ "@babel/traverse" "^7.14.5"
+ "@babel/types" "^7.14.5"
+
+"@babel/helper-simple-access@^7.14.8":
+ version "7.14.8"
+ resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.14.8.tgz#82e1fec0644a7e775c74d305f212c39f8fe73924"
+ integrity sha512-TrFN4RHh9gnWEU+s7JloIho2T76GPwRHhdzOWLqTrMnlas8T9O7ec+oEDNsRXndOmru9ymH9DFrEOxpzPoSbdg==
+ dependencies:
+ "@babel/types" "^7.14.8"
+
+"@babel/helper-split-export-declaration@^7.14.5":
+ version "7.14.5"
+ resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.14.5.tgz#22b23a54ef51c2b7605d851930c1976dd0bc693a"
+ integrity sha512-hprxVPu6e5Kdp2puZUmvOGjaLv9TCe58E/Fl6hRq4YiVQxIcNvuq6uTM2r1mT/oPskuS9CgR+I94sqAYv0NGKA==
+ dependencies:
+ "@babel/types" "^7.14.5"
+
+"@babel/helper-validator-identifier@^7.14.5", "@babel/helper-validator-identifier@^7.14.8":
+ version "7.14.8"
+ resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.14.8.tgz#32be33a756f29e278a0d644fa08a2c9e0f88a34c"
+ integrity sha512-ZGy6/XQjllhYQrNw/3zfWRwZCTVSiBLZ9DHVZxn9n2gip/7ab8mv2TWlKPIBk26RwedCBoWdjLmn+t9na2Gcow==
+
+"@babel/helper-validator-option@^7.14.5":
+ version "7.14.5"
+ resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.14.5.tgz#6e72a1fff18d5dfcb878e1e62f1a021c4b72d5a3"
+ integrity sha512-OX8D5eeX4XwcroVW45NMvoYaIuFI+GQpA2a8Gi+X/U/cDUIRsV37qQfF905F0htTRCREQIB4KqPeaveRJUl3Ow==
+
+"@babel/helpers@^7.14.8":
+ version "7.14.8"
+ resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.14.8.tgz#839f88f463025886cff7f85a35297007e2da1b77"
+ integrity sha512-ZRDmI56pnV+p1dH6d+UN6GINGz7Krps3+270qqI9UJ4wxYThfAIcI5i7j5vXC4FJ3Wap+S9qcebxeYiqn87DZw==
+ dependencies:
+ "@babel/template" "^7.14.5"
+ "@babel/traverse" "^7.14.8"
+ "@babel/types" "^7.14.8"
+
+"@babel/highlight@^7.14.5":
+ version "7.14.5"
+ resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.14.5.tgz#6861a52f03966405001f6aa534a01a24d99e8cd9"
+ integrity sha512-qf9u2WFWVV0MppaL877j2dBtQIDgmidgjGk5VIMw3OadXvYaXn66U1BFlH2t4+t3i+8PhedppRv+i40ABzd+gg==
+ dependencies:
+ "@babel/helper-validator-identifier" "^7.14.5"
+ chalk "^2.0.0"
+ js-tokens "^4.0.0"
+
+"@babel/parser@^7.14.5", "@babel/parser@^7.14.8":
+ version "7.14.8"
+ resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.14.8.tgz#66fd41666b2d7b840bd5ace7f7416d5ac60208d4"
+ integrity sha512-syoCQFOoo/fzkWDeM0dLEZi5xqurb5vuyzwIMNZRNun+N/9A4cUZeQaE7dTrB8jGaKuJRBtEOajtnmw0I5hvvA==
+
+"@babel/register@^7.14.5":
+ version "7.14.5"
+ resolved "https://registry.yarnpkg.com/@babel/register/-/register-7.14.5.tgz#d0eac615065d9c2f1995842f85d6e56c345f3233"
+ integrity sha512-TjJpGz/aDjFGWsItRBQMOFTrmTI9tr79CHOK+KIvLeCkbxuOAk2M5QHjvruIMGoo9OuccMh5euplPzc5FjAKGg==
+ dependencies:
+ clone-deep "^4.0.1"
+ find-cache-dir "^2.0.0"
+ make-dir "^2.1.0"
+ pirates "^4.0.0"
+ source-map-support "^0.5.16"
+
+"@babel/runtime@^7.14.6":
+ version "7.14.8"
+ resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.14.8.tgz#7119a56f421018852694290b9f9148097391b446"
+ integrity sha512-twj3L8Og5SaCRCErB4x4ajbvBIVV77CGeFglHpeg5WC5FF8TZzBWXtTJ4MqaD9QszLYTtr+IsaAL2rEUevb+eg==
+ dependencies:
+ regenerator-runtime "^0.13.4"
+
+"@babel/template@^7.14.5":
+ version "7.14.5"
+ resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.14.5.tgz#a9bc9d8b33354ff6e55a9c60d1109200a68974f4"
+ integrity sha512-6Z3Po85sfxRGachLULUhOmvAaOo7xCvqGQtxINai2mEGPFm6pQ4z5QInFnUrRpfoSV60BnjyF5F3c+15fxFV1g==
+ dependencies:
+ "@babel/code-frame" "^7.14.5"
+ "@babel/parser" "^7.14.5"
+ "@babel/types" "^7.14.5"
+
+"@babel/traverse@^7.14.5", "@babel/traverse@^7.14.8":
+ version "7.14.8"
+ resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.14.8.tgz#c0253f02677c5de1a8ff9df6b0aacbec7da1a8ce"
+ integrity sha512-kexHhzCljJcFNn1KYAQ6A5wxMRzq9ebYpEDV4+WdNyr3i7O44tanbDOR/xjiG2F3sllan+LgwK+7OMk0EmydHg==
+ dependencies:
+ "@babel/code-frame" "^7.14.5"
+ "@babel/generator" "^7.14.8"
+ "@babel/helper-function-name" "^7.14.5"
+ "@babel/helper-hoist-variables" "^7.14.5"
+ "@babel/helper-split-export-declaration" "^7.14.5"
+ "@babel/parser" "^7.14.8"
+ "@babel/types" "^7.14.8"
+ debug "^4.1.0"
+ globals "^11.1.0"
+
+"@babel/types@^7.14.5", "@babel/types@^7.14.8":
+ version "7.14.8"
+ resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.14.8.tgz#38109de8fcadc06415fbd9b74df0065d4d41c728"
+ integrity sha512-iob4soQa7dZw8nodR/KlOQkPh9S4I8RwCxwRIFuiMRYjOzH/KJzdUfDgz6cGi5dDaclXF4P2PAhCdrBJNIg68Q==
+ dependencies:
+ "@babel/helper-validator-identifier" "^7.14.8"
+ to-fast-properties "^2.0.0"
+
+"@polkadot/api-derive@5.1.1":
+ version "5.1.1"
+ resolved "https://registry.yarnpkg.com/@polkadot/api-derive/-/api-derive-5.1.1.tgz#ee52886cec59a3b137f72cf55c56c0ed12f85d4b"
+ integrity sha512-3Y0T5HwdqUXOra7CwgFEqBzZ7eNYgeBM8WsA0bEz+WuaCkldTrnFFMpjUhLwpf/CHTdEbn0dPoqwh6Q15dzJVA==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+ "@polkadot/api" "5.1.1"
+ "@polkadot/rpc-core" "5.1.1"
+ "@polkadot/types" "5.1.1"
+ "@polkadot/util" "^7.0.2"
+ "@polkadot/util-crypto" "^7.0.2"
+ rxjs "^7.2.0"
+
+"@polkadot/api@5.1.1", "@polkadot/api@^5.1.1":
+ version "5.1.1"
+ resolved "https://registry.yarnpkg.com/@polkadot/api/-/api-5.1.1.tgz#b65714d69b7e1a758f85d9bc303fbe193203bc87"
+ integrity sha512-dBumQsSiHpyQ2kawpE2KbAROJxA2L06ISJ7G2ZGiOwQbFwGQWqN6i2inCKNY7smBCJrQAtCfYQBZWOSdn0avRw==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+ "@polkadot/api-derive" "5.1.1"
+ "@polkadot/keyring" "^7.0.2"
+ "@polkadot/rpc-core" "5.1.1"
+ "@polkadot/rpc-provider" "5.1.1"
+ "@polkadot/types" "5.1.1"
+ "@polkadot/types-known" "5.1.1"
+ "@polkadot/util" "^7.0.2"
+ "@polkadot/util-crypto" "^7.0.2"
+ eventemitter3 "^4.0.7"
+ rxjs "^7.2.0"
+
+"@polkadot/keyring@^7.0.2":
+ version "7.0.2"
+ resolved "https://registry.yarnpkg.com/@polkadot/keyring/-/keyring-7.0.2.tgz#87db80d13d61ddf204820f7c224e34d7e8c76eab"
+ integrity sha512-EV2lR4wV4uX4UHpBjcZgqKKOFvGR2fN2SvUXP/VLE+u2lK7wjNlx72MI9IbhlqJEg3j7SPqXH7BEw60w690vDQ==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+ "@polkadot/util" "7.0.2"
+ "@polkadot/util-crypto" "7.0.2"
+
+"@polkadot/networks@7.0.2", "@polkadot/networks@^7.0.2":
+ version "7.0.2"
+ resolved "https://registry.yarnpkg.com/@polkadot/networks/-/networks-7.0.2.tgz#e3da380f824258b939ca5379065fb973dff2bb9b"
+ integrity sha512-KP8T1uaUkwzmsOZPnpJ+EZWOTR26v+BxxeV9kc7NoD3UrSVHcHI7uz1mKfhmTn9gSDf04DqQ1zmFr6PIMlhncw==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+
+"@polkadot/rpc-core@5.1.1":
+ version "5.1.1"
+ resolved "https://registry.yarnpkg.com/@polkadot/rpc-core/-/rpc-core-5.1.1.tgz#5d387320dffe03a4f3e91e13288ce507120956d0"
+ integrity sha512-qzx1D7SpPk6lRMLHJZDKUFFXLRir2JV+r7SofmBJwpJxzBMAdRfEoD1qZI8H0Vz3BB5hz7vGFEdyNlYUOhHWaQ==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+ "@polkadot/rpc-provider" "5.1.1"
+ "@polkadot/types" "5.1.1"
+ "@polkadot/util" "^7.0.2"
+ rxjs "^7.2.0"
+
+"@polkadot/rpc-provider@5.1.1":
+ version "5.1.1"
+ resolved "https://registry.yarnpkg.com/@polkadot/rpc-provider/-/rpc-provider-5.1.1.tgz#640c80e2f3d2d78fe99312969af28aa4da4b2860"
+ integrity sha512-5/KeJxQcOfae5GT1CnuArHJREl+eh6wfIUjJaeO48x4caIbCgm4jnubjrSwhONLzSLDObsoomqJwA4zUh6OLQw==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+ "@polkadot/types" "5.1.1"
+ "@polkadot/util" "^7.0.2"
+ "@polkadot/util-crypto" "^7.0.2"
+ "@polkadot/x-fetch" "^7.0.2"
+ "@polkadot/x-global" "^7.0.2"
+ "@polkadot/x-ws" "^7.0.2"
+ eventemitter3 "^4.0.7"
+
+"@polkadot/typegen@^5.1.1":
+ version "5.1.1"
+ resolved "https://registry.yarnpkg.com/@polkadot/typegen/-/typegen-5.1.1.tgz#8a0d115011546abc23d6136c09f42175be4dd625"
+ integrity sha512-yRRqT2LCU0ZgLYEh3tyHAKl7ZfzOLVVs848dII/vRVQ4WJsC7TWLUMlCwfWE/syFP5osvI2ziCLyfFJ1I7prHQ==
+ dependencies:
+ "@babel/core" "^7.14.6"
+ "@babel/register" "^7.14.5"
+ "@babel/runtime" "^7.14.6"
+ "@polkadot/api" "5.1.1"
+ "@polkadot/rpc-provider" "5.1.1"
+ "@polkadot/types" "5.1.1"
+ "@polkadot/util" "^7.0.2"
+ handlebars "^4.7.7"
+ websocket "^1.0.34"
+ yargs "^17.0.1"
+
+"@polkadot/types-known@5.1.1":
+ version "5.1.1"
+ resolved "https://registry.yarnpkg.com/@polkadot/types-known/-/types-known-5.1.1.tgz#54c27bd0fb50aa5e0ae9f86cb548d2d60dbe38d9"
+ integrity sha512-XlTAB2T5lxdTXVz5Yscng+EjV3V/wUapoEm+Ac+AjEeqXz6dhYTaiap6IQGtxLWmrMmhaeH5xIAEHVkWwEYcNA==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+ "@polkadot/networks" "^7.0.2"
+ "@polkadot/types" "5.1.1"
+ "@polkadot/util" "^7.0.2"
+
+"@polkadot/types@5.1.1":
+ version "5.1.1"
+ resolved "https://registry.yarnpkg.com/@polkadot/types/-/types-5.1.1.tgz#fde3a6f5bb7ac14cd5291d9aba9e0bd21d653872"
+ integrity sha512-9NOLghfAV+P3wZys3DHL350TMY+UL/lRB4ZOAwRFBfye2FYVklNqzEkudKPDSEaKqRpx7KRaETpC/txWQLAwfw==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+ "@polkadot/util" "^7.0.2"
+ "@polkadot/util-crypto" "^7.0.2"
+ rxjs "^7.2.0"
+
+"@polkadot/util-crypto@7.0.2", "@polkadot/util-crypto@^7.0.2":
+ version "7.0.2"
+ resolved "https://registry.yarnpkg.com/@polkadot/util-crypto/-/util-crypto-7.0.2.tgz#c892942b6c7cb63a7c2c0a602115b0645b7fe8eb"
+ integrity sha512-d4X+4YQOiVqIV82fU1DaOWMRKawpDVHZBsCMkE6twYadpc/BlNfrksiUhmTUklZPPMF6jIfLPjz8j7fH7GZeCQ==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+ "@polkadot/networks" "7.0.2"
+ "@polkadot/util" "7.0.2"
+ "@polkadot/wasm-crypto" "^4.1.2"
+ "@polkadot/x-randomvalues" "7.0.2"
+ base-x "^3.0.8"
+ base64-js "^1.5.1"
+ blakejs "^1.1.1"
+ bn.js "^4.11.9"
+ create-hash "^1.2.0"
+ elliptic "^6.5.4"
+ hash.js "^1.1.7"
+ js-sha3 "^0.8.0"
+ scryptsy "^2.1.0"
+ tweetnacl "^1.0.3"
+ xxhashjs "^0.2.2"
+
+"@polkadot/util@7.0.2", "@polkadot/util@^7.0.2":
+ version "7.0.2"
+ resolved "https://registry.yarnpkg.com/@polkadot/util/-/util-7.0.2.tgz#ec2625c506b9d1b8c68cc45f97f60be7f5f1c097"
+ integrity sha512-NJHRprsEZ61p9Ch0CSch0O8lHFC9rzYinOSPYmbsur7upZJKNzeqnQ7GxiMI/4u9lznfAmD/TW6BTwkWHenncg==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+ "@polkadot/x-textdecoder" "7.0.2"
+ "@polkadot/x-textencoder" "7.0.2"
+ "@types/bn.js" "^4.11.6"
+ bn.js "^4.11.9"
+ camelcase "^5.3.1"
+ ip-regex "^4.3.0"
+
+"@polkadot/wasm-crypto-asmjs@^4.1.2":
+ version "4.1.2"
+ resolved "https://registry.yarnpkg.com/@polkadot/wasm-crypto-asmjs/-/wasm-crypto-asmjs-4.1.2.tgz#094b3eeeb5fd39a93db177583b48454511874cfc"
+ integrity sha512-3Q+vVUxDAC2tXgKMM3lKzx2JW+tarDpTjkvdxIKATyi8Ek69KkUqvMyJD0VL/iFZOFZED0YDX9UU4XOJ/astlg==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+
+"@polkadot/wasm-crypto-wasm@^4.1.2":
+ version "4.1.2"
+ resolved "https://registry.yarnpkg.com/@polkadot/wasm-crypto-wasm/-/wasm-crypto-wasm-4.1.2.tgz#773c78c1d65886671d3ba1d66c31afd86c93d02f"
+ integrity sha512-/l4IBEdQ41szHdHkuF//z1qr+XmWuLHlpBA7s9Eb221m1Fir6AKoCHoh1hp1r3v0ecZYLKvak1B225w6JAU3Fg==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+
+"@polkadot/wasm-crypto@^4.1.2":
+ version "4.1.2"
+ resolved "https://registry.yarnpkg.com/@polkadot/wasm-crypto/-/wasm-crypto-4.1.2.tgz#dead71ae5d2f7722d23aed5be2112e1732d315e9"
+ integrity sha512-2EKdOjIrD2xHP2rC+0G/3Qo6926nL/18vCFkd34lBd9zP9YNF2GDEtDY+zAeDIRFKe1sQHTpsKgNdYSWoV2eBg==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+ "@polkadot/wasm-crypto-asmjs" "^4.1.2"
+ "@polkadot/wasm-crypto-wasm" "^4.1.2"
+
+"@polkadot/x-fetch@^7.0.2":
+ version "7.0.2"
+ resolved "https://registry.yarnpkg.com/@polkadot/x-fetch/-/x-fetch-7.0.2.tgz#9b71269b51680ce2ee88fb02d24b296078820c75"
+ integrity sha512-S2akk8RfPXcO51mnmOFzTe3aLL26eCVMlq40CTvGQfv/BWUAxQTJYhOfkVb+DpoTT+SVaIRW8I6tuyX4FQH3Bg==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+ "@polkadot/x-global" "7.0.2"
+ "@types/node-fetch" "^2.5.11"
+ node-fetch "^2.6.1"
+
+"@polkadot/x-global@7.0.2", "@polkadot/x-global@^7.0.2":
+ version "7.0.2"
+ resolved "https://registry.yarnpkg.com/@polkadot/x-global/-/x-global-7.0.2.tgz#98d2271b470b7003ad85bf456acdb278acb8f05e"
+ integrity sha512-2M751KKNX5Rne8cO/Xx014eI8uq7SCr97Zl+bXaeZqChjgy0AeNd8/E4g2zcvjXXU6EiB+p51oCzEv3j5psq3w==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+
+"@polkadot/x-randomvalues@7.0.2":
+ version "7.0.2"
+ resolved "https://registry.yarnpkg.com/@polkadot/x-randomvalues/-/x-randomvalues-7.0.2.tgz#cab9bc6bb6d7df9ed1a21b1a07681c0b6e34a595"
+ integrity sha512-KmfEL75dU2jvLEJBLScoNXnC489jW0LvFPeFXD4uoLNRaaLesJ+wWcbGN+Ek1lHJDnGCNfk0AdHfJCWNyxE96A==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+ "@polkadot/x-global" "7.0.2"
+
+"@polkadot/x-textdecoder@7.0.2":
+ version "7.0.2"
+ resolved "https://registry.yarnpkg.com/@polkadot/x-textdecoder/-/x-textdecoder-7.0.2.tgz#bd7e49f8dece8b582f07a61124a64986dcd50732"
+ integrity sha512-eFJFdAS6K9nt/9i+jnehSKPHrvkFwkS5WdtqkNetT530dpD/BWg7wRTZApJQhN7Q8A6zSGvZnee1EJt4aNK0Bw==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+ "@polkadot/x-global" "7.0.2"
+
+"@polkadot/x-textencoder@7.0.2":
+ version "7.0.2"
+ resolved "https://registry.yarnpkg.com/@polkadot/x-textencoder/-/x-textencoder-7.0.2.tgz#56f1a02a692b3fa94b97f303809e38ec1fde65ed"
+ integrity sha512-6l4f6VlOMXz83R1QanA21EHPbpfn1odKiV9FFa9dY9bIuyMUwtDkKW+XsQqcvWJCsa26OSwGwDHQ9ru6rV+6CQ==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+ "@polkadot/x-global" "7.0.2"
+
+"@polkadot/x-ws@^7.0.2":
+ version "7.0.2"
+ resolved "https://registry.yarnpkg.com/@polkadot/x-ws/-/x-ws-7.0.2.tgz#44085b948050c1b34e4fbed81885d81d0538369a"
+ integrity sha512-UfzOBQFBcBcbWDMLSUvb0uh112JbDgXhzTGC9yXABwD8/WZTbi7E7TpcXDpu8xVaGfE4A3aYO9KVxIi+PrCfrw==
+ dependencies:
+ "@babel/runtime" "^7.14.6"
+ "@polkadot/x-global" "7.0.2"
+ "@types/websocket" "^1.0.3"
+ websocket "^1.0.34"
+
+"@types/bn.js@^4.11.6":
+ version "4.11.6"
+ resolved "https://registry.yarnpkg.com/@types/bn.js/-/bn.js-4.11.6.tgz#c306c70d9358aaea33cd4eda092a742b9505967c"
+ integrity sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg==
+ dependencies:
+ "@types/node" "*"
+
+"@types/node-fetch@^2.5.11":
+ version "2.5.11"
+ resolved "https://registry.yarnpkg.com/@types/node-fetch/-/node-fetch-2.5.11.tgz#ce22a2e65fc8999f4dbdb7ddbbcf187d755169e4"
+ integrity sha512-2upCKaqVZETDRb8A2VTaRymqFBEgH8u6yr96b/u3+1uQEPDRo3mJLEiPk7vdXBHRtjwkjqzFYMJXrt0Z9QsYjQ==
+ dependencies:
+ "@types/node" "*"
+ form-data "^3.0.0"
+
+"@types/node@*":
+ version "16.3.3"
+ resolved "https://registry.yarnpkg.com/@types/node/-/node-16.3.3.tgz#0c30adff37bbbc7a50eb9b58fae2a504d0d88038"
+ integrity sha512-8h7k1YgQKxKXWckzFCMfsIwn0Y61UK6tlD6y2lOb3hTOIMlK3t9/QwHOhc81TwU+RMf0As5fj7NPjroERCnejQ==
+
+"@types/websocket@^1.0.3":
+ version "1.0.3"
+ resolved "https://registry.yarnpkg.com/@types/websocket/-/websocket-1.0.3.tgz#49e09f939afd0ccdee4f7108d4712ec9feb0f153"
+ integrity sha512-ZdoTSwmDsKR7l1I8fpfQtmTI/hUwlOvE3q0iyJsp4tXU0MkdrYowimDzwxjhQvxU4qjhHLd3a6ig0OXRbLgIdw==
+ dependencies:
+ "@types/node" "*"
+
+ansi-regex@^5.0.0:
+ version "5.0.0"
+ resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.0.tgz#388539f55179bf39339c81af30a654d69f87cb75"
+ integrity sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==
+
+ansi-styles@^3.2.1:
+ version "3.2.1"
+ resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
+ integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==
+ dependencies:
+ color-convert "^1.9.0"
+
+ansi-styles@^4.0.0:
+ version "4.3.0"
+ resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937"
+ integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==
+ dependencies:
+ color-convert "^2.0.1"
+
+arg@^4.1.0:
+ version "4.1.3"
+ resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089"
+ integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==
+
+asynckit@^0.4.0:
+ version "0.4.0"
+ resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79"
+ integrity sha1-x57Zf380y48robyXkLzDZkdLS3k=
+
+base-x@^3.0.8:
+ version "3.0.8"
+ resolved "https://registry.yarnpkg.com/base-x/-/base-x-3.0.8.tgz#1e1106c2537f0162e8b52474a557ebb09000018d"
+ integrity sha512-Rl/1AWP4J/zRrk54hhlxH4drNxPJXYUaKffODVI53/dAsV4t9fBxyxYKAVPU1XBHxYwOWP9h9H0hM2MVw4YfJA==
+ dependencies:
+ safe-buffer "^5.0.1"
+
+base64-js@^1.5.1:
+ version "1.5.1"
+ resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a"
+ integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==
+
+blakejs@^1.1.1:
+ version "1.1.1"
+ resolved "https://registry.yarnpkg.com/blakejs/-/blakejs-1.1.1.tgz#bf313053978b2cd4c444a48795710be05c785702"
+ integrity sha512-bLG6PHOCZJKNshTjGRBvET0vTciwQE6zFKOKKXPDJfwFBd4Ac0yBfPZqcGvGJap50l7ktvlpFqc2jGVaUgbJgg==
+
+bn.js@^4.11.9:
+ version "4.12.0"
+ resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.12.0.tgz#775b3f278efbb9718eec7361f483fb36fbbfea88"
+ integrity sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==
+
+brorand@^1.1.0:
+ version "1.1.0"
+ resolved "https://registry.yarnpkg.com/brorand/-/brorand-1.1.0.tgz#12c25efe40a45e3c323eb8675a0a0ce57b22371f"
+ integrity sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=
+
+browserslist@^4.16.6:
+ version "4.16.6"
+ resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.16.6.tgz#d7901277a5a88e554ed305b183ec9b0c08f66fa2"
+ integrity sha512-Wspk/PqO+4W9qp5iUTJsa1B/QrYn1keNCcEP5OvP7WBwT4KaDly0uONYmC6Xa3Z5IqnUgS0KcgLYu1l74x0ZXQ==
+ dependencies:
+ caniuse-lite "^1.0.30001219"
+ colorette "^1.2.2"
+ electron-to-chromium "^1.3.723"
+ escalade "^3.1.1"
+ node-releases "^1.1.71"
+
+buffer-from@^1.0.0:
+ version "1.1.1"
+ resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.1.tgz#32713bc028f75c02fdb710d7c7bcec1f2c6070ef"
+ integrity sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==
+
+bufferutil@^4.0.1:
+ version "4.0.3"
+ resolved "https://registry.yarnpkg.com/bufferutil/-/bufferutil-4.0.3.tgz#66724b756bed23cd7c28c4d306d7994f9943cc6b"
+ integrity sha512-yEYTwGndELGvfXsImMBLop58eaGW+YdONi1fNjTINSY98tmMmFijBG6WXgdkfuLNt4imzQNtIE+eBp1PVpMCSw==
+ dependencies:
+ node-gyp-build "^4.2.0"
+
+camelcase@^5.3.1:
+ version "5.3.1"
+ resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320"
+ integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==
+
+caniuse-lite@^1.0.30001219:
+ version "1.0.30001245"
+ resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001245.tgz#45b941bbd833cb0fa53861ff2bae746b3c6ca5d4"
+ integrity sha512-768fM9j1PKXpOCKws6eTo3RHmvTUsG9UrpT4WoREFeZgJBTi4/X9g565azS/rVUGtqb8nt7FjLeF5u4kukERnA==
+
+chalk@^2.0.0:
+ version "2.4.2"
+ resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
+ integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
+ dependencies:
+ ansi-styles "^3.2.1"
+ escape-string-regexp "^1.0.5"
+ supports-color "^5.3.0"
+
+cipher-base@^1.0.1:
+ version "1.0.4"
+ resolved "https://registry.yarnpkg.com/cipher-base/-/cipher-base-1.0.4.tgz#8760e4ecc272f4c363532f926d874aae2c1397de"
+ integrity sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==
+ dependencies:
+ inherits "^2.0.1"
+ safe-buffer "^5.0.1"
+
+cliui@^7.0.2:
+ version "7.0.4"
+ resolved "https://registry.yarnpkg.com/cliui/-/cliui-7.0.4.tgz#a0265ee655476fc807aea9df3df8df7783808b4f"
+ integrity sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==
+ dependencies:
+ string-width "^4.2.0"
+ strip-ansi "^6.0.0"
+ wrap-ansi "^7.0.0"
+
+clone-deep@^4.0.1:
+ version "4.0.1"
+ resolved "https://registry.yarnpkg.com/clone-deep/-/clone-deep-4.0.1.tgz#c19fd9bdbbf85942b4fd979c84dcf7d5f07c2387"
+ integrity sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==
+ dependencies:
+ is-plain-object "^2.0.4"
+ kind-of "^6.0.2"
+ shallow-clone "^3.0.0"
+
+color-convert@^1.9.0:
+ version "1.9.3"
+ resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8"
+ integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==
+ dependencies:
+ color-name "1.1.3"
+
+color-convert@^2.0.1:
+ version "2.0.1"
+ resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-2.0.1.tgz#72d3a68d598c9bdb3af2ad1e84f21d896abd4de3"
+ integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==
+ dependencies:
+ color-name "~1.1.4"
+
+color-name@1.1.3:
+ version "1.1.3"
+ resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25"
+ integrity sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=
+
+color-name@~1.1.4:
+ version "1.1.4"
+ resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.4.tgz#c2a09a87acbde69543de6f63fa3995c826c536a2"
+ integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==
+
+colorette@^1.2.2:
+ version "1.2.2"
+ resolved "https://registry.yarnpkg.com/colorette/-/colorette-1.2.2.tgz#cbcc79d5e99caea2dbf10eb3a26fd8b3e6acfa94"
+ integrity sha512-MKGMzyfeuutC/ZJ1cba9NqcNpfeqMUcYmyF1ZFY6/Cn7CNSAKx6a+s48sqLqyAiZuaP2TcqMhoo+dlwFnVxT9w==
+
+combined-stream@^1.0.8:
+ version "1.0.8"
+ resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f"
+ integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==
+ dependencies:
+ delayed-stream "~1.0.0"
+
+commondir@^1.0.1:
+ version "1.0.1"
+ resolved "https://registry.yarnpkg.com/commondir/-/commondir-1.0.1.tgz#ddd800da0c66127393cca5950ea968a3aaf1253b"
+ integrity sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs=
+
+convert-source-map@^1.7.0:
+ version "1.8.0"
+ resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.8.0.tgz#f3373c32d21b4d780dd8004514684fb791ca4369"
+ integrity sha512-+OQdjP49zViI/6i7nIJpA8rAl4sV/JdPfU9nZs3VqOwGIgizICvuN2ru6fMd+4llL0tar18UYJXfZ/TWtmhUjA==
+ dependencies:
+ safe-buffer "~5.1.1"
+
+create-hash@^1.2.0:
+ version "1.2.0"
+ resolved "https://registry.yarnpkg.com/create-hash/-/create-hash-1.2.0.tgz#889078af11a63756bcfb59bd221996be3a9ef196"
+ integrity sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==
+ dependencies:
+ cipher-base "^1.0.1"
+ inherits "^2.0.1"
+ md5.js "^1.3.4"
+ ripemd160 "^2.0.1"
+ sha.js "^2.4.0"
+
+cuint@^0.2.2:
+ version "0.2.2"
+ resolved "https://registry.yarnpkg.com/cuint/-/cuint-0.2.2.tgz#408086d409550c2631155619e9fa7bcadc3b991b"
+ integrity sha1-QICG1AlVDCYxFVYZ6fp7ytw7mRs=
+
+d@1, d@^1.0.1:
+ version "1.0.1"
+ resolved "https://registry.yarnpkg.com/d/-/d-1.0.1.tgz#8698095372d58dbee346ffd0c7093f99f8f9eb5a"
+ integrity sha512-m62ShEObQ39CfralilEQRjH6oAMtNCV1xJyEx5LpRYUVN+EviphDgUc/F3hnYbADmkiNs67Y+3ylmlG7Lnu+FA==
+ dependencies:
+ es5-ext "^0.10.50"
+ type "^1.0.1"
+
+debug@^2.2.0:
+ version "2.6.9"
+ resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.9.tgz#5d128515df134ff327e90a4c93f4e077a536341f"
+ integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==
+ dependencies:
+ ms "2.0.0"
+
+debug@^4.1.0:
+ version "4.3.2"
+ resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.2.tgz#f0a49c18ac8779e31d4a0c6029dfb76873c7428b"
+ integrity sha512-mOp8wKcvj7XxC78zLgw/ZA+6TSgkoE2C/ienthhRD298T7UNwAg9diBpLRxC0mOezLl4B0xV7M0cCO6P/O0Xhw==
+ dependencies:
+ ms "2.1.2"
+
+delayed-stream@~1.0.0:
+ version "1.0.0"
+ resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619"
+ integrity sha1-3zrhmayt+31ECqrgsp4icrJOxhk=
+
+diff@^4.0.1:
+ version "4.0.2"
+ resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d"
+ integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==
+
+electron-to-chromium@^1.3.723:
+ version "1.3.780"
+ resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.3.780.tgz#f946e10dc0005a3b59b9afa2d2c92f5c421f7fc5"
+ integrity sha512-2KQ9OYm9WMUNpAPA/4aerURl3hwRc9tNlpsiEj3Y8Gf7LVf26NzyLIX2v0hSagQwrS9+cWab+28A2GPKDoVNRA==
+
+elliptic@^6.5.4:
+ version "6.5.4"
+ resolved "https://registry.yarnpkg.com/elliptic/-/elliptic-6.5.4.tgz#da37cebd31e79a1367e941b592ed1fbebd58abbb"
+ integrity sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==
+ dependencies:
+ bn.js "^4.11.9"
+ brorand "^1.1.0"
+ hash.js "^1.0.0"
+ hmac-drbg "^1.0.1"
+ inherits "^2.0.4"
+ minimalistic-assert "^1.0.1"
+ minimalistic-crypto-utils "^1.0.1"
+
+emoji-regex@^8.0.0:
+ version "8.0.0"
+ resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
+ integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
+
+es5-ext@^0.10.35, es5-ext@^0.10.50:
+ version "0.10.53"
+ resolved "https://registry.yarnpkg.com/es5-ext/-/es5-ext-0.10.53.tgz#93c5a3acfdbef275220ad72644ad02ee18368de1"
+ integrity sha512-Xs2Stw6NiNHWypzRTY1MtaG/uJlwCk8kH81920ma8mvN8Xq1gsfhZvpkImLQArw8AHnv8MT2I45J3c0R8slE+Q==
+ dependencies:
+ es6-iterator "~2.0.3"
+ es6-symbol "~3.1.3"
+ next-tick "~1.0.0"
+
+es6-iterator@~2.0.3:
+ version "2.0.3"
+ resolved "https://registry.yarnpkg.com/es6-iterator/-/es6-iterator-2.0.3.tgz#a7de889141a05a94b0854403b2d0a0fbfa98f3b7"
+ integrity sha1-p96IkUGgWpSwhUQDstCg+/qY87c=
+ dependencies:
+ d "1"
+ es5-ext "^0.10.35"
+ es6-symbol "^3.1.1"
+
+es6-symbol@^3.1.1, es6-symbol@~3.1.3:
+ version "3.1.3"
+ resolved "https://registry.yarnpkg.com/es6-symbol/-/es6-symbol-3.1.3.tgz#bad5d3c1bcdac28269f4cb331e431c78ac705d18"
+ integrity sha512-NJ6Yn3FuDinBaBRWl/q5X/s4koRHBrgKAu+yGI6JCBeiu3qrcbJhwT2GeR/EXVfylRk8dpQVJoLEFhK+Mu31NA==
+ dependencies:
+ d "^1.0.1"
+ ext "^1.1.2"
+
+escalade@^3.1.1:
+ version "3.1.1"
+ resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.1.1.tgz#d8cfdc7000965c5a0174b4a82eaa5c0552742e40"
+ integrity sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==
+
+escape-string-regexp@^1.0.5:
+ version "1.0.5"
+ resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
+ integrity sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=
+
+eventemitter3@^4.0.7:
+ version "4.0.7"
+ resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-4.0.7.tgz#2de9b68f6528d5644ef5c59526a1b4a07306169f"
+ integrity sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==
+
+ext@^1.1.2:
+ version "1.4.0"
+ resolved "https://registry.yarnpkg.com/ext/-/ext-1.4.0.tgz#89ae7a07158f79d35517882904324077e4379244"
+ integrity sha512-Key5NIsUxdqKg3vIsdw9dSuXpPCQ297y6wBjL30edxwPgt2E44WcWBZey/ZvUc6sERLTxKdyCu4gZFmUbk1Q7A==
+ dependencies:
+ type "^2.0.0"
+
+find-cache-dir@^2.0.0:
+ version "2.1.0"
+ resolved "https://registry.yarnpkg.com/find-cache-dir/-/find-cache-dir-2.1.0.tgz#8d0f94cd13fe43c6c7c261a0d86115ca918c05f7"
+ integrity sha512-Tq6PixE0w/VMFfCgbONnkiQIVol/JJL7nRMi20fqzA4NRs9AfeqMGeRdPi3wIhYkxjeBaWh2rxwapn5Tu3IqOQ==
+ dependencies:
+ commondir "^1.0.1"
+ make-dir "^2.0.0"
+ pkg-dir "^3.0.0"
+
+find-up@^3.0.0:
+ version "3.0.0"
+ resolved "https://registry.yarnpkg.com/find-up/-/find-up-3.0.0.tgz#49169f1d7993430646da61ecc5ae355c21c97b73"
+ integrity sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==
+ dependencies:
+ locate-path "^3.0.0"
+
+form-data@^3.0.0:
+ version "3.0.1"
+ resolved "https://registry.yarnpkg.com/form-data/-/form-data-3.0.1.tgz#ebd53791b78356a99af9a300d4282c4d5eb9755f"
+ integrity sha512-RHkBKtLWUVwd7SqRIvCZMEvAMoGUp0XU+seQiZejj0COz3RI3hWP4sCv3gZWWLjJTd7rGwcsF5eKZGii0r/hbg==
+ dependencies:
+ asynckit "^0.4.0"
+ combined-stream "^1.0.8"
+ mime-types "^2.1.12"
+
+gensync@^1.0.0-beta.2:
+ version "1.0.0-beta.2"
+ resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0"
+ integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==
+
+get-caller-file@^2.0.5:
+ version "2.0.5"
+ resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e"
+ integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==
+
+globals@^11.1.0:
+ version "11.12.0"
+ resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e"
+ integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==
+
+handlebars@^4.7.7:
+ version "4.7.7"
+ resolved "https://registry.yarnpkg.com/handlebars/-/handlebars-4.7.7.tgz#9ce33416aad02dbd6c8fafa8240d5d98004945a1"
+ integrity sha512-aAcXm5OAfE/8IXkcZvCepKU3VzW1/39Fb5ZuqMtgI/hT8X2YgoMvBY5dLhq/cpOvw7Lk1nK/UF71aLG/ZnVYRA==
+ dependencies:
+ minimist "^1.2.5"
+ neo-async "^2.6.0"
+ source-map "^0.6.1"
+ wordwrap "^1.0.0"
+ optionalDependencies:
+ uglify-js "^3.1.4"
+
+has-flag@^3.0.0:
+ version "3.0.0"
+ resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
+ integrity sha1-tdRU3CGZriJWmfNGfloH87lVuv0=
+
+hash-base@^3.0.0:
+ version "3.1.0"
+ resolved "https://registry.yarnpkg.com/hash-base/-/hash-base-3.1.0.tgz#55c381d9e06e1d2997a883b4a3fddfe7f0d3af33"
+ integrity sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==
+ dependencies:
+ inherits "^2.0.4"
+ readable-stream "^3.6.0"
+ safe-buffer "^5.2.0"
+
+hash.js@^1.0.0, hash.js@^1.0.3, hash.js@^1.1.7:
+ version "1.1.7"
+ resolved "https://registry.yarnpkg.com/hash.js/-/hash.js-1.1.7.tgz#0babca538e8d4ee4a0f8988d68866537a003cf42"
+ integrity sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==
+ dependencies:
+ inherits "^2.0.3"
+ minimalistic-assert "^1.0.1"
+
+hmac-drbg@^1.0.1:
+ version "1.0.1"
+ resolved "https://registry.yarnpkg.com/hmac-drbg/-/hmac-drbg-1.0.1.tgz#d2745701025a6c775a6c545793ed502fc0c649a1"
+ integrity sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=
+ dependencies:
+ hash.js "^1.0.3"
+ minimalistic-assert "^1.0.0"
+ minimalistic-crypto-utils "^1.0.1"
+
+inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4:
+ version "2.0.4"
+ resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
+ integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
+
+ip-regex@^4.3.0:
+ version "4.3.0"
+ resolved "https://registry.yarnpkg.com/ip-regex/-/ip-regex-4.3.0.tgz#687275ab0f57fa76978ff8f4dddc8a23d5990db5"
+ integrity sha512-B9ZWJxHHOHUhUjCPrMpLD4xEq35bUTClHM1S6CBU5ixQnkZmwipwgc96vAd7AAGM9TGHvJR+Uss+/Ak6UphK+Q==
+
+is-fullwidth-code-point@^3.0.0:
+ version "3.0.0"
+ resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d"
+ integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==
+
+is-plain-object@^2.0.4:
+ version "2.0.4"
+ resolved "https://registry.yarnpkg.com/is-plain-object/-/is-plain-object-2.0.4.tgz#2c163b3fafb1b606d9d17928f05c2a1c38e07677"
+ integrity sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==
+ dependencies:
+ isobject "^3.0.1"
+
+is-typedarray@^1.0.0:
+ version "1.0.0"
+ resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a"
+ integrity sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=
+
+isobject@^3.0.1:
+ version "3.0.1"
+ resolved "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df"
+ integrity sha1-TkMekrEalzFjaqH5yNHMvP2reN8=
+
+js-sha3@^0.8.0:
+ version "0.8.0"
+ resolved "https://registry.yarnpkg.com/js-sha3/-/js-sha3-0.8.0.tgz#b9b7a5da73afad7dedd0f8c463954cbde6818840"
+ integrity sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==
+
+js-tokens@^4.0.0:
+ version "4.0.0"
+ resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499"
+ integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==
+
+jsesc@^2.5.1:
+ version "2.5.2"
+ resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-2.5.2.tgz#80564d2e483dacf6e8ef209650a67df3f0c283a4"
+ integrity sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==
+
+json5@^2.1.2:
+ version "2.2.0"
+ resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.0.tgz#2dfefe720c6ba525d9ebd909950f0515316c89a3"
+ integrity sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==
+ dependencies:
+ minimist "^1.2.5"
+
+kind-of@^6.0.2:
+ version "6.0.3"
+ resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
+ integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==
+
+locate-path@^3.0.0:
+ version "3.0.0"
+ resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-3.0.0.tgz#dbec3b3ab759758071b58fe59fc41871af21400e"
+ integrity sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==
+ dependencies:
+ p-locate "^3.0.0"
+ path-exists "^3.0.0"
+
+make-dir@^2.0.0, make-dir@^2.1.0:
+ version "2.1.0"
+ resolved "https://registry.yarnpkg.com/make-dir/-/make-dir-2.1.0.tgz#5f0310e18b8be898cc07009295a30ae41e91e6f5"
+ integrity sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==
+ dependencies:
+ pify "^4.0.1"
+ semver "^5.6.0"
+
+make-error@^1.1.1:
+ version "1.3.6"
+ resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2"
+ integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==
+
+md5.js@^1.3.4:
+ version "1.3.5"
+ resolved "https://registry.yarnpkg.com/md5.js/-/md5.js-1.3.5.tgz#b5d07b8e3216e3e27cd728d72f70d1e6a342005f"
+ integrity sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==
+ dependencies:
+ hash-base "^3.0.0"
+ inherits "^2.0.1"
+ safe-buffer "^5.1.2"
+
+mime-db@1.48.0:
+ version "1.48.0"
+ resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.48.0.tgz#e35b31045dd7eada3aaad537ed88a33afbef2d1d"
+ integrity sha512-FM3QwxV+TnZYQ2aRqhlKBMHxk10lTbMt3bBkMAp54ddrNeVSfcQYOOKuGuy3Ddrm38I04If834fOUSq1yzslJQ==
+
+mime-types@^2.1.12:
+ version "2.1.31"
+ resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.31.tgz#a00d76b74317c61f9c2db2218b8e9f8e9c5c9e6b"
+ integrity sha512-XGZnNzm3QvgKxa8dpzyhFTHmpP3l5YNusmne07VUOXxou9CqUqYa/HBy124RqtVh/O2pECas/MOcsDgpilPOPg==
+ dependencies:
+ mime-db "1.48.0"
+
+minimalistic-assert@^1.0.0, minimalistic-assert@^1.0.1:
+ version "1.0.1"
+ resolved "https://registry.yarnpkg.com/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz#2e194de044626d4a10e7f7fbc00ce73e83e4d5c7"
+ integrity sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==
+
+minimalistic-crypto-utils@^1.0.1:
+ version "1.0.1"
+ resolved "https://registry.yarnpkg.com/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz#f6c00c1c0b082246e5c4d99dfb8c7c083b2b582a"
+ integrity sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=
+
+minimist@^1.2.5:
+ version "1.2.5"
+ resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602"
+ integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==
+
+ms@2.0.0:
+ version "2.0.0"
+ resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8"
+ integrity sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=
+
+ms@2.1.2:
+ version "2.1.2"
+ resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009"
+ integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
+
+neo-async@^2.6.0:
+ version "2.6.2"
+ resolved "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.2.tgz#b4aafb93e3aeb2d8174ca53cf163ab7d7308305f"
+ integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==
+
+next-tick@~1.0.0:
+ version "1.0.0"
+ resolved "https://registry.yarnpkg.com/next-tick/-/next-tick-1.0.0.tgz#ca86d1fe8828169b0120208e3dc8424b9db8342c"
+ integrity sha1-yobR/ogoFpsBICCOPchCS524NCw=
+
+node-fetch@^2.6.1:
+ version "2.6.1"
+ resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.1.tgz#045bd323631f76ed2e2b55573394416b639a0052"
+ integrity sha512-V4aYg89jEoVRxRb2fJdAg8FHvI7cEyYdVAh94HH0UIK8oJxUfkjlDQN9RbMx+bEjP7+ggMiFRprSti032Oipxw==
+
+node-gyp-build@^4.2.0:
+ version "4.2.3"
+ resolved "https://registry.yarnpkg.com/node-gyp-build/-/node-gyp-build-4.2.3.tgz#ce6277f853835f718829efb47db20f3e4d9c4739"
+ integrity sha512-MN6ZpzmfNCRM+3t57PTJHgHyw/h4OWnZ6mR8P5j/uZtqQr46RRuDE/P+g3n0YR/AiYXeWixZZzaip77gdICfRg==
+
+node-modules-regexp@^1.0.0:
+ version "1.0.0"
+ resolved "https://registry.yarnpkg.com/node-modules-regexp/-/node-modules-regexp-1.0.0.tgz#8d9dbe28964a4ac5712e9131642107c71e90ec40"
+ integrity sha1-jZ2+KJZKSsVxLpExZCEHxx6Q7EA=
+
+node-releases@^1.1.71:
+ version "1.1.73"
+ resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-1.1.73.tgz#dd4e81ddd5277ff846b80b52bb40c49edf7a7b20"
+ integrity sha512-uW7fodD6pyW2FZNZnp/Z3hvWKeEW1Y8R1+1CnErE8cXFXzl5blBOoVB41CvMer6P6Q0S5FXDwcHgFd1Wj0U9zg==
+
+p-limit@^2.0.0:
+ version "2.3.0"
+ resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-2.3.0.tgz#3dd33c647a214fdfffd835933eb086da0dc21db1"
+ integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==
+ dependencies:
+ p-try "^2.0.0"
+
+p-locate@^3.0.0:
+ version "3.0.0"
+ resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-3.0.0.tgz#322d69a05c0264b25997d9f40cd8a891ab0064a4"
+ integrity sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==
+ dependencies:
+ p-limit "^2.0.0"
+
+p-try@^2.0.0:
+ version "2.2.0"
+ resolved "https://registry.yarnpkg.com/p-try/-/p-try-2.2.0.tgz#cb2868540e313d61de58fafbe35ce9004d5540e6"
+ integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==
+
+path-exists@^3.0.0:
+ version "3.0.0"
+ resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-3.0.0.tgz#ce0ebeaa5f78cb18925ea7d810d7b59b010fd515"
+ integrity sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=
+
+pify@^4.0.1:
+ version "4.0.1"
+ resolved "https://registry.yarnpkg.com/pify/-/pify-4.0.1.tgz#4b2cd25c50d598735c50292224fd8c6df41e3231"
+ integrity sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==
+
+pirates@^4.0.0:
+ version "4.0.1"
+ resolved "https://registry.yarnpkg.com/pirates/-/pirates-4.0.1.tgz#643a92caf894566f91b2b986d2c66950a8e2fb87"
+ integrity sha512-WuNqLTbMI3tmfef2TKxlQmAiLHKtFhlsCZnPIpuv2Ow0RDVO8lfy1Opf4NUzlMXLjPl+Men7AuVdX6TA+s+uGA==
+ dependencies:
+ node-modules-regexp "^1.0.0"
+
+pkg-dir@^3.0.0:
+ version "3.0.0"
+ resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-3.0.0.tgz#2749020f239ed990881b1f71210d51eb6523bea3"
+ integrity sha512-/E57AYkoeQ25qkxMj5PBOVgF8Kiu/h7cYS30Z5+R7WaiCCBfLq58ZI/dSeaEKb9WVJV5n/03QwrN3IeWIFllvw==
+ dependencies:
+ find-up "^3.0.0"
+
+readable-stream@^3.6.0:
+ version "3.6.0"
+ resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-3.6.0.tgz#337bbda3adc0706bd3e024426a286d4b4b2c9198"
+ integrity sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==
+ dependencies:
+ inherits "^2.0.3"
+ string_decoder "^1.1.1"
+ util-deprecate "^1.0.1"
+
+regenerator-runtime@^0.13.4:
+ version "0.13.7"
+ resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.13.7.tgz#cac2dacc8a1ea675feaabaeb8ae833898ae46f55"
+ integrity sha512-a54FxoJDIr27pgf7IgeQGxmqUNYrcV338lf/6gH456HZ/PhX+5BcwHXG9ajESmwe6WRO0tAzRUrRmNONWgkrew==
+
+require-directory@^2.1.1:
+ version "2.1.1"
+ resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42"
+ integrity sha1-jGStX9MNqxyXbiNE/+f3kqam30I=
+
+ripemd160@^2.0.1:
+ version "2.0.2"
+ resolved "https://registry.yarnpkg.com/ripemd160/-/ripemd160-2.0.2.tgz#a1c1a6f624751577ba5d07914cbc92850585890c"
+ integrity sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==
+ dependencies:
+ hash-base "^3.0.0"
+ inherits "^2.0.1"
+
+rxjs@^7.2.0:
+ version "7.2.0"
+ resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-7.2.0.tgz#5cd12409639e9514a71c9f5f9192b2c4ae94de31"
+ integrity sha512-aX8w9OpKrQmiPKfT1bqETtUr9JygIz6GZ+gql8v7CijClsP0laoFUdKzxFAoWuRdSlOdU2+crss+cMf+cqMTnw==
+ dependencies:
+ tslib "~2.1.0"
+
+safe-buffer@^5.0.1, safe-buffer@^5.1.2, safe-buffer@^5.2.0, safe-buffer@~5.2.0:
+ version "5.2.1"
+ resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.2.1.tgz#1eaf9fa9bdb1fdd4ec75f58f9cdb4e6b7827eec6"
+ integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==
+
+safe-buffer@~5.1.1:
+ version "5.1.2"
+ resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d"
+ integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==
+
+scryptsy@^2.1.0:
+ version "2.1.0"
+ resolved "https://registry.yarnpkg.com/scryptsy/-/scryptsy-2.1.0.tgz#8d1e8d0c025b58fdd25b6fa9a0dc905ee8faa790"
+ integrity sha512-1CdSqHQowJBnMAFyPEBRfqag/YP9OF394FV+4YREIJX4ljD7OxvQRDayyoyyCk+senRjSkP6VnUNQmVQqB6g7w==
+
+semver@^5.6.0:
+ version "5.7.1"
+ resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7"
+ integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==
+
+semver@^6.3.0:
+ version "6.3.0"
+ resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d"
+ integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==
+
+sha.js@^2.4.0:
+ version "2.4.11"
+ resolved "https://registry.yarnpkg.com/sha.js/-/sha.js-2.4.11.tgz#37a5cf0b81ecbc6943de109ba2960d1b26584ae7"
+ integrity sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==
+ dependencies:
+ inherits "^2.0.1"
+ safe-buffer "^5.0.1"
+
+shallow-clone@^3.0.0:
+ version "3.0.1"
+ resolved "https://registry.yarnpkg.com/shallow-clone/-/shallow-clone-3.0.1.tgz#8f2981ad92531f55035b01fb230769a40e02efa3"
+ integrity sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==
+ dependencies:
+ kind-of "^6.0.2"
+
+source-map-support@^0.5.16, source-map-support@^0.5.17:
+ version "0.5.19"
+ resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.19.tgz#a98b62f86dcaf4f67399648c085291ab9e8fed61"
+ integrity sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==
+ dependencies:
+ buffer-from "^1.0.0"
+ source-map "^0.6.0"
+
+source-map@^0.5.0:
+ version "0.5.7"
+ resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc"
+ integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=
+
+source-map@^0.6.0, source-map@^0.6.1:
+ version "0.6.1"
+ resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
+ integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
+
+string-width@^4.1.0, string-width@^4.2.0:
+ version "4.2.2"
+ resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.2.tgz#dafd4f9559a7585cfba529c6a0a4f73488ebd4c5"
+ integrity sha512-XBJbT3N4JhVumXE0eoLU9DCjcaF92KLNqTmFCnG1pf8duUxFGwtP6AD6nkjw9a3IdiRtL3E2w3JDiE/xi3vOeA==
+ dependencies:
+ emoji-regex "^8.0.0"
+ is-fullwidth-code-point "^3.0.0"
+ strip-ansi "^6.0.0"
+
+string_decoder@^1.1.1:
+ version "1.3.0"
+ resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e"
+ integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==
+ dependencies:
+ safe-buffer "~5.2.0"
+
+strip-ansi@^6.0.0:
+ version "6.0.0"
+ resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.0.tgz#0b1571dd7669ccd4f3e06e14ef1eed26225ae532"
+ integrity sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w==
+ dependencies:
+ ansi-regex "^5.0.0"
+
+supports-color@^5.3.0:
+ version "5.5.0"
+ resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
+ integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==
+ dependencies:
+ has-flag "^3.0.0"
+
+to-fast-properties@^2.0.0:
+ version "2.0.0"
+ resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e"
+ integrity sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=
+
+ts-node@^8.6.2:
+ version "8.10.2"
+ resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-8.10.2.tgz#eee03764633b1234ddd37f8db9ec10b75ec7fb8d"
+ integrity sha512-ISJJGgkIpDdBhWVu3jufsWpK3Rzo7bdiIXJjQc0ynKxVOVcg2oIrf2H2cejminGrptVc6q6/uynAHNCuWGbpVA==
+ dependencies:
+ arg "^4.1.0"
+ diff "^4.0.1"
+ make-error "^1.1.1"
+ source-map-support "^0.5.17"
+ yn "3.1.1"
+
+tslib@~2.1.0:
+ version "2.1.0"
+ resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.1.0.tgz#da60860f1c2ecaa5703ab7d39bc05b6bf988b97a"
+ integrity sha512-hcVC3wYEziELGGmEEXue7D75zbwIIVUMWAVbHItGPx0ziyXxrOMQx4rQEVEV45Ut/1IotuEvwqPopzIOkDMf0A==
+
+tweetnacl@^1.0.3:
+ version "1.0.3"
+ resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-1.0.3.tgz#ac0af71680458d8a6378d0d0d050ab1407d35596"
+ integrity sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==
+
+type@^1.0.1:
+ version "1.2.0"
+ resolved "https://registry.yarnpkg.com/type/-/type-1.2.0.tgz#848dd7698dafa3e54a6c479e759c4bc3f18847a0"
+ integrity sha512-+5nt5AAniqsCnu2cEQQdpzCAh33kVx8n0VoFidKpB1dVVLAN/F+bgVOqOJqOnEnrhp222clB5p3vUlD+1QAnfg==
+
+type@^2.0.0:
+ version "2.5.0"
+ resolved "https://registry.yarnpkg.com/type/-/type-2.5.0.tgz#0a2e78c2e77907b252abe5f298c1b01c63f0db3d"
+ integrity sha512-180WMDQaIMm3+7hGXWf12GtdniDEy7nYcyFMKJn/eZz/6tSLXrUN9V0wKSbMjej0I1WHWbpREDEKHtqPQa9NNw==
+
+typedarray-to-buffer@^3.1.5:
+ version "3.1.5"
+ resolved "https://registry.yarnpkg.com/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz#a97ee7a9ff42691b9f783ff1bc5112fe3fca9080"
+ integrity sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==
+ dependencies:
+ is-typedarray "^1.0.0"
+
+typescript@^3.8.2:
+ version "3.9.10"
+ resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.9.10.tgz#70f3910ac7a51ed6bef79da7800690b19bf778b8"
+ integrity sha512-w6fIxVE/H1PkLKcCPsFqKE7Kv7QUwhU8qQY2MueZXWx5cPZdwFupLgKK3vntcK98BtNHZtAF4LA/yl2a7k8R6Q==
+
+uglify-js@^3.1.4:
+ version "3.13.10"
+ resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.13.10.tgz#a6bd0d28d38f592c3adb6b180ea6e07e1e540a8d"
+ integrity sha512-57H3ACYFXeo1IaZ1w02sfA71wI60MGco/IQFjOqK+WtKoprh7Go2/yvd2HPtoJILO2Or84ncLccI4xoHMTSbGg==
+
+utf-8-validate@^5.0.2:
+ version "5.0.5"
+ resolved "https://registry.yarnpkg.com/utf-8-validate/-/utf-8-validate-5.0.5.tgz#dd32c2e82c72002dc9f02eb67ba6761f43456ca1"
+ integrity sha512-+pnxRYsS/axEpkrrEpzYfNZGXp0IjC/9RIxwM5gntY4Koi8SHmUGSfxfWqxZdRxrtaoVstuOzUp/rbs3JSPELQ==
+ dependencies:
+ node-gyp-build "^4.2.0"
+
+util-deprecate@^1.0.1:
+ version "1.0.2"
+ resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf"
+ integrity sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=
+
+websocket@^1.0.34:
+ version "1.0.34"
+ resolved "https://registry.yarnpkg.com/websocket/-/websocket-1.0.34.tgz#2bdc2602c08bf2c82253b730655c0ef7dcab3111"
+ integrity sha512-PRDso2sGwF6kM75QykIesBijKSVceR6jL2G8NGYyq2XrItNC2P5/qL5XeR056GhA+Ly7JMFvJb9I312mJfmqnQ==
+ dependencies:
+ bufferutil "^4.0.1"
+ debug "^2.2.0"
+ es5-ext "^0.10.50"
+ typedarray-to-buffer "^3.1.5"
+ utf-8-validate "^5.0.2"
+ yaeti "^0.0.6"
+
+wordwrap@^1.0.0:
+ version "1.0.0"
+ resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-1.0.0.tgz#27584810891456a4171c8d0226441ade90cbcaeb"
+ integrity sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=
+
+wrap-ansi@^7.0.0:
+ version "7.0.0"
+ resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
+ integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
+ dependencies:
+ ansi-styles "^4.0.0"
+ string-width "^4.1.0"
+ strip-ansi "^6.0.0"
+
+xxhashjs@^0.2.2:
+ version "0.2.2"
+ resolved "https://registry.yarnpkg.com/xxhashjs/-/xxhashjs-0.2.2.tgz#8a6251567621a1c46a5ae204da0249c7f8caa9d8"
+ integrity sha512-AkTuIuVTET12tpsVIQo+ZU6f/qDmKuRUcjaqR+OIvm+aCBsZ95i7UVY5WJ9TMsSaZ0DA2WxoZ4acu0sPH+OKAw==
+ dependencies:
+ cuint "^0.2.2"
+
+y18n@^5.0.5:
+ version "5.0.8"
+ resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55"
+ integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==
+
+yaeti@^0.0.6:
+ version "0.0.6"
+ resolved "https://registry.yarnpkg.com/yaeti/-/yaeti-0.0.6.tgz#f26f484d72684cf42bedfb76970aa1608fbf9577"
+ integrity sha1-8m9ITXJoTPQr7ft2lwqhYI+/lXc=
+
+yargs-parser@^20.2.2:
+ version "20.2.9"
+ resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.9.tgz#2eb7dc3b0289718fc295f362753845c41a0c94ee"
+ integrity sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==
+
+yargs@^17.0.1:
+ version "17.0.1"
+ resolved "https://registry.yarnpkg.com/yargs/-/yargs-17.0.1.tgz#6a1ced4ed5ee0b388010ba9fd67af83b9362e0bb"
+ integrity sha512-xBBulfCc8Y6gLFcrPvtqKz9hz8SO0l1Ni8GgDekvBX2ro0HRQImDGnikfc33cgzcYUSncapnNcZDjVFIH3f6KQ==
+ dependencies:
+ cliui "^7.0.2"
+ escalade "^3.1.1"
+ get-caller-file "^2.0.5"
+ require-directory "^2.1.1"
+ string-width "^4.2.0"
+ y18n "^5.0.5"
+ yargs-parser "^20.2.2"
+
+yn@3.1.1:
+ version "3.1.1"
+ resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50"
+ integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==