@dedot/chaintypes 0.194.0 → 0.196.0

package/westend/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,55 +11,55 @@ 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;
 
     /**
      * 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 `Babe`'s errors
@@ -68,27 +68,27 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * An equivocation proof provided as part of an equivocation report is invalid.
      **/
-    InvalidEquivocationProof: GenericPalletError<Rv>;
+    InvalidEquivocationProof: GenericPalletError;
 
     /**
      * A key ownership proof provided as part of an equivocation report is invalid.
      **/
-    InvalidKeyOwnershipProof: GenericPalletError<Rv>;
+    InvalidKeyOwnershipProof: GenericPalletError;
 
     /**
      * A given equivocation report is valid but already previously reported.
      **/
-    DuplicateOffenceReport: GenericPalletError<Rv>;
+    DuplicateOffenceReport: GenericPalletError;
 
     /**
      * Submitted configuration is invalid.
      **/
-    InvalidConfiguration: GenericPalletError<Rv>;
+    InvalidConfiguration: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Indices`'s errors
@@ -97,32 +97,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 `Balances`'s errors
@@ -131,67 +131,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 `Staking`'s errors
@@ -200,182 +200,182 @@ 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 index out of bounds.
      **/
-    InvalidSlashIndex: GenericPalletError<Rv>;
+    InvalidSlashIndex: GenericPalletError;
 
     /**
      * Cannot have a validator or nominator role, 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;
 
     /**
      * Items are not sorted and unique.
      **/
-    NotSortedAndUnique: GenericPalletError<Rv>;
+    NotSortedAndUnique: 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;
 
     /**
      * Incorrect number of slashing spans provided.
      **/
-    IncorrectSlashingSpans: GenericPalletError<Rv>;
+    IncorrectSlashingSpans: 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;
 
     /**
      * 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;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Session`'s errors
@@ -384,32 +384,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 `Grandpa`'s errors
@@ -419,43 +419,43 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * Attempt to signal GRANDPA pause when the authority set isn't live
      * (either paused or already pending pause).
      **/
-    PauseFailed: GenericPalletError<Rv>;
+    PauseFailed: GenericPalletError;
 
     /**
      * Attempt to signal GRANDPA resume when the authority set isn't paused
      * (either live or already pending resume).
      **/
-    ResumeFailed: GenericPalletError<Rv>;
+    ResumeFailed: GenericPalletError;
 
     /**
      * Attempt to signal GRANDPA change with one already pending.
      **/
-    ChangePending: GenericPalletError<Rv>;
+    ChangePending: GenericPalletError;
 
     /**
      * Cannot signal forced change so soon after last.
      **/
-    TooSoon: GenericPalletError<Rv>;
+    TooSoon: GenericPalletError;
 
     /**
      * A key ownership proof provided as part of an equivocation report is invalid.
      **/
-    InvalidKeyOwnershipProof: GenericPalletError<Rv>;
+    InvalidKeyOwnershipProof: GenericPalletError;
 
     /**
      * An equivocation proof provided as part of an equivocation report is invalid.
      **/
-    InvalidEquivocationProof: GenericPalletError<Rv>;
+    InvalidEquivocationProof: GenericPalletError;
 
     /**
      * A given equivocation report is valid but already previously reported.
      **/
-    DuplicateOffenceReport: GenericPalletError<Rv>;
+    DuplicateOffenceReport: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Utility`'s errors
@@ -464,12 +464,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 `Identity`'s errors
@@ -478,158 +478,158 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Too many subs-accounts.
      **/
-    TooManySubAccounts: GenericPalletError<Rv>;
+    TooManySubAccounts: GenericPalletError;
 
     /**
      * Account isn't found.
      **/
-    NotFound: GenericPalletError<Rv>;
+    NotFound: GenericPalletError;
 
     /**
      * Account isn't named.
      **/
-    NotNamed: GenericPalletError<Rv>;
+    NotNamed: GenericPalletError;
 
     /**
      * Empty index.
      **/
-    EmptyIndex: GenericPalletError<Rv>;
+    EmptyIndex: GenericPalletError;
 
     /**
      * Fee is changed.
      **/
-    FeeChanged: GenericPalletError<Rv>;
+    FeeChanged: GenericPalletError;
 
     /**
      * No identity found.
      **/
-    NoIdentity: GenericPalletError<Rv>;
+    NoIdentity: GenericPalletError;
 
     /**
      * Sticky judgement.
      **/
-    StickyJudgement: GenericPalletError<Rv>;
+    StickyJudgement: GenericPalletError;
 
     /**
      * Judgement given.
      **/
-    JudgementGiven: GenericPalletError<Rv>;
+    JudgementGiven: GenericPalletError;
 
     /**
      * Invalid judgement.
      **/
-    InvalidJudgement: GenericPalletError<Rv>;
+    InvalidJudgement: GenericPalletError;
 
     /**
      * The index is invalid.
      **/
-    InvalidIndex: GenericPalletError<Rv>;
+    InvalidIndex: GenericPalletError;
 
     /**
      * The target is invalid.
      **/
-    InvalidTarget: GenericPalletError<Rv>;
+    InvalidTarget: GenericPalletError;
 
     /**
      * Maximum amount of registrars reached. Cannot add any more.
      **/
-    TooManyRegistrars: GenericPalletError<Rv>;
+    TooManyRegistrars: GenericPalletError;
 
     /**
      * Account ID is already named.
      **/
-    AlreadyClaimed: GenericPalletError<Rv>;
+    AlreadyClaimed: GenericPalletError;
 
     /**
      * Sender is not a sub-account.
      **/
-    NotSub: GenericPalletError<Rv>;
+    NotSub: GenericPalletError;
 
     /**
      * Sub-account isn't owned by sender.
      **/
-    NotOwned: GenericPalletError<Rv>;
+    NotOwned: GenericPalletError;
 
     /**
      * The provided judgement was for a different identity.
      **/
-    JudgementForDifferentIdentity: GenericPalletError<Rv>;
+    JudgementForDifferentIdentity: GenericPalletError;
 
     /**
      * Error that occurs when there is an issue paying for judgement.
      **/
-    JudgementPaymentFailed: GenericPalletError<Rv>;
+    JudgementPaymentFailed: GenericPalletError;
 
     /**
      * The provided suffix is too long.
      **/
-    InvalidSuffix: GenericPalletError<Rv>;
+    InvalidSuffix: GenericPalletError;
 
     /**
      * The sender does not have permission to issue a username.
      **/
-    NotUsernameAuthority: GenericPalletError<Rv>;
+    NotUsernameAuthority: GenericPalletError;
 
     /**
      * The authority cannot allocate any more usernames.
      **/
-    NoAllocation: GenericPalletError<Rv>;
+    NoAllocation: GenericPalletError;
 
     /**
      * The signature on a username was not valid.
      **/
-    InvalidSignature: GenericPalletError<Rv>;
+    InvalidSignature: GenericPalletError;
 
     /**
      * Setting this username requires a signature, but none was provided.
      **/
-    RequiresSignature: GenericPalletError<Rv>;
+    RequiresSignature: GenericPalletError;
 
     /**
      * The username does not meet the requirements.
      **/
-    InvalidUsername: GenericPalletError<Rv>;
+    InvalidUsername: GenericPalletError;
 
     /**
      * The username is already taken.
      **/
-    UsernameTaken: GenericPalletError<Rv>;
+    UsernameTaken: GenericPalletError;
 
     /**
      * The requested username does not exist.
      **/
-    NoUsername: GenericPalletError<Rv>;
+    NoUsername: GenericPalletError;
 
     /**
      * The username cannot be forcefully removed because it can still be accepted.
      **/
-    NotExpired: GenericPalletError<Rv>;
+    NotExpired: GenericPalletError;
 
     /**
      * The username cannot be removed because it's still in the grace period.
      **/
-    TooEarly: GenericPalletError<Rv>;
+    TooEarly: GenericPalletError;
 
     /**
      * The username cannot be removed because it is not unbinding.
      **/
-    NotUnbinding: GenericPalletError<Rv>;
+    NotUnbinding: GenericPalletError;
 
     /**
      * The username cannot be unbound because it is already unbinding.
      **/
-    AlreadyUnbinding: GenericPalletError<Rv>;
+    AlreadyUnbinding: GenericPalletError;
 
     /**
      * The action cannot be performed because of insufficient privileges (e.g. authority
      * trying to unbind a username provided by the system).
      **/
-    InsufficientPrivileges: GenericPalletError<Rv>;
+    InsufficientPrivileges: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Recovery`'s errors
@@ -638,87 +638,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 `Vesting`'s errors
@@ -727,33 +727,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 `Scheduler`'s errors
@@ -762,32 +762,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 `Preimage`'s errors
@@ -796,47 +796,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 `Sudo`'s errors
@@ -845,12 +845,12 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Sender must be the Sudo account.
      **/
-    RequireSudo: GenericPalletError<Rv>;
+    RequireSudo: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Proxy`'s errors
@@ -859,47 +859,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 `Multisig`'s errors
@@ -908,78 +908,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 `ElectionProviderMultiPhase`'s errors
@@ -988,82 +988,82 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Submission was too early.
      **/
-    PreDispatchEarlySubmission: GenericPalletError<Rv>;
+    PreDispatchEarlySubmission: GenericPalletError;
 
     /**
      * Wrong number of winners presented.
      **/
-    PreDispatchWrongWinnerCount: GenericPalletError<Rv>;
+    PreDispatchWrongWinnerCount: GenericPalletError;
 
     /**
      * Submission was too weak, score-wise.
      **/
-    PreDispatchWeakSubmission: GenericPalletError<Rv>;
+    PreDispatchWeakSubmission: GenericPalletError;
 
     /**
      * The queue was full, and the solution was not better than any of the existing ones.
      **/
-    SignedQueueFull: GenericPalletError<Rv>;
+    SignedQueueFull: GenericPalletError;
 
     /**
      * The origin failed to pay the deposit.
      **/
-    SignedCannotPayDeposit: GenericPalletError<Rv>;
+    SignedCannotPayDeposit: GenericPalletError;
 
     /**
      * Witness data to dispatchable is invalid.
      **/
-    SignedInvalidWitness: GenericPalletError<Rv>;
+    SignedInvalidWitness: GenericPalletError;
 
     /**
      * The signed submission consumes too much weight
      **/
-    SignedTooMuchWeight: GenericPalletError<Rv>;
+    SignedTooMuchWeight: GenericPalletError;
 
     /**
      * OCW submitted solution for wrong round
      **/
-    OcwCallWrongEra: GenericPalletError<Rv>;
+    OcwCallWrongEra: GenericPalletError;
 
     /**
      * Snapshot metadata should exist but didn't.
      **/
-    MissingSnapshotMetadata: GenericPalletError<Rv>;
+    MissingSnapshotMetadata: GenericPalletError;
 
     /**
      * `Self::insert_submission` returned an invalid index.
      **/
-    InvalidSubmissionIndex: GenericPalletError<Rv>;
+    InvalidSubmissionIndex: GenericPalletError;
 
     /**
      * The call is not allowed at this point.
      **/
-    CallNotAllowed: GenericPalletError<Rv>;
+    CallNotAllowed: GenericPalletError;
 
     /**
      * The fallback failed
      **/
-    FallbackFailed: GenericPalletError<Rv>;
+    FallbackFailed: GenericPalletError;
 
     /**
      * Some bound not met
      **/
-    BoundNotMet: GenericPalletError<Rv>;
+    BoundNotMet: GenericPalletError;
 
     /**
      * Submitted solution has too many winners
      **/
-    TooManyWinners: GenericPalletError<Rv>;
+    TooManyWinners: GenericPalletError;
 
     /**
      * Submission was prepared for a different round.
      **/
-    PreDispatchDifferentRound: GenericPalletError<Rv>;
+    PreDispatchDifferentRound: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `VoterList`'s errors
@@ -1072,17 +1072,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 `NominationPools`'s errors
@@ -1091,44 +1091,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.
@@ -1137,160 +1137,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 `FastUnstake`'s errors
@@ -1301,37 +1301,37 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      *
      * This means that the given account is not bonded.
      **/
-    NotController: GenericPalletError<Rv>;
+    NotController: GenericPalletError;
 
     /**
      * The bonded account has already been queued.
      **/
-    AlreadyQueued: GenericPalletError<Rv>;
+    AlreadyQueued: GenericPalletError;
 
     /**
      * The bonded account has active unlocking chunks.
      **/
-    NotFullyBonded: GenericPalletError<Rv>;
+    NotFullyBonded: GenericPalletError;
 
     /**
      * The provided un-staker is not in the `Queue`.
      **/
-    NotQueued: GenericPalletError<Rv>;
+    NotQueued: GenericPalletError;
 
     /**
      * The provided un-staker is already in Head, and cannot deregister.
      **/
-    AlreadyHead: GenericPalletError<Rv>;
+    AlreadyHead: GenericPalletError;
 
     /**
      * The call is not allowed at this point because the pallet is not active.
      **/
-    CallNotAllowed: GenericPalletError<Rv>;
+    CallNotAllowed: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ConvictionVoting`'s errors
@@ -1340,68 +1340,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
@@ -1410,77 +1410,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
@@ -1489,32 +1489,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 `Treasury`'s errors
@@ -1523,63 +1523,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 `DelegatedStaking`'s errors
@@ -1588,17 +1588,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.
@@ -1607,52 +1607,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 `Configuration`'s errors
@@ -1661,12 +1661,12 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The new value for a configuration parameter is invalid.
      **/
-    InvalidNewValue: GenericPalletError<Rv>;
+    InvalidNewValue: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ParaInclusion`'s errors
@@ -1675,95 +1675,95 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Validator index out of bounds.
      **/
-    ValidatorIndexOutOfBounds: GenericPalletError<Rv>;
+    ValidatorIndexOutOfBounds: GenericPalletError;
 
     /**
      * Candidate submitted but para not scheduled.
      **/
-    UnscheduledCandidate: GenericPalletError<Rv>;
+    UnscheduledCandidate: GenericPalletError;
 
     /**
      * Head data exceeds the configured maximum.
      **/
-    HeadDataTooLarge: GenericPalletError<Rv>;
+    HeadDataTooLarge: GenericPalletError;
 
     /**
      * Code upgrade prematurely.
      **/
-    PrematureCodeUpgrade: GenericPalletError<Rv>;
+    PrematureCodeUpgrade: GenericPalletError;
 
     /**
      * Output code is too large
      **/
-    NewCodeTooLarge: GenericPalletError<Rv>;
+    NewCodeTooLarge: GenericPalletError;
 
     /**
      * The candidate's relay-parent was not allowed. Either it was
      * not recent enough or it didn't advance based on the last parachain block.
      **/
-    DisallowedRelayParent: GenericPalletError<Rv>;
+    DisallowedRelayParent: GenericPalletError;
 
     /**
      * Failed to compute group index for the core: either it's out of bounds
      * or the relay parent doesn't belong to the current session.
      **/
-    InvalidAssignment: GenericPalletError<Rv>;
+    InvalidAssignment: GenericPalletError;
 
     /**
      * Invalid group index in core assignment.
      **/
-    InvalidGroupIndex: GenericPalletError<Rv>;
+    InvalidGroupIndex: GenericPalletError;
 
     /**
      * Insufficient (non-majority) backing.
      **/
-    InsufficientBacking: GenericPalletError<Rv>;
+    InsufficientBacking: GenericPalletError;
 
     /**
      * Invalid (bad signature, unknown validator, etc.) backing.
      **/
-    InvalidBacking: GenericPalletError<Rv>;
+    InvalidBacking: GenericPalletError;
 
     /**
      * The validation data hash does not match expected.
      **/
-    ValidationDataHashMismatch: GenericPalletError<Rv>;
+    ValidationDataHashMismatch: GenericPalletError;
 
     /**
      * The downward message queue is not processed correctly.
      **/
-    IncorrectDownwardMessageHandling: GenericPalletError<Rv>;
+    IncorrectDownwardMessageHandling: GenericPalletError;
 
     /**
      * At least one upward message sent does not pass the acceptance criteria.
      **/
-    InvalidUpwardMessages: GenericPalletError<Rv>;
+    InvalidUpwardMessages: GenericPalletError;
 
     /**
      * The candidate didn't follow the rules of HRMP watermark advancement.
      **/
-    HrmpWatermarkMishandling: GenericPalletError<Rv>;
+    HrmpWatermarkMishandling: GenericPalletError;
 
     /**
      * The HRMP messages sent by the candidate is not valid.
      **/
-    InvalidOutboundHrmp: GenericPalletError<Rv>;
+    InvalidOutboundHrmp: GenericPalletError;
 
     /**
      * The validation code hash of the candidate is not valid.
      **/
-    InvalidValidationCodeHash: GenericPalletError<Rv>;
+    InvalidValidationCodeHash: GenericPalletError;
 
     /**
      * The `para_head` hash in the candidate descriptor doesn't match the hash of the actual
      * para head in the commitments.
      **/
-    ParaHeadMismatch: GenericPalletError<Rv>;
+    ParaHeadMismatch: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ParaInherent`'s errors
@@ -1772,29 +1772,29 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Inclusion inherent called more than once per block.
      **/
-    TooManyInclusionInherents: GenericPalletError<Rv>;
+    TooManyInclusionInherents: GenericPalletError;
 
     /**
      * The hash of the submitted parent header doesn't correspond to the saved block hash of
      * the parent.
      **/
-    InvalidParentHeader: GenericPalletError<Rv>;
+    InvalidParentHeader: GenericPalletError;
 
     /**
      * Inherent data was filtered during execution. This should have only been done
      * during creation.
      **/
-    InherentDataFilteredDuringExecution: GenericPalletError<Rv>;
+    InherentDataFilteredDuringExecution: GenericPalletError;
 
     /**
      * Too many candidates supplied.
      **/
-    UnscheduledCandidate: GenericPalletError<Rv>;
+    UnscheduledCandidate: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Paras`'s errors
@@ -1803,87 +1803,87 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Para is not registered in our system.
      **/
-    NotRegistered: GenericPalletError<Rv>;
+    NotRegistered: GenericPalletError;
 
     /**
      * Para cannot be onboarded because it is already tracked by our system.
      **/
-    CannotOnboard: GenericPalletError<Rv>;
+    CannotOnboard: GenericPalletError;
 
     /**
      * Para cannot be offboarded at this time.
      **/
-    CannotOffboard: GenericPalletError<Rv>;
+    CannotOffboard: GenericPalletError;
 
     /**
      * Para cannot be upgraded to a lease holding parachain.
      **/
-    CannotUpgrade: GenericPalletError<Rv>;
+    CannotUpgrade: GenericPalletError;
 
     /**
      * Para cannot be downgraded to an on-demand parachain.
      **/
-    CannotDowngrade: GenericPalletError<Rv>;
+    CannotDowngrade: GenericPalletError;
 
     /**
      * The statement for PVF pre-checking is stale.
      **/
-    PvfCheckStatementStale: GenericPalletError<Rv>;
+    PvfCheckStatementStale: GenericPalletError;
 
     /**
      * The statement for PVF pre-checking is for a future session.
      **/
-    PvfCheckStatementFuture: GenericPalletError<Rv>;
+    PvfCheckStatementFuture: GenericPalletError;
 
     /**
      * Claimed validator index is out of bounds.
      **/
-    PvfCheckValidatorIndexOutOfBounds: GenericPalletError<Rv>;
+    PvfCheckValidatorIndexOutOfBounds: GenericPalletError;
 
     /**
      * The signature for the PVF pre-checking is invalid.
      **/
-    PvfCheckInvalidSignature: GenericPalletError<Rv>;
+    PvfCheckInvalidSignature: GenericPalletError;
 
     /**
      * The given validator already has cast a vote.
      **/
-    PvfCheckDoubleVote: GenericPalletError<Rv>;
+    PvfCheckDoubleVote: GenericPalletError;
 
     /**
      * The given PVF does not exist at the moment of process a vote.
      **/
-    PvfCheckSubjectInvalid: GenericPalletError<Rv>;
+    PvfCheckSubjectInvalid: GenericPalletError;
 
     /**
      * Parachain cannot currently schedule a code upgrade.
      **/
-    CannotUpgradeCode: GenericPalletError<Rv>;
+    CannotUpgradeCode: GenericPalletError;
 
     /**
      * Invalid validation code size.
      **/
-    InvalidCode: GenericPalletError<Rv>;
+    InvalidCode: GenericPalletError;
 
     /**
      * No upgrade authorized.
      **/
-    NothingAuthorized: GenericPalletError<Rv>;
+    NothingAuthorized: GenericPalletError;
 
     /**
      * The submitted code is not authorized.
      **/
-    Unauthorized: GenericPalletError<Rv>;
+    Unauthorized: GenericPalletError;
 
     /**
      * Invalid block number.
      **/
-    InvalidBlockNumber: GenericPalletError<Rv>;
+    InvalidBlockNumber: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Hrmp`'s errors
@@ -1892,107 +1892,107 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The sender tried to open a channel to themselves.
      **/
-    OpenHrmpChannelToSelf: GenericPalletError<Rv>;
+    OpenHrmpChannelToSelf: GenericPalletError;
 
     /**
      * The recipient is not a valid para.
      **/
-    OpenHrmpChannelInvalidRecipient: GenericPalletError<Rv>;
+    OpenHrmpChannelInvalidRecipient: GenericPalletError;
 
     /**
      * The requested capacity is zero.
      **/
-    OpenHrmpChannelZeroCapacity: GenericPalletError<Rv>;
+    OpenHrmpChannelZeroCapacity: GenericPalletError;
 
     /**
      * The requested capacity exceeds the global limit.
      **/
-    OpenHrmpChannelCapacityExceedsLimit: GenericPalletError<Rv>;
+    OpenHrmpChannelCapacityExceedsLimit: GenericPalletError;
 
     /**
      * The requested maximum message size is 0.
      **/
-    OpenHrmpChannelZeroMessageSize: GenericPalletError<Rv>;
+    OpenHrmpChannelZeroMessageSize: GenericPalletError;
 
     /**
      * The open request requested the message size that exceeds the global limit.
      **/
-    OpenHrmpChannelMessageSizeExceedsLimit: GenericPalletError<Rv>;
+    OpenHrmpChannelMessageSizeExceedsLimit: GenericPalletError;
 
     /**
      * The channel already exists
      **/
-    OpenHrmpChannelAlreadyExists: GenericPalletError<Rv>;
+    OpenHrmpChannelAlreadyExists: GenericPalletError;
 
     /**
      * There is already a request to open the same channel.
      **/
-    OpenHrmpChannelAlreadyRequested: GenericPalletError<Rv>;
+    OpenHrmpChannelAlreadyRequested: GenericPalletError;
 
     /**
      * The sender already has the maximum number of allowed outbound channels.
      **/
-    OpenHrmpChannelLimitExceeded: GenericPalletError<Rv>;
+    OpenHrmpChannelLimitExceeded: GenericPalletError;
 
     /**
      * The channel from the sender to the origin doesn't exist.
      **/
-    AcceptHrmpChannelDoesntExist: GenericPalletError<Rv>;
+    AcceptHrmpChannelDoesntExist: GenericPalletError;
 
     /**
      * The channel is already confirmed.
      **/
-    AcceptHrmpChannelAlreadyConfirmed: GenericPalletError<Rv>;
+    AcceptHrmpChannelAlreadyConfirmed: GenericPalletError;
 
     /**
      * The recipient already has the maximum number of allowed inbound channels.
      **/
-    AcceptHrmpChannelLimitExceeded: GenericPalletError<Rv>;
+    AcceptHrmpChannelLimitExceeded: GenericPalletError;
 
     /**
      * The origin tries to close a channel where it is neither the sender nor the recipient.
      **/
-    CloseHrmpChannelUnauthorized: GenericPalletError<Rv>;
+    CloseHrmpChannelUnauthorized: GenericPalletError;
 
     /**
      * The channel to be closed doesn't exist.
      **/
-    CloseHrmpChannelDoesntExist: GenericPalletError<Rv>;
+    CloseHrmpChannelDoesntExist: GenericPalletError;
 
     /**
      * The channel close request is already requested.
      **/
-    CloseHrmpChannelAlreadyUnderway: GenericPalletError<Rv>;
+    CloseHrmpChannelAlreadyUnderway: GenericPalletError;
 
     /**
      * Canceling is requested by neither the sender nor recipient of the open channel request.
      **/
-    CancelHrmpOpenChannelUnauthorized: GenericPalletError<Rv>;
+    CancelHrmpOpenChannelUnauthorized: GenericPalletError;
 
     /**
      * The open request doesn't exist.
      **/
-    OpenHrmpChannelDoesntExist: GenericPalletError<Rv>;
+    OpenHrmpChannelDoesntExist: GenericPalletError;
 
     /**
      * Cannot cancel an HRMP open channel request because it is already confirmed.
      **/
-    OpenHrmpChannelAlreadyConfirmed: GenericPalletError<Rv>;
+    OpenHrmpChannelAlreadyConfirmed: GenericPalletError;
 
     /**
      * The provided witness data is wrong.
      **/
-    WrongWitness: GenericPalletError<Rv>;
+    WrongWitness: GenericPalletError;
 
     /**
      * The channel between these two chains cannot be authorized.
      **/
-    ChannelCreationNotAuthorized: GenericPalletError<Rv>;
+    ChannelCreationNotAuthorized: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ParasDisputes`'s errors
@@ -2001,52 +2001,52 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Duplicate dispute statement sets provided.
      **/
-    DuplicateDisputeStatementSets: GenericPalletError<Rv>;
+    DuplicateDisputeStatementSets: GenericPalletError;
 
     /**
      * Ancient dispute statement provided.
      **/
-    AncientDisputeStatement: GenericPalletError<Rv>;
+    AncientDisputeStatement: GenericPalletError;
 
     /**
      * Validator index on statement is out of bounds for session.
      **/
-    ValidatorIndexOutOfBounds: GenericPalletError<Rv>;
+    ValidatorIndexOutOfBounds: GenericPalletError;
 
     /**
      * Invalid signature on statement.
      **/
-    InvalidSignature: GenericPalletError<Rv>;
+    InvalidSignature: GenericPalletError;
 
     /**
      * Validator vote submitted more than once to dispute.
      **/
-    DuplicateStatement: GenericPalletError<Rv>;
+    DuplicateStatement: GenericPalletError;
 
     /**
      * A dispute where there are only votes on one side.
      **/
-    SingleSidedDispute: GenericPalletError<Rv>;
+    SingleSidedDispute: GenericPalletError;
 
     /**
      * A dispute vote from a malicious backer.
      **/
-    MaliciousBacker: GenericPalletError<Rv>;
+    MaliciousBacker: GenericPalletError;
 
     /**
      * No backing votes were provides along dispute statements.
      **/
-    MissingBackingVotes: GenericPalletError<Rv>;
+    MissingBackingVotes: GenericPalletError;
 
     /**
      * Unconfirmed dispute statement sets provided.
      **/
-    UnconfirmedDispute: GenericPalletError<Rv>;
+    UnconfirmedDispute: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ParasSlashing`'s errors
@@ -2055,38 +2055,38 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The key ownership proof is invalid.
      **/
-    InvalidKeyOwnershipProof: GenericPalletError<Rv>;
+    InvalidKeyOwnershipProof: GenericPalletError;
 
     /**
      * The session index is too old or invalid.
      **/
-    InvalidSessionIndex: GenericPalletError<Rv>;
+    InvalidSessionIndex: GenericPalletError;
 
     /**
      * The candidate hash is invalid.
      **/
-    InvalidCandidateHash: GenericPalletError<Rv>;
+    InvalidCandidateHash: GenericPalletError;
 
     /**
      * There is no pending slash for the given validator index and time
      * slot.
      **/
-    InvalidValidatorIndex: GenericPalletError<Rv>;
+    InvalidValidatorIndex: GenericPalletError;
 
     /**
      * The validator index does not match the validator id.
      **/
-    ValidatorIndexIdMismatch: GenericPalletError<Rv>;
+    ValidatorIndexIdMismatch: GenericPalletError;
 
     /**
      * The given slashing report is valid but already previously reported.
      **/
-    DuplicateSlashingReport: GenericPalletError<Rv>;
+    DuplicateSlashingReport: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `OnDemandAssignmentProvider`'s errors
@@ -2095,40 +2095,40 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The order queue is full, `place_order` will not continue.
      **/
-    QueueFull: GenericPalletError<Rv>;
+    QueueFull: GenericPalletError;
 
     /**
      * The current spot price is higher than the max amount specified in the `place_order`
      * call, making it invalid.
      **/
-    SpotPriceHigherThanMaxAmount: GenericPalletError<Rv>;
+    SpotPriceHigherThanMaxAmount: GenericPalletError;
 
     /**
      * The account doesn't have enough credits to purchase on-demand coretime.
      **/
-    InsufficientCredits: GenericPalletError<Rv>;
+    InsufficientCredits: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `CoretimeAssignmentProvider`'s errors
    **/
   coretimeAssignmentProvider: {
-    AssignmentsEmpty: GenericPalletError<Rv>;
+    AssignmentsEmpty: GenericPalletError;
 
     /**
      * assign_core is only allowed to append new assignments at the end of already existing
      * ones or update the last entry.
      **/
-    DisallowedInsert: GenericPalletError<Rv>;
+    DisallowedInsert: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Registrar`'s errors
@@ -2137,79 +2137,79 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The ID is not registered.
      **/
-    NotRegistered: GenericPalletError<Rv>;
+    NotRegistered: GenericPalletError;
 
     /**
      * The ID is already registered.
      **/
-    AlreadyRegistered: GenericPalletError<Rv>;
+    AlreadyRegistered: GenericPalletError;
 
     /**
      * The caller is not the owner of this Id.
      **/
-    NotOwner: GenericPalletError<Rv>;
+    NotOwner: GenericPalletError;
 
     /**
      * Invalid para code size.
      **/
-    CodeTooLarge: GenericPalletError<Rv>;
+    CodeTooLarge: GenericPalletError;
 
     /**
      * Invalid para head data size.
      **/
-    HeadDataTooLarge: GenericPalletError<Rv>;
+    HeadDataTooLarge: GenericPalletError;
 
     /**
      * Para is not a Parachain.
      **/
-    NotParachain: GenericPalletError<Rv>;
+    NotParachain: GenericPalletError;
 
     /**
      * Para is not a Parathread (on-demand parachain).
      **/
-    NotParathread: GenericPalletError<Rv>;
+    NotParathread: GenericPalletError;
 
     /**
      * Cannot deregister para
      **/
-    CannotDeregister: GenericPalletError<Rv>;
+    CannotDeregister: GenericPalletError;
 
     /**
      * Cannot schedule downgrade of lease holding parachain to on-demand parachain
      **/
-    CannotDowngrade: GenericPalletError<Rv>;
+    CannotDowngrade: GenericPalletError;
 
     /**
      * Cannot schedule upgrade of on-demand parachain to lease holding parachain
      **/
-    CannotUpgrade: GenericPalletError<Rv>;
+    CannotUpgrade: GenericPalletError;
 
     /**
      * Para is locked from manipulation by the manager. Must use parachain or relay chain
      * governance.
      **/
-    ParaLocked: GenericPalletError<Rv>;
+    ParaLocked: GenericPalletError;
 
     /**
      * The ID given for registration has not been reserved.
      **/
-    NotReserved: GenericPalletError<Rv>;
+    NotReserved: GenericPalletError;
 
     /**
      * The validation code is invalid.
      **/
-    InvalidCode: GenericPalletError<Rv>;
+    InvalidCode: GenericPalletError;
 
     /**
      * Cannot perform a parachain slot / lifecycle swap. Check that the state of both paras
      * are correct for the swap to work.
      **/
-    CannotSwap: GenericPalletError<Rv>;
+    CannotSwap: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Slots`'s errors
@@ -2218,17 +2218,17 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The parachain ID is not onboarding.
      **/
-    ParaNotOnboarding: GenericPalletError<Rv>;
+    ParaNotOnboarding: GenericPalletError;
 
     /**
      * There was an error with the lease.
      **/
-    LeaseError: GenericPalletError<Rv>;
+    LeaseError: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ParasSudoWrapper`'s errors
@@ -2237,58 +2237,58 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The specified parachain is not registered.
      **/
-    ParaDoesntExist: GenericPalletError<Rv>;
+    ParaDoesntExist: GenericPalletError;
 
     /**
      * The specified parachain is already registered.
      **/
-    ParaAlreadyExists: GenericPalletError<Rv>;
+    ParaAlreadyExists: GenericPalletError;
 
     /**
      * A DMP message couldn't be sent because it exceeds the maximum size allowed for a
      * downward message.
      **/
-    ExceedsMaxMessageSize: GenericPalletError<Rv>;
+    ExceedsMaxMessageSize: GenericPalletError;
 
     /**
      * A DMP message couldn't be sent because the destination is unreachable.
      **/
-    Unroutable: GenericPalletError<Rv>;
+    Unroutable: GenericPalletError;
 
     /**
      * Could not schedule para cleanup.
      **/
-    CouldntCleanup: GenericPalletError<Rv>;
+    CouldntCleanup: GenericPalletError;
 
     /**
      * Not a parathread (on-demand parachain).
      **/
-    NotParathread: GenericPalletError<Rv>;
+    NotParathread: GenericPalletError;
 
     /**
      * Not a lease holding parachain.
      **/
-    NotParachain: GenericPalletError<Rv>;
+    NotParachain: GenericPalletError;
 
     /**
      * Cannot upgrade on-demand parachain to lease holding parachain.
      **/
-    CannotUpgrade: GenericPalletError<Rv>;
+    CannotUpgrade: GenericPalletError;
 
     /**
      * Cannot downgrade lease holding parachain to on-demand.
      **/
-    CannotDowngrade: GenericPalletError<Rv>;
+    CannotDowngrade: GenericPalletError;
 
     /**
      * There are more cores than supported by the runtime.
      **/
-    TooManyCores: GenericPalletError<Rv>;
+    TooManyCores: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Auctions`'s errors
@@ -2297,42 +2297,42 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * This auction is already in progress.
      **/
-    AuctionInProgress: GenericPalletError<Rv>;
+    AuctionInProgress: GenericPalletError;
 
     /**
      * The lease period is in the past.
      **/
-    LeasePeriodInPast: GenericPalletError<Rv>;
+    LeasePeriodInPast: GenericPalletError;
 
     /**
      * Para is not registered
      **/
-    ParaNotRegistered: GenericPalletError<Rv>;
+    ParaNotRegistered: GenericPalletError;
 
     /**
      * Not a current auction.
      **/
-    NotCurrentAuction: GenericPalletError<Rv>;
+    NotCurrentAuction: GenericPalletError;
 
     /**
      * Not an auction.
      **/
-    NotAuction: GenericPalletError<Rv>;
+    NotAuction: GenericPalletError;
 
     /**
      * Auction has already ended.
      **/
-    AuctionEnded: GenericPalletError<Rv>;
+    AuctionEnded: GenericPalletError;
 
     /**
      * The para is already leased out for part of this range.
      **/
-    AlreadyLeasedOut: GenericPalletError<Rv>;
+    AlreadyLeasedOut: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Crowdloan`'s errors
@@ -2341,123 +2341,123 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The current lease period is more than the first lease period.
      **/
-    FirstPeriodInPast: GenericPalletError<Rv>;
+    FirstPeriodInPast: GenericPalletError;
 
     /**
      * The first lease period needs to at least be less than 3 `max_value`.
      **/
-    FirstPeriodTooFarInFuture: GenericPalletError<Rv>;
+    FirstPeriodTooFarInFuture: GenericPalletError;
 
     /**
      * Last lease period must be greater than first lease period.
      **/
-    LastPeriodBeforeFirstPeriod: GenericPalletError<Rv>;
+    LastPeriodBeforeFirstPeriod: GenericPalletError;
 
     /**
      * The last lease period cannot be more than 3 periods after the first period.
      **/
-    LastPeriodTooFarInFuture: GenericPalletError<Rv>;
+    LastPeriodTooFarInFuture: GenericPalletError;
 
     /**
      * The campaign ends before the current block number. The end must be in the future.
      **/
-    CannotEndInPast: GenericPalletError<Rv>;
+    CannotEndInPast: GenericPalletError;
 
     /**
      * The end date for this crowdloan is not sensible.
      **/
-    EndTooFarInFuture: GenericPalletError<Rv>;
+    EndTooFarInFuture: GenericPalletError;
 
     /**
      * There was an overflow.
      **/
-    Overflow: GenericPalletError<Rv>;
+    Overflow: GenericPalletError;
 
     /**
      * The contribution was below the minimum, `MinContribution`.
      **/
-    ContributionTooSmall: GenericPalletError<Rv>;
+    ContributionTooSmall: GenericPalletError;
 
     /**
      * Invalid fund index.
      **/
-    InvalidParaId: GenericPalletError<Rv>;
+    InvalidParaId: GenericPalletError;
 
     /**
      * Contributions exceed maximum amount.
      **/
-    CapExceeded: GenericPalletError<Rv>;
+    CapExceeded: GenericPalletError;
 
     /**
      * The contribution period has already ended.
      **/
-    ContributionPeriodOver: GenericPalletError<Rv>;
+    ContributionPeriodOver: GenericPalletError;
 
     /**
      * The origin of this call is invalid.
      **/
-    InvalidOrigin: GenericPalletError<Rv>;
+    InvalidOrigin: GenericPalletError;
 
     /**
      * This crowdloan does not correspond to a parachain.
      **/
-    NotParachain: GenericPalletError<Rv>;
+    NotParachain: GenericPalletError;
 
     /**
      * This parachain lease is still active and retirement cannot yet begin.
      **/
-    LeaseActive: GenericPalletError<Rv>;
+    LeaseActive: GenericPalletError;
 
     /**
      * This parachain's bid or lease is still active and withdraw cannot yet begin.
      **/
-    BidOrLeaseActive: GenericPalletError<Rv>;
+    BidOrLeaseActive: GenericPalletError;
 
     /**
      * The crowdloan has not yet ended.
      **/
-    FundNotEnded: GenericPalletError<Rv>;
+    FundNotEnded: GenericPalletError;
 
     /**
      * There are no contributions stored in this crowdloan.
      **/
-    NoContributions: GenericPalletError<Rv>;
+    NoContributions: GenericPalletError;
 
     /**
      * The crowdloan is not ready to dissolve. Potentially still has a slot or in retirement
      * period.
      **/
-    NotReadyToDissolve: GenericPalletError<Rv>;
+    NotReadyToDissolve: GenericPalletError;
 
     /**
      * Invalid signature.
      **/
-    InvalidSignature: GenericPalletError<Rv>;
+    InvalidSignature: GenericPalletError;
 
     /**
      * The provided memo is too large.
      **/
-    MemoTooLarge: GenericPalletError<Rv>;
+    MemoTooLarge: GenericPalletError;
 
     /**
      * The fund is already in `NewRaise`
      **/
-    AlreadyInNewRaise: GenericPalletError<Rv>;
+    AlreadyInNewRaise: GenericPalletError;
 
     /**
      * No contributions allowed during the VRF delay
      **/
-    VrfDelayInProgress: GenericPalletError<Rv>;
+    VrfDelayInProgress: GenericPalletError;
 
     /**
      * A lease period has not started yet, due to an offset in the starting block.
      **/
-    NoLeasePeriod: GenericPalletError<Rv>;
+    NoLeasePeriod: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `AssignedSlots`'s errors
@@ -2466,46 +2466,46 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The specified parachain is not registered.
      **/
-    ParaDoesntExist: GenericPalletError<Rv>;
+    ParaDoesntExist: GenericPalletError;
 
     /**
      * Not a parathread (on-demand parachain).
      **/
-    NotParathread: GenericPalletError<Rv>;
+    NotParathread: GenericPalletError;
 
     /**
      * Cannot upgrade on-demand parachain to lease holding
      * parachain.
      **/
-    CannotUpgrade: GenericPalletError<Rv>;
+    CannotUpgrade: GenericPalletError;
 
     /**
      * Cannot downgrade lease holding parachain to
      * on-demand.
      **/
-    CannotDowngrade: GenericPalletError<Rv>;
+    CannotDowngrade: GenericPalletError;
 
     /**
      * Permanent or Temporary slot already assigned.
      **/
-    SlotAlreadyAssigned: GenericPalletError<Rv>;
+    SlotAlreadyAssigned: GenericPalletError;
 
     /**
      * Permanent or Temporary slot has not been assigned.
      **/
-    SlotNotAssigned: GenericPalletError<Rv>;
+    SlotNotAssigned: GenericPalletError;
 
     /**
      * An ongoing lease already exists.
      **/
-    OngoingLeaseExists: GenericPalletError<Rv>;
-    MaxPermanentSlotsExceeded: GenericPalletError<Rv>;
-    MaxTemporarySlotsExceeded: GenericPalletError<Rv>;
+    OngoingLeaseExists: GenericPalletError;
+    MaxPermanentSlotsExceeded: GenericPalletError;
+    MaxTemporarySlotsExceeded: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Coretime`'s errors
@@ -2514,23 +2514,23 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The paraid making the call is not the coretime brokerage system parachain.
      **/
-    NotBroker: GenericPalletError<Rv>;
+    NotBroker: GenericPalletError;
 
     /**
      * Requested revenue information `when` parameter was in the future from the current
      * block height.
      **/
-    RequestedFutureRevenue: GenericPalletError<Rv>;
+    RequestedFutureRevenue: GenericPalletError;
 
     /**
      * Failed to transfer assets to the coretime chain
      **/
-    AssetTransferFailed: GenericPalletError<Rv>;
+    AssetTransferFailed: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `StakingAhClient`'s errors
@@ -2539,12 +2539,12 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Could not process incoming message because incoming messages are blocked.
      **/
-    Blocked: GenericPalletError<Rv>;
+    Blocked: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `MultiBlockMigrations`'s errors
@@ -2553,12 +2553,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 `XcmPallet`'s errors
@@ -2568,152 +2568,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
@@ -2723,32 +2723,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.
@@ -2756,24 +2756,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 `AssetRate`'s errors
@@ -2782,22 +2782,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 `MetaTx`'s errors
@@ -2806,37 +2806,37 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Invalid proof (e.g. signature).
      **/
-    BadProof: GenericPalletError<Rv>;
+    BadProof: GenericPalletError;
 
     /**
      * The meta transaction is not yet valid (e.g. nonce too high).
      **/
-    Future: GenericPalletError<Rv>;
+    Future: GenericPalletError;
 
     /**
      * The meta transaction is outdated (e.g. nonce too low).
      **/
-    Stale: GenericPalletError<Rv>;
+    Stale: GenericPalletError;
 
     /**
      * The meta transactions's birth block is ancient.
      **/
-    AncientBirthBlock: GenericPalletError<Rv>;
+    AncientBirthBlock: GenericPalletError;
 
     /**
      * The transaction extension did not authorize any origin.
      **/
-    UnknownOrigin: GenericPalletError<Rv>;
+    UnknownOrigin: GenericPalletError;
 
     /**
      * The meta transaction is invalid.
      **/
-    Invalid: GenericPalletError<Rv>;
+    Invalid: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `RootOffences`'s errors
@@ -2845,12 +2845,12 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Failed to get the active era from the staking pallet.
      **/
-    FailedToGetActiveEra: GenericPalletError<Rv>;
+    FailedToGetActiveEra: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Beefy`'s errors
@@ -2859,41 +2859,41 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * A key ownership proof provided as part of an equivocation report is invalid.
      **/
-    InvalidKeyOwnershipProof: GenericPalletError<Rv>;
+    InvalidKeyOwnershipProof: GenericPalletError;
 
     /**
      * A double voting proof provided as part of an equivocation report is invalid.
      **/
-    InvalidDoubleVotingProof: GenericPalletError<Rv>;
+    InvalidDoubleVotingProof: GenericPalletError;
 
     /**
      * A fork voting proof provided as part of an equivocation report is invalid.
      **/
-    InvalidForkVotingProof: GenericPalletError<Rv>;
+    InvalidForkVotingProof: GenericPalletError;
 
     /**
      * A future block voting proof provided as part of an equivocation report is invalid.
      **/
-    InvalidFutureBlockVotingProof: GenericPalletError<Rv>;
+    InvalidFutureBlockVotingProof: GenericPalletError;
 
     /**
      * The session of the equivocation proof is invalid
      **/
-    InvalidEquivocationProofSession: GenericPalletError<Rv>;
+    InvalidEquivocationProofSession: GenericPalletError;
 
     /**
      * A given equivocation report is valid but already previously reported.
      **/
-    DuplicateOffenceReport: GenericPalletError<Rv>;
+    DuplicateOffenceReport: GenericPalletError;
 
     /**
      * Submitted configuration is invalid.
      **/
-    InvalidConfiguration: GenericPalletError<Rv>;
+    InvalidConfiguration: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
 }