@dedot/chaintypes 0.194.0 → 0.195.0

package/kusama-asset-hub/errors.d.ts

@@ -1,8 +1,8 @@
 // Generated by dedot cli
 
-import type { GenericChainErrors, GenericPalletError, RpcVersion } from 'dedot/types';
+import type { GenericChainErrors, GenericPalletError } from 'dedot/types';
 
-export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<Rv> {
+export interface ChainErrors extends GenericChainErrors {
   /**
    * Pallet `System`'s errors
    **/
@@ -11,65 +11,65 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * The name of specification does not match between the current runtime
      * and the new runtime.
      **/
-    InvalidSpecName: GenericPalletError<Rv>;
+    InvalidSpecName: GenericPalletError;
 
     /**
      * The specification version is not allowed to decrease between the current runtime
      * and the new runtime.
      **/
-    SpecVersionNeedsToIncrease: GenericPalletError<Rv>;
+    SpecVersionNeedsToIncrease: GenericPalletError;
 
     /**
      * Failed to extract the runtime version from the new runtime.
      *
      * Either calling `Core_version` or decoding `RuntimeVersion` failed.
      **/
-    FailedToExtractRuntimeVersion: GenericPalletError<Rv>;
+    FailedToExtractRuntimeVersion: GenericPalletError;
 
     /**
      * Suicide called when the account has non-default composite data.
      **/
-    NonDefaultComposite: GenericPalletError<Rv>;
+    NonDefaultComposite: GenericPalletError;
 
     /**
      * There is a non-zero reference count preventing the account from being purged.
      **/
-    NonZeroRefCount: GenericPalletError<Rv>;
+    NonZeroRefCount: GenericPalletError;
 
     /**
      * The origin filter prevent the call to be dispatched.
      **/
-    CallFiltered: GenericPalletError<Rv>;
+    CallFiltered: GenericPalletError;
 
     /**
      * A multi-block migration is ongoing and prevents the current code from being replaced.
      **/
-    MultiBlockMigrationsOngoing: GenericPalletError<Rv>;
+    MultiBlockMigrationsOngoing: GenericPalletError;
 
     /**
      * The specified [`Task`] is not valid.
      **/
-    InvalidTask: GenericPalletError<Rv>;
+    InvalidTask: GenericPalletError;
 
     /**
      * The specified [`Task`] failed during execution.
      **/
-    FailedTask: GenericPalletError<Rv>;
+    FailedTask: GenericPalletError;
 
     /**
      * No upgrade authorized.
      **/
-    NothingAuthorized: GenericPalletError<Rv>;
+    NothingAuthorized: GenericPalletError;
 
     /**
      * The submitted code is not authorized.
      **/
-    Unauthorized: GenericPalletError<Rv>;
+    Unauthorized: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ParachainSystem`'s errors
@@ -78,38 +78,38 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Attempt to upgrade validation function while existing upgrade pending.
      **/
-    OverlappingUpgrades: GenericPalletError<Rv>;
+    OverlappingUpgrades: GenericPalletError;
 
     /**
      * Polkadot currently prohibits this parachain from upgrading its validation function.
      **/
-    ProhibitedByPolkadot: GenericPalletError<Rv>;
+    ProhibitedByPolkadot: GenericPalletError;
 
     /**
      * The supplied validation function has compiled into a blob larger than Polkadot is
      * willing to run.
      **/
-    TooBig: GenericPalletError<Rv>;
+    TooBig: GenericPalletError;
 
     /**
      * The inherent which supplies the validation data did not run this block.
      **/
-    ValidationDataNotAvailable: GenericPalletError<Rv>;
+    ValidationDataNotAvailable: GenericPalletError;
 
     /**
      * The inherent which supplies the host configuration did not run this block.
      **/
-    HostConfigurationNotAvailable: GenericPalletError<Rv>;
+    HostConfigurationNotAvailable: GenericPalletError;
 
     /**
      * No validation function upgrade is currently scheduled.
      **/
-    NotScheduled: GenericPalletError<Rv>;
+    NotScheduled: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `MultiBlockMigrations`'s errors
@@ -118,12 +118,12 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The operation cannot complete since some MBMs are ongoing.
      **/
-    Ongoing: GenericPalletError<Rv>;
+    Ongoing: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Preimage`'s errors
@@ -132,47 +132,47 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Preimage is too large to store on-chain.
      **/
-    TooBig: GenericPalletError<Rv>;
+    TooBig: GenericPalletError;
 
     /**
      * Preimage has already been noted on-chain.
      **/
-    AlreadyNoted: GenericPalletError<Rv>;
+    AlreadyNoted: GenericPalletError;
 
     /**
      * The user is not authorized to perform this action.
      **/
-    NotAuthorized: GenericPalletError<Rv>;
+    NotAuthorized: GenericPalletError;
 
     /**
      * The preimage cannot be removed since it has not yet been noted.
      **/
-    NotNoted: GenericPalletError<Rv>;
+    NotNoted: GenericPalletError;
 
     /**
      * A preimage may not be removed when there are outstanding requests.
      **/
-    Requested: GenericPalletError<Rv>;
+    Requested: GenericPalletError;
 
     /**
      * The preimage request cannot be removed since no outstanding requests exist.
      **/
-    NotRequested: GenericPalletError<Rv>;
+    NotRequested: GenericPalletError;
 
     /**
      * More than `MAX_HASH_UPGRADE_BULK_COUNT` hashes were requested to be upgraded at once.
      **/
-    TooMany: GenericPalletError<Rv>;
+    TooMany: GenericPalletError;
 
     /**
      * Too few hashes were requested to be upgraded (i.e. zero).
      **/
-    TooFew: GenericPalletError<Rv>;
+    TooFew: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Scheduler`'s errors
@@ -181,32 +181,32 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Failed to schedule a call
      **/
-    FailedToSchedule: GenericPalletError<Rv>;
+    FailedToSchedule: GenericPalletError;
 
     /**
      * Cannot find the scheduled call.
      **/
-    NotFound: GenericPalletError<Rv>;
+    NotFound: GenericPalletError;
 
     /**
      * Given target block number is in the past.
      **/
-    TargetBlockNumberInPast: GenericPalletError<Rv>;
+    TargetBlockNumberInPast: GenericPalletError;
 
     /**
      * Reschedule failed because it does not change scheduled time.
      **/
-    RescheduleNoChange: GenericPalletError<Rv>;
+    RescheduleNoChange: GenericPalletError;
 
     /**
      * Attempt to use a non-named function on a named task.
      **/
-    Named: GenericPalletError<Rv>;
+    Named: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Balances`'s errors
@@ -215,67 +215,67 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Vesting balance too high to send value.
      **/
-    VestingBalance: GenericPalletError<Rv>;
+    VestingBalance: GenericPalletError;
 
     /**
      * Account liquidity restrictions prevent withdrawal.
      **/
-    LiquidityRestrictions: GenericPalletError<Rv>;
+    LiquidityRestrictions: GenericPalletError;
 
     /**
      * Balance too low to send value.
      **/
-    InsufficientBalance: GenericPalletError<Rv>;
+    InsufficientBalance: GenericPalletError;
 
     /**
      * Value too low to create account due to existential deposit.
      **/
-    ExistentialDeposit: GenericPalletError<Rv>;
+    ExistentialDeposit: GenericPalletError;
 
     /**
      * Transfer/payment would kill account.
      **/
-    Expendability: GenericPalletError<Rv>;
+    Expendability: GenericPalletError;
 
     /**
      * A vesting schedule already exists for this account.
      **/
-    ExistingVestingSchedule: GenericPalletError<Rv>;
+    ExistingVestingSchedule: GenericPalletError;
 
     /**
      * Beneficiary account must pre-exist.
      **/
-    DeadAccount: GenericPalletError<Rv>;
+    DeadAccount: GenericPalletError;
 
     /**
      * Number of named reserves exceed `MaxReserves`.
      **/
-    TooManyReserves: GenericPalletError<Rv>;
+    TooManyReserves: GenericPalletError;
 
     /**
      * Number of holds exceed `VariantCountOf<T::RuntimeHoldReason>`.
      **/
-    TooManyHolds: GenericPalletError<Rv>;
+    TooManyHolds: GenericPalletError;
 
     /**
      * Number of freezes exceed `MaxFreezes`.
      **/
-    TooManyFreezes: GenericPalletError<Rv>;
+    TooManyFreezes: GenericPalletError;
 
     /**
      * The issuance cannot be modified since it is already deactivated.
      **/
-    IssuanceDeactivated: GenericPalletError<Rv>;
+    IssuanceDeactivated: GenericPalletError;
 
     /**
      * The delta cannot be zero.
      **/
-    DeltaZero: GenericPalletError<Rv>;
+    DeltaZero: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Vesting`'s errors
@@ -284,33 +284,33 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The account given is not vesting.
      **/
-    NotVesting: GenericPalletError<Rv>;
+    NotVesting: GenericPalletError;
 
     /**
      * The account already has `MaxVestingSchedules` count of schedules and thus
      * cannot add another one. Consider merging existing schedules in order to add another.
      **/
-    AtMaxVestingSchedules: GenericPalletError<Rv>;
+    AtMaxVestingSchedules: GenericPalletError;
 
     /**
      * Amount being transferred is too low to create a vesting schedule.
      **/
-    AmountLow: GenericPalletError<Rv>;
+    AmountLow: GenericPalletError;
 
     /**
      * An index was out of bounds of the vesting schedules.
      **/
-    ScheduleIndexOutOfBounds: GenericPalletError<Rv>;
+    ScheduleIndexOutOfBounds: GenericPalletError;
 
     /**
      * Failed to create a new schedule because some parameter was invalid.
      **/
-    InvalidScheduleParams: GenericPalletError<Rv>;
+    InvalidScheduleParams: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Claims`'s errors
@@ -319,38 +319,38 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Invalid Ethereum signature.
      **/
-    InvalidEthereumSignature: GenericPalletError<Rv>;
+    InvalidEthereumSignature: GenericPalletError;
 
     /**
      * Ethereum address has no claim.
      **/
-    SignerHasNoClaim: GenericPalletError<Rv>;
+    SignerHasNoClaim: GenericPalletError;
 
     /**
      * Account ID sending transaction has no claim.
      **/
-    SenderHasNoClaim: GenericPalletError<Rv>;
+    SenderHasNoClaim: GenericPalletError;
 
     /**
      * There's not enough in the pot to pay out some unvested amount. Generally implies a
      * logic error.
      **/
-    PotUnderflow: GenericPalletError<Rv>;
+    PotUnderflow: GenericPalletError;
 
     /**
      * A needed statement was not included.
      **/
-    InvalidStatement: GenericPalletError<Rv>;
+    InvalidStatement: GenericPalletError;
 
     /**
      * The account already has a vested balance.
      **/
-    VestedBalanceExists: GenericPalletError<Rv>;
+    VestedBalanceExists: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `CollatorSelection`'s errors
@@ -359,92 +359,92 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The pallet has too many candidates.
      **/
-    TooManyCandidates: GenericPalletError<Rv>;
+    TooManyCandidates: GenericPalletError;
 
     /**
      * Leaving would result in too few candidates.
      **/
-    TooFewEligibleCollators: GenericPalletError<Rv>;
+    TooFewEligibleCollators: GenericPalletError;
 
     /**
      * Account is already a candidate.
      **/
-    AlreadyCandidate: GenericPalletError<Rv>;
+    AlreadyCandidate: GenericPalletError;
 
     /**
      * Account is not a candidate.
      **/
-    NotCandidate: GenericPalletError<Rv>;
+    NotCandidate: GenericPalletError;
 
     /**
      * There are too many Invulnerables.
      **/
-    TooManyInvulnerables: GenericPalletError<Rv>;
+    TooManyInvulnerables: GenericPalletError;
 
     /**
      * Account is already an Invulnerable.
      **/
-    AlreadyInvulnerable: GenericPalletError<Rv>;
+    AlreadyInvulnerable: GenericPalletError;
 
     /**
      * Account is not an Invulnerable.
      **/
-    NotInvulnerable: GenericPalletError<Rv>;
+    NotInvulnerable: GenericPalletError;
 
     /**
      * Account has no associated validator ID.
      **/
-    NoAssociatedValidatorId: GenericPalletError<Rv>;
+    NoAssociatedValidatorId: GenericPalletError;
 
     /**
      * Validator ID is not yet registered.
      **/
-    ValidatorNotRegistered: GenericPalletError<Rv>;
+    ValidatorNotRegistered: GenericPalletError;
 
     /**
      * Could not insert in the candidate list.
      **/
-    InsertToCandidateListFailed: GenericPalletError<Rv>;
+    InsertToCandidateListFailed: GenericPalletError;
 
     /**
      * Could not remove from the candidate list.
      **/
-    RemoveFromCandidateListFailed: GenericPalletError<Rv>;
+    RemoveFromCandidateListFailed: GenericPalletError;
 
     /**
      * New deposit amount would be below the minimum candidacy bond.
      **/
-    DepositTooLow: GenericPalletError<Rv>;
+    DepositTooLow: GenericPalletError;
 
     /**
      * Could not update the candidate list.
      **/
-    UpdateCandidateListFailed: GenericPalletError<Rv>;
+    UpdateCandidateListFailed: GenericPalletError;
 
     /**
      * Deposit amount is too low to take the target's slot in the candidate list.
      **/
-    InsufficientBond: GenericPalletError<Rv>;
+    InsufficientBond: GenericPalletError;
 
     /**
      * The target account to be replaced in the candidate list is not a candidate.
      **/
-    TargetIsNotCandidate: GenericPalletError<Rv>;
+    TargetIsNotCandidate: GenericPalletError;
 
     /**
      * The updated deposit amount is equal to the amount already reserved.
      **/
-    IdenticalDeposit: GenericPalletError<Rv>;
+    IdenticalDeposit: GenericPalletError;
 
     /**
      * Cannot lower candidacy bond while occupying a future collator slot in the list.
      **/
-    InvalidUnreserve: GenericPalletError<Rv>;
+    InvalidUnreserve: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Session`'s errors
@@ -453,32 +453,32 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Invalid ownership proof.
      **/
-    InvalidProof: GenericPalletError<Rv>;
+    InvalidProof: GenericPalletError;
 
     /**
      * No associated validator ID for account.
      **/
-    NoAssociatedValidatorId: GenericPalletError<Rv>;
+    NoAssociatedValidatorId: GenericPalletError;
 
     /**
      * Registered duplicate key.
      **/
-    DuplicatedKey: GenericPalletError<Rv>;
+    DuplicatedKey: GenericPalletError;
 
     /**
      * No keys are associated with this account.
      **/
-    NoKeys: GenericPalletError<Rv>;
+    NoKeys: GenericPalletError;
 
     /**
      * Key setting account is not live, so it's impossible to associate keys.
      **/
-    NoAccount: GenericPalletError<Rv>;
+    NoAccount: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `XcmpQueue`'s errors
@@ -487,32 +487,32 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Setting the queue config failed since one of its values was invalid.
      **/
-    BadQueueConfig: GenericPalletError<Rv>;
+    BadQueueConfig: GenericPalletError;
 
     /**
      * The execution is already suspended.
      **/
-    AlreadySuspended: GenericPalletError<Rv>;
+    AlreadySuspended: GenericPalletError;
 
     /**
      * The execution is already resumed.
      **/
-    AlreadyResumed: GenericPalletError<Rv>;
+    AlreadyResumed: GenericPalletError;
 
     /**
      * There are too many active outbound channels.
      **/
-    TooManyActiveOutboundChannels: GenericPalletError<Rv>;
+    TooManyActiveOutboundChannels: GenericPalletError;
 
     /**
      * The message is too big.
      **/
-    TooBig: GenericPalletError<Rv>;
+    TooBig: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `PolkadotXcm`'s errors
@@ -522,152 +522,152 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * The desired destination was unreachable, generally because there is a no way of routing
      * to it.
      **/
-    Unreachable: GenericPalletError<Rv>;
+    Unreachable: GenericPalletError;
 
     /**
      * There was some other issue (i.e. not to do with routing) in sending the message.
      * Perhaps a lack of space for buffering the message.
      **/
-    SendFailure: GenericPalletError<Rv>;
+    SendFailure: GenericPalletError;
 
     /**
      * The message execution fails the filter.
      **/
-    Filtered: GenericPalletError<Rv>;
+    Filtered: GenericPalletError;
 
     /**
      * The message's weight could not be determined.
      **/
-    UnweighableMessage: GenericPalletError<Rv>;
+    UnweighableMessage: GenericPalletError;
 
     /**
      * The destination `Location` provided cannot be inverted.
      **/
-    DestinationNotInvertible: GenericPalletError<Rv>;
+    DestinationNotInvertible: GenericPalletError;
 
     /**
      * The assets to be sent are empty.
      **/
-    Empty: GenericPalletError<Rv>;
+    Empty: GenericPalletError;
 
     /**
      * Could not re-anchor the assets to declare the fees for the destination chain.
      **/
-    CannotReanchor: GenericPalletError<Rv>;
+    CannotReanchor: GenericPalletError;
 
     /**
      * Too many assets have been attempted for transfer.
      **/
-    TooManyAssets: GenericPalletError<Rv>;
+    TooManyAssets: GenericPalletError;
 
     /**
      * Origin is invalid for sending.
      **/
-    InvalidOrigin: GenericPalletError<Rv>;
+    InvalidOrigin: GenericPalletError;
 
     /**
      * The version of the `Versioned` value used is not able to be interpreted.
      **/
-    BadVersion: GenericPalletError<Rv>;
+    BadVersion: GenericPalletError;
 
     /**
      * The given location could not be used (e.g. because it cannot be expressed in the
      * desired version of XCM).
      **/
-    BadLocation: GenericPalletError<Rv>;
+    BadLocation: GenericPalletError;
 
     /**
      * The referenced subscription could not be found.
      **/
-    NoSubscription: GenericPalletError<Rv>;
+    NoSubscription: GenericPalletError;
 
     /**
      * The location is invalid since it already has a subscription from us.
      **/
-    AlreadySubscribed: GenericPalletError<Rv>;
+    AlreadySubscribed: GenericPalletError;
 
     /**
      * Could not check-out the assets for teleportation to the destination chain.
      **/
-    CannotCheckOutTeleport: GenericPalletError<Rv>;
+    CannotCheckOutTeleport: GenericPalletError;
 
     /**
      * The owner does not own (all) of the asset that they wish to do the operation on.
      **/
-    LowBalance: GenericPalletError<Rv>;
+    LowBalance: GenericPalletError;
 
     /**
      * The asset owner has too many locks on the asset.
      **/
-    TooManyLocks: GenericPalletError<Rv>;
+    TooManyLocks: GenericPalletError;
 
     /**
      * The given account is not an identifiable sovereign account for any location.
      **/
-    AccountNotSovereign: GenericPalletError<Rv>;
+    AccountNotSovereign: GenericPalletError;
 
     /**
      * The operation required fees to be paid which the initiator could not meet.
      **/
-    FeesNotMet: GenericPalletError<Rv>;
+    FeesNotMet: GenericPalletError;
 
     /**
      * A remote lock with the corresponding data could not be found.
      **/
-    LockNotFound: GenericPalletError<Rv>;
+    LockNotFound: GenericPalletError;
 
     /**
      * The unlock operation cannot succeed because there are still consumers of the lock.
      **/
-    InUse: GenericPalletError<Rv>;
+    InUse: GenericPalletError;
 
     /**
      * Invalid asset, reserve chain could not be determined for it.
      **/
-    InvalidAssetUnknownReserve: GenericPalletError<Rv>;
+    InvalidAssetUnknownReserve: GenericPalletError;
 
     /**
      * Invalid asset, do not support remote asset reserves with different fees reserves.
      **/
-    InvalidAssetUnsupportedReserve: GenericPalletError<Rv>;
+    InvalidAssetUnsupportedReserve: GenericPalletError;
 
     /**
      * Too many assets with different reserve locations have been attempted for transfer.
      **/
-    TooManyReserves: GenericPalletError<Rv>;
+    TooManyReserves: GenericPalletError;
 
     /**
      * Local XCM execution incomplete.
      **/
-    LocalExecutionIncomplete: GenericPalletError<Rv>;
+    LocalExecutionIncomplete: GenericPalletError;
 
     /**
      * Too many locations authorized to alias origin.
      *
      * @deprecated Use `LocalExecutionIncompleteWithError` instead (since 20.0.0)
      **/
-    TooManyAuthorizedAliases: GenericPalletError<Rv>;
+    TooManyAuthorizedAliases: GenericPalletError;
 
     /**
      * Expiry block number is in the past.
      **/
-    ExpiresInPast: GenericPalletError<Rv>;
+    ExpiresInPast: GenericPalletError;
 
     /**
      * The alias to remove authorization for was not found.
      **/
-    AliasNotFound: GenericPalletError<Rv>;
+    AliasNotFound: GenericPalletError;
 
     /**
      * Local XCM execution incomplete with the actual XCM error and the index of the
      * instruction that caused the error.
      **/
-    LocalExecutionIncompleteWithError: GenericPalletError<Rv>;
+    LocalExecutionIncompleteWithError: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `MessageQueue`'s errors
@@ -677,32 +677,32 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * Page is not reapable because it has items remaining to be processed and is not old
      * enough.
      **/
-    NotReapable: GenericPalletError<Rv>;
+    NotReapable: GenericPalletError;
 
     /**
      * Page to be reaped does not exist.
      **/
-    NoPage: GenericPalletError<Rv>;
+    NoPage: GenericPalletError;
 
     /**
      * The referenced message could not be found.
      **/
-    NoMessage: GenericPalletError<Rv>;
+    NoMessage: GenericPalletError;
 
     /**
      * The message was already processed and cannot be processed again.
      **/
-    AlreadyProcessed: GenericPalletError<Rv>;
+    AlreadyProcessed: GenericPalletError;
 
     /**
      * The message is queued for future execution.
      **/
-    Queued: GenericPalletError<Rv>;
+    Queued: GenericPalletError;
 
     /**
      * There is temporarily not enough weight to continue servicing messages.
      **/
-    InsufficientWeight: GenericPalletError<Rv>;
+    InsufficientWeight: GenericPalletError;
 
     /**
      * This message is temporarily unprocessable.
@@ -710,24 +710,24 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * Such errors are expected, but not guaranteed, to resolve themselves eventually through
      * retrying.
      **/
-    TemporarilyUnprocessable: GenericPalletError<Rv>;
+    TemporarilyUnprocessable: GenericPalletError;
 
     /**
      * The queue is paused and no message can be executed from it.
      *
      * This can change at any time and may resolve in the future by re-trying.
      **/
-    QueuePaused: GenericPalletError<Rv>;
+    QueuePaused: GenericPalletError;
 
     /**
      * Another call is in progress and needs to finish before this call can happen.
      **/
-    RecursiveDisallowed: GenericPalletError<Rv>;
+    RecursiveDisallowed: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Utility`'s errors
@@ -736,12 +736,12 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Too many calls batched.
      **/
-    TooManyCalls: GenericPalletError<Rv>;
+    TooManyCalls: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Multisig`'s errors
@@ -750,78 +750,78 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Threshold must be 2 or greater.
      **/
-    MinimumThreshold: GenericPalletError<Rv>;
+    MinimumThreshold: GenericPalletError;
 
     /**
      * Call is already approved by this signatory.
      **/
-    AlreadyApproved: GenericPalletError<Rv>;
+    AlreadyApproved: GenericPalletError;
 
     /**
      * Call doesn't need any (more) approvals.
      **/
-    NoApprovalsNeeded: GenericPalletError<Rv>;
+    NoApprovalsNeeded: GenericPalletError;
 
     /**
      * There are too few signatories in the list.
      **/
-    TooFewSignatories: GenericPalletError<Rv>;
+    TooFewSignatories: GenericPalletError;
 
     /**
      * There are too many signatories in the list.
      **/
-    TooManySignatories: GenericPalletError<Rv>;
+    TooManySignatories: GenericPalletError;
 
     /**
      * The signatories were provided out of order; they should be ordered.
      **/
-    SignatoriesOutOfOrder: GenericPalletError<Rv>;
+    SignatoriesOutOfOrder: GenericPalletError;
 
     /**
      * The sender was contained in the other signatories; it shouldn't be.
      **/
-    SenderInSignatories: GenericPalletError<Rv>;
+    SenderInSignatories: GenericPalletError;
 
     /**
      * Multisig operation not found in storage.
      **/
-    NotFound: GenericPalletError<Rv>;
+    NotFound: GenericPalletError;
 
     /**
      * Only the account that originally created the multisig is able to cancel it or update
      * its deposits.
      **/
-    NotOwner: GenericPalletError<Rv>;
+    NotOwner: GenericPalletError;
 
     /**
      * No timepoint was given, yet the multisig operation is already underway.
      **/
-    NoTimepoint: GenericPalletError<Rv>;
+    NoTimepoint: GenericPalletError;
 
     /**
      * A different timepoint was given to the multisig operation that is underway.
      **/
-    WrongTimepoint: GenericPalletError<Rv>;
+    WrongTimepoint: GenericPalletError;
 
     /**
      * A timepoint was given, yet no multisig operation is underway.
      **/
-    UnexpectedTimepoint: GenericPalletError<Rv>;
+    UnexpectedTimepoint: GenericPalletError;
 
     /**
      * The maximum weight information provided was too low.
      **/
-    MaxWeightTooLow: GenericPalletError<Rv>;
+    MaxWeightTooLow: GenericPalletError;
 
     /**
      * The data to be stored is already stored.
      **/
-    AlreadyStored: GenericPalletError<Rv>;
+    AlreadyStored: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Proxy`'s errors
@@ -830,47 +830,47 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * There are too many proxies registered or too many announcements pending.
      **/
-    TooMany: GenericPalletError<Rv>;
+    TooMany: GenericPalletError;
 
     /**
      * Proxy registration not found.
      **/
-    NotFound: GenericPalletError<Rv>;
+    NotFound: GenericPalletError;
 
     /**
      * Sender is not a proxy of the account to be proxied.
      **/
-    NotProxy: GenericPalletError<Rv>;
+    NotProxy: GenericPalletError;
 
     /**
      * A call which is incompatible with the proxy type's filter was attempted.
      **/
-    Unproxyable: GenericPalletError<Rv>;
+    Unproxyable: GenericPalletError;
 
     /**
      * Account is already a proxy.
      **/
-    Duplicate: GenericPalletError<Rv>;
+    Duplicate: GenericPalletError;
 
     /**
      * Call may not be made by proxy because it may escalate its privileges.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * Announcement, if made at all, was made too recently.
      **/
-    Unannounced: GenericPalletError<Rv>;
+    Unannounced: GenericPalletError;
 
     /**
      * Cannot add self as proxy.
      **/
-    NoSelfProxy: GenericPalletError<Rv>;
+    NoSelfProxy: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `RemoteProxyRelayChain`'s errors
@@ -879,42 +879,42 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The local account id could not converted to the remote account id.
      **/
-    CouldNotConvertLocalToRemoteAccountId: GenericPalletError<Rv>;
+    CouldNotConvertLocalToRemoteAccountId: GenericPalletError;
 
     /**
      * The anchor block of the remote proof is unknown.
      **/
-    UnknownProofAnchorBlock: GenericPalletError<Rv>;
+    UnknownProofAnchorBlock: GenericPalletError;
 
     /**
      * The proxy definition could not be found in the proof.
      **/
-    InvalidProof: GenericPalletError<Rv>;
+    InvalidProof: GenericPalletError;
 
     /**
      * Failed to decode the remote proxy definition from the proof.
      **/
-    ProxyDefinitionDecodingFailed: GenericPalletError<Rv>;
+    ProxyDefinitionDecodingFailed: GenericPalletError;
 
     /**
      * Announcement, if made at all, was made too recently.
      **/
-    Unannounced: GenericPalletError<Rv>;
+    Unannounced: GenericPalletError;
 
     /**
      * Could not find any matching proxy definition in the proof.
      **/
-    DidNotFindMatchingProxyDefinition: GenericPalletError<Rv>;
+    DidNotFindMatchingProxyDefinition: GenericPalletError;
 
     /**
      * Proxy proof not registered.
      **/
-    ProxyProofNotRegistered: GenericPalletError<Rv>;
+    ProxyProofNotRegistered: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Indices`'s errors
@@ -923,32 +923,32 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The index was not already assigned.
      **/
-    NotAssigned: GenericPalletError<Rv>;
+    NotAssigned: GenericPalletError;
 
     /**
      * The index is assigned to another account.
      **/
-    NotOwner: GenericPalletError<Rv>;
+    NotOwner: GenericPalletError;
 
     /**
      * The index was not available.
      **/
-    InUse: GenericPalletError<Rv>;
+    InUse: GenericPalletError;
 
     /**
      * The source and destination accounts are identical.
      **/
-    NotTransfer: GenericPalletError<Rv>;
+    NotTransfer: GenericPalletError;
 
     /**
      * The index is permanent and may not be freed/changed.
      **/
-    Permanent: GenericPalletError<Rv>;
+    Permanent: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Assets`'s errors
@@ -957,125 +957,125 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Account balance must be greater than or equal to the transfer amount.
      **/
-    BalanceLow: GenericPalletError<Rv>;
+    BalanceLow: GenericPalletError;
 
     /**
      * The account to alter does not exist.
      **/
-    NoAccount: GenericPalletError<Rv>;
+    NoAccount: GenericPalletError;
 
     /**
      * The signing account has no permission to do the operation.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * The given asset ID is unknown.
      **/
-    Unknown: GenericPalletError<Rv>;
+    Unknown: GenericPalletError;
 
     /**
      * The origin account is frozen.
      **/
-    Frozen: GenericPalletError<Rv>;
+    Frozen: GenericPalletError;
 
     /**
      * The asset ID is already taken.
      **/
-    InUse: GenericPalletError<Rv>;
+    InUse: GenericPalletError;
 
     /**
      * Invalid witness data given.
      **/
-    BadWitness: GenericPalletError<Rv>;
+    BadWitness: GenericPalletError;
 
     /**
      * Minimum balance should be non-zero.
      **/
-    MinBalanceZero: GenericPalletError<Rv>;
+    MinBalanceZero: GenericPalletError;
 
     /**
      * Unable to increment the consumer reference counters on the account. Either no provider
      * reference exists to allow a non-zero balance of a non-self-sufficient asset, or one
      * fewer then the maximum number of consumers has been reached.
      **/
-    UnavailableConsumer: GenericPalletError<Rv>;
+    UnavailableConsumer: GenericPalletError;
 
     /**
      * Invalid metadata given.
      **/
-    BadMetadata: GenericPalletError<Rv>;
+    BadMetadata: GenericPalletError;
 
     /**
      * No approval exists that would allow the transfer.
      **/
-    Unapproved: GenericPalletError<Rv>;
+    Unapproved: GenericPalletError;
 
     /**
      * The source account would not survive the transfer and it needs to stay alive.
      **/
-    WouldDie: GenericPalletError<Rv>;
+    WouldDie: GenericPalletError;
 
     /**
      * The asset-account already exists.
      **/
-    AlreadyExists: GenericPalletError<Rv>;
+    AlreadyExists: GenericPalletError;
 
     /**
      * The asset-account doesn't have an associated deposit.
      **/
-    NoDeposit: GenericPalletError<Rv>;
+    NoDeposit: GenericPalletError;
 
     /**
      * The operation would result in funds being burned.
      **/
-    WouldBurn: GenericPalletError<Rv>;
+    WouldBurn: GenericPalletError;
 
     /**
      * The asset is a live asset and is actively being used. Usually emit for operations such
      * as `start_destroy` which require the asset to be in a destroying state.
      **/
-    LiveAsset: GenericPalletError<Rv>;
+    LiveAsset: GenericPalletError;
 
     /**
      * The asset is not live, and likely being destroyed.
      **/
-    AssetNotLive: GenericPalletError<Rv>;
+    AssetNotLive: GenericPalletError;
 
     /**
      * The asset status is not the expected status.
      **/
-    IncorrectStatus: GenericPalletError<Rv>;
+    IncorrectStatus: GenericPalletError;
 
     /**
      * The asset should be frozen before the given operation.
      **/
-    NotFrozen: GenericPalletError<Rv>;
+    NotFrozen: GenericPalletError;
 
     /**
      * Callback action resulted in error
      **/
-    CallbackFailed: GenericPalletError<Rv>;
+    CallbackFailed: GenericPalletError;
 
     /**
      * The asset ID must be equal to the [`NextAssetId`].
      **/
-    BadAssetId: GenericPalletError<Rv>;
+    BadAssetId: GenericPalletError;
 
     /**
      * The asset cannot be destroyed because some accounts for this asset contain freezes.
      **/
-    ContainsFreezes: GenericPalletError<Rv>;
+    ContainsFreezes: GenericPalletError;
 
     /**
      * The asset cannot be destroyed because some accounts for this asset contain holds.
      **/
-    ContainsHolds: GenericPalletError<Rv>;
+    ContainsHolds: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Uniques`'s errors
@@ -1084,117 +1084,117 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The signing account has no permission to do the operation.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * The given item ID is unknown.
      **/
-    UnknownCollection: GenericPalletError<Rv>;
+    UnknownCollection: GenericPalletError;
 
     /**
      * The item ID has already been used for an item.
      **/
-    AlreadyExists: GenericPalletError<Rv>;
+    AlreadyExists: GenericPalletError;
 
     /**
      * The owner turned out to be different to what was expected.
      **/
-    WrongOwner: GenericPalletError<Rv>;
+    WrongOwner: GenericPalletError;
 
     /**
      * Invalid witness data given.
      **/
-    BadWitness: GenericPalletError<Rv>;
+    BadWitness: GenericPalletError;
 
     /**
      * The item ID is already taken.
      **/
-    InUse: GenericPalletError<Rv>;
+    InUse: GenericPalletError;
 
     /**
      * The item or collection is frozen.
      **/
-    Frozen: GenericPalletError<Rv>;
+    Frozen: GenericPalletError;
 
     /**
      * The delegate turned out to be different to what was expected.
      **/
-    WrongDelegate: GenericPalletError<Rv>;
+    WrongDelegate: GenericPalletError;
 
     /**
      * There is no delegate approved.
      **/
-    NoDelegate: GenericPalletError<Rv>;
+    NoDelegate: GenericPalletError;
 
     /**
      * No approval exists that would allow the transfer.
      **/
-    Unapproved: GenericPalletError<Rv>;
+    Unapproved: GenericPalletError;
 
     /**
      * The named owner has not signed ownership of the collection is acceptable.
      **/
-    Unaccepted: GenericPalletError<Rv>;
+    Unaccepted: GenericPalletError;
 
     /**
      * The item is locked.
      **/
-    Locked: GenericPalletError<Rv>;
+    Locked: GenericPalletError;
 
     /**
      * All items have been minted.
      **/
-    MaxSupplyReached: GenericPalletError<Rv>;
+    MaxSupplyReached: GenericPalletError;
 
     /**
      * The max supply has already been set.
      **/
-    MaxSupplyAlreadySet: GenericPalletError<Rv>;
+    MaxSupplyAlreadySet: GenericPalletError;
 
     /**
      * The provided max supply is less to the amount of items a collection already has.
      **/
-    MaxSupplyTooSmall: GenericPalletError<Rv>;
+    MaxSupplyTooSmall: GenericPalletError;
 
     /**
      * The given item ID is unknown.
      **/
-    UnknownItem: GenericPalletError<Rv>;
+    UnknownItem: GenericPalletError;
 
     /**
      * Item is not for sale.
      **/
-    NotForSale: GenericPalletError<Rv>;
+    NotForSale: GenericPalletError;
 
     /**
      * The provided bid is too low.
      **/
-    BidTooLow: GenericPalletError<Rv>;
+    BidTooLow: GenericPalletError;
 
     /**
      * No metadata is found.
      **/
-    NoMetadata: GenericPalletError<Rv>;
+    NoMetadata: GenericPalletError;
 
     /**
      * Wrong metadata key/value bytes supplied.
      **/
-    WrongMetadata: GenericPalletError<Rv>;
+    WrongMetadata: GenericPalletError;
 
     /**
      * An attribute is not found.
      **/
-    AttributeNotFound: GenericPalletError<Rv>;
+    AttributeNotFound: GenericPalletError;
 
     /**
      * Wrong attribute key/value bytes supplied.
      **/
-    WrongAttribute: GenericPalletError<Rv>;
+    WrongAttribute: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Nfts`'s errors
@@ -1203,232 +1203,232 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The signing account has no permission to do the operation.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * The given item ID is unknown.
      **/
-    UnknownCollection: GenericPalletError<Rv>;
+    UnknownCollection: GenericPalletError;
 
     /**
      * The item ID has already been used for an item.
      **/
-    AlreadyExists: GenericPalletError<Rv>;
+    AlreadyExists: GenericPalletError;
 
     /**
      * The approval had a deadline that expired, so the approval isn't valid anymore.
      **/
-    ApprovalExpired: GenericPalletError<Rv>;
+    ApprovalExpired: GenericPalletError;
 
     /**
      * The owner turned out to be different to what was expected.
      **/
-    WrongOwner: GenericPalletError<Rv>;
+    WrongOwner: GenericPalletError;
 
     /**
      * The witness data given does not match the current state of the chain.
      **/
-    BadWitness: GenericPalletError<Rv>;
+    BadWitness: GenericPalletError;
 
     /**
      * Collection ID is already taken.
      **/
-    CollectionIdInUse: GenericPalletError<Rv>;
+    CollectionIdInUse: GenericPalletError;
 
     /**
      * Items within that collection are non-transferable.
      **/
-    ItemsNonTransferable: GenericPalletError<Rv>;
+    ItemsNonTransferable: GenericPalletError;
 
     /**
      * The provided account is not a delegate.
      **/
-    NotDelegate: GenericPalletError<Rv>;
+    NotDelegate: GenericPalletError;
 
     /**
      * The delegate turned out to be different to what was expected.
      **/
-    WrongDelegate: GenericPalletError<Rv>;
+    WrongDelegate: GenericPalletError;
 
     /**
      * No approval exists that would allow the transfer.
      **/
-    Unapproved: GenericPalletError<Rv>;
+    Unapproved: GenericPalletError;
 
     /**
      * The named owner has not signed ownership acceptance of the collection.
      **/
-    Unaccepted: GenericPalletError<Rv>;
+    Unaccepted: GenericPalletError;
 
     /**
      * The item is locked (non-transferable).
      **/
-    ItemLocked: GenericPalletError<Rv>;
+    ItemLocked: GenericPalletError;
 
     /**
      * Item's attributes are locked.
      **/
-    LockedItemAttributes: GenericPalletError<Rv>;
+    LockedItemAttributes: GenericPalletError;
 
     /**
      * Collection's attributes are locked.
      **/
-    LockedCollectionAttributes: GenericPalletError<Rv>;
+    LockedCollectionAttributes: GenericPalletError;
 
     /**
      * Item's metadata is locked.
      **/
-    LockedItemMetadata: GenericPalletError<Rv>;
+    LockedItemMetadata: GenericPalletError;
 
     /**
      * Collection's metadata is locked.
      **/
-    LockedCollectionMetadata: GenericPalletError<Rv>;
+    LockedCollectionMetadata: GenericPalletError;
 
     /**
      * All items have been minted.
      **/
-    MaxSupplyReached: GenericPalletError<Rv>;
+    MaxSupplyReached: GenericPalletError;
 
     /**
      * The max supply is locked and can't be changed.
      **/
-    MaxSupplyLocked: GenericPalletError<Rv>;
+    MaxSupplyLocked: GenericPalletError;
 
     /**
      * The provided max supply is less than the number of items a collection already has.
      **/
-    MaxSupplyTooSmall: GenericPalletError<Rv>;
+    MaxSupplyTooSmall: GenericPalletError;
 
     /**
      * The given item ID is unknown.
      **/
-    UnknownItem: GenericPalletError<Rv>;
+    UnknownItem: GenericPalletError;
 
     /**
      * Swap doesn't exist.
      **/
-    UnknownSwap: GenericPalletError<Rv>;
+    UnknownSwap: GenericPalletError;
 
     /**
      * The given item has no metadata set.
      **/
-    MetadataNotFound: GenericPalletError<Rv>;
+    MetadataNotFound: GenericPalletError;
 
     /**
      * The provided attribute can't be found.
      **/
-    AttributeNotFound: GenericPalletError<Rv>;
+    AttributeNotFound: GenericPalletError;
 
     /**
      * Item is not for sale.
      **/
-    NotForSale: GenericPalletError<Rv>;
+    NotForSale: GenericPalletError;
 
     /**
      * The provided bid is too low.
      **/
-    BidTooLow: GenericPalletError<Rv>;
+    BidTooLow: GenericPalletError;
 
     /**
      * The item has reached its approval limit.
      **/
-    ReachedApprovalLimit: GenericPalletError<Rv>;
+    ReachedApprovalLimit: GenericPalletError;
 
     /**
      * The deadline has already expired.
      **/
-    DeadlineExpired: GenericPalletError<Rv>;
+    DeadlineExpired: GenericPalletError;
 
     /**
      * The duration provided should be less than or equal to `MaxDeadlineDuration`.
      **/
-    WrongDuration: GenericPalletError<Rv>;
+    WrongDuration: GenericPalletError;
 
     /**
      * The method is disabled by system settings.
      **/
-    MethodDisabled: GenericPalletError<Rv>;
+    MethodDisabled: GenericPalletError;
 
     /**
      * The provided setting can't be set.
      **/
-    WrongSetting: GenericPalletError<Rv>;
+    WrongSetting: GenericPalletError;
 
     /**
      * Item's config already exists and should be equal to the provided one.
      **/
-    InconsistentItemConfig: GenericPalletError<Rv>;
+    InconsistentItemConfig: GenericPalletError;
 
     /**
      * Config for a collection or an item can't be found.
      **/
-    NoConfig: GenericPalletError<Rv>;
+    NoConfig: GenericPalletError;
 
     /**
      * Some roles were not cleared.
      **/
-    RolesNotCleared: GenericPalletError<Rv>;
+    RolesNotCleared: GenericPalletError;
 
     /**
      * Mint has not started yet.
      **/
-    MintNotStarted: GenericPalletError<Rv>;
+    MintNotStarted: GenericPalletError;
 
     /**
      * Mint has already ended.
      **/
-    MintEnded: GenericPalletError<Rv>;
+    MintEnded: GenericPalletError;
 
     /**
      * The provided Item was already used for claiming.
      **/
-    AlreadyClaimed: GenericPalletError<Rv>;
+    AlreadyClaimed: GenericPalletError;
 
     /**
      * The provided data is incorrect.
      **/
-    IncorrectData: GenericPalletError<Rv>;
+    IncorrectData: GenericPalletError;
 
     /**
      * The extrinsic was sent by the wrong origin.
      **/
-    WrongOrigin: GenericPalletError<Rv>;
+    WrongOrigin: GenericPalletError;
 
     /**
      * The provided signature is incorrect.
      **/
-    WrongSignature: GenericPalletError<Rv>;
+    WrongSignature: GenericPalletError;
 
     /**
      * The provided metadata might be too long.
      **/
-    IncorrectMetadata: GenericPalletError<Rv>;
+    IncorrectMetadata: GenericPalletError;
 
     /**
      * Can't set more attributes per one call.
      **/
-    MaxAttributesLimitReached: GenericPalletError<Rv>;
+    MaxAttributesLimitReached: GenericPalletError;
 
     /**
      * The provided namespace isn't supported in this call.
      **/
-    WrongNamespace: GenericPalletError<Rv>;
+    WrongNamespace: GenericPalletError;
 
     /**
      * Can't delete non-empty collections.
      **/
-    CollectionNotEmpty: GenericPalletError<Rv>;
+    CollectionNotEmpty: GenericPalletError;
 
     /**
      * The witness data should be provided.
      **/
-    WitnessRequired: GenericPalletError<Rv>;
+    WitnessRequired: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ForeignAssets`'s errors
@@ -1437,125 +1437,125 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Account balance must be greater than or equal to the transfer amount.
      **/
-    BalanceLow: GenericPalletError<Rv>;
+    BalanceLow: GenericPalletError;
 
     /**
      * The account to alter does not exist.
      **/
-    NoAccount: GenericPalletError<Rv>;
+    NoAccount: GenericPalletError;
 
     /**
      * The signing account has no permission to do the operation.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * The given asset ID is unknown.
      **/
-    Unknown: GenericPalletError<Rv>;
+    Unknown: GenericPalletError;
 
     /**
      * The origin account is frozen.
      **/
-    Frozen: GenericPalletError<Rv>;
+    Frozen: GenericPalletError;
 
     /**
      * The asset ID is already taken.
      **/
-    InUse: GenericPalletError<Rv>;
+    InUse: GenericPalletError;
 
     /**
      * Invalid witness data given.
      **/
-    BadWitness: GenericPalletError<Rv>;
+    BadWitness: GenericPalletError;
 
     /**
      * Minimum balance should be non-zero.
      **/
-    MinBalanceZero: GenericPalletError<Rv>;
+    MinBalanceZero: GenericPalletError;
 
     /**
      * Unable to increment the consumer reference counters on the account. Either no provider
      * reference exists to allow a non-zero balance of a non-self-sufficient asset, or one
      * fewer then the maximum number of consumers has been reached.
      **/
-    UnavailableConsumer: GenericPalletError<Rv>;
+    UnavailableConsumer: GenericPalletError;
 
     /**
      * Invalid metadata given.
      **/
-    BadMetadata: GenericPalletError<Rv>;
+    BadMetadata: GenericPalletError;
 
     /**
      * No approval exists that would allow the transfer.
      **/
-    Unapproved: GenericPalletError<Rv>;
+    Unapproved: GenericPalletError;
 
     /**
      * The source account would not survive the transfer and it needs to stay alive.
      **/
-    WouldDie: GenericPalletError<Rv>;
+    WouldDie: GenericPalletError;
 
     /**
      * The asset-account already exists.
      **/
-    AlreadyExists: GenericPalletError<Rv>;
+    AlreadyExists: GenericPalletError;
 
     /**
      * The asset-account doesn't have an associated deposit.
      **/
-    NoDeposit: GenericPalletError<Rv>;
+    NoDeposit: GenericPalletError;
 
     /**
      * The operation would result in funds being burned.
      **/
-    WouldBurn: GenericPalletError<Rv>;
+    WouldBurn: GenericPalletError;
 
     /**
      * The asset is a live asset and is actively being used. Usually emit for operations such
      * as `start_destroy` which require the asset to be in a destroying state.
      **/
-    LiveAsset: GenericPalletError<Rv>;
+    LiveAsset: GenericPalletError;
 
     /**
      * The asset is not live, and likely being destroyed.
      **/
-    AssetNotLive: GenericPalletError<Rv>;
+    AssetNotLive: GenericPalletError;
 
     /**
      * The asset status is not the expected status.
      **/
-    IncorrectStatus: GenericPalletError<Rv>;
+    IncorrectStatus: GenericPalletError;
 
     /**
      * The asset should be frozen before the given operation.
      **/
-    NotFrozen: GenericPalletError<Rv>;
+    NotFrozen: GenericPalletError;
 
     /**
      * Callback action resulted in error
      **/
-    CallbackFailed: GenericPalletError<Rv>;
+    CallbackFailed: GenericPalletError;
 
     /**
      * The asset ID must be equal to the [`NextAssetId`].
      **/
-    BadAssetId: GenericPalletError<Rv>;
+    BadAssetId: GenericPalletError;
 
     /**
      * The asset cannot be destroyed because some accounts for this asset contain freezes.
      **/
-    ContainsFreezes: GenericPalletError<Rv>;
+    ContainsFreezes: GenericPalletError;
 
     /**
      * The asset cannot be destroyed because some accounts for this asset contain holds.
      **/
-    ContainsHolds: GenericPalletError<Rv>;
+    ContainsHolds: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `NftFractionalization`'s errors
@@ -1564,27 +1564,27 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Asset ID does not correspond to locked NFT.
      **/
-    IncorrectAssetId: GenericPalletError<Rv>;
+    IncorrectAssetId: GenericPalletError;
 
     /**
      * The signing account has no permission to do the operation.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * NFT doesn't exist.
      **/
-    NftNotFound: GenericPalletError<Rv>;
+    NftNotFound: GenericPalletError;
 
     /**
      * NFT has not yet been fractionalised.
      **/
-    NftNotFractionalized: GenericPalletError<Rv>;
+    NftNotFractionalized: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `PoolAssets`'s errors
@@ -1593,125 +1593,125 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Account balance must be greater than or equal to the transfer amount.
      **/
-    BalanceLow: GenericPalletError<Rv>;
+    BalanceLow: GenericPalletError;
 
     /**
      * The account to alter does not exist.
      **/
-    NoAccount: GenericPalletError<Rv>;
+    NoAccount: GenericPalletError;
 
     /**
      * The signing account has no permission to do the operation.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * The given asset ID is unknown.
      **/
-    Unknown: GenericPalletError<Rv>;
+    Unknown: GenericPalletError;
 
     /**
      * The origin account is frozen.
      **/
-    Frozen: GenericPalletError<Rv>;
+    Frozen: GenericPalletError;
 
     /**
      * The asset ID is already taken.
      **/
-    InUse: GenericPalletError<Rv>;
+    InUse: GenericPalletError;
 
     /**
      * Invalid witness data given.
      **/
-    BadWitness: GenericPalletError<Rv>;
+    BadWitness: GenericPalletError;
 
     /**
      * Minimum balance should be non-zero.
      **/
-    MinBalanceZero: GenericPalletError<Rv>;
+    MinBalanceZero: GenericPalletError;
 
     /**
      * Unable to increment the consumer reference counters on the account. Either no provider
      * reference exists to allow a non-zero balance of a non-self-sufficient asset, or one
      * fewer then the maximum number of consumers has been reached.
      **/
-    UnavailableConsumer: GenericPalletError<Rv>;
+    UnavailableConsumer: GenericPalletError;
 
     /**
      * Invalid metadata given.
      **/
-    BadMetadata: GenericPalletError<Rv>;
+    BadMetadata: GenericPalletError;
 
     /**
      * No approval exists that would allow the transfer.
      **/
-    Unapproved: GenericPalletError<Rv>;
+    Unapproved: GenericPalletError;
 
     /**
      * The source account would not survive the transfer and it needs to stay alive.
      **/
-    WouldDie: GenericPalletError<Rv>;
+    WouldDie: GenericPalletError;
 
     /**
      * The asset-account already exists.
      **/
-    AlreadyExists: GenericPalletError<Rv>;
+    AlreadyExists: GenericPalletError;
 
     /**
      * The asset-account doesn't have an associated deposit.
      **/
-    NoDeposit: GenericPalletError<Rv>;
+    NoDeposit: GenericPalletError;
 
     /**
      * The operation would result in funds being burned.
      **/
-    WouldBurn: GenericPalletError<Rv>;
+    WouldBurn: GenericPalletError;
 
     /**
      * The asset is a live asset and is actively being used. Usually emit for operations such
      * as `start_destroy` which require the asset to be in a destroying state.
      **/
-    LiveAsset: GenericPalletError<Rv>;
+    LiveAsset: GenericPalletError;
 
     /**
      * The asset is not live, and likely being destroyed.
      **/
-    AssetNotLive: GenericPalletError<Rv>;
+    AssetNotLive: GenericPalletError;
 
     /**
      * The asset status is not the expected status.
      **/
-    IncorrectStatus: GenericPalletError<Rv>;
+    IncorrectStatus: GenericPalletError;
 
     /**
      * The asset should be frozen before the given operation.
      **/
-    NotFrozen: GenericPalletError<Rv>;
+    NotFrozen: GenericPalletError;
 
     /**
      * Callback action resulted in error
      **/
-    CallbackFailed: GenericPalletError<Rv>;
+    CallbackFailed: GenericPalletError;
 
     /**
      * The asset ID must be equal to the [`NextAssetId`].
      **/
-    BadAssetId: GenericPalletError<Rv>;
+    BadAssetId: GenericPalletError;
 
     /**
      * The asset cannot be destroyed because some accounts for this asset contain freezes.
      **/
-    ContainsFreezes: GenericPalletError<Rv>;
+    ContainsFreezes: GenericPalletError;
 
     /**
      * The asset cannot be destroyed because some accounts for this asset contain holds.
      **/
-    ContainsHolds: GenericPalletError<Rv>;
+    ContainsHolds: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `AssetConversion`'s errors
@@ -1720,125 +1720,125 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Provided asset pair is not supported for pool.
      **/
-    InvalidAssetPair: GenericPalletError<Rv>;
+    InvalidAssetPair: GenericPalletError;
 
     /**
      * Pool already exists.
      **/
-    PoolExists: GenericPalletError<Rv>;
+    PoolExists: GenericPalletError;
 
     /**
      * Desired amount can't be zero.
      **/
-    WrongDesiredAmount: GenericPalletError<Rv>;
+    WrongDesiredAmount: GenericPalletError;
 
     /**
      * Provided amount should be greater than or equal to the existential deposit/asset's
      * minimal amount.
      **/
-    AmountOneLessThanMinimal: GenericPalletError<Rv>;
+    AmountOneLessThanMinimal: GenericPalletError;
 
     /**
      * Provided amount should be greater than or equal to the existential deposit/asset's
      * minimal amount.
      **/
-    AmountTwoLessThanMinimal: GenericPalletError<Rv>;
+    AmountTwoLessThanMinimal: GenericPalletError;
 
     /**
      * Reserve needs to always be greater than or equal to the existential deposit/asset's
      * minimal amount.
      **/
-    ReserveLeftLessThanMinimal: GenericPalletError<Rv>;
+    ReserveLeftLessThanMinimal: GenericPalletError;
 
     /**
      * Desired amount can't be equal to the pool reserve.
      **/
-    AmountOutTooHigh: GenericPalletError<Rv>;
+    AmountOutTooHigh: GenericPalletError;
 
     /**
      * The pool doesn't exist.
      **/
-    PoolNotFound: GenericPalletError<Rv>;
+    PoolNotFound: GenericPalletError;
 
     /**
      * An overflow happened.
      **/
-    Overflow: GenericPalletError<Rv>;
+    Overflow: GenericPalletError;
 
     /**
      * The minimal amount requirement for the first token in the pair wasn't met.
      **/
-    AssetOneDepositDidNotMeetMinimum: GenericPalletError<Rv>;
+    AssetOneDepositDidNotMeetMinimum: GenericPalletError;
 
     /**
      * The minimal amount requirement for the second token in the pair wasn't met.
      **/
-    AssetTwoDepositDidNotMeetMinimum: GenericPalletError<Rv>;
+    AssetTwoDepositDidNotMeetMinimum: GenericPalletError;
 
     /**
      * The minimal amount requirement for the first token in the pair wasn't met.
      **/
-    AssetOneWithdrawalDidNotMeetMinimum: GenericPalletError<Rv>;
+    AssetOneWithdrawalDidNotMeetMinimum: GenericPalletError;
 
     /**
      * The minimal amount requirement for the second token in the pair wasn't met.
      **/
-    AssetTwoWithdrawalDidNotMeetMinimum: GenericPalletError<Rv>;
+    AssetTwoWithdrawalDidNotMeetMinimum: GenericPalletError;
 
     /**
      * Optimal calculated amount is less than desired.
      **/
-    OptimalAmountLessThanDesired: GenericPalletError<Rv>;
+    OptimalAmountLessThanDesired: GenericPalletError;
 
     /**
      * Insufficient liquidity minted.
      **/
-    InsufficientLiquidityMinted: GenericPalletError<Rv>;
+    InsufficientLiquidityMinted: GenericPalletError;
 
     /**
      * Requested liquidity can't be zero.
      **/
-    ZeroLiquidity: GenericPalletError<Rv>;
+    ZeroLiquidity: GenericPalletError;
 
     /**
      * Amount can't be zero.
      **/
-    ZeroAmount: GenericPalletError<Rv>;
+    ZeroAmount: GenericPalletError;
 
     /**
      * Calculated amount out is less than provided minimum amount.
      **/
-    ProvidedMinimumNotSufficientForSwap: GenericPalletError<Rv>;
+    ProvidedMinimumNotSufficientForSwap: GenericPalletError;
 
     /**
      * Provided maximum amount is not sufficient for swap.
      **/
-    ProvidedMaximumNotSufficientForSwap: GenericPalletError<Rv>;
+    ProvidedMaximumNotSufficientForSwap: GenericPalletError;
 
     /**
      * The provided path must consists of 2 assets at least.
      **/
-    InvalidPath: GenericPalletError<Rv>;
+    InvalidPath: GenericPalletError;
 
     /**
      * The provided path must consists of unique assets.
      **/
-    NonUniquePath: GenericPalletError<Rv>;
+    NonUniquePath: GenericPalletError;
 
     /**
      * It was not possible to get or increment the Id of the pool.
      **/
-    IncorrectPoolAssetId: GenericPalletError<Rv>;
+    IncorrectPoolAssetId: GenericPalletError;
 
     /**
      * The destination account cannot exist with the swapped funds.
      **/
-    BelowMinimum: GenericPalletError<Rv>;
+    BelowMinimum: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Recovery`'s errors
@@ -1847,87 +1847,87 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * User is not allowed to make a call on behalf of this account
      **/
-    NotAllowed: GenericPalletError<Rv>;
+    NotAllowed: GenericPalletError;
 
     /**
      * Threshold must be greater than zero
      **/
-    ZeroThreshold: GenericPalletError<Rv>;
+    ZeroThreshold: GenericPalletError;
 
     /**
      * Friends list must be greater than zero and threshold
      **/
-    NotEnoughFriends: GenericPalletError<Rv>;
+    NotEnoughFriends: GenericPalletError;
 
     /**
      * Friends list must be less than max friends
      **/
-    MaxFriends: GenericPalletError<Rv>;
+    MaxFriends: GenericPalletError;
 
     /**
      * Friends list must be sorted and free of duplicates
      **/
-    NotSorted: GenericPalletError<Rv>;
+    NotSorted: GenericPalletError;
 
     /**
      * This account is not set up for recovery
      **/
-    NotRecoverable: GenericPalletError<Rv>;
+    NotRecoverable: GenericPalletError;
 
     /**
      * This account is already set up for recovery
      **/
-    AlreadyRecoverable: GenericPalletError<Rv>;
+    AlreadyRecoverable: GenericPalletError;
 
     /**
      * A recovery process has already started for this account
      **/
-    AlreadyStarted: GenericPalletError<Rv>;
+    AlreadyStarted: GenericPalletError;
 
     /**
      * A recovery process has not started for this rescuer
      **/
-    NotStarted: GenericPalletError<Rv>;
+    NotStarted: GenericPalletError;
 
     /**
      * This account is not a friend who can vouch
      **/
-    NotFriend: GenericPalletError<Rv>;
+    NotFriend: GenericPalletError;
 
     /**
      * The friend must wait until the delay period to vouch for this recovery
      **/
-    DelayPeriod: GenericPalletError<Rv>;
+    DelayPeriod: GenericPalletError;
 
     /**
      * This user has already vouched for this recovery
      **/
-    AlreadyVouched: GenericPalletError<Rv>;
+    AlreadyVouched: GenericPalletError;
 
     /**
      * The threshold for recovering this account has not been met
      **/
-    Threshold: GenericPalletError<Rv>;
+    Threshold: GenericPalletError;
 
     /**
      * There are still active recovery attempts that need to be closed
      **/
-    StillActive: GenericPalletError<Rv>;
+    StillActive: GenericPalletError;
 
     /**
      * This account is already set up for recovery
      **/
-    AlreadyProxy: GenericPalletError<Rv>;
+    AlreadyProxy: GenericPalletError;
 
     /**
      * Some internal state is broken.
      **/
-    BadState: GenericPalletError<Rv>;
+    BadState: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Society`'s errors
@@ -1936,172 +1936,172 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * User is not a member.
      **/
-    NotMember: GenericPalletError<Rv>;
+    NotMember: GenericPalletError;
 
     /**
      * User is already a member.
      **/
-    AlreadyMember: GenericPalletError<Rv>;
+    AlreadyMember: GenericPalletError;
 
     /**
      * User is suspended.
      **/
-    Suspended: GenericPalletError<Rv>;
+    Suspended: GenericPalletError;
 
     /**
      * User is not suspended.
      **/
-    NotSuspended: GenericPalletError<Rv>;
+    NotSuspended: GenericPalletError;
 
     /**
      * Nothing to payout.
      **/
-    NoPayout: GenericPalletError<Rv>;
+    NoPayout: GenericPalletError;
 
     /**
      * Society already founded.
      **/
-    AlreadyFounded: GenericPalletError<Rv>;
+    AlreadyFounded: GenericPalletError;
 
     /**
      * Not enough in pot to accept candidate.
      **/
-    InsufficientPot: GenericPalletError<Rv>;
+    InsufficientPot: GenericPalletError;
 
     /**
      * Member is already vouching or banned from vouching again.
      **/
-    AlreadyVouching: GenericPalletError<Rv>;
+    AlreadyVouching: GenericPalletError;
 
     /**
      * Member is not vouching.
      **/
-    NotVouchingOnBidder: GenericPalletError<Rv>;
+    NotVouchingOnBidder: GenericPalletError;
 
     /**
      * Cannot remove the head of the chain.
      **/
-    Head: GenericPalletError<Rv>;
+    Head: GenericPalletError;
 
     /**
      * Cannot remove the founder.
      **/
-    Founder: GenericPalletError<Rv>;
+    Founder: GenericPalletError;
 
     /**
      * User has already made a bid.
      **/
-    AlreadyBid: GenericPalletError<Rv>;
+    AlreadyBid: GenericPalletError;
 
     /**
      * User is already a candidate.
      **/
-    AlreadyCandidate: GenericPalletError<Rv>;
+    AlreadyCandidate: GenericPalletError;
 
     /**
      * User is not a candidate.
      **/
-    NotCandidate: GenericPalletError<Rv>;
+    NotCandidate: GenericPalletError;
 
     /**
      * Too many members in the society.
      **/
-    MaxMembers: GenericPalletError<Rv>;
+    MaxMembers: GenericPalletError;
 
     /**
      * The caller is not the founder.
      **/
-    NotFounder: GenericPalletError<Rv>;
+    NotFounder: GenericPalletError;
 
     /**
      * The caller is not the head.
      **/
-    NotHead: GenericPalletError<Rv>;
+    NotHead: GenericPalletError;
 
     /**
      * The membership cannot be claimed as the candidate was not clearly approved.
      **/
-    NotApproved: GenericPalletError<Rv>;
+    NotApproved: GenericPalletError;
 
     /**
      * The candidate cannot be kicked as the candidate was not clearly rejected.
      **/
-    NotRejected: GenericPalletError<Rv>;
+    NotRejected: GenericPalletError;
 
     /**
      * The candidacy cannot be dropped as the candidate was clearly approved.
      **/
-    Approved: GenericPalletError<Rv>;
+    Approved: GenericPalletError;
 
     /**
      * The candidacy cannot be bestowed as the candidate was clearly rejected.
      **/
-    Rejected: GenericPalletError<Rv>;
+    Rejected: GenericPalletError;
 
     /**
      * The candidacy cannot be concluded as the voting is still in progress.
      **/
-    InProgress: GenericPalletError<Rv>;
+    InProgress: GenericPalletError;
 
     /**
      * The candidacy cannot be pruned until a full additional intake period has passed.
      **/
-    TooEarly: GenericPalletError<Rv>;
+    TooEarly: GenericPalletError;
 
     /**
      * The skeptic already voted.
      **/
-    Voted: GenericPalletError<Rv>;
+    Voted: GenericPalletError;
 
     /**
      * The skeptic need not vote on candidates from expired rounds.
      **/
-    Expired: GenericPalletError<Rv>;
+    Expired: GenericPalletError;
 
     /**
      * User is not a bidder.
      **/
-    NotBidder: GenericPalletError<Rv>;
+    NotBidder: GenericPalletError;
 
     /**
      * There is no defender currently.
      **/
-    NoDefender: GenericPalletError<Rv>;
+    NoDefender: GenericPalletError;
 
     /**
      * Group doesn't exist.
      **/
-    NotGroup: GenericPalletError<Rv>;
+    NotGroup: GenericPalletError;
 
     /**
      * The member is already elevated to this rank.
      **/
-    AlreadyElevated: GenericPalletError<Rv>;
+    AlreadyElevated: GenericPalletError;
 
     /**
      * The skeptic has already been punished for this offence.
      **/
-    AlreadyPunished: GenericPalletError<Rv>;
+    AlreadyPunished: GenericPalletError;
 
     /**
      * Funds are insufficient to pay off society debts.
      **/
-    InsufficientFunds: GenericPalletError<Rv>;
+    InsufficientFunds: GenericPalletError;
 
     /**
      * The candidate/defender has no stale votes to remove.
      **/
-    NoVotes: GenericPalletError<Rv>;
+    NoVotes: GenericPalletError;
 
     /**
      * There is no deposit associated with a bid.
      **/
-    NoDeposit: GenericPalletError<Rv>;
+    NoDeposit: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Revive`'s errors
@@ -2110,122 +2110,122 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Invalid schedule supplied, e.g. with zero weight of a basic operation.
      **/
-    InvalidSchedule: GenericPalletError<Rv>;
+    InvalidSchedule: GenericPalletError;
 
     /**
      * Invalid combination of flags supplied to `seal_call` or `seal_delegate_call`.
      **/
-    InvalidCallFlags: GenericPalletError<Rv>;
+    InvalidCallFlags: GenericPalletError;
 
     /**
      * The executed contract exhausted its gas limit.
      **/
-    OutOfGas: GenericPalletError<Rv>;
+    OutOfGas: GenericPalletError;
 
     /**
      * Performing the requested transfer failed. Probably because there isn't enough
      * free balance in the sender's account.
      **/
-    TransferFailed: GenericPalletError<Rv>;
+    TransferFailed: GenericPalletError;
 
     /**
      * Performing a call was denied because the calling depth reached the limit
      * of what is specified in the schedule.
      **/
-    MaxCallDepthReached: GenericPalletError<Rv>;
+    MaxCallDepthReached: GenericPalletError;
 
     /**
      * No contract was found at the specified address.
      **/
-    ContractNotFound: GenericPalletError<Rv>;
+    ContractNotFound: GenericPalletError;
 
     /**
      * No code could be found at the supplied code hash.
      **/
-    CodeNotFound: GenericPalletError<Rv>;
+    CodeNotFound: GenericPalletError;
 
     /**
      * No code info could be found at the supplied code hash.
      **/
-    CodeInfoNotFound: GenericPalletError<Rv>;
+    CodeInfoNotFound: GenericPalletError;
 
     /**
      * A buffer outside of sandbox memory was passed to a contract API function.
      **/
-    OutOfBounds: GenericPalletError<Rv>;
+    OutOfBounds: GenericPalletError;
 
     /**
      * Input passed to a contract API function failed to decode as expected type.
      **/
-    DecodingFailed: GenericPalletError<Rv>;
+    DecodingFailed: GenericPalletError;
 
     /**
      * Contract trapped during execution.
      **/
-    ContractTrapped: GenericPalletError<Rv>;
+    ContractTrapped: GenericPalletError;
 
     /**
      * Event body or storage item exceeds [`limits::PAYLOAD_BYTES`].
      **/
-    ValueTooLarge: GenericPalletError<Rv>;
+    ValueTooLarge: GenericPalletError;
 
     /**
      * Termination of a contract is not allowed while the contract is already
      * on the call stack. Can be triggered by `seal_terminate`.
      **/
-    TerminatedWhileReentrant: GenericPalletError<Rv>;
+    TerminatedWhileReentrant: GenericPalletError;
 
     /**
      * `seal_call` forwarded this contracts input. It therefore is no longer available.
      **/
-    InputForwarded: GenericPalletError<Rv>;
+    InputForwarded: GenericPalletError;
 
     /**
      * The amount of topics passed to `seal_deposit_events` exceeds the limit.
      **/
-    TooManyTopics: GenericPalletError<Rv>;
+    TooManyTopics: GenericPalletError;
 
     /**
      * A contract with the same AccountId already exists.
      **/
-    DuplicateContract: GenericPalletError<Rv>;
+    DuplicateContract: GenericPalletError;
 
     /**
      * A contract self destructed in its constructor.
      *
      * This can be triggered by a call to `seal_terminate`.
      **/
-    TerminatedInConstructor: GenericPalletError<Rv>;
+    TerminatedInConstructor: GenericPalletError;
 
     /**
      * A call tried to invoke a contract that is flagged as non-reentrant.
      **/
-    ReentranceDenied: GenericPalletError<Rv>;
+    ReentranceDenied: GenericPalletError;
 
     /**
      * A contract called into the runtime which then called back into this pallet.
      **/
-    ReenteredPallet: GenericPalletError<Rv>;
+    ReenteredPallet: GenericPalletError;
 
     /**
      * A contract attempted to invoke a state modifying API while being in read-only mode.
      **/
-    StateChangeDenied: GenericPalletError<Rv>;
+    StateChangeDenied: GenericPalletError;
 
     /**
      * Origin doesn't have enough balance to pay the required storage deposits.
      **/
-    StorageDepositNotEnoughFunds: GenericPalletError<Rv>;
+    StorageDepositNotEnoughFunds: GenericPalletError;
 
     /**
      * More storage was created than allowed by the storage deposit limit.
      **/
-    StorageDepositLimitExhausted: GenericPalletError<Rv>;
+    StorageDepositLimitExhausted: GenericPalletError;
 
     /**
      * Code removal was denied because the code is still in use by at least one contract.
      **/
-    CodeInUse: GenericPalletError<Rv>;
+    CodeInUse: GenericPalletError;
 
     /**
      * The contract ran to completion but decided to revert its storage changes.
@@ -2233,7 +2233,7 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * or via RPC an `Ok` will be returned. In this case the caller needs to inspect the flags
      * to determine whether a reversion has taken place.
      **/
-    ContractReverted: GenericPalletError<Rv>;
+    ContractReverted: GenericPalletError;
 
     /**
      * The contract failed to compile or is missing the correct entry points.
@@ -2241,120 +2241,120 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * A more detailed error can be found on the node console if debug messages are enabled
      * by supplying `-lruntime::revive=debug`.
      **/
-    CodeRejected: GenericPalletError<Rv>;
+    CodeRejected: GenericPalletError;
 
     /**
      * The code blob supplied is larger than [`limits::code::BLOB_BYTES`].
      **/
-    BlobTooLarge: GenericPalletError<Rv>;
+    BlobTooLarge: GenericPalletError;
 
     /**
      * The contract declares too much memory (ro + rw + stack).
      **/
-    StaticMemoryTooLarge: GenericPalletError<Rv>;
+    StaticMemoryTooLarge: GenericPalletError;
 
     /**
      * The program contains a basic block that is larger than allowed.
      **/
-    BasicBlockTooLarge: GenericPalletError<Rv>;
+    BasicBlockTooLarge: GenericPalletError;
 
     /**
      * The program contains an invalid instruction.
      **/
-    InvalidInstruction: GenericPalletError<Rv>;
+    InvalidInstruction: GenericPalletError;
 
     /**
      * The contract has reached its maximum number of delegate dependencies.
      **/
-    MaxDelegateDependenciesReached: GenericPalletError<Rv>;
+    MaxDelegateDependenciesReached: GenericPalletError;
 
     /**
      * The dependency was not found in the contract's delegate dependencies.
      **/
-    DelegateDependencyNotFound: GenericPalletError<Rv>;
+    DelegateDependencyNotFound: GenericPalletError;
 
     /**
      * The contract already depends on the given delegate dependency.
      **/
-    DelegateDependencyAlreadyExists: GenericPalletError<Rv>;
+    DelegateDependencyAlreadyExists: GenericPalletError;
 
     /**
      * Can not add a delegate dependency to the code hash of the contract itself.
      **/
-    CannotAddSelfAsDelegateDependency: GenericPalletError<Rv>;
+    CannotAddSelfAsDelegateDependency: GenericPalletError;
 
     /**
      * Can not add more data to transient storage.
      **/
-    OutOfTransientStorage: GenericPalletError<Rv>;
+    OutOfTransientStorage: GenericPalletError;
 
     /**
      * The contract tried to call a syscall which does not exist (at its current api level).
      **/
-    InvalidSyscall: GenericPalletError<Rv>;
+    InvalidSyscall: GenericPalletError;
 
     /**
      * Invalid storage flags were passed to one of the storage syscalls.
      **/
-    InvalidStorageFlags: GenericPalletError<Rv>;
+    InvalidStorageFlags: GenericPalletError;
 
     /**
      * PolkaVM failed during code execution. Probably due to a malformed program.
      **/
-    ExecutionFailed: GenericPalletError<Rv>;
+    ExecutionFailed: GenericPalletError;
 
     /**
      * Failed to convert a U256 to a Balance.
      **/
-    BalanceConversionFailed: GenericPalletError<Rv>;
+    BalanceConversionFailed: GenericPalletError;
 
     /**
      * Immutable data can only be set during deploys and only be read during calls.
      * Additionally, it is only valid to set the data once and it must not be empty.
      **/
-    InvalidImmutableAccess: GenericPalletError<Rv>;
+    InvalidImmutableAccess: GenericPalletError;
 
     /**
      * An `AccountID32` account tried to interact with the pallet without having a mapping.
      *
      * Call [`Pallet::map_account`] in order to create a mapping for the account.
      **/
-    AccountUnmapped: GenericPalletError<Rv>;
+    AccountUnmapped: GenericPalletError;
 
     /**
      * Tried to map an account that is already mapped.
      **/
-    AccountAlreadyMapped: GenericPalletError<Rv>;
+    AccountAlreadyMapped: GenericPalletError;
 
     /**
      * The transaction used to dry-run a contract is invalid.
      **/
-    InvalidGenericTransaction: GenericPalletError<Rv>;
+    InvalidGenericTransaction: GenericPalletError;
 
     /**
      * The refcount of a code either over or underflowed.
      **/
-    RefcountOverOrUnderflow: GenericPalletError<Rv>;
+    RefcountOverOrUnderflow: GenericPalletError;
 
     /**
      * Unsupported precompile address.
      **/
-    UnsupportedPrecompileAddress: GenericPalletError<Rv>;
+    UnsupportedPrecompileAddress: GenericPalletError;
 
     /**
      * The calldata exceeds [`limits::CALLDATA_BYTES`].
      **/
-    CallDataTooLarge: GenericPalletError<Rv>;
+    CallDataTooLarge: GenericPalletError;
 
     /**
      * The return data exceeds [`limits::CALLDATA_BYTES`].
      **/
-    ReturnDataTooLarge: GenericPalletError<Rv>;
+    ReturnDataTooLarge: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `StateTrieMigration`'s errors
@@ -2363,7 +2363,7 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Max signed limits not respected.
      **/
-    MaxSignedLimits: GenericPalletError<Rv>;
+    MaxSignedLimits: GenericPalletError;
 
     /**
      * A key was longer than the configured maximum.
@@ -2374,32 +2374,32 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * The value should only be increased to avoid a storage migration for the currently
      * stored [`crate::Progress::LastKey`].
      **/
-    KeyTooLong: GenericPalletError<Rv>;
+    KeyTooLong: GenericPalletError;
 
     /**
      * submitter does not have enough funds.
      **/
-    NotEnoughFunds: GenericPalletError<Rv>;
+    NotEnoughFunds: GenericPalletError;
 
     /**
      * Bad witness data provided.
      **/
-    BadWitness: GenericPalletError<Rv>;
+    BadWitness: GenericPalletError;
 
     /**
      * Signed migration is not allowed because the maximum limit is not set yet.
      **/
-    SignedMigrationNotAllowed: GenericPalletError<Rv>;
+    SignedMigrationNotAllowed: GenericPalletError;
 
     /**
      * Bad child root provided.
      **/
-    BadChildRoot: GenericPalletError<Rv>;
+    BadChildRoot: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `NominationPools`'s errors
@@ -2408,44 +2408,44 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * A (bonded) pool id does not exist.
      **/
-    PoolNotFound: GenericPalletError<Rv>;
+    PoolNotFound: GenericPalletError;
 
     /**
      * An account is not a member.
      **/
-    PoolMemberNotFound: GenericPalletError<Rv>;
+    PoolMemberNotFound: GenericPalletError;
 
     /**
      * A reward pool does not exist. In all cases this is a system logic error.
      **/
-    RewardPoolNotFound: GenericPalletError<Rv>;
+    RewardPoolNotFound: GenericPalletError;
 
     /**
      * A sub pool does not exist.
      **/
-    SubPoolsNotFound: GenericPalletError<Rv>;
+    SubPoolsNotFound: GenericPalletError;
 
     /**
      * An account is already delegating in another pool. An account may only belong to one
      * pool at a time.
      **/
-    AccountBelongsToOtherPool: GenericPalletError<Rv>;
+    AccountBelongsToOtherPool: GenericPalletError;
 
     /**
      * The member is fully unbonded (and thus cannot access the bonded and reward pool
      * anymore to, for example, collect rewards).
      **/
-    FullyUnbonding: GenericPalletError<Rv>;
+    FullyUnbonding: GenericPalletError;
 
     /**
      * The member cannot unbond further chunks due to reaching the limit.
      **/
-    MaxUnbondingLimit: GenericPalletError<Rv>;
+    MaxUnbondingLimit: GenericPalletError;
 
     /**
      * None of the funds can be withdrawn yet because the bonding duration has not passed.
      **/
-    CannotWithdrawAny: GenericPalletError<Rv>;
+    CannotWithdrawAny: GenericPalletError;
 
     /**
      * The amount does not meet the minimum bond to either join or create a pool.
@@ -2454,160 +2454,160 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * caller does not have nominating permissions for the pool. Members can never unbond to a
      * value below `MinJoinBond`.
      **/
-    MinimumBondNotMet: GenericPalletError<Rv>;
+    MinimumBondNotMet: GenericPalletError;
 
     /**
      * The transaction could not be executed due to overflow risk for the pool.
      **/
-    OverflowRisk: GenericPalletError<Rv>;
+    OverflowRisk: GenericPalletError;
 
     /**
      * A pool must be in [`PoolState::Destroying`] in order for the depositor to unbond or for
      * other members to be permissionlessly unbonded.
      **/
-    NotDestroying: GenericPalletError<Rv>;
+    NotDestroying: GenericPalletError;
 
     /**
      * The caller does not have nominating permissions for the pool.
      **/
-    NotNominator: GenericPalletError<Rv>;
+    NotNominator: GenericPalletError;
 
     /**
      * Either a) the caller cannot make a valid kick or b) the pool is not destroying.
      **/
-    NotKickerOrDestroying: GenericPalletError<Rv>;
+    NotKickerOrDestroying: GenericPalletError;
 
     /**
      * The pool is not open to join
      **/
-    NotOpen: GenericPalletError<Rv>;
+    NotOpen: GenericPalletError;
 
     /**
      * The system is maxed out on pools.
      **/
-    MaxPools: GenericPalletError<Rv>;
+    MaxPools: GenericPalletError;
 
     /**
      * Too many members in the pool or system.
      **/
-    MaxPoolMembers: GenericPalletError<Rv>;
+    MaxPoolMembers: GenericPalletError;
 
     /**
      * The pools state cannot be changed.
      **/
-    CanNotChangeState: GenericPalletError<Rv>;
+    CanNotChangeState: GenericPalletError;
 
     /**
      * The caller does not have adequate permissions.
      **/
-    DoesNotHavePermission: GenericPalletError<Rv>;
+    DoesNotHavePermission: GenericPalletError;
 
     /**
      * Metadata exceeds [`Config::MaxMetadataLen`]
      **/
-    MetadataExceedsMaxLen: GenericPalletError<Rv>;
+    MetadataExceedsMaxLen: GenericPalletError;
 
     /**
      * Some error occurred that should never happen. This should be reported to the
      * maintainers.
      **/
-    Defensive: GenericPalletError<Rv>;
+    Defensive: GenericPalletError;
 
     /**
      * Partial unbonding now allowed permissionlessly.
      **/
-    PartialUnbondNotAllowedPermissionlessly: GenericPalletError<Rv>;
+    PartialUnbondNotAllowedPermissionlessly: GenericPalletError;
 
     /**
      * The pool's max commission cannot be set higher than the existing value.
      **/
-    MaxCommissionRestricted: GenericPalletError<Rv>;
+    MaxCommissionRestricted: GenericPalletError;
 
     /**
      * The supplied commission exceeds the max allowed commission.
      **/
-    CommissionExceedsMaximum: GenericPalletError<Rv>;
+    CommissionExceedsMaximum: GenericPalletError;
 
     /**
      * The supplied commission exceeds global maximum commission.
      **/
-    CommissionExceedsGlobalMaximum: GenericPalletError<Rv>;
+    CommissionExceedsGlobalMaximum: GenericPalletError;
 
     /**
      * Not enough blocks have surpassed since the last commission update.
      **/
-    CommissionChangeThrottled: GenericPalletError<Rv>;
+    CommissionChangeThrottled: GenericPalletError;
 
     /**
      * The submitted changes to commission change rate are not allowed.
      **/
-    CommissionChangeRateNotAllowed: GenericPalletError<Rv>;
+    CommissionChangeRateNotAllowed: GenericPalletError;
 
     /**
      * There is no pending commission to claim.
      **/
-    NoPendingCommission: GenericPalletError<Rv>;
+    NoPendingCommission: GenericPalletError;
 
     /**
      * No commission current has been set.
      **/
-    NoCommissionCurrentSet: GenericPalletError<Rv>;
+    NoCommissionCurrentSet: GenericPalletError;
 
     /**
      * Pool id currently in use.
      **/
-    PoolIdInUse: GenericPalletError<Rv>;
+    PoolIdInUse: GenericPalletError;
 
     /**
      * Pool id provided is not correct/usable.
      **/
-    InvalidPoolId: GenericPalletError<Rv>;
+    InvalidPoolId: GenericPalletError;
 
     /**
      * Bonding extra is restricted to the exact pending reward amount.
      **/
-    BondExtraRestricted: GenericPalletError<Rv>;
+    BondExtraRestricted: GenericPalletError;
 
     /**
      * No imbalance in the ED deposit for the pool.
      **/
-    NothingToAdjust: GenericPalletError<Rv>;
+    NothingToAdjust: GenericPalletError;
 
     /**
      * No slash pending that can be applied to the member.
      **/
-    NothingToSlash: GenericPalletError<Rv>;
+    NothingToSlash: GenericPalletError;
 
     /**
      * The slash amount is too low to be applied.
      **/
-    SlashTooLow: GenericPalletError<Rv>;
+    SlashTooLow: GenericPalletError;
 
     /**
      * The pool or member delegation has already migrated to delegate stake.
      **/
-    AlreadyMigrated: GenericPalletError<Rv>;
+    AlreadyMigrated: GenericPalletError;
 
     /**
      * The pool or member delegation has not migrated yet to delegate stake.
      **/
-    NotMigrated: GenericPalletError<Rv>;
+    NotMigrated: GenericPalletError;
 
     /**
      * This call is not allowed in the current state of the pallet.
      **/
-    NotSupported: GenericPalletError<Rv>;
+    NotSupported: GenericPalletError;
 
     /**
      * Account is restricted from participation in pools. This may happen if the account is
      * staking in another way already.
      **/
-    Restricted: GenericPalletError<Rv>;
+    Restricted: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `VoterList`'s errors
@@ -2616,17 +2616,17 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * A error in the list interface implementation.
      **/
-    List: GenericPalletError<Rv>;
+    List: GenericPalletError;
 
     /**
      * Could not update a node, because the pallet is locked.
      **/
-    Locked: GenericPalletError<Rv>;
+    Locked: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `DelegatedStaking`'s errors
@@ -2635,17 +2635,17 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The account cannot perform this operation.
      **/
-    NotAllowed: GenericPalletError<Rv>;
+    NotAllowed: GenericPalletError;
 
     /**
      * An existing staker cannot perform this action.
      **/
-    AlreadyStaking: GenericPalletError<Rv>;
+    AlreadyStaking: GenericPalletError;
 
     /**
      * Reward Destination cannot be same as `Agent` account.
      **/
-    InvalidRewardDestination: GenericPalletError<Rv>;
+    InvalidRewardDestination: GenericPalletError;
 
     /**
      * Delegation conditions are not met.
@@ -2654,52 +2654,52 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * 1) Cannot delegate to self,
      * 2) Cannot delegate to multiple delegates.
      **/
-    InvalidDelegation: GenericPalletError<Rv>;
+    InvalidDelegation: GenericPalletError;
 
     /**
      * The account does not have enough funds to perform the operation.
      **/
-    NotEnoughFunds: GenericPalletError<Rv>;
+    NotEnoughFunds: GenericPalletError;
 
     /**
      * Not an existing `Agent` account.
      **/
-    NotAgent: GenericPalletError<Rv>;
+    NotAgent: GenericPalletError;
 
     /**
      * Not a Delegator account.
      **/
-    NotDelegator: GenericPalletError<Rv>;
+    NotDelegator: GenericPalletError;
 
     /**
      * Some corruption in internal state.
      **/
-    BadState: GenericPalletError<Rv>;
+    BadState: GenericPalletError;
 
     /**
      * Unapplied pending slash restricts operation on `Agent`.
      **/
-    UnappliedSlash: GenericPalletError<Rv>;
+    UnappliedSlash: GenericPalletError;
 
     /**
      * `Agent` has no pending slash to be applied.
      **/
-    NothingToSlash: GenericPalletError<Rv>;
+    NothingToSlash: GenericPalletError;
 
     /**
      * Failed to withdraw amount from Core Staking.
      **/
-    WithdrawFailed: GenericPalletError<Rv>;
+    WithdrawFailed: GenericPalletError;
 
     /**
      * Operation not supported by this pallet.
      **/
-    NotSupported: GenericPalletError<Rv>;
+    NotSupported: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `MultiBlockElection`'s errors
@@ -2708,22 +2708,22 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Triggering the `Fallback` failed.
      **/
-    Fallback: GenericPalletError<Rv>;
+    Fallback: GenericPalletError;
 
     /**
      * Unexpected phase
      **/
-    UnexpectedPhase: GenericPalletError<Rv>;
+    UnexpectedPhase: GenericPalletError;
 
     /**
      * Snapshot was unavailable.
      **/
-    Snapshot: GenericPalletError<Rv>;
+    Snapshot: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `MultiBlockElectionSigned`'s errors
@@ -2732,52 +2732,52 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The phase is not signed.
      **/
-    PhaseNotSigned: GenericPalletError<Rv>;
+    PhaseNotSigned: GenericPalletError;
 
     /**
      * The submission is a duplicate.
      **/
-    Duplicate: GenericPalletError<Rv>;
+    Duplicate: GenericPalletError;
 
     /**
      * The queue is full.
      **/
-    QueueFull: GenericPalletError<Rv>;
+    QueueFull: GenericPalletError;
 
     /**
      * The page index is out of bounds.
      **/
-    BadPageIndex: GenericPalletError<Rv>;
+    BadPageIndex: GenericPalletError;
 
     /**
      * The account is not registered.
      **/
-    NotRegistered: GenericPalletError<Rv>;
+    NotRegistered: GenericPalletError;
 
     /**
      * No submission found.
      **/
-    NoSubmission: GenericPalletError<Rv>;
+    NoSubmission: GenericPalletError;
 
     /**
      * Round is not yet over.
      **/
-    RoundNotOver: GenericPalletError<Rv>;
+    RoundNotOver: GenericPalletError;
 
     /**
      * Bad witness data provided.
      **/
-    BadWitnessData: GenericPalletError<Rv>;
+    BadWitnessData: GenericPalletError;
 
     /**
      * Too many invulnerable accounts are provided,
      **/
-    TooManyInvulnerables: GenericPalletError<Rv>;
+    TooManyInvulnerables: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Staking`'s errors
@@ -2786,193 +2786,193 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Not a controller account.
      **/
-    NotController: GenericPalletError<Rv>;
+    NotController: GenericPalletError;
 
     /**
      * Not a stash account.
      **/
-    NotStash: GenericPalletError<Rv>;
+    NotStash: GenericPalletError;
 
     /**
      * Stash is already bonded.
      **/
-    AlreadyBonded: GenericPalletError<Rv>;
+    AlreadyBonded: GenericPalletError;
 
     /**
      * Controller is already paired.
      **/
-    AlreadyPaired: GenericPalletError<Rv>;
+    AlreadyPaired: GenericPalletError;
 
     /**
      * Targets cannot be empty.
      **/
-    EmptyTargets: GenericPalletError<Rv>;
+    EmptyTargets: GenericPalletError;
 
     /**
      * Duplicate index.
      **/
-    DuplicateIndex: GenericPalletError<Rv>;
+    DuplicateIndex: GenericPalletError;
 
     /**
      * Slash record not found.
      **/
-    InvalidSlashRecord: GenericPalletError<Rv>;
+    InvalidSlashRecord: GenericPalletError;
 
     /**
      * Cannot bond, nominate or validate with value less than the minimum defined by
      * governance (see `MinValidatorBond` and `MinNominatorBond`). If unbonding is the
      * intention, `chill` first to remove one's role as validator/nominator.
      **/
-    InsufficientBond: GenericPalletError<Rv>;
+    InsufficientBond: GenericPalletError;
 
     /**
      * Can not schedule more unlock chunks.
      **/
-    NoMoreChunks: GenericPalletError<Rv>;
+    NoMoreChunks: GenericPalletError;
 
     /**
      * Can not rebond without unlocking chunks.
      **/
-    NoUnlockChunk: GenericPalletError<Rv>;
+    NoUnlockChunk: GenericPalletError;
 
     /**
      * Attempting to target a stash that still has funds.
      **/
-    FundedTarget: GenericPalletError<Rv>;
+    FundedTarget: GenericPalletError;
 
     /**
      * Invalid era to reward.
      **/
-    InvalidEraToReward: GenericPalletError<Rv>;
+    InvalidEraToReward: GenericPalletError;
 
     /**
      * Invalid number of nominations.
      **/
-    InvalidNumberOfNominations: GenericPalletError<Rv>;
+    InvalidNumberOfNominations: GenericPalletError;
 
     /**
      * Rewards for this era have already been claimed for this validator.
      **/
-    AlreadyClaimed: GenericPalletError<Rv>;
+    AlreadyClaimed: GenericPalletError;
 
     /**
      * No nominators exist on this page.
      **/
-    InvalidPage: GenericPalletError<Rv>;
+    InvalidPage: GenericPalletError;
 
     /**
      * Incorrect previous history depth input provided.
      **/
-    IncorrectHistoryDepth: GenericPalletError<Rv>;
+    IncorrectHistoryDepth: GenericPalletError;
 
     /**
      * Internal state has become somehow corrupted and the operation cannot continue.
      **/
-    BadState: GenericPalletError<Rv>;
+    BadState: GenericPalletError;
 
     /**
      * Too many nomination targets supplied.
      **/
-    TooManyTargets: GenericPalletError<Rv>;
+    TooManyTargets: GenericPalletError;
 
     /**
      * A nomination target was supplied that was blocked or otherwise not a validator.
      **/
-    BadTarget: GenericPalletError<Rv>;
+    BadTarget: GenericPalletError;
 
     /**
      * The user has enough bond and thus cannot be chilled forcefully by an external person.
      **/
-    CannotChillOther: GenericPalletError<Rv>;
+    CannotChillOther: GenericPalletError;
 
     /**
      * There are too many nominators in the system. Governance needs to adjust the staking
      * settings to keep things safe for the runtime.
      **/
-    TooManyNominators: GenericPalletError<Rv>;
+    TooManyNominators: GenericPalletError;
 
     /**
      * There are too many validator candidates in the system. Governance needs to adjust the
      * staking settings to keep things safe for the runtime.
      **/
-    TooManyValidators: GenericPalletError<Rv>;
+    TooManyValidators: GenericPalletError;
 
     /**
      * Commission is too low. Must be at least `MinCommission`.
      **/
-    CommissionTooLow: GenericPalletError<Rv>;
+    CommissionTooLow: GenericPalletError;
 
     /**
      * Some bound is not met.
      **/
-    BoundNotMet: GenericPalletError<Rv>;
+    BoundNotMet: GenericPalletError;
 
     /**
      * Used when attempting to use deprecated controller account logic.
      **/
-    ControllerDeprecated: GenericPalletError<Rv>;
+    ControllerDeprecated: GenericPalletError;
 
     /**
      * Cannot reset a ledger.
      **/
-    CannotRestoreLedger: GenericPalletError<Rv>;
+    CannotRestoreLedger: GenericPalletError;
 
     /**
      * Provided reward destination is not allowed.
      **/
-    RewardDestinationRestricted: GenericPalletError<Rv>;
+    RewardDestinationRestricted: GenericPalletError;
 
     /**
      * Not enough funds available to withdraw.
      **/
-    NotEnoughFunds: GenericPalletError<Rv>;
+    NotEnoughFunds: GenericPalletError;
 
     /**
      * Operation not allowed for virtual stakers.
      **/
-    VirtualStakerNotAllowed: GenericPalletError<Rv>;
+    VirtualStakerNotAllowed: GenericPalletError;
 
     /**
      * Stash could not be reaped as other pallet might depend on it.
      **/
-    CannotReapStash: GenericPalletError<Rv>;
+    CannotReapStash: GenericPalletError;
 
     /**
      * The stake of this account is already migrated to `Fungible` holds.
      **/
-    AlreadyMigrated: GenericPalletError<Rv>;
+    AlreadyMigrated: GenericPalletError;
 
     /**
      * Era not yet started.
      **/
-    EraNotStarted: GenericPalletError<Rv>;
+    EraNotStarted: GenericPalletError;
 
     /**
      * Account is restricted from participation in staking. This may happen if the account is
      * staking in another way already, such as via pool.
      **/
-    Restricted: GenericPalletError<Rv>;
+    Restricted: GenericPalletError;
 
     /**
      * Unapplied slashes in the recently concluded era is blocking this operation.
      * See `Call::apply_slash` to apply them.
      **/
-    UnappliedSlashesInPreviousEra: GenericPalletError<Rv>;
+    UnappliedSlashesInPreviousEra: GenericPalletError;
 
     /**
      * The era is not eligible for pruning.
      **/
-    EraNotPrunable: GenericPalletError<Rv>;
+    EraNotPrunable: GenericPalletError;
 
     /**
      * The slash has been cancelled and cannot be applied.
      **/
-    CancelledSlash: GenericPalletError<Rv>;
+    CancelledSlash: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Treasury`'s errors
@@ -2981,63 +2981,63 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * No proposal, bounty or spend at that index.
      **/
-    InvalidIndex: GenericPalletError<Rv>;
+    InvalidIndex: GenericPalletError;
 
     /**
      * Too many approvals in the queue.
      **/
-    TooManyApprovals: GenericPalletError<Rv>;
+    TooManyApprovals: GenericPalletError;
 
     /**
      * The spend origin is valid but the amount it is allowed to spend is lower than the
      * amount to be spent.
      **/
-    InsufficientPermission: GenericPalletError<Rv>;
+    InsufficientPermission: GenericPalletError;
 
     /**
      * Proposal has not been approved.
      **/
-    ProposalNotApproved: GenericPalletError<Rv>;
+    ProposalNotApproved: GenericPalletError;
 
     /**
      * The balance of the asset kind is not convertible to the balance of the native asset.
      **/
-    FailedToConvertBalance: GenericPalletError<Rv>;
+    FailedToConvertBalance: GenericPalletError;
 
     /**
      * The spend has expired and cannot be claimed.
      **/
-    SpendExpired: GenericPalletError<Rv>;
+    SpendExpired: GenericPalletError;
 
     /**
      * The spend is not yet eligible for payout.
      **/
-    EarlyPayout: GenericPalletError<Rv>;
+    EarlyPayout: GenericPalletError;
 
     /**
      * The payment has already been attempted.
      **/
-    AlreadyAttempted: GenericPalletError<Rv>;
+    AlreadyAttempted: GenericPalletError;
 
     /**
      * There was some issue with the mechanism of payment.
      **/
-    PayoutError: GenericPalletError<Rv>;
+    PayoutError: GenericPalletError;
 
     /**
      * The payout was not yet attempted/claimed.
      **/
-    NotAttempted: GenericPalletError<Rv>;
+    NotAttempted: GenericPalletError;
 
     /**
      * The payment has neither failed nor succeeded yet.
      **/
-    Inconclusive: GenericPalletError<Rv>;
+    Inconclusive: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ConvictionVoting`'s errors
@@ -3046,68 +3046,68 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Poll is not ongoing.
      **/
-    NotOngoing: GenericPalletError<Rv>;
+    NotOngoing: GenericPalletError;
 
     /**
      * The given account did not vote on the poll.
      **/
-    NotVoter: GenericPalletError<Rv>;
+    NotVoter: GenericPalletError;
 
     /**
      * The actor has no permission to conduct the action.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * The actor has no permission to conduct the action right now but will do in the future.
      **/
-    NoPermissionYet: GenericPalletError<Rv>;
+    NoPermissionYet: GenericPalletError;
 
     /**
      * The account is already delegating.
      **/
-    AlreadyDelegating: GenericPalletError<Rv>;
+    AlreadyDelegating: GenericPalletError;
 
     /**
      * The account currently has votes attached to it and the operation cannot succeed until
      * these are removed through `remove_vote`.
      **/
-    AlreadyVoting: GenericPalletError<Rv>;
+    AlreadyVoting: GenericPalletError;
 
     /**
      * Too high a balance was provided that the account cannot afford.
      **/
-    InsufficientFunds: GenericPalletError<Rv>;
+    InsufficientFunds: GenericPalletError;
 
     /**
      * The account is not currently delegating.
      **/
-    NotDelegating: GenericPalletError<Rv>;
+    NotDelegating: GenericPalletError;
 
     /**
      * Delegation to oneself makes no sense.
      **/
-    Nonsense: GenericPalletError<Rv>;
+    Nonsense: GenericPalletError;
 
     /**
      * Maximum number of votes reached.
      **/
-    MaxVotesReached: GenericPalletError<Rv>;
+    MaxVotesReached: GenericPalletError;
 
     /**
      * The class must be supplied since it is not easily determinable from the state.
      **/
-    ClassNeeded: GenericPalletError<Rv>;
+    ClassNeeded: GenericPalletError;
 
     /**
      * The class ID supplied is invalid.
      **/
-    BadClass: GenericPalletError<Rv>;
+    BadClass: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Referenda`'s errors
@@ -3116,77 +3116,77 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Referendum is not ongoing.
      **/
-    NotOngoing: GenericPalletError<Rv>;
+    NotOngoing: GenericPalletError;
 
     /**
      * Referendum's decision deposit is already paid.
      **/
-    HasDeposit: GenericPalletError<Rv>;
+    HasDeposit: GenericPalletError;
 
     /**
      * The track identifier given was invalid.
      **/
-    BadTrack: GenericPalletError<Rv>;
+    BadTrack: GenericPalletError;
 
     /**
      * There are already a full complement of referenda in progress for this track.
      **/
-    Full: GenericPalletError<Rv>;
+    Full: GenericPalletError;
 
     /**
      * The queue of the track is empty.
      **/
-    QueueEmpty: GenericPalletError<Rv>;
+    QueueEmpty: GenericPalletError;
 
     /**
      * The referendum index provided is invalid in this context.
      **/
-    BadReferendum: GenericPalletError<Rv>;
+    BadReferendum: GenericPalletError;
 
     /**
      * There was nothing to do in the advancement.
      **/
-    NothingToDo: GenericPalletError<Rv>;
+    NothingToDo: GenericPalletError;
 
     /**
      * No track exists for the proposal origin.
      **/
-    NoTrack: GenericPalletError<Rv>;
+    NoTrack: GenericPalletError;
 
     /**
      * Any deposit cannot be refunded until after the decision is over.
      **/
-    Unfinished: GenericPalletError<Rv>;
+    Unfinished: GenericPalletError;
 
     /**
      * The deposit refunder is not the depositor.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * The deposit cannot be refunded since none was made.
      **/
-    NoDeposit: GenericPalletError<Rv>;
+    NoDeposit: GenericPalletError;
 
     /**
      * The referendum status is invalid for this operation.
      **/
-    BadStatus: GenericPalletError<Rv>;
+    BadStatus: GenericPalletError;
 
     /**
      * The preimage does not exist.
      **/
-    PreimageNotExist: GenericPalletError<Rv>;
+    PreimageNotExist: GenericPalletError;
 
     /**
      * The preimage is stored with a different length than the one provided.
      **/
-    PreimageStoredWithDifferentLength: GenericPalletError<Rv>;
+    PreimageStoredWithDifferentLength: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Whitelist`'s errors
@@ -3195,32 +3195,32 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The preimage of the call hash could not be loaded.
      **/
-    UnavailablePreImage: GenericPalletError<Rv>;
+    UnavailablePreImage: GenericPalletError;
 
     /**
      * The call could not be decoded.
      **/
-    UndecodableCall: GenericPalletError<Rv>;
+    UndecodableCall: GenericPalletError;
 
     /**
      * The weight of the decoded call was higher than the witness.
      **/
-    InvalidCallWeightWitness: GenericPalletError<Rv>;
+    InvalidCallWeightWitness: GenericPalletError;
 
     /**
      * The call was not whitelisted.
      **/
-    CallIsNotWhitelisted: GenericPalletError<Rv>;
+    CallIsNotWhitelisted: GenericPalletError;
 
     /**
      * The call was already whitelisted; No-Op.
      **/
-    CallAlreadyWhitelisted: GenericPalletError<Rv>;
+    CallAlreadyWhitelisted: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Bounties`'s errors
@@ -3229,68 +3229,68 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Proposer's balance is too low.
      **/
-    InsufficientProposersBalance: GenericPalletError<Rv>;
+    InsufficientProposersBalance: GenericPalletError;
 
     /**
      * No proposal or bounty at that index.
      **/
-    InvalidIndex: GenericPalletError<Rv>;
+    InvalidIndex: GenericPalletError;
 
     /**
      * The reason given is just too big.
      **/
-    ReasonTooBig: GenericPalletError<Rv>;
+    ReasonTooBig: GenericPalletError;
 
     /**
      * The bounty status is unexpected.
      **/
-    UnexpectedStatus: GenericPalletError<Rv>;
+    UnexpectedStatus: GenericPalletError;
 
     /**
      * Require bounty curator.
      **/
-    RequireCurator: GenericPalletError<Rv>;
+    RequireCurator: GenericPalletError;
 
     /**
      * Invalid bounty value.
      **/
-    InvalidValue: GenericPalletError<Rv>;
+    InvalidValue: GenericPalletError;
 
     /**
      * Invalid bounty fee.
      **/
-    InvalidFee: GenericPalletError<Rv>;
+    InvalidFee: GenericPalletError;
 
     /**
      * A bounty payout is pending.
      * To cancel the bounty, you must unassign and slash the curator.
      **/
-    PendingPayout: GenericPalletError<Rv>;
+    PendingPayout: GenericPalletError;
 
     /**
      * The bounties cannot be claimed/closed because it's still in the countdown period.
      **/
-    Premature: GenericPalletError<Rv>;
+    Premature: GenericPalletError;
 
     /**
      * The bounty cannot be closed because it has active child bounties.
      **/
-    HasActiveChildBounty: GenericPalletError<Rv>;
+    HasActiveChildBounty: GenericPalletError;
 
     /**
      * Too many approvals are already queued.
      **/
-    TooManyQueued: GenericPalletError<Rv>;
+    TooManyQueued: GenericPalletError;
 
     /**
      * User is not the proposer of the bounty.
      **/
-    NotProposer: GenericPalletError<Rv>;
+    NotProposer: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ChildBounties`'s errors
@@ -3299,22 +3299,22 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The parent bounty is not in active state.
      **/
-    ParentBountyNotActive: GenericPalletError<Rv>;
+    ParentBountyNotActive: GenericPalletError;
 
     /**
      * The bounty balance is not enough to add new child-bounty.
      **/
-    InsufficientBountyBalance: GenericPalletError<Rv>;
+    InsufficientBountyBalance: GenericPalletError;
 
     /**
      * Number of child bounties exceeds limit `MaxActiveChildBountyCount`.
      **/
-    TooManyChildBounties: GenericPalletError<Rv>;
+    TooManyChildBounties: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `AssetRate`'s errors
@@ -3323,22 +3323,22 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The given asset ID is unknown.
      **/
-    UnknownAssetKind: GenericPalletError<Rv>;
+    UnknownAssetKind: GenericPalletError;
 
     /**
      * The given asset ID already has an assigned conversion rate and cannot be re-created.
      **/
-    AlreadyExists: GenericPalletError<Rv>;
+    AlreadyExists: GenericPalletError;
 
     /**
      * Overflow ocurred when calculating the inverse rate.
      **/
-    Overflow: GenericPalletError<Rv>;
+    Overflow: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `AhOps`'s errors
@@ -3347,62 +3347,62 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Either no lease deposit or already unreserved.
      **/
-    NoLeaseReserve: GenericPalletError<Rv>;
+    NoLeaseReserve: GenericPalletError;
 
     /**
      * Either no crowdloan contribution or already withdrawn.
      **/
-    NoCrowdloanContribution: GenericPalletError<Rv>;
+    NoCrowdloanContribution: GenericPalletError;
 
     /**
      * Either no crowdloan reserve or already unreserved.
      **/
-    NoCrowdloanReserve: GenericPalletError<Rv>;
+    NoCrowdloanReserve: GenericPalletError;
 
     /**
      * Failed to withdraw crowdloan contribution.
      **/
-    FailedToWithdrawCrowdloanContribution: GenericPalletError<Rv>;
+    FailedToWithdrawCrowdloanContribution: GenericPalletError;
 
     /**
      * Block number is not yet reached.
      **/
-    NotYet: GenericPalletError<Rv>;
+    NotYet: GenericPalletError;
 
     /**
      * Not all contributions are withdrawn.
      **/
-    ContributionsRemaining: GenericPalletError<Rv>;
+    ContributionsRemaining: GenericPalletError;
 
     /**
      * The account is not a derived account.
      **/
-    WrongDerivedTranslation: GenericPalletError<Rv>;
+    WrongDerivedTranslation: GenericPalletError;
 
     /**
      * Account cannot be migrated since it is not a sovereign parachain account.
      **/
-    NotSovereign: GenericPalletError<Rv>;
+    NotSovereign: GenericPalletError;
 
     /**
      * Internal error, please bug report.
      **/
-    InternalError: GenericPalletError<Rv>;
+    InternalError: GenericPalletError;
 
     /**
      * The Asset Hub migration is not completed.
      **/
-    MigrationNotCompleted: GenericPalletError<Rv>;
+    MigrationNotCompleted: GenericPalletError;
 
     /**
      * The balance is zero.
      **/
-    ZeroBalance: GenericPalletError<Rv>;
+    ZeroBalance: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `AhMigrator`'s errors
@@ -3411,101 +3411,101 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Failed to unreserve deposit.
      **/
-    FailedToUnreserveDeposit: GenericPalletError<Rv>;
+    FailedToUnreserveDeposit: GenericPalletError;
 
     /**
      * Failed to process an account data from RC.
      **/
-    FailedToProcessAccount: GenericPalletError<Rv>;
+    FailedToProcessAccount: GenericPalletError;
 
     /**
      * Some item could not be inserted because it already exists.
      **/
-    InsertConflict: GenericPalletError<Rv>;
+    InsertConflict: GenericPalletError;
 
     /**
      * Failed to convert RC type to AH type.
      **/
-    FailedToConvertType: GenericPalletError<Rv>;
+    FailedToConvertType: GenericPalletError;
 
     /**
      * Failed to fetch preimage.
      **/
-    PreimageNotFound: GenericPalletError<Rv>;
+    PreimageNotFound: GenericPalletError;
 
     /**
      * Failed to convert RC call to AH call.
      **/
-    FailedToConvertCall: GenericPalletError<Rv>;
+    FailedToConvertCall: GenericPalletError;
 
     /**
      * Failed to bound a call.
      **/
-    FailedToBoundCall: GenericPalletError<Rv>;
+    FailedToBoundCall: GenericPalletError;
 
     /**
      * Failed to send XCM message.
      **/
-    XcmError: GenericPalletError<Rv>;
+    XcmError: GenericPalletError;
 
     /**
      * Failed to integrate a vesting schedule.
      **/
-    FailedToIntegrateVestingSchedule: GenericPalletError<Rv>;
+    FailedToIntegrateVestingSchedule: GenericPalletError;
 
     /**
      * Checking account overflow or underflow.
      **/
-    FailedToCalculateCheckingAccount: GenericPalletError<Rv>;
+    FailedToCalculateCheckingAccount: GenericPalletError;
 
     /**
      * Vector did not fit into its compile-time bound.
      **/
-    FailedToBoundVector: GenericPalletError<Rv>;
+    FailedToBoundVector: GenericPalletError;
 
     /**
      * The DMP queue priority is already set to the same value.
      **/
-    DmpQueuePriorityAlreadySet: GenericPalletError<Rv>;
+    DmpQueuePriorityAlreadySet: GenericPalletError;
 
     /**
      * Invalid parameter.
      **/
-    InvalidParameter: GenericPalletError<Rv>;
+    InvalidParameter: GenericPalletError;
 
     /**
      * Preimage missing.
      **/
-    PreimageMissing: GenericPalletError<Rv>;
+    PreimageMissing: GenericPalletError;
 
     /**
      * Preimage too big.
      **/
-    PreimageTooBig: GenericPalletError<Rv>;
+    PreimageTooBig: GenericPalletError;
 
     /**
      * Preimage chunk missing.
      **/
-    PreimageChunkMissing: GenericPalletError<Rv>;
+    PreimageChunkMissing: GenericPalletError;
 
     /**
      * Preimage status invalid.
      **/
-    PreimageStatusInvalid: GenericPalletError<Rv>;
+    PreimageStatusInvalid: GenericPalletError;
 
     /**
      * The XCM version is invalid.
      **/
-    BadXcmVersion: GenericPalletError<Rv>;
+    BadXcmVersion: GenericPalletError;
 
     /**
      * The origin is invalid.
      **/
-    InvalidOrigin: GenericPalletError<Rv>;
+    InvalidOrigin: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
 }