@dedot/chaintypes 0.194.0 → 0.196.0

package/vara/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 `Grandpa`'s errors
@@ -98,43 +98,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 `Balances`'s errors
@@ -143,67 +143,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 `Session`'s errors
@@ -212,32 +212,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 `Utility`'s errors
@@ -246,12 +246,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 `Vesting`'s errors
@@ -260,33 +260,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 `BagsList`'s errors
@@ -295,12 +295,12 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * A error in the list interface implementation.
      **/
-    List: GenericPalletError<Rv>;
+    List: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ImOnline`'s errors
@@ -309,17 +309,17 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Non existent public key.
      **/
-    InvalidKey: GenericPalletError<Rv>;
+    InvalidKey: GenericPalletError;
 
     /**
      * Duplicated heartbeat.
      **/
-    DuplicatedHeartbeat: GenericPalletError<Rv>;
+    DuplicatedHeartbeat: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Staking`'s errors
@@ -328,166 +328,166 @@ 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;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Treasury`'s errors
@@ -496,63 +496,63 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * No proposal, bounty or spend at that index.
      **/
-    InvalidIndex: GenericPalletError<Rv>;
+    InvalidIndex: GenericPalletError;
 
     /**
      * Too many approvals in the queue.
      **/
-    TooManyApprovals: GenericPalletError<Rv>;
+    TooManyApprovals: GenericPalletError;
 
     /**
      * The spend origin is valid but the amount it is allowed to spend is lower than the
      * amount to be spent.
      **/
-    InsufficientPermission: GenericPalletError<Rv>;
+    InsufficientPermission: GenericPalletError;
 
     /**
      * Proposal has not been approved.
      **/
-    ProposalNotApproved: GenericPalletError<Rv>;
+    ProposalNotApproved: GenericPalletError;
 
     /**
      * The balance of the asset kind is not convertible to the balance of the native asset.
      **/
-    FailedToConvertBalance: GenericPalletError<Rv>;
+    FailedToConvertBalance: GenericPalletError;
 
     /**
      * The spend has expired and cannot be claimed.
      **/
-    SpendExpired: GenericPalletError<Rv>;
+    SpendExpired: GenericPalletError;
 
     /**
      * The spend is not yet eligible for payout.
      **/
-    EarlyPayout: GenericPalletError<Rv>;
+    EarlyPayout: GenericPalletError;
 
     /**
      * The payment has already been attempted.
      **/
-    AlreadyAttempted: GenericPalletError<Rv>;
+    AlreadyAttempted: GenericPalletError;
 
     /**
      * There was some issue with the mechanism of payment.
      **/
-    PayoutError: GenericPalletError<Rv>;
+    PayoutError: GenericPalletError;
 
     /**
      * The payout was not yet attempted/claimed.
      **/
-    NotAttempted: GenericPalletError<Rv>;
+    NotAttempted: GenericPalletError;
 
     /**
      * The payment has neither failed nor succeeded yet.
      **/
-    Inconclusive: GenericPalletError<Rv>;
+    Inconclusive: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ConvictionVoting`'s errors
@@ -561,68 +561,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
@@ -631,77 +631,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 `FellowshipCollective`'s errors
@@ -710,62 +710,62 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Account is already a member.
      **/
-    AlreadyMember: GenericPalletError<Rv>;
+    AlreadyMember: GenericPalletError;
 
     /**
      * Account is not a member.
      **/
-    NotMember: GenericPalletError<Rv>;
+    NotMember: GenericPalletError;
 
     /**
      * The given poll index is unknown or has closed.
      **/
-    NotPolling: GenericPalletError<Rv>;
+    NotPolling: GenericPalletError;
 
     /**
      * The given poll is still ongoing.
      **/
-    Ongoing: GenericPalletError<Rv>;
+    Ongoing: GenericPalletError;
 
     /**
      * There are no further records to be removed.
      **/
-    NoneRemaining: GenericPalletError<Rv>;
+    NoneRemaining: GenericPalletError;
 
     /**
      * Unexpected error in state.
      **/
-    Corruption: GenericPalletError<Rv>;
+    Corruption: GenericPalletError;
 
     /**
      * The member's rank is too low to vote.
      **/
-    RankTooLow: GenericPalletError<Rv>;
+    RankTooLow: GenericPalletError;
 
     /**
      * The information provided is incorrect.
      **/
-    InvalidWitness: GenericPalletError<Rv>;
+    InvalidWitness: GenericPalletError;
 
     /**
      * The origin is not sufficiently privileged to do the operation.
      **/
-    NoPermission: GenericPalletError<Rv>;
+    NoPermission: GenericPalletError;
 
     /**
      * The new member to exchange is the same as the old member
      **/
-    SameMember: GenericPalletError<Rv>;
+    SameMember: GenericPalletError;
 
     /**
      * The max member count for the rank has been reached.
      **/
-    TooManyMembers: GenericPalletError<Rv>;
+    TooManyMembers: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `FellowshipReferenda`'s errors
@@ -774,77 +774,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
@@ -853,32 +853,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 `Scheduler`'s errors
@@ -887,32 +887,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
@@ -921,47 +921,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 `Identity`'s errors
@@ -970,137 +970,137 @@ 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;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Proxy`'s errors
@@ -1109,47 +1109,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
@@ -1158,77 +1158,77 @@ 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 when attempting to cancel.
      **/
-    NotFound: GenericPalletError<Rv>;
+    NotFound: GenericPalletError;
 
     /**
      * Only the account that originally created the multisig is able to cancel it.
      **/
-    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
@@ -1237,82 +1237,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 `Bounties`'s errors
@@ -1321,63 +1321,63 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Proposer's balance is too low.
      **/
-    InsufficientProposersBalance: GenericPalletError<Rv>;
+    InsufficientProposersBalance: GenericPalletError;
 
     /**
      * No proposal or bounty at that index.
      **/
-    InvalidIndex: GenericPalletError<Rv>;
+    InvalidIndex: GenericPalletError;
 
     /**
      * The reason given is just too big.
      **/
-    ReasonTooBig: GenericPalletError<Rv>;
+    ReasonTooBig: GenericPalletError;
 
     /**
      * The bounty status is unexpected.
      **/
-    UnexpectedStatus: GenericPalletError<Rv>;
+    UnexpectedStatus: GenericPalletError;
 
     /**
      * Require bounty curator.
      **/
-    RequireCurator: GenericPalletError<Rv>;
+    RequireCurator: GenericPalletError;
 
     /**
      * Invalid bounty value.
      **/
-    InvalidValue: GenericPalletError<Rv>;
+    InvalidValue: GenericPalletError;
 
     /**
      * Invalid bounty fee.
      **/
-    InvalidFee: GenericPalletError<Rv>;
+    InvalidFee: GenericPalletError;
 
     /**
      * A bounty payout is pending.
      * To cancel the bounty, you must unassign and slash the curator.
      **/
-    PendingPayout: GenericPalletError<Rv>;
+    PendingPayout: GenericPalletError;
 
     /**
      * The bounties cannot be claimed/closed because it's still in the countdown period.
      **/
-    Premature: GenericPalletError<Rv>;
+    Premature: GenericPalletError;
 
     /**
      * The bounty cannot be closed because it has active child bounties.
      **/
-    HasActiveChildBounty: GenericPalletError<Rv>;
+    HasActiveChildBounty: GenericPalletError;
 
     /**
      * Too many approvals are already queued.
      **/
-    TooManyQueued: GenericPalletError<Rv>;
+    TooManyQueued: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `ChildBounties`'s errors
@@ -1386,22 +1386,22 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The parent bounty is not in active state.
      **/
-    ParentBountyNotActive: GenericPalletError<Rv>;
+    ParentBountyNotActive: GenericPalletError;
 
     /**
      * The bounty balance is not enough to add new child-bounty.
      **/
-    InsufficientBountyBalance: GenericPalletError<Rv>;
+    InsufficientBountyBalance: GenericPalletError;
 
     /**
      * Number of child bounties exceeds limit `MaxActiveChildBountyCount`.
      **/
-    TooManyChildBounties: GenericPalletError<Rv>;
+    TooManyChildBounties: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `NominationPools`'s errors
@@ -1410,44 +1410,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.
@@ -1456,164 +1456,164 @@ 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 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;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `GearProgram`'s errors
    **/
   gearProgram: {
-    DuplicateItem: GenericPalletError<Rv>;
-    ProgramNotFound: GenericPalletError<Rv>;
-    NotActiveProgram: GenericPalletError<Rv>;
-    CannotFindDataForPage: GenericPalletError<Rv>;
-    ProgramCodeNotFound: GenericPalletError<Rv>;
+    DuplicateItem: GenericPalletError;
+    ProgramNotFound: GenericPalletError;
+    NotActiveProgram: GenericPalletError;
+    CannotFindDataForPage: GenericPalletError;
+    ProgramCodeNotFound: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `GearMessenger`'s errors
@@ -1622,73 +1622,73 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Occurs when given key already exists in queue.
      **/
-    QueueDuplicateKey: GenericPalletError<Rv>;
+    QueueDuplicateKey: GenericPalletError;
 
     /**
      * Occurs when queue's element wasn't found in storage.
      **/
-    QueueElementNotFound: GenericPalletError<Rv>;
+    QueueElementNotFound: GenericPalletError;
 
     /**
      * Occurs when queue's head should contain value,
      * but it's empty for some reason.
      **/
-    QueueHeadShouldBeSet: GenericPalletError<Rv>;
+    QueueHeadShouldBeSet: GenericPalletError;
 
     /**
      * Occurs when queue's head should be empty,
      * but it contains value for some reason.
      **/
-    QueueHeadShouldNotBeSet: GenericPalletError<Rv>;
+    QueueHeadShouldNotBeSet: GenericPalletError;
 
     /**
      * Occurs when queue's tail element contains link
      * to the next element.
      **/
-    QueueTailHasNextKey: GenericPalletError<Rv>;
+    QueueTailHasNextKey: GenericPalletError;
 
     /**
      * Occurs when while searching queue's pre-tail,
      * element wasn't found.
      **/
-    QueueTailParentNotFound: GenericPalletError<Rv>;
+    QueueTailParentNotFound: GenericPalletError;
 
     /**
      * Occurs when queue's tail should contain value,
      * but it's empty for some reason.
      **/
-    QueueTailShouldBeSet: GenericPalletError<Rv>;
+    QueueTailShouldBeSet: GenericPalletError;
 
     /**
      * Occurs when queue's tail should be empty,
      * but it contains value for some reason.
      **/
-    QueueTailShouldNotBeSet: GenericPalletError<Rv>;
+    QueueTailShouldNotBeSet: GenericPalletError;
 
     /**
      * Occurs when given value already exists in mailbox.
      **/
-    MailboxDuplicateKey: GenericPalletError<Rv>;
+    MailboxDuplicateKey: GenericPalletError;
 
     /**
      * Occurs when mailbox's element wasn't found in storage.
      **/
-    MailboxElementNotFound: GenericPalletError<Rv>;
+    MailboxElementNotFound: GenericPalletError;
 
     /**
      * Occurs when given value already exists in waitlist.
      **/
-    WaitlistDuplicateKey: GenericPalletError<Rv>;
+    WaitlistDuplicateKey: GenericPalletError;
 
     /**
      * Occurs when waitlist's element wasn't found in storage.
      **/
-    WaitlistElementNotFound: GenericPalletError<Rv>;
+    WaitlistElementNotFound: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `GearScheduler`'s errors
@@ -1697,33 +1697,33 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Occurs when given task already exists in task pool.
      **/
-    DuplicateTask: GenericPalletError<Rv>;
+    DuplicateTask: GenericPalletError;
 
     /**
      * Occurs when task wasn't found in storage.
      **/
-    TaskNotFound: GenericPalletError<Rv>;
+    TaskNotFound: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `GearGas`'s errors
    **/
   gearGas: {
-    Forbidden: GenericPalletError<Rv>;
-    NodeAlreadyExists: GenericPalletError<Rv>;
-    InsufficientBalance: GenericPalletError<Rv>;
-    NodeNotFound: GenericPalletError<Rv>;
-    NodeWasConsumed: GenericPalletError<Rv>;
+    Forbidden: GenericPalletError;
+    NodeAlreadyExists: GenericPalletError;
+    InsufficientBalance: GenericPalletError;
+    NodeNotFound: GenericPalletError;
+    NodeWasConsumed: GenericPalletError;
 
     /**
      * Errors stating that gas tree has been invalidated
      **/
-    ParentIsLost: GenericPalletError<Rv>;
-    ParentHasNoChildren: GenericPalletError<Rv>;
+    ParentIsLost: GenericPalletError;
+    ParentHasNoChildren: GenericPalletError;
 
     /**
      * Output of `Tree::consume` procedure that wasn't expected.
@@ -1732,54 +1732,54 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * when unexpected one occurred. That signals, that algorithm works wrong
      * and expected invariants are not correct.
      **/
-    UnexpectedConsumeOutput: GenericPalletError<Rv>;
+    UnexpectedConsumeOutput: GenericPalletError;
 
     /**
      * Node type that can't occur if algorithm work well
      **/
-    UnexpectedNodeType: GenericPalletError<Rv>;
+    UnexpectedNodeType: GenericPalletError;
 
     /**
      * Value must have been caught, but was missed or blocked (for more info see `ValueNode::catch_value`).
      **/
-    ValueIsNotCaught: GenericPalletError<Rv>;
+    ValueIsNotCaught: GenericPalletError;
 
     /**
      * Value must have been caught or moved upstream, but was blocked (for more info see `ValueNode::catch_value`).
      **/
-    ValueIsBlocked: GenericPalletError<Rv>;
+    ValueIsBlocked: GenericPalletError;
 
     /**
      * Value must have been blocked, but was either moved or caught (for more info see `ValueNode::catch_value`).
      **/
-    ValueIsNotBlocked: GenericPalletError<Rv>;
+    ValueIsNotBlocked: GenericPalletError;
 
     /**
      * `GasTree::consume` called on node, which has some balance locked.
      **/
-    ConsumedWithLock: GenericPalletError<Rv>;
+    ConsumedWithLock: GenericPalletError;
 
     /**
      * `GasTree::consume` called on node, which has some system reservation.
      **/
-    ConsumedWithSystemReservation: GenericPalletError<Rv>;
+    ConsumedWithSystemReservation: GenericPalletError;
 
     /**
      * `GasTree::create` called with some value amount leading to
      * the total value overflow.
      **/
-    TotalValueIsOverflowed: GenericPalletError<Rv>;
+    TotalValueIsOverflowed: GenericPalletError;
 
     /**
      * Either `GasTree::consume` or `GasTree::spent` called on a node creating
      * negative imbalance which leads to the total value drop below 0.
      **/
-    TotalValueIsUnderflowed: GenericPalletError<Rv>;
+    TotalValueIsUnderflowed: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `Gear`'s errors
@@ -1788,102 +1788,102 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Message wasn't found in the mailbox.
      **/
-    MessageNotFound: GenericPalletError<Rv>;
+    MessageNotFound: GenericPalletError;
 
     /**
      * Not enough balance to execute an action.
      *
      * Usually occurs when the gas_limit specified is such that the origin account can't afford the message.
      **/
-    InsufficientBalance: GenericPalletError<Rv>;
+    InsufficientBalance: GenericPalletError;
 
     /**
      * Gas limit too high.
      *
      * Occurs when an extrinsic's declared `gas_limit` is greater than a block's maximum gas limit.
      **/
-    GasLimitTooHigh: GenericPalletError<Rv>;
+    GasLimitTooHigh: GenericPalletError;
 
     /**
      * Program already exists.
      *
      * Occurs if a program with some specific program id already exists in program storage.
      **/
-    ProgramAlreadyExists: GenericPalletError<Rv>;
+    ProgramAlreadyExists: GenericPalletError;
 
     /**
      * Program is terminated.
      *
      * Program init failed, so such message destination is no longer unavailable.
      **/
-    InactiveProgram: GenericPalletError<Rv>;
+    InactiveProgram: GenericPalletError;
 
     /**
      * Message gas tree is not found.
      *
      * When a message claimed from the mailbox has a corrupted or non-extant gas tree associated.
      **/
-    NoMessageTree: GenericPalletError<Rv>;
+    NoMessageTree: GenericPalletError;
 
     /**
      * Code already exists.
      *
      * Occurs when trying to save to storage a program code that has been saved there.
      **/
-    CodeAlreadyExists: GenericPalletError<Rv>;
+    CodeAlreadyExists: GenericPalletError;
 
     /**
      * Code does not exist.
      *
      * Occurs when trying to get a program code from storage, that doesn't exist.
      **/
-    CodeDoesntExist: GenericPalletError<Rv>;
+    CodeDoesntExist: GenericPalletError;
 
     /**
      * The code supplied to `upload_code` or `upload_program` exceeds the limit specified in the
      * current schedule.
      **/
-    CodeTooLarge: GenericPalletError<Rv>;
+    CodeTooLarge: GenericPalletError;
 
     /**
      * Failed to create a program.
      **/
-    ProgramConstructionFailed: GenericPalletError<Rv>;
+    ProgramConstructionFailed: GenericPalletError;
 
     /**
      * Message queue processing is disabled.
      **/
-    MessageQueueProcessingDisabled: GenericPalletError<Rv>;
+    MessageQueueProcessingDisabled: GenericPalletError;
 
     /**
      * Block count doesn't cover MinimalResumePeriod.
      **/
-    ResumePeriodLessThanMinimal: GenericPalletError<Rv>;
+    ResumePeriodLessThanMinimal: GenericPalletError;
 
     /**
      * Program with the specified id is not found.
      **/
-    ProgramNotFound: GenericPalletError<Rv>;
+    ProgramNotFound: GenericPalletError;
 
     /**
      * Gear::run() already included in current block.
      **/
-    GearRunAlreadyInBlock: GenericPalletError<Rv>;
+    GearRunAlreadyInBlock: GenericPalletError;
 
     /**
      * The program rent logic is disabled.
      **/
-    ProgramRentDisabled: GenericPalletError<Rv>;
+    ProgramRentDisabled: GenericPalletError;
 
     /**
      * Program is active.
      **/
-    ActiveProgram: GenericPalletError<Rv>;
+    ActiveProgram: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `StakingRewards`'s errors
@@ -1892,17 +1892,17 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Pool not replenished due to error.
      **/
-    FailureToRefillPool: GenericPalletError<Rv>;
+    FailureToRefillPool: GenericPalletError;
 
     /**
      * Failure to withdraw funds from the rewards pool.
      **/
-    FailureToWithdrawFromPool: GenericPalletError<Rv>;
+    FailureToWithdrawFromPool: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `GearVoucher`'s errors
@@ -1911,62 +1911,62 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * The origin is not eligible to execute call.
      **/
-    BadOrigin: GenericPalletError<Rv>;
+    BadOrigin: GenericPalletError;
 
     /**
      * Error trying transfer balance to/from voucher account.
      **/
-    BalanceTransfer: GenericPalletError<Rv>;
+    BalanceTransfer: GenericPalletError;
 
     /**
      * Destination program is not in whitelisted set for voucher.
      **/
-    InappropriateDestination: GenericPalletError<Rv>;
+    InappropriateDestination: GenericPalletError;
 
     /**
      * Voucher with given identifier doesn't exist for given spender id.
      **/
-    InexistentVoucher: GenericPalletError<Rv>;
+    InexistentVoucher: GenericPalletError;
 
     /**
      * Voucher still valid and couldn't be revoked.
      **/
-    IrrevocableYet: GenericPalletError<Rv>;
+    IrrevocableYet: GenericPalletError;
 
     /**
      * Try to whitelist more programs than allowed.
      **/
-    MaxProgramsLimitExceeded: GenericPalletError<Rv>;
+    MaxProgramsLimitExceeded: GenericPalletError;
 
     /**
      * Failed to query destination of the prepaid call.
      **/
-    UnknownDestination: GenericPalletError<Rv>;
+    UnknownDestination: GenericPalletError;
 
     /**
      * Voucher has expired and couldn't be used.
      **/
-    VoucherExpired: GenericPalletError<Rv>;
+    VoucherExpired: GenericPalletError;
 
     /**
      * Voucher issue/prolongation duration out of [min; max] constants.
      **/
-    DurationOutOfBounds: GenericPalletError<Rv>;
+    DurationOutOfBounds: GenericPalletError;
 
     /**
      * Voucher update function tries to cut voucher ability of code upload.
      **/
-    CodeUploadingEnabled: GenericPalletError<Rv>;
+    CodeUploadingEnabled: GenericPalletError;
 
     /**
      * Voucher is disabled for code uploading, but requested.
      **/
-    CodeUploadingDisabled: GenericPalletError<Rv>;
+    CodeUploadingDisabled: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `GearBank`'s errors
@@ -1975,40 +1975,40 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
     /**
      * Insufficient user balance.
      **/
-    InsufficientBalance: GenericPalletError<Rv>;
+    InsufficientBalance: GenericPalletError;
 
     /**
      * Insufficient user's bank account gas balance.
      **/
-    InsufficientGasBalance: GenericPalletError<Rv>;
+    InsufficientGasBalance: GenericPalletError;
 
     /**
      * Insufficient user's bank account gas balance.
      **/
-    InsufficientValueBalance: GenericPalletError<Rv>;
+    InsufficientValueBalance: GenericPalletError;
 
     /**
      * Insufficient bank account balance.
      * **Must be unreachable in Gear main protocol.**
      **/
-    InsufficientBankBalance: GenericPalletError<Rv>;
+    InsufficientBankBalance: GenericPalletError;
 
     /**
      * Deposit of funds that will not keep bank account alive.
      * **Must be unreachable in Gear main protocol.**
      **/
-    InsufficientDeposit: GenericPalletError<Rv>;
+    InsufficientDeposit: GenericPalletError;
 
     /**
      * Overflow during funds transfer.
      * **Must be unreachable in Gear main protocol.**
      **/
-    Overflow: GenericPalletError<Rv>;
+    Overflow: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
   };
   /**
    * Pallet `GearEthBridge`'s errors
@@ -2018,39 +2018,59 @@ export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<R
      * The error happens when bridge queue is temporarily overflowed
      * and needs cleanup to proceed.
      **/
-    BridgeCleanupRequired: GenericPalletError<Rv>;
+    BridgeCleanupRequired: GenericPalletError;
 
     /**
      * The error happens when bridge got called before
      * proper initialization after deployment.
      **/
-    BridgeIsNotYetInitialized: GenericPalletError<Rv>;
+    BridgeIsNotYetInitialized: GenericPalletError;
 
     /**
      * The error happens when bridge got called when paused.
      **/
-    BridgeIsPaused: GenericPalletError<Rv>;
+    BridgeIsPaused: GenericPalletError;
 
     /**
      * The error happens when bridging message sent with too big payload.
      **/
-    MaxPayloadSizeExceeded: GenericPalletError<Rv>;
+    MaxPayloadSizeExceeded: GenericPalletError;
 
     /**
      * The error happens when bridging thorough builtin and message value
      * is inapplicable to operation or insufficient.
      **/
-    InsufficientValueApplied: GenericPalletError<Rv>;
+    InsufficientValueApplied: GenericPalletError;
 
     /**
      * The error happens when attempted to reset overflowed queue, but
      * queue isn't overflowed or incorrect finality proof provided.
      **/
-    InvalidQueueReset: GenericPalletError<Rv>;
+    InvalidQueueReset: GenericPalletError;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError<Rv>;
+    [error: string]: GenericPalletError;
+  };
+  /**
+   * Pallet `GrandpaSigner`'s errors
+   **/
+  grandpaSigner: {
+    TooManyRequests: GenericPalletError;
+    RequestIdExhausted: GenericPalletError;
+    UnknownRequest: GenericPalletError;
+    RequestExpired: GenericPalletError;
+    AuthorityNotInSet: GenericPalletError;
+    AlreadySigned: GenericPalletError;
+    BadSignature: GenericPalletError;
+    UnsupportedSet: GenericPalletError;
+    PayloadTooLong: GenericPalletError;
+    MaxSignaturesReached: GenericPalletError;
+
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError;
   };
 }