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

package/aleph/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,40 +11,40 @@ 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>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Scheduler`'s errors
@@ -53,32 +53,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 `Balances`'s errors
@@ -87,57 +87,57 @@ 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 `MaxHolds`.
      **/
-    TooManyHolds: GenericPalletError;
+    TooManyHolds: GenericPalletError<Rv>;
 
     /**
      * Number of freezes exceed `MaxFreezes`.
      **/
-    TooManyFreezes: GenericPalletError;
+    TooManyFreezes: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Staking`'s errors
@@ -146,136 +146,136 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Not a controller account.
      **/
-    NotController: GenericPalletError;
+    NotController: GenericPalletError<Rv>;
 
     /**
      * Not a stash account.
      **/
-    NotStash: GenericPalletError;
+    NotStash: GenericPalletError<Rv>;
 
     /**
      * Stash is already bonded.
      **/
-    AlreadyBonded: GenericPalletError;
+    AlreadyBonded: GenericPalletError<Rv>;
 
     /**
      * Controller is already paired.
      **/
-    AlreadyPaired: GenericPalletError;
+    AlreadyPaired: GenericPalletError<Rv>;
 
     /**
      * Targets cannot be empty.
      **/
-    EmptyTargets: GenericPalletError;
+    EmptyTargets: GenericPalletError<Rv>;
 
     /**
      * Duplicate index.
      **/
-    DuplicateIndex: GenericPalletError;
+    DuplicateIndex: GenericPalletError<Rv>;
 
     /**
      * Slash record index out of bounds.
      **/
-    InvalidSlashIndex: GenericPalletError;
+    InvalidSlashIndex: GenericPalletError<Rv>;
 
     /**
      * Cannot have a validator or nominator role, with value less than the minimum defined by
      * governance (see `MinValidatorBond` and `MinNominatorBond`). If unbonding is the
      * intention, `chill` first to remove one's role as validator/nominator.
      **/
-    InsufficientBond: GenericPalletError;
+    InsufficientBond: GenericPalletError<Rv>;
 
     /**
      * Can not schedule more unlock chunks.
      **/
-    NoMoreChunks: GenericPalletError;
+    NoMoreChunks: GenericPalletError<Rv>;
 
     /**
      * Can not rebond without unlocking chunks.
      **/
-    NoUnlockChunk: GenericPalletError;
+    NoUnlockChunk: GenericPalletError<Rv>;
 
     /**
      * Attempting to target a stash that still has funds.
      **/
-    FundedTarget: GenericPalletError;
+    FundedTarget: GenericPalletError<Rv>;
 
     /**
      * Invalid era to reward.
      **/
-    InvalidEraToReward: GenericPalletError;
+    InvalidEraToReward: GenericPalletError<Rv>;
 
     /**
      * Invalid number of nominations.
      **/
-    InvalidNumberOfNominations: GenericPalletError;
+    InvalidNumberOfNominations: GenericPalletError<Rv>;
 
     /**
      * Items are not sorted and unique.
      **/
-    NotSortedAndUnique: GenericPalletError;
+    NotSortedAndUnique: GenericPalletError<Rv>;
 
     /**
      * Rewards for this era have already been claimed for this validator.
      **/
-    AlreadyClaimed: GenericPalletError;
+    AlreadyClaimed: GenericPalletError<Rv>;
 
     /**
      * Incorrect previous history depth input provided.
      **/
-    IncorrectHistoryDepth: GenericPalletError;
+    IncorrectHistoryDepth: GenericPalletError<Rv>;
 
     /**
      * Incorrect number of slashing spans provided.
      **/
-    IncorrectSlashingSpans: GenericPalletError;
+    IncorrectSlashingSpans: GenericPalletError<Rv>;
 
     /**
      * Internal state has become somehow corrupted and the operation cannot continue.
      **/
-    BadState: GenericPalletError;
+    BadState: GenericPalletError<Rv>;
 
     /**
      * Too many nomination targets supplied.
      **/
-    TooManyTargets: GenericPalletError;
+    TooManyTargets: GenericPalletError<Rv>;
 
     /**
      * A nomination target was supplied that was blocked or otherwise not a validator.
      **/
-    BadTarget: GenericPalletError;
+    BadTarget: GenericPalletError<Rv>;
 
     /**
      * The user has enough bond and thus cannot be chilled forcefully by an external person.
      **/
-    CannotChillOther: GenericPalletError;
+    CannotChillOther: GenericPalletError<Rv>;
 
     /**
      * There are too many nominators in the system. Governance needs to adjust the staking
      * settings to keep things safe for the runtime.
      **/
-    TooManyNominators: GenericPalletError;
+    TooManyNominators: GenericPalletError<Rv>;
 
     /**
      * There are too many validator candidates in the system. Governance needs to adjust the
      * staking settings to keep things safe for the runtime.
      **/
-    TooManyValidators: GenericPalletError;
+    TooManyValidators: GenericPalletError<Rv>;
 
     /**
      * Commission is too low. Must be at least `MinCommission`.
      **/
-    CommissionTooLow: GenericPalletError;
+    CommissionTooLow: GenericPalletError<Rv>;
 
     /**
      * Some bound is not met.
      **/
-    BoundNotMet: GenericPalletError;
+    BoundNotMet: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Session`'s errors
@@ -284,47 +284,47 @@ 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 `Elections`'s errors
    **/
   elections: {
-    NotEnoughValidators: GenericPalletError;
-    NotEnoughReservedValidators: GenericPalletError;
-    NotEnoughNonReservedValidators: GenericPalletError;
-    NonUniqueListOfValidators: GenericPalletError;
-    NonReservedFinalitySeatsLargerThanNonReservedSeats: GenericPalletError;
+    NotEnoughValidators: GenericPalletError<Rv>;
+    NotEnoughReservedValidators: GenericPalletError<Rv>;
+    NotEnoughNonReservedValidators: GenericPalletError<Rv>;
+    NonUniqueListOfValidators: GenericPalletError<Rv>;
+    NonReservedFinalitySeatsLargerThanNonReservedSeats: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Treasury`'s errors
@@ -333,33 +333,33 @@ 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>;
 
     /**
      * 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>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Vesting`'s errors
@@ -368,33 +368,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 `Utility`'s errors
@@ -403,12 +403,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 `Multisig`'s errors
@@ -417,77 +417,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 `Sudo`'s errors
@@ -496,12 +496,12 @@ 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>;
   };
   /**
    * Pallet `Contracts`'s errors
@@ -510,115 +510,115 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * Invalid schedule supplied, e.g. with zero weight of a basic operation.
      **/
-    InvalidSchedule: GenericPalletError;
+    InvalidSchedule: GenericPalletError<Rv>;
 
     /**
      * Invalid combination of flags supplied to `seal_call` or `seal_delegate_call`.
      **/
-    InvalidCallFlags: GenericPalletError;
+    InvalidCallFlags: GenericPalletError<Rv>;
 
     /**
      * The executed contract exhausted its gas limit.
      **/
-    OutOfGas: GenericPalletError;
+    OutOfGas: GenericPalletError<Rv>;
 
     /**
      * The output buffer supplied to a contract API call was too small.
      **/
-    OutputBufferTooSmall: GenericPalletError;
+    OutputBufferTooSmall: GenericPalletError<Rv>;
 
     /**
      * Performing the requested transfer failed. Probably because there isn't enough
      * free balance in the sender's account.
      **/
-    TransferFailed: GenericPalletError;
+    TransferFailed: GenericPalletError<Rv>;
 
     /**
      * Performing a call was denied because the calling depth reached the limit
      * of what is specified in the schedule.
      **/
-    MaxCallDepthReached: GenericPalletError;
+    MaxCallDepthReached: GenericPalletError<Rv>;
 
     /**
      * No contract was found at the specified address.
      **/
-    ContractNotFound: GenericPalletError;
+    ContractNotFound: GenericPalletError<Rv>;
 
     /**
      * The code supplied to `instantiate_with_code` exceeds the limit specified in the
      * current schedule.
      **/
-    CodeTooLarge: GenericPalletError;
+    CodeTooLarge: GenericPalletError<Rv>;
 
     /**
      * No code could be found at the supplied code hash.
      **/
-    CodeNotFound: GenericPalletError;
+    CodeNotFound: GenericPalletError<Rv>;
 
     /**
      * No code info could be found at the supplied code hash.
      **/
-    CodeInfoNotFound: GenericPalletError;
+    CodeInfoNotFound: GenericPalletError<Rv>;
 
     /**
      * A buffer outside of sandbox memory was passed to a contract API function.
      **/
-    OutOfBounds: GenericPalletError;
+    OutOfBounds: GenericPalletError<Rv>;
 
     /**
      * Input passed to a contract API function failed to decode as expected type.
      **/
-    DecodingFailed: GenericPalletError;
+    DecodingFailed: GenericPalletError<Rv>;
 
     /**
      * Contract trapped during execution.
      **/
-    ContractTrapped: GenericPalletError;
+    ContractTrapped: GenericPalletError<Rv>;
 
     /**
      * The size defined in `T::MaxValueSize` was exceeded.
      **/
-    ValueTooLarge: GenericPalletError;
+    ValueTooLarge: GenericPalletError<Rv>;
 
     /**
      * Termination of a contract is not allowed while the contract is already
      * on the call stack. Can be triggered by `seal_terminate`.
      **/
-    TerminatedWhileReentrant: GenericPalletError;
+    TerminatedWhileReentrant: GenericPalletError<Rv>;
 
     /**
      * `seal_call` forwarded this contracts input. It therefore is no longer available.
      **/
-    InputForwarded: GenericPalletError;
+    InputForwarded: GenericPalletError<Rv>;
 
     /**
      * The subject passed to `seal_random` exceeds the limit.
      **/
-    RandomSubjectTooLong: GenericPalletError;
+    RandomSubjectTooLong: GenericPalletError<Rv>;
 
     /**
      * The amount of topics passed to `seal_deposit_events` exceeds the limit.
      **/
-    TooManyTopics: GenericPalletError;
+    TooManyTopics: GenericPalletError<Rv>;
 
     /**
      * The chain does not provide a chain extension. Calling the chain extension results
      * in this error. Note that this usually shouldn't happen as deploying such contracts
      * is rejected.
      **/
-    NoChainExtension: GenericPalletError;
+    NoChainExtension: GenericPalletError<Rv>;
 
     /**
      * A contract with the same AccountId already exists.
      **/
-    DuplicateContract: GenericPalletError;
+    DuplicateContract: GenericPalletError<Rv>;
 
     /**
      * A contract self destructed in its constructor.
      *
      * This can be triggered by a call to `seal_terminate`.
      **/
-    TerminatedInConstructor: GenericPalletError;
+    TerminatedInConstructor: GenericPalletError<Rv>;
 
     /**
      * A call tried to invoke a contract that is flagged as non-reentrant.
@@ -626,22 +626,22 @@ export interface ChainErrors extends GenericChainErrors {
      * into `pallet-contracts`. This would make the whole pallet reentrant with regard to
      * contract code execution which is not supported.
      **/
-    ReentranceDenied: GenericPalletError;
+    ReentranceDenied: GenericPalletError<Rv>;
 
     /**
      * Origin doesn't have enough balance to pay the required storage deposits.
      **/
-    StorageDepositNotEnoughFunds: GenericPalletError;
+    StorageDepositNotEnoughFunds: GenericPalletError<Rv>;
 
     /**
      * More storage was created than allowed by the storage deposit limit.
      **/
-    StorageDepositLimitExhausted: GenericPalletError;
+    StorageDepositLimitExhausted: GenericPalletError<Rv>;
 
     /**
      * Code removal was denied because the code is still in use by at least one contract.
      **/
-    CodeInUse: GenericPalletError;
+    CodeInUse: GenericPalletError<Rv>;
 
     /**
      * The contract ran to completion but decided to revert its storage changes.
@@ -649,7 +649,7 @@ export interface ChainErrors extends GenericChainErrors {
      * or via RPC an `Ok` will be returned. In this case the caller needs to inspect the flags
      * to determine whether a reversion has taken place.
      **/
-    ContractReverted: GenericPalletError;
+    ContractReverted: GenericPalletError<Rv>;
 
     /**
      * The contract's code was found to be invalid during validation.
@@ -661,27 +661,47 @@ export interface ChainErrors extends GenericChainErrors {
      * A more detailed error can be found on the node console if debug messages are enabled
      * by supplying `-lruntime::contracts=debug`.
      **/
-    CodeRejected: GenericPalletError;
+    CodeRejected: GenericPalletError<Rv>;
 
     /**
      * An indetermistic code was used in a context where this is not permitted.
      **/
-    Indeterministic: GenericPalletError;
+    Indeterministic: GenericPalletError<Rv>;
 
     /**
      * A pending migration needs to complete before the extrinsic can be called.
      **/
-    MigrationInProgress: GenericPalletError;
+    MigrationInProgress: GenericPalletError<Rv>;
 
     /**
      * Migrate dispatch call was attempted but no migration was performed.
      **/
-    NoMigrationPerformed: GenericPalletError;
+    NoMigrationPerformed: GenericPalletError<Rv>;
+
+    /**
+     * The contract has reached its maximum number of delegate dependencies.
+     **/
+    MaxDelegateDependenciesReached: GenericPalletError<Rv>;
+
+    /**
+     * The dependency was not found in the contract's delegate dependencies.
+     **/
+    DelegateDependencyNotFound: GenericPalletError<Rv>;
+
+    /**
+     * The contract already depends on the given delegate dependency.
+     **/
+    DelegateDependencyAlreadyExists: GenericPalletError<Rv>;
+
+    /**
+     * Can not add a delegate dependency to the code hash of the contract itself.
+     **/
+    CannotAddSelfAsDelegateDependency: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `NominationPools`'s errors
@@ -690,44 +710,44 @@ export interface ChainErrors extends GenericChainErrors {
     /**
      * A (bonded) pool id does not exist.
      **/
-    PoolNotFound: GenericPalletError;
+    PoolNotFound: GenericPalletError<Rv>;
 
     /**
      * An account is not a member.
      **/
-    PoolMemberNotFound: GenericPalletError;
+    PoolMemberNotFound: GenericPalletError<Rv>;
 
     /**
      * A reward pool does not exist. In all cases this is a system logic error.
      **/
-    RewardPoolNotFound: GenericPalletError;
+    RewardPoolNotFound: GenericPalletError<Rv>;
 
     /**
      * A sub pool does not exist.
      **/
-    SubPoolsNotFound: GenericPalletError;
+    SubPoolsNotFound: GenericPalletError<Rv>;
 
     /**
      * An account is already delegating in another pool. An account may only belong to one
      * pool at a time.
      **/
-    AccountBelongsToOtherPool: GenericPalletError;
+    AccountBelongsToOtherPool: GenericPalletError<Rv>;
 
     /**
      * The member is fully unbonded (and thus cannot access the bonded and reward pool
      * anymore to, for example, collect rewards).
      **/
-    FullyUnbonding: GenericPalletError;
+    FullyUnbonding: GenericPalletError<Rv>;
 
     /**
      * The member cannot unbond further chunks due to reaching the limit.
      **/
-    MaxUnbondingLimit: GenericPalletError;
+    MaxUnbondingLimit: GenericPalletError<Rv>;
 
     /**
      * None of the funds can be withdrawn yet because the bonding duration has not passed.
      **/
-    CannotWithdrawAny: GenericPalletError;
+    CannotWithdrawAny: GenericPalletError<Rv>;
 
     /**
      * The amount does not meet the minimum bond to either join or create a pool.
@@ -736,124 +756,124 @@ export interface ChainErrors extends GenericChainErrors {
      * `Pallet::depositor_min_bond`. The caller does not have nominating
      * permissions for the pool. Members can never unbond to a value below `MinJoinBond`.
      **/
-    MinimumBondNotMet: GenericPalletError;
+    MinimumBondNotMet: GenericPalletError<Rv>;
 
     /**
      * The transaction could not be executed due to overflow risk for the pool.
      **/
-    OverflowRisk: GenericPalletError;
+    OverflowRisk: GenericPalletError<Rv>;
 
     /**
      * A pool must be in [`PoolState::Destroying`] in order for the depositor to unbond or for
      * other members to be permissionlessly unbonded.
      **/
-    NotDestroying: GenericPalletError;
+    NotDestroying: GenericPalletError<Rv>;
 
     /**
      * The caller does not have nominating permissions for the pool.
      **/
-    NotNominator: GenericPalletError;
+    NotNominator: GenericPalletError<Rv>;
 
     /**
      * Either a) the caller cannot make a valid kick or b) the pool is not destroying.
      **/
-    NotKickerOrDestroying: GenericPalletError;
+    NotKickerOrDestroying: GenericPalletError<Rv>;
 
     /**
      * The pool is not open to join
      **/
-    NotOpen: GenericPalletError;
+    NotOpen: GenericPalletError<Rv>;
 
     /**
      * The system is maxed out on pools.
      **/
-    MaxPools: GenericPalletError;
+    MaxPools: GenericPalletError<Rv>;
 
     /**
      * Too many members in the pool or system.
      **/
-    MaxPoolMembers: GenericPalletError;
+    MaxPoolMembers: GenericPalletError<Rv>;
 
     /**
      * The pools state cannot be changed.
      **/
-    CanNotChangeState: GenericPalletError;
+    CanNotChangeState: GenericPalletError<Rv>;
 
     /**
      * The caller does not have adequate permissions.
      **/
-    DoesNotHavePermission: GenericPalletError;
+    DoesNotHavePermission: GenericPalletError<Rv>;
 
     /**
      * Metadata exceeds [`Config::MaxMetadataLen`]
      **/
-    MetadataExceedsMaxLen: GenericPalletError;
+    MetadataExceedsMaxLen: GenericPalletError<Rv>;
 
     /**
      * Some error occurred that should never happen. This should be reported to the
      * maintainers.
      **/
-    Defensive: GenericPalletError;
+    Defensive: GenericPalletError<Rv>;
 
     /**
      * Partial unbonding now allowed permissionlessly.
      **/
-    PartialUnbondNotAllowedPermissionlessly: GenericPalletError;
+    PartialUnbondNotAllowedPermissionlessly: GenericPalletError<Rv>;
 
     /**
      * The pool's max commission cannot be set higher than the existing value.
      **/
-    MaxCommissionRestricted: GenericPalletError;
+    MaxCommissionRestricted: GenericPalletError<Rv>;
 
     /**
      * The supplied commission exceeds the max allowed commission.
      **/
-    CommissionExceedsMaximum: GenericPalletError;
+    CommissionExceedsMaximum: GenericPalletError<Rv>;
 
     /**
      * The supplied commission exceeds global maximum commission.
      **/
-    CommissionExceedsGlobalMaximum: GenericPalletError;
+    CommissionExceedsGlobalMaximum: GenericPalletError<Rv>;
 
     /**
      * Not enough blocks have surpassed since the last commission update.
      **/
-    CommissionChangeThrottled: GenericPalletError;
+    CommissionChangeThrottled: GenericPalletError<Rv>;
 
     /**
      * The submitted changes to commission change rate are not allowed.
      **/
-    CommissionChangeRateNotAllowed: GenericPalletError;
+    CommissionChangeRateNotAllowed: GenericPalletError<Rv>;
 
     /**
      * There is no pending commission to claim.
      **/
-    NoPendingCommission: GenericPalletError;
+    NoPendingCommission: GenericPalletError<Rv>;
 
     /**
      * No commission current has been set.
      **/
-    NoCommissionCurrentSet: GenericPalletError;
+    NoCommissionCurrentSet: GenericPalletError<Rv>;
 
     /**
      * Pool id currently in use.
      **/
-    PoolIdInUse: GenericPalletError;
+    PoolIdInUse: GenericPalletError<Rv>;
 
     /**
      * Pool id provided is not correct/usable.
      **/
-    InvalidPoolId: GenericPalletError;
+    InvalidPoolId: GenericPalletError<Rv>;
 
     /**
      * Bonding extra is restricted to the exact pending reward amount.
      **/
-    BondExtraRestricted: GenericPalletError;
+    BondExtraRestricted: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `Identity`'s errors
@@ -862,97 +882,97 @@ 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>;
 
     /**
      * Too many additional fields.
      **/
-    TooManyFields: GenericPalletError;
+    TooManyFields: 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>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
   /**
    * Pallet `CommitteeManagement`'s errors
@@ -964,22 +984,71 @@ export interface ChainErrors extends GenericChainErrors {
      * * `underperformed_session_count_threshold` must be a positive number,
      * * `clean_session_counter_delay` must be a positive number.
      **/
-    InvalidBanConfig: GenericPalletError;
+    InvalidBanConfig: GenericPalletError<Rv>;
 
     /**
      * Ban reason is too big, ie given vector of bytes is greater than
      * [`primitives::DEFAULT_BAN_REASON_LENGTH`]
      **/
-    BanReasonTooBig: GenericPalletError;
+    BanReasonTooBig: GenericPalletError<Rv>;
 
     /**
      * Lenient threshold not in [0-100] range
      **/
-    InvalidLenientThreshold: GenericPalletError;
+    InvalidLenientThreshold: GenericPalletError<Rv>;
+
+    /**
+     * Generic pallet error
+     **/
+    [error: string]: GenericPalletError<Rv>;
+  };
+  /**
+   * Pallet `Proxy`'s errors
+   **/
+  proxy: {
+    /**
+     * There are too many proxies registered or too many announcements pending.
+     **/
+    TooMany: GenericPalletError<Rv>;
+
+    /**
+     * Proxy registration not found.
+     **/
+    NotFound: GenericPalletError<Rv>;
+
+    /**
+     * Sender is not a proxy of the account to be proxied.
+     **/
+    NotProxy: GenericPalletError<Rv>;
+
+    /**
+     * A call which is incompatible with the proxy type's filter was attempted.
+     **/
+    Unproxyable: GenericPalletError<Rv>;
+
+    /**
+     * Account is already a proxy.
+     **/
+    Duplicate: GenericPalletError<Rv>;
+
+    /**
+     * Call may not be made by proxy because it may escalate its privileges.
+     **/
+    NoPermission: GenericPalletError<Rv>;
+
+    /**
+     * Announcement, if made at all, was made too recently.
+     **/
+    Unannounced: GenericPalletError<Rv>;
+
+    /**
+     * Cannot add self as proxy.
+     **/
+    NoSelfProxy: GenericPalletError<Rv>;
 
     /**
      * Generic pallet error
      **/
-    [error: string]: GenericPalletError;
+    [error: string]: GenericPalletError<Rv>;
   };
 }