@dedot/chaintypes 0.0.1-next.f5bf4fc2.1 → 0.1.0

package/rococo/errors.d.ts

@@ -1,8 +1,8 @@
-// Generated by @dedot/codegen
+// Generated by dedot cli
 
-import type { GenericChainErrors, GenericPalletError } from '@dedot/types';
+import type { GenericChainErrors, GenericPalletError, RpcVersion } from 'dedot/types';
 
-export interface ChainErrors extends GenericChainErrors {
+export interface ChainErrors<Rv extends RpcVersion> extends GenericChainErrors<Rv> {
   /**
    * Pallet `System`'s errors
    **/
@@ -11,50 +11,55 @@ export interface ChainErrors extends GenericChainErrors {
      * The name of specification does not match between the current runtime
      * and the new runtime.
      **/
-    InvalidSpecName: GenericPalletError;
+    InvalidSpecName: GenericPalletError<Rv>;
 
     /**
      * The specification version is not allowed to decrease between the current runtime
      * and the new runtime.
      **/
-    SpecVersionNeedsToIncrease: GenericPalletError;
+    SpecVersionNeedsToIncrease: GenericPalletError<Rv>;
 
     /**
      * Failed to extract the runtime version from the new runtime.
      *
      * Either calling `Core_version` or decoding `RuntimeVersion` failed.
      **/
-    FailedToExtractRuntimeVersion: GenericPalletError;
+    FailedToExtractRuntimeVersion: GenericPalletError<Rv>;
 
     /**
      * Suicide called when the account has non-default composite data.
      **/
-    NonDefaultComposite: GenericPalletError;
+    NonDefaultComposite: GenericPalletError<Rv>;
 
     /**
      * There is a non-zero reference count preventing the account from being purged.
      **/
-    NonZeroRefCount: GenericPalletError;
+    NonZeroRefCount: GenericPalletError<Rv>;
 
     /**
      * The origin filter prevent the call to be dispatched.
      **/
-    CallFiltered: GenericPalletError;
+    CallFiltered: GenericPalletError<Rv>;
+
+    /**
+     * A multi-block migration is ongoing and prevents the current code from being replaced.
+     **/
+    MultiBlockMigrationsOngoing: GenericPalletError<Rv>;
 
     /**
      * No upgrade authorized.
      **/
-    NothingAuthorized: GenericPalletError;
+    NothingAuthorized: GenericPalletError<Rv>;
 
     /**
      * The submitted code is not authorized.
      **/
-    Unauthorized: GenericPalletError;
+    Unauthorized: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Babe`'s errors
@@ -63,27 +68,27 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * An equivocation proof provided as part of an equivocation report is invalid.
      **/
-    InvalidEquivocationProof: GenericPalletError;
+    InvalidEquivocationProof: GenericPalletError<Rv>;
 
     /**
      * A key ownership proof provided as part of an equivocation report is invalid.
      **/
-    InvalidKeyOwnershipProof: GenericPalletError;
+    InvalidKeyOwnershipProof: GenericPalletError<Rv>;
 
     /**
      * A given equivocation report is valid but already previously reported.
      **/
-    DuplicateOffenceReport: GenericPalletError;
+    DuplicateOffenceReport: GenericPalletError<Rv>;
 
     /**
      * Submitted configuration is invalid.
      **/
-    InvalidConfiguration: GenericPalletError;
+    InvalidConfiguration: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Indices`'s errors
@@ -92,32 +97,32 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The index was not already assigned.
      **/
-    NotAssigned: GenericPalletError;
+    NotAssigned: GenericPalletError<Rv>;
 
     /**
      * The index is assigned to another account.
      **/
-    NotOwner: GenericPalletError;
+    NotOwner: GenericPalletError<Rv>;
 
     /**
      * The index was not available.
      **/
-    InUse: GenericPalletError;
+    InUse: GenericPalletError<Rv>;
 
     /**
      * The source and destination accounts are identical.
      **/
-    NotTransfer: GenericPalletError;
+    NotTransfer: GenericPalletError<Rv>;
 
     /**
      * The index is permanent and may not be freed/changed.
      **/
-    Permanent: GenericPalletError;
+    Permanent: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Balances`'s errors
@@ -126,67 +131,67 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Vesting balance too high to send value.
      **/
-    VestingBalance: GenericPalletError;
+    VestingBalance: GenericPalletError<Rv>;
 
     /**
      * Account liquidity restrictions prevent withdrawal.
      **/
-    LiquidityRestrictions: GenericPalletError;
+    LiquidityRestrictions: GenericPalletError<Rv>;
 
     /**
      * Balance too low to send value.
      **/
-    InsufficientBalance: GenericPalletError;
+    InsufficientBalance: GenericPalletError<Rv>;
 
     /**
      * Value too low to create account due to existential deposit.
      **/
-    ExistentialDeposit: GenericPalletError;
+    ExistentialDeposit: GenericPalletError<Rv>;
 
     /**
      * Transfer/payment would kill account.
      **/
-    Expendability: GenericPalletError;
+    Expendability: GenericPalletError<Rv>;
 
     /**
      * A vesting schedule already exists for this account.
      **/
-    ExistingVestingSchedule: GenericPalletError;
+    ExistingVestingSchedule: GenericPalletError<Rv>;
 
     /**
      * Beneficiary account must pre-exist.
      **/
-    DeadAccount: GenericPalletError;
+    DeadAccount: GenericPalletError<Rv>;
 
     /**
      * Number of named reserves exceed `MaxReserves`.
      **/
-    TooManyReserves: GenericPalletError;
+    TooManyReserves: GenericPalletError<Rv>;
 
     /**
      * Number of holds exceed `VariantCountOf<T::RuntimeHoldReason>`.
      **/
-    TooManyHolds: GenericPalletError;
+    TooManyHolds: GenericPalletError<Rv>;
 
     /**
      * Number of freezes exceed `MaxFreezes`.
      **/
-    TooManyFreezes: GenericPalletError;
+    TooManyFreezes: GenericPalletError<Rv>;
 
     /**
      * The issuance cannot be modified since it is already deactivated.
      **/
-    IssuanceDeactivated: GenericPalletError;
+    IssuanceDeactivated: GenericPalletError<Rv>;
 
     /**
      * The delta cannot be zero.
      **/
-    DeltaZero: GenericPalletError;
+    DeltaZero: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Session`'s errors
@@ -195,32 +200,32 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Invalid ownership proof.
      **/
-    InvalidProof: GenericPalletError;
+    InvalidProof: GenericPalletError<Rv>;
 
     /**
      * No associated validator ID for account.
      **/
-    NoAssociatedValidatorId: GenericPalletError;
+    NoAssociatedValidatorId: GenericPalletError<Rv>;
 
     /**
      * Registered duplicate key.
      **/
-    DuplicatedKey: GenericPalletError;
+    DuplicatedKey: GenericPalletError<Rv>;
 
     /**
      * No keys are associated with this account.
      **/
-    NoKeys: GenericPalletError;
+    NoKeys: GenericPalletError<Rv>;
 
     /**
      * Key setting account is not live, so it's impossible to associate keys.
      **/
-    NoAccount: GenericPalletError;
+    NoAccount: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Grandpa`'s errors
@@ -230,113 +235,108 @@ export interface ChainErrors extends GenericChainErrors {
      * Attempt to signal GRANDPA pause when the authority set isn't live
      * (either paused or already pending pause).
      **/
-    PauseFailed: GenericPalletError;
+    PauseFailed: GenericPalletError<Rv>;
 
     /**
      * Attempt to signal GRANDPA resume when the authority set isn't paused
      * (either live or already pending resume).
      **/
-    ResumeFailed: GenericPalletError;
+    ResumeFailed: GenericPalletError<Rv>;
 
     /**
      * Attempt to signal GRANDPA change with one already pending.
      **/
-    ChangePending: GenericPalletError;
+    ChangePending: GenericPalletError<Rv>;
 
     /**
      * Cannot signal forced change so soon after last.
      **/
-    TooSoon: GenericPalletError;
+    TooSoon: GenericPalletError<Rv>;
 
     /**
      * A key ownership proof provided as part of an equivocation report is invalid.
      **/
-    InvalidKeyOwnershipProof: GenericPalletError;
+    InvalidKeyOwnershipProof: GenericPalletError<Rv>;
 
     /**
      * An equivocation proof provided as part of an equivocation report is invalid.
      **/
-    InvalidEquivocationProof: GenericPalletError;
+    InvalidEquivocationProof: GenericPalletError<Rv>;
 
     /**
      * A given equivocation report is valid but already previously reported.
      **/
-    DuplicateOffenceReport: GenericPalletError;
+    DuplicateOffenceReport: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Treasury`'s errors
    **/
   treasury: {
-    /**
-     * Proposer's balance is too low.
-     **/
-    InsufficientProposersBalance: GenericPalletError;
-
     /**
      * No proposal, bounty or spend at that index.
      **/
-    InvalidIndex: GenericPalletError;
+    InvalidIndex: GenericPalletError<Rv>;
 
     /**
      * Too many approvals in the queue.
      **/
-    TooManyApprovals: GenericPalletError;
+    TooManyApprovals: GenericPalletError<Rv>;
 
     /**
      * The spend origin is valid but the amount it is allowed to spend is lower than the
      * amount to be spent.
      **/
-    InsufficientPermission: GenericPalletError;
+    InsufficientPermission: GenericPalletError<Rv>;
 
     /**
      * Proposal has not been approved.
      **/
-    ProposalNotApproved: GenericPalletError;
+    ProposalNotApproved: GenericPalletError<Rv>;
 
     /**
      * The balance of the asset kind is not convertible to the balance of the native asset.
      **/
-    FailedToConvertBalance: GenericPalletError;
+    FailedToConvertBalance: GenericPalletError<Rv>;
 
     /**
      * The spend has expired and cannot be claimed.
      **/
-    SpendExpired: GenericPalletError;
+    SpendExpired: GenericPalletError<Rv>;
 
     /**
      * The spend is not yet eligible for payout.
      **/
-    EarlyPayout: GenericPalletError;
+    EarlyPayout: GenericPalletError<Rv>;
 
     /**
      * The payment has already been attempted.
      **/
-    AlreadyAttempted: GenericPalletError;
+    AlreadyAttempted: GenericPalletError<Rv>;
 
     /**
      * There was some issue with the mechanism of payment.
      **/
-    PayoutError: GenericPalletError;
+    PayoutError: GenericPalletError<Rv>;
 
     /**
      * The payout was not yet attempted/claimed.
      **/
-    NotAttempted: GenericPalletError;
+    NotAttempted: GenericPalletError<Rv>;
 
     /**
      * The payment has neither failed nor succeeded yet.
      **/
-    Inconclusive: GenericPalletError;
+    Inconclusive: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `ConvictionVoting`'s errors
@@ -345,68 +345,68 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Poll is not ongoing.
      **/
-    NotOngoing: GenericPalletError;
+    NotOngoing: GenericPalletError<Rv>;
 
     /**
      * The given account did not vote on the poll.
      **/
-    NotVoter: GenericPalletError;
+    NotVoter: GenericPalletError<Rv>;
 
     /**
      * The actor has no permission to conduct the action.
      **/
-    NoPermission: GenericPalletError;
+    NoPermission: GenericPalletError<Rv>;
 
     /**
      * The actor has no permission to conduct the action right now but will do in the future.
      **/
-    NoPermissionYet: GenericPalletError;
+    NoPermissionYet: GenericPalletError<Rv>;
 
     /**
      * The account is already delegating.
      **/
-    AlreadyDelegating: GenericPalletError;
+    AlreadyDelegating: GenericPalletError<Rv>;
 
     /**
      * The account currently has votes attached to it and the operation cannot succeed until
      * these are removed through `remove_vote`.
      **/
-    AlreadyVoting: GenericPalletError;
+    AlreadyVoting: GenericPalletError<Rv>;
 
     /**
      * Too high a balance was provided that the account cannot afford.
      **/
-    InsufficientFunds: GenericPalletError;
+    InsufficientFunds: GenericPalletError<Rv>;
 
     /**
      * The account is not currently delegating.
      **/
-    NotDelegating: GenericPalletError;
+    NotDelegating: GenericPalletError<Rv>;
 
     /**
      * Delegation to oneself makes no sense.
      **/
-    Nonsense: GenericPalletError;
+    Nonsense: GenericPalletError<Rv>;
 
     /**
      * Maximum number of votes reached.
      **/
-    MaxVotesReached: GenericPalletError;
+    MaxVotesReached: GenericPalletError<Rv>;
 
     /**
      * The class must be supplied since it is not easily determinable from the state.
      **/
-    ClassNeeded: GenericPalletError;
+    ClassNeeded: GenericPalletError<Rv>;
 
     /**
      * The class ID supplied is invalid.
      **/
-    BadClass: GenericPalletError;
+    BadClass: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Referenda`'s errors
@@ -415,72 +415,77 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Referendum is not ongoing.
      **/
-    NotOngoing: GenericPalletError;
+    NotOngoing: GenericPalletError<Rv>;
 
     /**
      * Referendum's decision deposit is already paid.
      **/
-    HasDeposit: GenericPalletError;
+    HasDeposit: GenericPalletError<Rv>;
 
     /**
      * The track identifier given was invalid.
      **/
-    BadTrack: GenericPalletError;
+    BadTrack: GenericPalletError<Rv>;
 
     /**
      * There are already a full complement of referenda in progress for this track.
      **/
-    Full: GenericPalletError;
+    Full: GenericPalletError<Rv>;
 
     /**
      * The queue of the track is empty.
      **/
-    QueueEmpty: GenericPalletError;
+    QueueEmpty: GenericPalletError<Rv>;
 
     /**
      * The referendum index provided is invalid in this context.
      **/
-    BadReferendum: GenericPalletError;
+    BadReferendum: GenericPalletError<Rv>;
 
     /**
      * There was nothing to do in the advancement.
      **/
-    NothingToDo: GenericPalletError;
+    NothingToDo: GenericPalletError<Rv>;
 
     /**
      * No track exists for the proposal origin.
      **/
-    NoTrack: GenericPalletError;
+    NoTrack: GenericPalletError<Rv>;
 
     /**
      * Any deposit cannot be refunded until after the decision is over.
      **/
-    Unfinished: GenericPalletError;
+    Unfinished: GenericPalletError<Rv>;
 
     /**
      * The deposit refunder is not the depositor.
      **/
-    NoPermission: GenericPalletError;
+    NoPermission: GenericPalletError<Rv>;
 
     /**
      * The deposit cannot be refunded since none was made.
      **/
-    NoDeposit: GenericPalletError;
+    NoDeposit: GenericPalletError<Rv>;
 
     /**
      * The referendum status is invalid for this operation.
      **/
-    BadStatus: GenericPalletError;
+    BadStatus: GenericPalletError<Rv>;
 
     /**
      * The preimage does not exist.
      **/
-    PreimageNotExist: GenericPalletError;
+    PreimageNotExist: GenericPalletError<Rv>;
+
+    /**
+     * The preimage is stored with a different length than the one provided.
+     **/
+    PreimageStoredWithDifferentLength: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `FellowshipCollective`'s errors
@@ -489,57 +494,62 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Account is already a member.
      **/
-    AlreadyMember: GenericPalletError;
+    AlreadyMember: GenericPalletError<Rv>;
 
     /**
      * Account is not a member.
      **/
-    NotMember: GenericPalletError;
+    NotMember: GenericPalletError<Rv>;
 
     /**
      * The given poll index is unknown or has closed.
      **/
-    NotPolling: GenericPalletError;
+    NotPolling: GenericPalletError<Rv>;
 
     /**
      * The given poll is still ongoing.
      **/
-    Ongoing: GenericPalletError;
+    Ongoing: GenericPalletError<Rv>;
 
     /**
      * There are no further records to be removed.
      **/
-    NoneRemaining: GenericPalletError;
+    NoneRemaining: GenericPalletError<Rv>;
 
     /**
      * Unexpected error in state.
      **/
-    Corruption: GenericPalletError;
+    Corruption: GenericPalletError<Rv>;
 
     /**
      * The member's rank is too low to vote.
      **/
-    RankTooLow: GenericPalletError;
+    RankTooLow: GenericPalletError<Rv>;
 
     /**
      * The information provided is incorrect.
      **/
-    InvalidWitness: GenericPalletError;
+    InvalidWitness: GenericPalletError<Rv>;
 
     /**
      * The origin is not sufficiently privileged to do the operation.
      **/
-    NoPermission: GenericPalletError;
+    NoPermission: GenericPalletError<Rv>;
 
     /**
      * The new member to exchange is the same as the old member
      **/
-    SameMember: GenericPalletError;
+    SameMember: GenericPalletError<Rv>;
+
+    /**
+     * The max member count for the rank has been reached.
+     **/
+    TooManyMembers: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `FellowshipReferenda`'s errors
@@ -548,72 +558,77 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Referendum is not ongoing.
      **/
-    NotOngoing: GenericPalletError;
+    NotOngoing: GenericPalletError<Rv>;
 
     /**
      * Referendum's decision deposit is already paid.
      **/
-    HasDeposit: GenericPalletError;
+    HasDeposit: GenericPalletError<Rv>;
 
     /**
      * The track identifier given was invalid.
      **/
-    BadTrack: GenericPalletError;
+    BadTrack: GenericPalletError<Rv>;
 
     /**
      * There are already a full complement of referenda in progress for this track.
      **/
-    Full: GenericPalletError;
+    Full: GenericPalletError<Rv>;
 
     /**
      * The queue of the track is empty.
      **/
-    QueueEmpty: GenericPalletError;
+    QueueEmpty: GenericPalletError<Rv>;
 
     /**
      * The referendum index provided is invalid in this context.
      **/
-    BadReferendum: GenericPalletError;
+    BadReferendum: GenericPalletError<Rv>;
 
     /**
      * There was nothing to do in the advancement.
      **/
-    NothingToDo: GenericPalletError;
+    NothingToDo: GenericPalletError<Rv>;
 
     /**
      * No track exists for the proposal origin.
      **/
-    NoTrack: GenericPalletError;
+    NoTrack: GenericPalletError<Rv>;
 
     /**
      * Any deposit cannot be refunded until after the decision is over.
      **/
-    Unfinished: GenericPalletError;
+    Unfinished: GenericPalletError<Rv>;
 
     /**
      * The deposit refunder is not the depositor.
      **/
-    NoPermission: GenericPalletError;
+    NoPermission: GenericPalletError<Rv>;
 
     /**
      * The deposit cannot be refunded since none was made.
      **/
-    NoDeposit: GenericPalletError;
+    NoDeposit: GenericPalletError<Rv>;
 
     /**
      * The referendum status is invalid for this operation.
      **/
-    BadStatus: GenericPalletError;
+    BadStatus: GenericPalletError<Rv>;
 
     /**
      * The preimage does not exist.
      **/
-    PreimageNotExist: GenericPalletError;
+    PreimageNotExist: GenericPalletError<Rv>;
+
+    /**
+     * The preimage is stored with a different length than the one provided.
+     **/
+    PreimageStoredWithDifferentLength: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Whitelist`'s errors
@@ -622,32 +637,32 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The preimage of the call hash could not be loaded.
      **/
-    UnavailablePreImage: GenericPalletError;
+    UnavailablePreImage: GenericPalletError<Rv>;
 
     /**
      * The call could not be decoded.
      **/
-    UndecodableCall: GenericPalletError;
+    UndecodableCall: GenericPalletError<Rv>;
 
     /**
      * The weight of the decoded call was higher than the witness.
      **/
-    InvalidCallWeightWitness: GenericPalletError;
+    InvalidCallWeightWitness: GenericPalletError<Rv>;
 
     /**
      * The call was not whitelisted.
      **/
-    CallIsNotWhitelisted: GenericPalletError;
+    CallIsNotWhitelisted: GenericPalletError<Rv>;
 
     /**
      * The call was already whitelisted; No-Op.
      **/
-    CallAlreadyWhitelisted: GenericPalletError;
+    CallAlreadyWhitelisted: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Claims`'s errors
@@ -656,38 +671,38 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Invalid Ethereum signature.
      **/
-    InvalidEthereumSignature: GenericPalletError;
+    InvalidEthereumSignature: GenericPalletError<Rv>;
 
     /**
      * Ethereum address has no claim.
      **/
-    SignerHasNoClaim: GenericPalletError;
+    SignerHasNoClaim: GenericPalletError<Rv>;
 
     /**
      * Account ID sending transaction has no claim.
      **/
-    SenderHasNoClaim: GenericPalletError;
+    SenderHasNoClaim: GenericPalletError<Rv>;
 
     /**
      * There's not enough in the pot to pay out some unvested amount. Generally implies a
      * logic error.
      **/
-    PotUnderflow: GenericPalletError;
+    PotUnderflow: GenericPalletError<Rv>;
 
     /**
      * A needed statement was not included.
      **/
-    InvalidStatement: GenericPalletError;
+    InvalidStatement: GenericPalletError<Rv>;
 
     /**
      * The account already has a vested balance.
      **/
-    VestedBalanceExists: GenericPalletError;
+    VestedBalanceExists: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Utility`'s errors
@@ -696,12 +711,12 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Too many calls batched.
      **/
-    TooManyCalls: GenericPalletError;
+    TooManyCalls: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Identity`'s errors
@@ -710,137 +725,137 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Too many subs-accounts.
      **/
-    TooManySubAccounts: GenericPalletError;
+    TooManySubAccounts: GenericPalletError<Rv>;
 
     /**
      * Account isn't found.
      **/
-    NotFound: GenericPalletError;
+    NotFound: GenericPalletError<Rv>;
 
     /**
      * Account isn't named.
      **/
-    NotNamed: GenericPalletError;
+    NotNamed: GenericPalletError<Rv>;
 
     /**
      * Empty index.
      **/
-    EmptyIndex: GenericPalletError;
+    EmptyIndex: GenericPalletError<Rv>;
 
     /**
      * Fee is changed.
      **/
-    FeeChanged: GenericPalletError;
+    FeeChanged: GenericPalletError<Rv>;
 
     /**
      * No identity found.
      **/
-    NoIdentity: GenericPalletError;
+    NoIdentity: GenericPalletError<Rv>;
 
     /**
      * Sticky judgement.
      **/
-    StickyJudgement: GenericPalletError;
+    StickyJudgement: GenericPalletError<Rv>;
 
     /**
      * Judgement given.
      **/
-    JudgementGiven: GenericPalletError;
+    JudgementGiven: GenericPalletError<Rv>;
 
     /**
      * Invalid judgement.
      **/
-    InvalidJudgement: GenericPalletError;
+    InvalidJudgement: GenericPalletError<Rv>;
 
     /**
      * The index is invalid.
      **/
-    InvalidIndex: GenericPalletError;
+    InvalidIndex: GenericPalletError<Rv>;
 
     /**
      * The target is invalid.
      **/
-    InvalidTarget: GenericPalletError;
+    InvalidTarget: GenericPalletError<Rv>;
 
     /**
      * Maximum amount of registrars reached. Cannot add any more.
      **/
-    TooManyRegistrars: GenericPalletError;
+    TooManyRegistrars: GenericPalletError<Rv>;
 
     /**
      * Account ID is already named.
      **/
-    AlreadyClaimed: GenericPalletError;
+    AlreadyClaimed: GenericPalletError<Rv>;
 
     /**
      * Sender is not a sub-account.
      **/
-    NotSub: GenericPalletError;
+    NotSub: GenericPalletError<Rv>;
 
     /**
      * Sub-account isn't owned by sender.
      **/
-    NotOwned: GenericPalletError;
+    NotOwned: GenericPalletError<Rv>;
 
     /**
      * The provided judgement was for a different identity.
      **/
-    JudgementForDifferentIdentity: GenericPalletError;
+    JudgementForDifferentIdentity: GenericPalletError<Rv>;
 
     /**
      * Error that occurs when there is an issue paying for judgement.
      **/
-    JudgementPaymentFailed: GenericPalletError;
+    JudgementPaymentFailed: GenericPalletError<Rv>;
 
     /**
      * The provided suffix is too long.
      **/
-    InvalidSuffix: GenericPalletError;
+    InvalidSuffix: GenericPalletError<Rv>;
 
     /**
      * The sender does not have permission to issue a username.
      **/
-    NotUsernameAuthority: GenericPalletError;
+    NotUsernameAuthority: GenericPalletError<Rv>;
 
     /**
      * The authority cannot allocate any more usernames.
      **/
-    NoAllocation: GenericPalletError;
+    NoAllocation: GenericPalletError<Rv>;
 
     /**
      * The signature on a username was not valid.
      **/
-    InvalidSignature: GenericPalletError;
+    InvalidSignature: GenericPalletError<Rv>;
 
     /**
      * Setting this username requires a signature, but none was provided.
      **/
-    RequiresSignature: GenericPalletError;
+    RequiresSignature: GenericPalletError<Rv>;
 
     /**
      * The username does not meet the requirements.
      **/
-    InvalidUsername: GenericPalletError;
+    InvalidUsername: GenericPalletError<Rv>;
 
     /**
      * The username is already taken.
      **/
-    UsernameTaken: GenericPalletError;
+    UsernameTaken: GenericPalletError<Rv>;
 
     /**
      * The requested username does not exist.
      **/
-    NoUsername: GenericPalletError;
+    NoUsername: GenericPalletError<Rv>;
 
     /**
      * The username cannot be forcefully removed because it can still be accepted.
      **/
-    NotExpired: GenericPalletError;
+    NotExpired: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Society`'s errors
@@ -849,167 +864,167 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * User is not a member.
      **/
-    NotMember: GenericPalletError;
+    NotMember: GenericPalletError<Rv>;
 
     /**
      * User is already a member.
      **/
-    AlreadyMember: GenericPalletError;
+    AlreadyMember: GenericPalletError<Rv>;
 
     /**
      * User is suspended.
      **/
-    Suspended: GenericPalletError;
+    Suspended: GenericPalletError<Rv>;
 
     /**
      * User is not suspended.
      **/
-    NotSuspended: GenericPalletError;
+    NotSuspended: GenericPalletError<Rv>;
 
     /**
      * Nothing to payout.
      **/
-    NoPayout: GenericPalletError;
+    NoPayout: GenericPalletError<Rv>;
 
     /**
      * Society already founded.
      **/
-    AlreadyFounded: GenericPalletError;
+    AlreadyFounded: GenericPalletError<Rv>;
 
     /**
      * Not enough in pot to accept candidate.
      **/
-    InsufficientPot: GenericPalletError;
+    InsufficientPot: GenericPalletError<Rv>;
 
     /**
      * Member is already vouching or banned from vouching again.
      **/
-    AlreadyVouching: GenericPalletError;
+    AlreadyVouching: GenericPalletError<Rv>;
 
     /**
      * Member is not vouching.
      **/
-    NotVouchingOnBidder: GenericPalletError;
+    NotVouchingOnBidder: GenericPalletError<Rv>;
 
     /**
      * Cannot remove the head of the chain.
      **/
-    Head: GenericPalletError;
+    Head: GenericPalletError<Rv>;
 
     /**
      * Cannot remove the founder.
      **/
-    Founder: GenericPalletError;
+    Founder: GenericPalletError<Rv>;
 
     /**
      * User has already made a bid.
      **/
-    AlreadyBid: GenericPalletError;
+    AlreadyBid: GenericPalletError<Rv>;
 
     /**
      * User is already a candidate.
      **/
-    AlreadyCandidate: GenericPalletError;
+    AlreadyCandidate: GenericPalletError<Rv>;
 
     /**
      * User is not a candidate.
      **/
-    NotCandidate: GenericPalletError;
+    NotCandidate: GenericPalletError<Rv>;
 
     /**
      * Too many members in the society.
      **/
-    MaxMembers: GenericPalletError;
+    MaxMembers: GenericPalletError<Rv>;
 
     /**
      * The caller is not the founder.
      **/
-    NotFounder: GenericPalletError;
+    NotFounder: GenericPalletError<Rv>;
 
     /**
      * The caller is not the head.
      **/
-    NotHead: GenericPalletError;
+    NotHead: GenericPalletError<Rv>;
 
     /**
      * The membership cannot be claimed as the candidate was not clearly approved.
      **/
-    NotApproved: GenericPalletError;
+    NotApproved: GenericPalletError<Rv>;
 
     /**
      * The candidate cannot be kicked as the candidate was not clearly rejected.
      **/
-    NotRejected: GenericPalletError;
+    NotRejected: GenericPalletError<Rv>;
 
     /**
      * The candidacy cannot be dropped as the candidate was clearly approved.
      **/
-    Approved: GenericPalletError;
+    Approved: GenericPalletError<Rv>;
 
     /**
      * The candidacy cannot be bestowed as the candidate was clearly rejected.
      **/
-    Rejected: GenericPalletError;
+    Rejected: GenericPalletError<Rv>;
 
     /**
      * The candidacy cannot be concluded as the voting is still in progress.
      **/
-    InProgress: GenericPalletError;
+    InProgress: GenericPalletError<Rv>;
 
     /**
      * The candidacy cannot be pruned until a full additional intake period has passed.
      **/
-    TooEarly: GenericPalletError;
+    TooEarly: GenericPalletError<Rv>;
 
     /**
      * The skeptic already voted.
      **/
-    Voted: GenericPalletError;
+    Voted: GenericPalletError<Rv>;
 
     /**
      * The skeptic need not vote on candidates from expired rounds.
      **/
-    Expired: GenericPalletError;
+    Expired: GenericPalletError<Rv>;
 
     /**
      * User is not a bidder.
      **/
-    NotBidder: GenericPalletError;
+    NotBidder: GenericPalletError<Rv>;
 
     /**
      * There is no defender currently.
      **/
-    NoDefender: GenericPalletError;
+    NoDefender: GenericPalletError<Rv>;
 
     /**
      * Group doesn't exist.
      **/
-    NotGroup: GenericPalletError;
+    NotGroup: GenericPalletError<Rv>;
 
     /**
      * The member is already elevated to this rank.
      **/
-    AlreadyElevated: GenericPalletError;
+    AlreadyElevated: GenericPalletError<Rv>;
 
     /**
      * The skeptic has already been punished for this offence.
      **/
-    AlreadyPunished: GenericPalletError;
+    AlreadyPunished: GenericPalletError<Rv>;
 
     /**
      * Funds are insufficient to pay off society debts.
      **/
-    InsufficientFunds: GenericPalletError;
+    InsufficientFunds: GenericPalletError<Rv>;
 
     /**
      * The candidate/defender has no stale votes to remove.
      **/
-    NoVotes: GenericPalletError;
+    NoVotes: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Recovery`'s errors
@@ -1018,87 +1033,87 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * User is not allowed to make a call on behalf of this account
      **/
-    NotAllowed: GenericPalletError;
+    NotAllowed: GenericPalletError<Rv>;
 
     /**
      * Threshold must be greater than zero
      **/
-    ZeroThreshold: GenericPalletError;
+    ZeroThreshold: GenericPalletError<Rv>;
 
     /**
      * Friends list must be greater than zero and threshold
      **/
-    NotEnoughFriends: GenericPalletError;
+    NotEnoughFriends: GenericPalletError<Rv>;
 
     /**
      * Friends list must be less than max friends
      **/
-    MaxFriends: GenericPalletError;
+    MaxFriends: GenericPalletError<Rv>;
 
     /**
      * Friends list must be sorted and free of duplicates
      **/
-    NotSorted: GenericPalletError;
+    NotSorted: GenericPalletError<Rv>;
 
     /**
      * This account is not set up for recovery
      **/
-    NotRecoverable: GenericPalletError;
+    NotRecoverable: GenericPalletError<Rv>;
 
     /**
      * This account is already set up for recovery
      **/
-    AlreadyRecoverable: GenericPalletError;
+    AlreadyRecoverable: GenericPalletError<Rv>;
 
     /**
      * A recovery process has already started for this account
      **/
-    AlreadyStarted: GenericPalletError;
+    AlreadyStarted: GenericPalletError<Rv>;
 
     /**
      * A recovery process has not started for this rescuer
      **/
-    NotStarted: GenericPalletError;
+    NotStarted: GenericPalletError<Rv>;
 
     /**
      * This account is not a friend who can vouch
      **/
-    NotFriend: GenericPalletError;
+    NotFriend: GenericPalletError<Rv>;
 
     /**
      * The friend must wait until the delay period to vouch for this recovery
      **/
-    DelayPeriod: GenericPalletError;
+    DelayPeriod: GenericPalletError<Rv>;
 
     /**
      * This user has already vouched for this recovery
      **/
-    AlreadyVouched: GenericPalletError;
+    AlreadyVouched: GenericPalletError<Rv>;
 
     /**
      * The threshold for recovering this account has not been met
      **/
-    Threshold: GenericPalletError;
+    Threshold: GenericPalletError<Rv>;
 
     /**
      * There are still active recovery attempts that need to be closed
      **/
-    StillActive: GenericPalletError;
+    StillActive: GenericPalletError<Rv>;
 
     /**
      * This account is already set up for recovery
      **/
-    AlreadyProxy: GenericPalletError;
+    AlreadyProxy: GenericPalletError<Rv>;
 
     /**
      * Some internal state is broken.
      **/
-    BadState: GenericPalletError;
+    BadState: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Vesting`'s errors
@@ -1107,33 +1122,33 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The account given is not vesting.
      **/
-    NotVesting: GenericPalletError;
+    NotVesting: GenericPalletError<Rv>;
 
     /**
      * 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;
+    AtMaxVestingSchedules: GenericPalletError<Rv>;
 
     /**
      * Amount being transferred is too low to create a vesting schedule.
      **/
-    AmountLow: GenericPalletError;
+    AmountLow: GenericPalletError<Rv>;
 
     /**
      * An index was out of bounds of the vesting schedules.
      **/
-    ScheduleIndexOutOfBounds: GenericPalletError;
+    ScheduleIndexOutOfBounds: GenericPalletError<Rv>;
 
     /**
      * Failed to create a new schedule because some parameter was invalid.
      **/
-    InvalidScheduleParams: GenericPalletError;
+    InvalidScheduleParams: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Scheduler`'s errors
@@ -1142,32 +1157,32 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Failed to schedule a call
      **/
-    FailedToSchedule: GenericPalletError;
+    FailedToSchedule: GenericPalletError<Rv>;
 
     /**
      * Cannot find the scheduled call.
      **/
-    NotFound: GenericPalletError;
+    NotFound: GenericPalletError<Rv>;
 
     /**
      * Given target block number is in the past.
      **/
-    TargetBlockNumberInPast: GenericPalletError;
+    TargetBlockNumberInPast: GenericPalletError<Rv>;
 
     /**
      * Reschedule failed because it does not change scheduled time.
      **/
-    RescheduleNoChange: GenericPalletError;
+    RescheduleNoChange: GenericPalletError<Rv>;
 
     /**
      * Attempt to use a non-named function on a named task.
      **/
-    Named: GenericPalletError;
+    Named: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Proxy`'s errors
@@ -1176,47 +1191,47 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * There are too many proxies registered or too many announcements pending.
      **/
-    TooMany: GenericPalletError;
+    TooMany: GenericPalletError<Rv>;
 
     /**
      * Proxy registration not found.
      **/
-    NotFound: GenericPalletError;
+    NotFound: GenericPalletError<Rv>;
 
     /**
      * Sender is not a proxy of the account to be proxied.
      **/
-    NotProxy: GenericPalletError;
+    NotProxy: GenericPalletError<Rv>;
 
     /**
      * A call which is incompatible with the proxy type's filter was attempted.
      **/
-    Unproxyable: GenericPalletError;
+    Unproxyable: GenericPalletError<Rv>;
 
     /**
      * Account is already a proxy.
      **/
-    Duplicate: GenericPalletError;
+    Duplicate: GenericPalletError<Rv>;
 
     /**
      * Call may not be made by proxy because it may escalate its privileges.
      **/
-    NoPermission: GenericPalletError;
+    NoPermission: GenericPalletError<Rv>;
 
     /**
      * Announcement, if made at all, was made too recently.
      **/
-    Unannounced: GenericPalletError;
+    Unannounced: GenericPalletError<Rv>;
 
     /**
      * Cannot add self as proxy.
      **/
-    NoSelfProxy: GenericPalletError;
+    NoSelfProxy: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Multisig`'s errors
@@ -1225,77 +1240,77 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Threshold must be 2 or greater.
      **/
-    MinimumThreshold: GenericPalletError;
+    MinimumThreshold: GenericPalletError<Rv>;
 
     /**
      * Call is already approved by this signatory.
      **/
-    AlreadyApproved: GenericPalletError;
+    AlreadyApproved: GenericPalletError<Rv>;
 
     /**
      * Call doesn't need any (more) approvals.
      **/
-    NoApprovalsNeeded: GenericPalletError;
+    NoApprovalsNeeded: GenericPalletError<Rv>;
 
     /**
      * There are too few signatories in the list.
      **/
-    TooFewSignatories: GenericPalletError;
+    TooFewSignatories: GenericPalletError<Rv>;
 
     /**
      * There are too many signatories in the list.
      **/
-    TooManySignatories: GenericPalletError;
+    TooManySignatories: GenericPalletError<Rv>;
 
     /**
      * The signatories were provided out of order; they should be ordered.
      **/
-    SignatoriesOutOfOrder: GenericPalletError;
+    SignatoriesOutOfOrder: GenericPalletError<Rv>;
 
     /**
      * The sender was contained in the other signatories; it shouldn't be.
      **/
-    SenderInSignatories: GenericPalletError;
+    SenderInSignatories: GenericPalletError<Rv>;
 
     /**
      * Multisig operation not found when attempting to cancel.
      **/
-    NotFound: GenericPalletError;
+    NotFound: GenericPalletError<Rv>;
 
     /**
      * Only the account that originally created the multisig is able to cancel it.
      **/
-    NotOwner: GenericPalletError;
+    NotOwner: GenericPalletError<Rv>;
 
     /**
      * No timepoint was given, yet the multisig operation is already underway.
      **/
-    NoTimepoint: GenericPalletError;
+    NoTimepoint: GenericPalletError<Rv>;
 
     /**
      * A different timepoint was given to the multisig operation that is underway.
      **/
-    WrongTimepoint: GenericPalletError;
+    WrongTimepoint: GenericPalletError<Rv>;
 
     /**
      * A timepoint was given, yet no multisig operation is underway.
      **/
-    UnexpectedTimepoint: GenericPalletError;
+    UnexpectedTimepoint: GenericPalletError<Rv>;
 
     /**
      * The maximum weight information provided was too low.
      **/
-    MaxWeightTooLow: GenericPalletError;
+    MaxWeightTooLow: GenericPalletError<Rv>;
 
     /**
      * The data to be stored is already stored.
      **/
-    AlreadyStored: GenericPalletError;
+    AlreadyStored: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Preimage`'s errors
@@ -1304,47 +1319,52 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Preimage is too large to store on-chain.
      **/
-    TooBig: GenericPalletError;
+    TooBig: GenericPalletError<Rv>;
 
     /**
      * Preimage has already been noted on-chain.
      **/
-    AlreadyNoted: GenericPalletError;
+    AlreadyNoted: GenericPalletError<Rv>;
 
     /**
      * The user is not authorized to perform this action.
      **/
-    NotAuthorized: GenericPalletError;
+    NotAuthorized: GenericPalletError<Rv>;
 
     /**
      * The preimage cannot be removed since it has not yet been noted.
      **/
-    NotNoted: GenericPalletError;
+    NotNoted: GenericPalletError<Rv>;
 
     /**
      * A preimage may not be removed when there are outstanding requests.
      **/
-    Requested: GenericPalletError;
+    Requested: GenericPalletError<Rv>;
 
     /**
      * The preimage request cannot be removed since no outstanding requests exist.
      **/
-    NotRequested: GenericPalletError;
+    NotRequested: GenericPalletError<Rv>;
 
     /**
      * More than `MAX_HASH_UPGRADE_BULK_COUNT` hashes were requested to be upgraded at once.
      **/
-    TooMany: GenericPalletError;
+    TooMany: GenericPalletError<Rv>;
 
     /**
      * Too few hashes were requested to be upgraded (i.e. zero).
      **/
-    TooFew: GenericPalletError;
+    TooFew: GenericPalletError<Rv>;
+
+    /**
+     * No ticket with a cost was returned by [`Config::Consideration`] to store the preimage.
+     **/
+    NoCost: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `AssetRate`'s errors
@@ -1353,22 +1373,22 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The given asset ID is unknown.
      **/
-    UnknownAssetKind: GenericPalletError;
+    UnknownAssetKind: GenericPalletError<Rv>;
 
     /**
      * The given asset ID already has an assigned conversion rate and cannot be re-created.
      **/
-    AlreadyExists: GenericPalletError;
+    AlreadyExists: GenericPalletError<Rv>;
 
     /**
      * Overflow ocurred when calculating the inverse rate.
      **/
-    Overflow: GenericPalletError;
+    Overflow: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Bounties`'s errors
@@ -1377,63 +1397,63 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Proposer's balance is too low.
      **/
-    InsufficientProposersBalance: GenericPalletError;
+    InsufficientProposersBalance: GenericPalletError<Rv>;
 
     /**
      * No proposal or bounty at that index.
      **/
-    InvalidIndex: GenericPalletError;
+    InvalidIndex: GenericPalletError<Rv>;
 
     /**
      * The reason given is just too big.
      **/
-    ReasonTooBig: GenericPalletError;
+    ReasonTooBig: GenericPalletError<Rv>;
 
     /**
      * The bounty status is unexpected.
      **/
-    UnexpectedStatus: GenericPalletError;
+    UnexpectedStatus: GenericPalletError<Rv>;
 
     /**
      * Require bounty curator.
      **/
-    RequireCurator: GenericPalletError;
+    RequireCurator: GenericPalletError<Rv>;
 
     /**
      * Invalid bounty value.
      **/
-    InvalidValue: GenericPalletError;
+    InvalidValue: GenericPalletError<Rv>;
 
     /**
      * Invalid bounty fee.
      **/
-    InvalidFee: GenericPalletError;
+    InvalidFee: GenericPalletError<Rv>;
 
     /**
      * A bounty payout is pending.
      * To cancel the bounty, you must unassign and slash the curator.
      **/
-    PendingPayout: GenericPalletError;
+    PendingPayout: GenericPalletError<Rv>;
 
     /**
      * The bounties cannot be claimed/closed because it's still in the countdown period.
      **/
-    Premature: GenericPalletError;
+    Premature: GenericPalletError<Rv>;
 
     /**
      * The bounty cannot be closed because it has active child bounties.
      **/
-    HasActiveChildBounty: GenericPalletError;
+    HasActiveChildBounty: GenericPalletError<Rv>;
 
     /**
      * Too many approvals are already queued.
      **/
-    TooManyQueued: GenericPalletError;
+    TooManyQueued: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `ChildBounties`'s errors
@@ -1442,22 +1462,22 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The parent bounty is not in active state.
      **/
-    ParentBountyNotActive: GenericPalletError;
+    ParentBountyNotActive: GenericPalletError<Rv>;
 
     /**
      * The bounty balance is not enough to add new child-bounty.
      **/
-    InsufficientBountyBalance: GenericPalletError;
+    InsufficientBountyBalance: GenericPalletError<Rv>;
 
     /**
      * Number of child bounties exceeds limit `MaxActiveChildBountyCount`.
      **/
-    TooManyChildBounties: GenericPalletError;
+    TooManyChildBounties: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Nis`'s errors
@@ -1466,83 +1486,83 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The duration of the bid is less than one.
      **/
-    DurationTooSmall: GenericPalletError;
+    DurationTooSmall: GenericPalletError<Rv>;
 
     /**
      * The duration is the bid is greater than the number of queues.
      **/
-    DurationTooBig: GenericPalletError;
+    DurationTooBig: GenericPalletError<Rv>;
 
     /**
      * The amount of the bid is less than the minimum allowed.
      **/
-    AmountTooSmall: GenericPalletError;
+    AmountTooSmall: GenericPalletError<Rv>;
 
     /**
      * The queue for the bid's duration is full and the amount bid is too low to get in
      * through replacing an existing bid.
      **/
-    BidTooLow: GenericPalletError;
+    BidTooLow: GenericPalletError<Rv>;
 
     /**
      * Receipt index is unknown.
      **/
-    UnknownReceipt: GenericPalletError;
+    UnknownReceipt: GenericPalletError<Rv>;
 
     /**
      * Not the owner of the receipt.
      **/
-    NotOwner: GenericPalletError;
+    NotOwner: GenericPalletError<Rv>;
 
     /**
      * Bond not yet at expiry date.
      **/
-    NotExpired: GenericPalletError;
+    NotExpired: GenericPalletError<Rv>;
 
     /**
      * The given bid for retraction is not found.
      **/
-    UnknownBid: GenericPalletError;
+    UnknownBid: GenericPalletError<Rv>;
 
     /**
      * The portion supplied is beyond the value of the receipt.
      **/
-    PortionTooBig: GenericPalletError;
+    PortionTooBig: GenericPalletError<Rv>;
 
     /**
      * Not enough funds are held to pay out.
      **/
-    Unfunded: GenericPalletError;
+    Unfunded: GenericPalletError<Rv>;
 
     /**
      * There are enough funds for what is required.
      **/
-    AlreadyFunded: GenericPalletError;
+    AlreadyFunded: GenericPalletError<Rv>;
 
     /**
      * The thaw throttle has been reached for this period.
      **/
-    Throttled: GenericPalletError;
+    Throttled: GenericPalletError<Rv>;
 
     /**
-     * The operation would result in a receipt worth an insignficant value.
+     * The operation would result in a receipt worth an insignificant value.
      **/
-    MakesDust: GenericPalletError;
+    MakesDust: GenericPalletError<Rv>;
 
     /**
      * The receipt is already communal.
      **/
-    AlreadyCommunal: GenericPalletError;
+    AlreadyCommunal: GenericPalletError<Rv>;
 
     /**
      * The receipt is already private.
      **/
-    AlreadyPrivate: GenericPalletError;
+    AlreadyPrivate: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `NisCounterpartBalances`'s errors
@@ -1551,67 +1571,67 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Vesting balance too high to send value.
      **/
-    VestingBalance: GenericPalletError;
+    VestingBalance: GenericPalletError<Rv>;
 
     /**
      * Account liquidity restrictions prevent withdrawal.
      **/
-    LiquidityRestrictions: GenericPalletError;
+    LiquidityRestrictions: GenericPalletError<Rv>;
 
     /**
      * Balance too low to send value.
      **/
-    InsufficientBalance: GenericPalletError;
+    InsufficientBalance: GenericPalletError<Rv>;
 
     /**
      * Value too low to create account due to existential deposit.
      **/
-    ExistentialDeposit: GenericPalletError;
+    ExistentialDeposit: GenericPalletError<Rv>;
 
     /**
      * Transfer/payment would kill account.
      **/
-    Expendability: GenericPalletError;
+    Expendability: GenericPalletError<Rv>;
 
     /**
      * A vesting schedule already exists for this account.
      **/
-    ExistingVestingSchedule: GenericPalletError;
+    ExistingVestingSchedule: GenericPalletError<Rv>;
 
     /**
      * Beneficiary account must pre-exist.
      **/
-    DeadAccount: GenericPalletError;
+    DeadAccount: GenericPalletError<Rv>;
 
     /**
      * Number of named reserves exceed `MaxReserves`.
      **/
-    TooManyReserves: GenericPalletError;
+    TooManyReserves: GenericPalletError<Rv>;
 
     /**
      * Number of holds exceed `VariantCountOf<T::RuntimeHoldReason>`.
      **/
-    TooManyHolds: GenericPalletError;
+    TooManyHolds: GenericPalletError<Rv>;
 
     /**
      * Number of freezes exceed `MaxFreezes`.
      **/
-    TooManyFreezes: GenericPalletError;
+    TooManyFreezes: GenericPalletError<Rv>;
 
     /**
      * The issuance cannot be modified since it is already deactivated.
      **/
-    IssuanceDeactivated: GenericPalletError;
+    IssuanceDeactivated: GenericPalletError<Rv>;
 
     /**
      * The delta cannot be zero.
      **/
-    DeltaZero: GenericPalletError;
+    DeltaZero: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Configuration`'s errors
@@ -1620,171 +1640,114 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The new value for a configuration parameter is invalid.
      **/
-    InvalidNewValue: GenericPalletError;
+    InvalidNewValue: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `ParaInclusion`'s errors
    **/
   paraInclusion: {
-    /**
-     * Validator indices are out of order or contains duplicates.
-     **/
-    UnsortedOrDuplicateValidatorIndices: GenericPalletError;
-
-    /**
-     * Dispute statement sets are out of order or contain duplicates.
-     **/
-    UnsortedOrDuplicateDisputeStatementSet: GenericPalletError;
-
-    /**
-     * Backed candidates are out of order (core index) or contain duplicates.
-     **/
-    UnsortedOrDuplicateBackedCandidates: GenericPalletError;
-
-    /**
-     * A different relay parent was provided compared to the on-chain stored one.
-     **/
-    UnexpectedRelayParent: GenericPalletError;
-
-    /**
-     * Availability bitfield has unexpected size.
-     **/
-    WrongBitfieldSize: GenericPalletError;
-
-    /**
-     * Bitfield consists of zeros only.
-     **/
-    BitfieldAllZeros: GenericPalletError;
-
-    /**
-     * Multiple bitfields submitted by same validator or validators out of order by index.
-     **/
-    BitfieldDuplicateOrUnordered: GenericPalletError;
-
     /**
      * Validator index out of bounds.
      **/
-    ValidatorIndexOutOfBounds: GenericPalletError;
-
-    /**
-     * Invalid signature
-     **/
-    InvalidBitfieldSignature: GenericPalletError;
+    ValidatorIndexOutOfBounds: GenericPalletError<Rv>;
 
     /**
      * Candidate submitted but para not scheduled.
      **/
-    UnscheduledCandidate: GenericPalletError;
-
-    /**
-     * Candidate scheduled despite pending candidate already existing for the para.
-     **/
-    CandidateScheduledBeforeParaFree: GenericPalletError;
-
-    /**
-     * Scheduled cores out of order.
-     **/
-    ScheduledOutOfOrder: GenericPalletError;
+    UnscheduledCandidate: GenericPalletError<Rv>;
 
     /**
      * Head data exceeds the configured maximum.
      **/
-    HeadDataTooLarge: GenericPalletError;
+    HeadDataTooLarge: GenericPalletError<Rv>;
 
     /**
      * Code upgrade prematurely.
      **/
-    PrematureCodeUpgrade: GenericPalletError;
+    PrematureCodeUpgrade: GenericPalletError<Rv>;
 
     /**
      * Output code is too large
      **/
-    NewCodeTooLarge: GenericPalletError;
+    NewCodeTooLarge: GenericPalletError<Rv>;
 
     /**
      * 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;
+    DisallowedRelayParent: GenericPalletError<Rv>;
 
     /**
      * 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;
+    InvalidAssignment: GenericPalletError<Rv>;
 
     /**
      * Invalid group index in core assignment.
      **/
-    InvalidGroupIndex: GenericPalletError;
+    InvalidGroupIndex: GenericPalletError<Rv>;
 
     /**
      * Insufficient (non-majority) backing.
      **/
-    InsufficientBacking: GenericPalletError;
+    InsufficientBacking: GenericPalletError<Rv>;
 
     /**
      * Invalid (bad signature, unknown validator, etc.) backing.
      **/
-    InvalidBacking: GenericPalletError;
+    InvalidBacking: GenericPalletError<Rv>;
 
     /**
      * Collator did not sign PoV.
      **/
-    NotCollatorSigned: GenericPalletError;
+    NotCollatorSigned: GenericPalletError<Rv>;
 
     /**
      * The validation data hash does not match expected.
      **/
-    ValidationDataHashMismatch: GenericPalletError;
+    ValidationDataHashMismatch: GenericPalletError<Rv>;
 
     /**
      * The downward message queue is not processed correctly.
      **/
-    IncorrectDownwardMessageHandling: GenericPalletError;
+    IncorrectDownwardMessageHandling: GenericPalletError<Rv>;
 
     /**
      * At least one upward message sent does not pass the acceptance criteria.
      **/
-    InvalidUpwardMessages: GenericPalletError;
+    InvalidUpwardMessages: GenericPalletError<Rv>;
 
     /**
      * The candidate didn't follow the rules of HRMP watermark advancement.
      **/
-    HrmpWatermarkMishandling: GenericPalletError;
+    HrmpWatermarkMishandling: GenericPalletError<Rv>;
 
     /**
      * The HRMP messages sent by the candidate is not valid.
      **/
-    InvalidOutboundHrmp: GenericPalletError;
+    InvalidOutboundHrmp: GenericPalletError<Rv>;
 
     /**
      * The validation code hash of the candidate is not valid.
      **/
-    InvalidValidationCodeHash: GenericPalletError;
+    InvalidValidationCodeHash: GenericPalletError<Rv>;
 
     /**
      * The `para_head` hash in the candidate descriptor doesn't match the hash of the actual
      * para head in the commitments.
      **/
-    ParaHeadMismatch: GenericPalletError;
-
-    /**
-     * A bitfield that references a freed core,
-     * either intentionally or as part of a concluded
-     * invalid dispute.
-     **/
-    BitfieldReferencesFreedCore: GenericPalletError;
+    ParaHeadMismatch: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `ParaInherent`'s errors
@@ -1793,53 +1756,34 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Inclusion inherent called more than once per block.
      **/
-    TooManyInclusionInherents: GenericPalletError;
+    TooManyInclusionInherents: GenericPalletError<Rv>;
 
     /**
      * The hash of the submitted parent header doesn't correspond to the saved block hash of
      * the parent.
      **/
-    InvalidParentHeader: GenericPalletError;
-
-    /**
-     * Disputed candidate that was concluded invalid.
-     **/
-    CandidateConcludedInvalid: GenericPalletError;
+    InvalidParentHeader: GenericPalletError<Rv>;
 
     /**
      * The data given to the inherent will result in an overweight block.
      **/
-    InherentOverweight: GenericPalletError;
-
-    /**
-     * The ordering of dispute statements was invalid.
-     **/
-    DisputeStatementsUnsortedOrDuplicates: GenericPalletError;
-
-    /**
-     * A dispute statement was invalid.
-     **/
-    DisputeInvalid: GenericPalletError;
-
-    /**
-     * A candidate was backed by a disabled validator
-     **/
-    BackedByDisabled: GenericPalletError;
+    InherentOverweight: GenericPalletError<Rv>;
 
     /**
-     * A candidate was backed even though the paraid was not scheduled.
+     * A candidate was filtered during inherent execution. This should have only been done
+     * during creation.
      **/
-    BackedOnUnscheduledCore: GenericPalletError;
+    CandidatesFilteredDuringExecution: GenericPalletError<Rv>;
 
     /**
      * Too many candidates supplied.
      **/
-    UnscheduledCandidate: GenericPalletError;
+    UnscheduledCandidate: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Paras`'s errors
@@ -1848,72 +1792,72 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Para is not registered in our system.
      **/
-    NotRegistered: GenericPalletError;
+    NotRegistered: GenericPalletError<Rv>;
 
     /**
      * Para cannot be onboarded because it is already tracked by our system.
      **/
-    CannotOnboard: GenericPalletError;
+    CannotOnboard: GenericPalletError<Rv>;
 
     /**
      * Para cannot be offboarded at this time.
      **/
-    CannotOffboard: GenericPalletError;
+    CannotOffboard: GenericPalletError<Rv>;
 
     /**
      * Para cannot be upgraded to a lease holding parachain.
      **/
-    CannotUpgrade: GenericPalletError;
+    CannotUpgrade: GenericPalletError<Rv>;
 
     /**
      * Para cannot be downgraded to an on-demand parachain.
      **/
-    CannotDowngrade: GenericPalletError;
+    CannotDowngrade: GenericPalletError<Rv>;
 
     /**
      * The statement for PVF pre-checking is stale.
      **/
-    PvfCheckStatementStale: GenericPalletError;
+    PvfCheckStatementStale: GenericPalletError<Rv>;
 
     /**
      * The statement for PVF pre-checking is for a future session.
      **/
-    PvfCheckStatementFuture: GenericPalletError;
+    PvfCheckStatementFuture: GenericPalletError<Rv>;
 
     /**
      * Claimed validator index is out of bounds.
      **/
-    PvfCheckValidatorIndexOutOfBounds: GenericPalletError;
+    PvfCheckValidatorIndexOutOfBounds: GenericPalletError<Rv>;
 
     /**
      * The signature for the PVF pre-checking is invalid.
      **/
-    PvfCheckInvalidSignature: GenericPalletError;
+    PvfCheckInvalidSignature: GenericPalletError<Rv>;
 
     /**
      * The given validator already has cast a vote.
      **/
-    PvfCheckDoubleVote: GenericPalletError;
+    PvfCheckDoubleVote: GenericPalletError<Rv>;
 
     /**
      * The given PVF does not exist at the moment of process a vote.
      **/
-    PvfCheckSubjectInvalid: GenericPalletError;
+    PvfCheckSubjectInvalid: GenericPalletError<Rv>;
 
     /**
      * Parachain cannot currently schedule a code upgrade.
      **/
-    CannotUpgradeCode: GenericPalletError;
+    CannotUpgradeCode: GenericPalletError<Rv>;
 
     /**
      * Invalid validation code size.
      **/
-    InvalidCode: GenericPalletError;
+    InvalidCode: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Hrmp`'s errors
@@ -1922,107 +1866,107 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The sender tried to open a channel to themselves.
      **/
-    OpenHrmpChannelToSelf: GenericPalletError;
+    OpenHrmpChannelToSelf: GenericPalletError<Rv>;
 
     /**
      * The recipient is not a valid para.
      **/
-    OpenHrmpChannelInvalidRecipient: GenericPalletError;
+    OpenHrmpChannelInvalidRecipient: GenericPalletError<Rv>;
 
     /**
      * The requested capacity is zero.
      **/
-    OpenHrmpChannelZeroCapacity: GenericPalletError;
+    OpenHrmpChannelZeroCapacity: GenericPalletError<Rv>;
 
     /**
      * The requested capacity exceeds the global limit.
      **/
-    OpenHrmpChannelCapacityExceedsLimit: GenericPalletError;
+    OpenHrmpChannelCapacityExceedsLimit: GenericPalletError<Rv>;
 
     /**
      * The requested maximum message size is 0.
      **/
-    OpenHrmpChannelZeroMessageSize: GenericPalletError;
+    OpenHrmpChannelZeroMessageSize: GenericPalletError<Rv>;
 
     /**
      * The open request requested the message size that exceeds the global limit.
      **/
-    OpenHrmpChannelMessageSizeExceedsLimit: GenericPalletError;
+    OpenHrmpChannelMessageSizeExceedsLimit: GenericPalletError<Rv>;
 
     /**
      * The channel already exists
      **/
-    OpenHrmpChannelAlreadyExists: GenericPalletError;
+    OpenHrmpChannelAlreadyExists: GenericPalletError<Rv>;
 
     /**
      * There is already a request to open the same channel.
      **/
-    OpenHrmpChannelAlreadyRequested: GenericPalletError;
+    OpenHrmpChannelAlreadyRequested: GenericPalletError<Rv>;
 
     /**
      * The sender already has the maximum number of allowed outbound channels.
      **/
-    OpenHrmpChannelLimitExceeded: GenericPalletError;
+    OpenHrmpChannelLimitExceeded: GenericPalletError<Rv>;
 
     /**
      * The channel from the sender to the origin doesn't exist.
      **/
-    AcceptHrmpChannelDoesntExist: GenericPalletError;
+    AcceptHrmpChannelDoesntExist: GenericPalletError<Rv>;
 
     /**
      * The channel is already confirmed.
      **/
-    AcceptHrmpChannelAlreadyConfirmed: GenericPalletError;
+    AcceptHrmpChannelAlreadyConfirmed: GenericPalletError<Rv>;
 
     /**
      * The recipient already has the maximum number of allowed inbound channels.
      **/
-    AcceptHrmpChannelLimitExceeded: GenericPalletError;
+    AcceptHrmpChannelLimitExceeded: GenericPalletError<Rv>;
 
     /**
      * The origin tries to close a channel where it is neither the sender nor the recipient.
      **/
-    CloseHrmpChannelUnauthorized: GenericPalletError;
+    CloseHrmpChannelUnauthorized: GenericPalletError<Rv>;
 
     /**
      * The channel to be closed doesn't exist.
      **/
-    CloseHrmpChannelDoesntExist: GenericPalletError;
+    CloseHrmpChannelDoesntExist: GenericPalletError<Rv>;
 
     /**
      * The channel close request is already requested.
      **/
-    CloseHrmpChannelAlreadyUnderway: GenericPalletError;
+    CloseHrmpChannelAlreadyUnderway: GenericPalletError<Rv>;
 
     /**
      * Canceling is requested by neither the sender nor recipient of the open channel request.
      **/
-    CancelHrmpOpenChannelUnauthorized: GenericPalletError;
+    CancelHrmpOpenChannelUnauthorized: GenericPalletError<Rv>;
 
     /**
      * The open request doesn't exist.
      **/
-    OpenHrmpChannelDoesntExist: GenericPalletError;
+    OpenHrmpChannelDoesntExist: GenericPalletError<Rv>;
 
     /**
      * Cannot cancel an HRMP open channel request because it is already confirmed.
      **/
-    OpenHrmpChannelAlreadyConfirmed: GenericPalletError;
+    OpenHrmpChannelAlreadyConfirmed: GenericPalletError<Rv>;
 
     /**
      * The provided witness data is wrong.
      **/
-    WrongWitness: GenericPalletError;
+    WrongWitness: GenericPalletError<Rv>;
 
     /**
      * The channel between these two chains cannot be authorized.
      **/
-    ChannelCreationNotAuthorized: GenericPalletError;
+    ChannelCreationNotAuthorized: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `ParasDisputes`'s errors
@@ -2031,52 +1975,52 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Duplicate dispute statement sets provided.
      **/
-    DuplicateDisputeStatementSets: GenericPalletError;
+    DuplicateDisputeStatementSets: GenericPalletError<Rv>;
 
     /**
      * Ancient dispute statement provided.
      **/
-    AncientDisputeStatement: GenericPalletError;
+    AncientDisputeStatement: GenericPalletError<Rv>;
 
     /**
      * Validator index on statement is out of bounds for session.
      **/
-    ValidatorIndexOutOfBounds: GenericPalletError;
+    ValidatorIndexOutOfBounds: GenericPalletError<Rv>;
 
     /**
      * Invalid signature on statement.
      **/
-    InvalidSignature: GenericPalletError;
+    InvalidSignature: GenericPalletError<Rv>;
 
     /**
      * Validator vote submitted more than once to dispute.
      **/
-    DuplicateStatement: GenericPalletError;
+    DuplicateStatement: GenericPalletError<Rv>;
 
     /**
      * A dispute where there are only votes on one side.
      **/
-    SingleSidedDispute: GenericPalletError;
+    SingleSidedDispute: GenericPalletError<Rv>;
 
     /**
      * A dispute vote from a malicious backer.
      **/
-    MaliciousBacker: GenericPalletError;
+    MaliciousBacker: GenericPalletError<Rv>;
 
     /**
      * No backing votes were provides along dispute statements.
      **/
-    MissingBackingVotes: GenericPalletError;
+    MissingBackingVotes: GenericPalletError<Rv>;
 
     /**
      * Unconfirmed dispute statement sets provided.
      **/
-    UnconfirmedDispute: GenericPalletError;
+    UnconfirmedDispute: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `ParasSlashing`'s errors
@@ -2085,38 +2029,38 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The key ownership proof is invalid.
      **/
-    InvalidKeyOwnershipProof: GenericPalletError;
+    InvalidKeyOwnershipProof: GenericPalletError<Rv>;
 
     /**
      * The session index is too old or invalid.
      **/
-    InvalidSessionIndex: GenericPalletError;
+    InvalidSessionIndex: GenericPalletError<Rv>;
 
     /**
      * The candidate hash is invalid.
      **/
-    InvalidCandidateHash: GenericPalletError;
+    InvalidCandidateHash: GenericPalletError<Rv>;
 
     /**
      * There is no pending slash for the given validator index and time
      * slot.
      **/
-    InvalidValidatorIndex: GenericPalletError;
+    InvalidValidatorIndex: GenericPalletError<Rv>;
 
     /**
      * The validator index does not match the validator id.
      **/
-    ValidatorIndexIdMismatch: GenericPalletError;
+    ValidatorIndexIdMismatch: GenericPalletError<Rv>;
 
     /**
      * The given slashing report is valid but already previously reported.
      **/
-    DuplicateSlashingReport: GenericPalletError;
+    DuplicateSlashingReport: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `MessageQueue`'s errors
@@ -2126,32 +2070,32 @@ export interface ChainErrors extends GenericChainErrors {
      * Page is not reapable because it has items remaining to be processed and is not old
      * enough.
      **/
-    NotReapable: GenericPalletError;
+    NotReapable: GenericPalletError<Rv>;
 
     /**
      * Page to be reaped does not exist.
      **/
-    NoPage: GenericPalletError;
+    NoPage: GenericPalletError<Rv>;
 
     /**
      * The referenced message could not be found.
      **/
-    NoMessage: GenericPalletError;
+    NoMessage: GenericPalletError<Rv>;
 
     /**
      * The message was already processed and cannot be processed again.
      **/
-    AlreadyProcessed: GenericPalletError;
+    AlreadyProcessed: GenericPalletError<Rv>;
 
     /**
      * The message is queued for future execution.
      **/
-    Queued: GenericPalletError;
+    Queued: GenericPalletError<Rv>;
 
     /**
      * There is temporarily not enough weight to continue servicing messages.
      **/
-    InsufficientWeight: GenericPalletError;
+    InsufficientWeight: GenericPalletError<Rv>;
 
     /**
      * This message is temporarily unprocessable.
@@ -2159,87 +2103,81 @@ export interface ChainErrors extends GenericChainErrors {
      * Such errors are expected, but not guaranteed, to resolve themselves eventually through
      * retrying.
      **/
-    TemporarilyUnprocessable: GenericPalletError;
+    TemporarilyUnprocessable: GenericPalletError<Rv>;
 
     /**
      * 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;
+    QueuePaused: GenericPalletError<Rv>;
 
     /**
      * Another call is in progress and needs to finish before this call can happen.
      **/
-    RecursiveDisallowed: GenericPalletError;
+    RecursiveDisallowed: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `OnDemandAssignmentProvider`'s errors
    **/
   onDemandAssignmentProvider: {
-    /**
-     * The `ParaId` supplied to the `place_order` call is not a valid `ParaThread`, making the
-     * call is invalid.
-     **/
-    InvalidParaId: GenericPalletError;
-
     /**
      * The order queue is full, `place_order` will not continue.
      **/
-    QueueFull: GenericPalletError;
+    QueueFull: GenericPalletError<Rv>;
 
     /**
      * The current spot price is higher than the max amount specified in the `place_order`
      * call, making it invalid.
      **/
-    SpotPriceHigherThanMaxAmount: GenericPalletError;
+    SpotPriceHigherThanMaxAmount: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `CoretimeAssignmentProvider`'s errors
    **/
   coretimeAssignmentProvider: {
-    AssignmentsEmpty: GenericPalletError;
+    AssignmentsEmpty: GenericPalletError<Rv>;
 
     /**
      * Assignments together exceeded 57600.
      **/
-    OverScheduled: GenericPalletError;
+    OverScheduled: GenericPalletError<Rv>;
 
     /**
      * Assignments together less than 57600
      **/
-    UnderScheduled: GenericPalletError;
+    UnderScheduled: GenericPalletError<Rv>;
 
     /**
      * assign_core is only allowed to append new assignments at the end of already existing
      * ones.
      **/
-    DisallowedInsert: GenericPalletError;
+    DisallowedInsert: GenericPalletError<Rv>;
 
     /**
      * Tried to insert a schedule for the same core and block number as an existing schedule
      **/
-    DuplicateInsert: GenericPalletError;
+    DuplicateInsert: GenericPalletError<Rv>;
 
     /**
      * Tried to add an unsorted set of assignments
      **/
-    AssignmentsNotSorted: GenericPalletError;
+    AssignmentsNotSorted: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Registrar`'s errors
@@ -2248,79 +2186,79 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The ID is not registered.
      **/
-    NotRegistered: GenericPalletError;
+    NotRegistered: GenericPalletError<Rv>;
 
     /**
      * The ID is already registered.
      **/
-    AlreadyRegistered: GenericPalletError;
+    AlreadyRegistered: GenericPalletError<Rv>;
 
     /**
      * The caller is not the owner of this Id.
      **/
-    NotOwner: GenericPalletError;
+    NotOwner: GenericPalletError<Rv>;
 
     /**
      * Invalid para code size.
      **/
-    CodeTooLarge: GenericPalletError;
+    CodeTooLarge: GenericPalletError<Rv>;
 
     /**
      * Invalid para head data size.
      **/
-    HeadDataTooLarge: GenericPalletError;
+    HeadDataTooLarge: GenericPalletError<Rv>;
 
     /**
      * Para is not a Parachain.
      **/
-    NotParachain: GenericPalletError;
+    NotParachain: GenericPalletError<Rv>;
 
     /**
      * Para is not a Parathread (on-demand parachain).
      **/
-    NotParathread: GenericPalletError;
+    NotParathread: GenericPalletError<Rv>;
 
     /**
      * Cannot deregister para
      **/
-    CannotDeregister: GenericPalletError;
+    CannotDeregister: GenericPalletError<Rv>;
 
     /**
      * Cannot schedule downgrade of lease holding parachain to on-demand parachain
      **/
-    CannotDowngrade: GenericPalletError;
+    CannotDowngrade: GenericPalletError<Rv>;
 
     /**
      * Cannot schedule upgrade of on-demand parachain to lease holding parachain
      **/
-    CannotUpgrade: GenericPalletError;
+    CannotUpgrade: GenericPalletError<Rv>;
 
     /**
      * Para is locked from manipulation by the manager. Must use parachain or relay chain
      * governance.
      **/
-    ParaLocked: GenericPalletError;
+    ParaLocked: GenericPalletError<Rv>;
 
     /**
      * The ID given for registration has not been reserved.
      **/
-    NotReserved: GenericPalletError;
+    NotReserved: GenericPalletError<Rv>;
 
     /**
      * The validation code is invalid.
      **/
-    InvalidCode: GenericPalletError;
+    InvalidCode: GenericPalletError<Rv>;
 
     /**
      * Cannot perform a parachain slot / lifecycle swap. Check that the state of both paras
      * are correct for the swap to work.
      **/
-    CannotSwap: GenericPalletError;
+    CannotSwap: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Slots`'s errors
@@ -2329,17 +2267,17 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The parachain ID is not onboarding.
      **/
-    ParaNotOnboarding: GenericPalletError;
+    ParaNotOnboarding: GenericPalletError<Rv>;
 
     /**
      * There was an error with the lease.
      **/
-    LeaseError: GenericPalletError;
+    LeaseError: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Auctions`'s errors
@@ -2348,42 +2286,42 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * This auction is already in progress.
      **/
-    AuctionInProgress: GenericPalletError;
+    AuctionInProgress: GenericPalletError<Rv>;
 
     /**
      * The lease period is in the past.
      **/
-    LeasePeriodInPast: GenericPalletError;
+    LeasePeriodInPast: GenericPalletError<Rv>;
 
     /**
      * Para is not registered
      **/
-    ParaNotRegistered: GenericPalletError;
+    ParaNotRegistered: GenericPalletError<Rv>;
 
     /**
      * Not a current auction.
      **/
-    NotCurrentAuction: GenericPalletError;
+    NotCurrentAuction: GenericPalletError<Rv>;
 
     /**
      * Not an auction.
      **/
-    NotAuction: GenericPalletError;
+    NotAuction: GenericPalletError<Rv>;
 
     /**
      * Auction has already ended.
      **/
-    AuctionEnded: GenericPalletError;
+    AuctionEnded: GenericPalletError<Rv>;
 
     /**
      * The para is already leased out for part of this range.
      **/
-    AlreadyLeasedOut: GenericPalletError;
+    AlreadyLeasedOut: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Crowdloan`'s errors
@@ -2392,123 +2330,123 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The current lease period is more than the first lease period.
      **/
-    FirstPeriodInPast: GenericPalletError;
+    FirstPeriodInPast: GenericPalletError<Rv>;
 
     /**
      * The first lease period needs to at least be less than 3 `max_value`.
      **/
-    FirstPeriodTooFarInFuture: GenericPalletError;
+    FirstPeriodTooFarInFuture: GenericPalletError<Rv>;
 
     /**
      * Last lease period must be greater than first lease period.
      **/
-    LastPeriodBeforeFirstPeriod: GenericPalletError;
+    LastPeriodBeforeFirstPeriod: GenericPalletError<Rv>;
 
     /**
      * The last lease period cannot be more than 3 periods after the first period.
      **/
-    LastPeriodTooFarInFuture: GenericPalletError;
+    LastPeriodTooFarInFuture: GenericPalletError<Rv>;
 
     /**
      * The campaign ends before the current block number. The end must be in the future.
      **/
-    CannotEndInPast: GenericPalletError;
+    CannotEndInPast: GenericPalletError<Rv>;
 
     /**
      * The end date for this crowdloan is not sensible.
      **/
-    EndTooFarInFuture: GenericPalletError;
+    EndTooFarInFuture: GenericPalletError<Rv>;
 
     /**
      * There was an overflow.
      **/
-    Overflow: GenericPalletError;
+    Overflow: GenericPalletError<Rv>;
 
     /**
      * The contribution was below the minimum, `MinContribution`.
      **/
-    ContributionTooSmall: GenericPalletError;
+    ContributionTooSmall: GenericPalletError<Rv>;
 
     /**
      * Invalid fund index.
      **/
-    InvalidParaId: GenericPalletError;
+    InvalidParaId: GenericPalletError<Rv>;
 
     /**
      * Contributions exceed maximum amount.
      **/
-    CapExceeded: GenericPalletError;
+    CapExceeded: GenericPalletError<Rv>;
 
     /**
      * The contribution period has already ended.
      **/
-    ContributionPeriodOver: GenericPalletError;
+    ContributionPeriodOver: GenericPalletError<Rv>;
 
     /**
      * The origin of this call is invalid.
      **/
-    InvalidOrigin: GenericPalletError;
+    InvalidOrigin: GenericPalletError<Rv>;
 
     /**
      * This crowdloan does not correspond to a parachain.
      **/
-    NotParachain: GenericPalletError;
+    NotParachain: GenericPalletError<Rv>;
 
     /**
      * This parachain lease is still active and retirement cannot yet begin.
      **/
-    LeaseActive: GenericPalletError;
+    LeaseActive: GenericPalletError<Rv>;
 
     /**
      * This parachain's bid or lease is still active and withdraw cannot yet begin.
      **/
-    BidOrLeaseActive: GenericPalletError;
+    BidOrLeaseActive: GenericPalletError<Rv>;
 
     /**
      * The crowdloan has not yet ended.
      **/
-    FundNotEnded: GenericPalletError;
+    FundNotEnded: GenericPalletError<Rv>;
 
     /**
      * There are no contributions stored in this crowdloan.
      **/
-    NoContributions: GenericPalletError;
+    NoContributions: GenericPalletError<Rv>;
 
     /**
      * The crowdloan is not ready to dissolve. Potentially still has a slot or in retirement
      * period.
      **/
-    NotReadyToDissolve: GenericPalletError;
+    NotReadyToDissolve: GenericPalletError<Rv>;
 
     /**
      * Invalid signature.
      **/
-    InvalidSignature: GenericPalletError;
+    InvalidSignature: GenericPalletError<Rv>;
 
     /**
      * The provided memo is too large.
      **/
-    MemoTooLarge: GenericPalletError;
+    MemoTooLarge: GenericPalletError<Rv>;
 
     /**
      * The fund is already in `NewRaise`
      **/
-    AlreadyInNewRaise: GenericPalletError;
+    AlreadyInNewRaise: GenericPalletError<Rv>;
 
     /**
      * No contributions allowed during the VRF delay
      **/
-    VrfDelayInProgress: GenericPalletError;
+    VrfDelayInProgress: GenericPalletError<Rv>;
 
     /**
      * A lease period has not started yet, due to an offset in the starting block.
      **/
-    NoLeasePeriod: GenericPalletError;
+    NoLeasePeriod: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Coretime`'s errors
@@ -2517,12 +2455,23 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The paraid making the call is not the coretime brokerage system parachain.
      **/
-    NotBroker: GenericPalletError;
+    NotBroker: GenericPalletError<Rv>;
+
+    /**
+     * Requested revenue information `when` parameter was in the future from the current
+     * block height.
+     **/
+    RequestedFutureRevenue: GenericPalletError<Rv>;
+
+    /**
+     * Failed to transfer assets to the coretime chain
+     **/
+    AssetTransferFailed: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `XcmPallet`'s errors
@@ -2532,134 +2481,129 @@ export interface ChainErrors extends GenericChainErrors {
      * The desired destination was unreachable, generally because there is a no way of routing
      * to it.
      **/
-    Unreachable: GenericPalletError;
+    Unreachable: GenericPalletError<Rv>;
 
     /**
      * 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;
+    SendFailure: GenericPalletError<Rv>;
 
     /**
      * The message execution fails the filter.
      **/
-    Filtered: GenericPalletError;
+    Filtered: GenericPalletError<Rv>;
 
     /**
      * The message's weight could not be determined.
      **/
-    UnweighableMessage: GenericPalletError;
+    UnweighableMessage: GenericPalletError<Rv>;
 
     /**
      * The destination `Location` provided cannot be inverted.
      **/
-    DestinationNotInvertible: GenericPalletError;
+    DestinationNotInvertible: GenericPalletError<Rv>;
 
     /**
      * The assets to be sent are empty.
      **/
-    Empty: GenericPalletError;
+    Empty: GenericPalletError<Rv>;
 
     /**
      * Could not re-anchor the assets to declare the fees for the destination chain.
      **/
-    CannotReanchor: GenericPalletError;
+    CannotReanchor: GenericPalletError<Rv>;
 
     /**
      * Too many assets have been attempted for transfer.
      **/
-    TooManyAssets: GenericPalletError;
+    TooManyAssets: GenericPalletError<Rv>;
 
     /**
      * Origin is invalid for sending.
      **/
-    InvalidOrigin: GenericPalletError;
+    InvalidOrigin: GenericPalletError<Rv>;
 
     /**
      * The version of the `Versioned` value used is not able to be interpreted.
      **/
-    BadVersion: GenericPalletError;
+    BadVersion: GenericPalletError<Rv>;
 
     /**
      * The given location could not be used (e.g. because it cannot be expressed in the
      * desired version of XCM).
      **/
-    BadLocation: GenericPalletError;
+    BadLocation: GenericPalletError<Rv>;
 
     /**
      * The referenced subscription could not be found.
      **/
-    NoSubscription: GenericPalletError;
+    NoSubscription: GenericPalletError<Rv>;
 
     /**
      * The location is invalid since it already has a subscription from us.
      **/
-    AlreadySubscribed: GenericPalletError;
+    AlreadySubscribed: GenericPalletError<Rv>;
 
     /**
      * Could not check-out the assets for teleportation to the destination chain.
      **/
-    CannotCheckOutTeleport: GenericPalletError;
+    CannotCheckOutTeleport: GenericPalletError<Rv>;
 
     /**
      * The owner does not own (all) of the asset that they wish to do the operation on.
      **/
-    LowBalance: GenericPalletError;
+    LowBalance: GenericPalletError<Rv>;
 
     /**
      * The asset owner has too many locks on the asset.
      **/
-    TooManyLocks: GenericPalletError;
+    TooManyLocks: GenericPalletError<Rv>;
 
     /**
      * The given account is not an identifiable sovereign account for any location.
      **/
-    AccountNotSovereign: GenericPalletError;
+    AccountNotSovereign: GenericPalletError<Rv>;
 
     /**
      * The operation required fees to be paid which the initiator could not meet.
      **/
-    FeesNotMet: GenericPalletError;
+    FeesNotMet: GenericPalletError<Rv>;
 
     /**
      * A remote lock with the corresponding data could not be found.
      **/
-    LockNotFound: GenericPalletError;
+    LockNotFound: GenericPalletError<Rv>;
 
     /**
      * The unlock operation cannot succeed because there are still consumers of the lock.
      **/
-    InUse: GenericPalletError;
-
-    /**
-     * Invalid non-concrete asset.
-     **/
-    InvalidAssetNotConcrete: GenericPalletError;
+    InUse: GenericPalletError<Rv>;
 
     /**
      * Invalid asset, reserve chain could not be determined for it.
      **/
-    InvalidAssetUnknownReserve: GenericPalletError;
+    InvalidAssetUnknownReserve: GenericPalletError<Rv>;
 
     /**
      * Invalid asset, do not support remote asset reserves with different fees reserves.
      **/
-    InvalidAssetUnsupportedReserve: GenericPalletError;
+    InvalidAssetUnsupportedReserve: GenericPalletError<Rv>;
 
     /**
      * Too many assets with different reserve locations have been attempted for transfer.
      **/
-    TooManyReserves: GenericPalletError;
+    TooManyReserves: GenericPalletError<Rv>;
 
     /**
      * Local XCM execution incomplete.
      **/
-    LocalExecutionIncomplete: GenericPalletError;
+    LocalExecutionIncomplete: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Beefy`'s errors
@@ -2668,27 +2612,27 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * A key ownership proof provided as part of an equivocation report is invalid.
      **/
-    InvalidKeyOwnershipProof: GenericPalletError;
+    InvalidKeyOwnershipProof: GenericPalletError<Rv>;
 
     /**
      * An equivocation proof provided as part of an equivocation report is invalid.
      **/
-    InvalidEquivocationProof: GenericPalletError;
+    InvalidEquivocationProof: GenericPalletError<Rv>;
 
     /**
      * A given equivocation report is valid but already previously reported.
      **/
-    DuplicateOffenceReport: GenericPalletError;
+    DuplicateOffenceReport: GenericPalletError<Rv>;
 
     /**
      * Submitted configuration is invalid.
      **/
-    InvalidConfiguration: GenericPalletError;
+    InvalidConfiguration: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `ParasSudoWrapper`'s errors
@@ -2697,53 +2641,53 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The specified parachain is not registered.
      **/
-    ParaDoesntExist: GenericPalletError;
+    ParaDoesntExist: GenericPalletError<Rv>;
 
     /**
      * The specified parachain is already registered.
      **/
-    ParaAlreadyExists: GenericPalletError;
+    ParaAlreadyExists: GenericPalletError<Rv>;
 
     /**
      * A DMP message couldn't be sent because it exceeds the maximum size allowed for a
      * downward message.
      **/
-    ExceedsMaxMessageSize: GenericPalletError;
+    ExceedsMaxMessageSize: GenericPalletError<Rv>;
 
     /**
      * Could not schedule para cleanup.
      **/
-    CouldntCleanup: GenericPalletError;
+    CouldntCleanup: GenericPalletError<Rv>;
 
     /**
      * Not a parathread (on-demand parachain).
      **/
-    NotParathread: GenericPalletError;
+    NotParathread: GenericPalletError<Rv>;
 
     /**
      * Not a lease holding parachain.
      **/
-    NotParachain: GenericPalletError;
+    NotParachain: GenericPalletError<Rv>;
 
     /**
      * Cannot upgrade on-demand parachain to lease holding parachain.
      **/
-    CannotUpgrade: GenericPalletError;
+    CannotUpgrade: GenericPalletError<Rv>;
 
     /**
      * Cannot downgrade lease holding parachain to on-demand.
      **/
-    CannotDowngrade: GenericPalletError;
+    CannotDowngrade: GenericPalletError<Rv>;
 
     /**
      * There are more cores than supported by the runtime.
      **/
-    TooManyCores: GenericPalletError;
+    TooManyCores: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `AssignedSlots`'s errors
@@ -2752,46 +2696,46 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * The specified parachain is not registered.
      **/
-    ParaDoesntExist: GenericPalletError;
+    ParaDoesntExist: GenericPalletError<Rv>;
 
     /**
      * Not a parathread (on-demand parachain).
      **/
-    NotParathread: GenericPalletError;
+    NotParathread: GenericPalletError<Rv>;
 
     /**
      * Cannot upgrade on-demand parachain to lease holding
      * parachain.
      **/
-    CannotUpgrade: GenericPalletError;
+    CannotUpgrade: GenericPalletError<Rv>;
 
     /**
      * Cannot downgrade lease holding parachain to
      * on-demand.
      **/
-    CannotDowngrade: GenericPalletError;
+    CannotDowngrade: GenericPalletError<Rv>;
 
     /**
      * Permanent or Temporary slot already assigned.
      **/
-    SlotAlreadyAssigned: GenericPalletError;
+    SlotAlreadyAssigned: GenericPalletError<Rv>;
 
     /**
      * Permanent or Temporary slot has not been assigned.
      **/
-    SlotNotAssigned: GenericPalletError;
+    SlotNotAssigned: GenericPalletError<Rv>;
 
     /**
      * An ongoing lease already exists.
      **/
-    OngoingLeaseExists: GenericPalletError;
-    MaxPermanentSlotsExceeded: GenericPalletError;
-    MaxTemporarySlotsExceeded: GenericPalletError;
+    OngoingLeaseExists: GenericPalletError<Rv>;
+    MaxPermanentSlotsExceeded: GenericPalletError<Rv>;
+    MaxTemporarySlotsExceeded: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `StateTrieMigration`'s errors
@@ -2800,7 +2744,7 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Max signed limits not respected.
      **/
-    MaxSignedLimits: GenericPalletError;
+    MaxSignedLimits: GenericPalletError<Rv>;
 
     /**
      * A key was longer than the configured maximum.
@@ -2811,32 +2755,32 @@ export interface ChainErrors extends GenericChainErrors {
      * The value should only be increased to avoid a storage migration for the currently
      * stored [`crate::Progress::LastKey`].
      **/
-    KeyTooLong: GenericPalletError;
+    KeyTooLong: GenericPalletError<Rv>;
 
     /**
      * submitter does not have enough funds.
      **/
-    NotEnoughFunds: GenericPalletError;
+    NotEnoughFunds: GenericPalletError<Rv>;
 
     /**
      * Bad witness data provided.
      **/
-    BadWitness: GenericPalletError;
+    BadWitness: GenericPalletError<Rv>;
 
     /**
      * Signed migration is not allowed because the maximum limit is not set yet.
      **/
-    SignedMigrationNotAllowed: GenericPalletError;
+    SignedMigrationNotAllowed: GenericPalletError<Rv>;
 
     /**
      * Bad child root provided.
      **/
-    BadChildRoot: GenericPalletError;
+    BadChildRoot: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Sudo`'s errors
@@ -2845,11 +2789,11 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Sender must be the Sudo account.
      **/
-    RequireSudo: GenericPalletError;
+    RequireSudo: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
 }