@polkadot/api-augment/cjs/substrate/errors.d.ts

API generated augmentation

import '@polkadot/api-base/types/errors';
import type { ApiTypes, AugmentedError } from '@polkadot/api-base/types';
export type __AugmentedError<ApiType extends ApiTypes> = AugmentedError<ApiType>;
declare module '@polkadot/api-base/types/errors' {
    interface AugmentedErrors<ApiType extends ApiTypes> {
        alliance: {
            /**
             * Account has been deemed unscrupulous by the Alliance and is not welcome to join or be
             * nominated.
             **/
            AccountNonGrata: AugmentedError<ApiType>;
            /**
             * The Alliance has been initialized, therefore cannot be initialized again.
             **/
            AllianceAlreadyInitialized: AugmentedError<ApiType>;
            /**
             * The Alliance has not been initialized yet, therefore accounts cannot join it.
             **/
            AllianceNotYetInitialized: AugmentedError<ApiType>;
            /**
             * Account is already an elevated (fellow) member.
             **/
            AlreadyElevated: AugmentedError<ApiType>;
            /**
             * Account is already a member.
             **/
            AlreadyMember: AugmentedError<ApiType>;
            /**
             * Account already gave retirement notice
             **/
            AlreadyRetiring: AugmentedError<ApiType>;
            /**
             * Item is already listed as unscrupulous.
             **/
            AlreadyUnscrupulous: AugmentedError<ApiType>;
            /**
             * Invalid witness data given.
             **/
            BadWitness: AugmentedError<ApiType>;
            /**
             * Fellows must be provided to initialize the Alliance.
             **/
            FellowsMissing: AugmentedError<ApiType>;
            /**
             * Balance is insufficient for the required deposit.
             **/
            InsufficientFunds: AugmentedError<ApiType>;
            /**
             * The announcement is not found.
             **/
            MissingAnnouncement: AugmentedError<ApiType>;
            /**
             * The proposal hash is not found.
             **/
            MissingProposalHash: AugmentedError<ApiType>;
            /**
             * Account is not an ally.
             **/
            NotAlly: AugmentedError<ApiType>;
            /**
             * Item has not been deemed unscrupulous.
             **/
            NotListedAsUnscrupulous: AugmentedError<ApiType>;
            /**
             * Account is not a member.
             **/
            NotMember: AugmentedError<ApiType>;
            /**
             * Account does not have voting rights.
             **/
            NoVotingRights: AugmentedError<ApiType>;
            /**
             * Account did not give a retirement notice required to retire.
             **/
            RetirementNoticeNotGiven: AugmentedError<ApiType>;
            /**
             * Retirement period has not passed.
             **/
            RetirementPeriodNotPassed: AugmentedError<ApiType>;
            /**
             * Length of website URL exceeds `MaxWebsiteUrlLength`.
             **/
            TooLongWebsiteUrl: AugmentedError<ApiType>;
            /**
             * Number of announcements exceeds `MaxAnnouncementsCount`.
             **/
            TooManyAnnouncements: AugmentedError<ApiType>;
            /**
             * Number of members exceeds `MaxMembersCount`.
             **/
            TooManyMembers: AugmentedError<ApiType>;
            /**
             * The number of unscrupulous items exceeds `MaxUnscrupulousItems`.
             **/
            TooManyUnscrupulousItems: AugmentedError<ApiType>;
            /**
             * The account's identity has no good judgement.
             **/
            WithoutGoodIdentityJudgement: AugmentedError<ApiType>;
            /**
             * The account's identity does not have display field and website field.
             **/
            WithoutRequiredIdentityFields: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        allianceMotion: {
            /**
             * Members are already initialized!
             **/
            AlreadyInitialized: AugmentedError<ApiType>;
            /**
             * Duplicate proposals not allowed
             **/
            DuplicateProposal: AugmentedError<ApiType>;
            /**
             * Duplicate vote ignored
             **/
            DuplicateVote: AugmentedError<ApiType>;
            /**
             * Account is not a member
             **/
            NotMember: AugmentedError<ApiType>;
            /**
             * Prime account is not a member
             **/
            PrimeAccountNotMember: AugmentedError<ApiType>;
            /**
             * Proposal is still active.
             **/
            ProposalActive: AugmentedError<ApiType>;
            /**
             * Proposal must exist
             **/
            ProposalMissing: AugmentedError<ApiType>;
            /**
             * The close call was made too early, before the end of the voting.
             **/
            TooEarly: AugmentedError<ApiType>;
            /**
             * There can only be a maximum of `MaxProposals` active proposals.
             **/
            TooManyProposals: AugmentedError<ApiType>;
            /**
             * Mismatched index
             **/
            WrongIndex: AugmentedError<ApiType>;
            /**
             * The given length bound for the proposal was too low.
             **/
            WrongProposalLength: AugmentedError<ApiType>;
            /**
             * The given weight bound for the proposal was too low.
             **/
            WrongProposalWeight: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        assetConversion: {
            /**
             * Provided amount should be greater than or equal to the existential deposit/asset's
             * minimal amount.
             **/
            AmountOneLessThanMinimal: AugmentedError<ApiType>;
            /**
             * Desired amount can't be equal to the pool reserve.
             **/
            AmountOutTooHigh: AugmentedError<ApiType>;
            /**
             * Provided amount should be greater than or equal to the existential deposit/asset's
             * minimal amount.
             **/
            AmountTwoLessThanMinimal: AugmentedError<ApiType>;
            /**
             * The minimal amount requirement for the first token in the pair wasn't met.
             **/
            AssetOneDepositDidNotMeetMinimum: AugmentedError<ApiType>;
            /**
             * The minimal amount requirement for the first token in the pair wasn't met.
             **/
            AssetOneWithdrawalDidNotMeetMinimum: AugmentedError<ApiType>;
            /**
             * The minimal amount requirement for the second token in the pair wasn't met.
             **/
            AssetTwoDepositDidNotMeetMinimum: AugmentedError<ApiType>;
            /**
             * The minimal amount requirement for the second token in the pair wasn't met.
             **/
            AssetTwoWithdrawalDidNotMeetMinimum: AugmentedError<ApiType>;
            /**
             * The destination account cannot exist with the swapped funds.
             **/
            BelowMinimum: AugmentedError<ApiType>;
            /**
             * It was not possible to get or increment the Id of the pool.
             **/
            IncorrectPoolAssetId: AugmentedError<ApiType>;
            /**
             * Insufficient liquidity minted.
             **/
            InsufficientLiquidityMinted: AugmentedError<ApiType>;
            /**
             * Provided asset pair is not supported for pool.
             **/
            InvalidAssetPair: AugmentedError<ApiType>;
            /**
             * The provided path must consists of 2 assets at least.
             **/
            InvalidPath: AugmentedError<ApiType>;
            /**
             * The provided path must consists of unique assets.
             **/
            NonUniquePath: AugmentedError<ApiType>;
            /**
             * Optimal calculated amount is less than desired.
             **/
            OptimalAmountLessThanDesired: AugmentedError<ApiType>;
            /**
             * An overflow happened.
             **/
            Overflow: AugmentedError<ApiType>;
            /**
             * Pool already exists.
             **/
            PoolExists: AugmentedError<ApiType>;
            /**
             * The pool doesn't exist.
             **/
            PoolNotFound: AugmentedError<ApiType>;
            /**
             * Provided maximum amount is not sufficient for swap.
             **/
            ProvidedMaximumNotSufficientForSwap: AugmentedError<ApiType>;
            /**
             * Calculated amount out is less than provided minimum amount.
             **/
            ProvidedMinimumNotSufficientForSwap: AugmentedError<ApiType>;
            /**
             * Reserve needs to always be greater than or equal to the existential deposit/asset's
             * minimal amount.
             **/
            ReserveLeftLessThanMinimal: AugmentedError<ApiType>;
            /**
             * Desired amount can't be zero.
             **/
            WrongDesiredAmount: AugmentedError<ApiType>;
            /**
             * Amount can't be zero.
             **/
            ZeroAmount: AugmentedError<ApiType>;
            /**
             * Requested liquidity can't be zero.
             **/
            ZeroLiquidity: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        assetConversionMigration: {
            /**
             * Provided asset pair is not supported for pool.
             **/
            InvalidAssetPair: AugmentedError<ApiType>;
            /**
             * Indicates a partial transfer of balance to the new account during a migration.
             **/
            PartialTransfer: AugmentedError<ApiType>;
            /**
             * The pool doesn't exist.
             **/
            PoolNotFound: AugmentedError<ApiType>;
            /**
             * Pool's balance cannot be zero.
             **/
            ZeroBalance: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        assetRate: {
            /**
             * The given asset ID already has an assigned conversion rate and cannot be re-created.
             **/
            AlreadyExists: AugmentedError<ApiType>;
            /**
             * Overflow ocurred when calculating the inverse rate.
             **/
            Overflow: AugmentedError<ApiType>;
            /**
             * The given asset ID is unknown.
             **/
            UnknownAssetKind: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        assetRewards: {
            /**
             * There was an error converting a block number.
             **/
            BlockNumberConversionError: AugmentedError<ApiType>;
            /**
             * The expiry block must be in the future.
             **/
            ExpiryBlockMustBeInTheFuture: AugmentedError<ApiType>;
            /**
             * The expiry block can be only extended.
             **/
            ExpiryCut: AugmentedError<ApiType>;
            /**
             * Insufficient funds to create the freeze.
             **/
            InsufficientFunds: AugmentedError<ApiType>;
            /**
             * The pool still has staked tokens or rewards.
             **/
            NonEmptyPool: AugmentedError<ApiType>;
            /**
             * An operation was attempted with a non-existent asset.
             **/
            NonExistentAsset: AugmentedError<ApiType>;
            /**
             * An operation was attempted on a non-existent pool.
             **/
            NonExistentPool: AugmentedError<ApiType>;
            /**
             * An operation was attempted for a non-existent staker.
             **/
            NonExistentStaker: AugmentedError<ApiType>;
            /**
             * The staker does not have enough tokens to perform the operation.
             **/
            NotEnoughTokens: AugmentedError<ApiType>;
            /**
             * The reward rate per block can be only increased.
             **/
            RewardRateCut: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        assets: {
            /**
             * The asset-account already exists.
             **/
            AlreadyExists: AugmentedError<ApiType>;
            /**
             * The asset is not live, and likely being destroyed.
             **/
            AssetNotLive: AugmentedError<ApiType>;
            /**
             * The asset ID must be equal to the [`NextAssetId`].
             **/
            BadAssetId: AugmentedError<ApiType>;
            /**
             * Invalid metadata given.
             **/
            BadMetadata: AugmentedError<ApiType>;
            /**
             * Invalid witness data given.
             **/
            BadWitness: AugmentedError<ApiType>;
            /**
             * Account balance must be greater than or equal to the transfer amount.
             **/
            BalanceLow: AugmentedError<ApiType>;
            /**
             * Callback action resulted in error
             **/
            CallbackFailed: AugmentedError<ApiType>;
            /**
             * The asset cannot be destroyed because some accounts for this asset contain freezes.
             **/
            ContainsFreezes: AugmentedError<ApiType>;
            /**
             * The asset cannot be destroyed because some accounts for this asset contain holds.
             **/
            ContainsHolds: AugmentedError<ApiType>;
            /**
             * The origin account is frozen.
             **/
            Frozen: AugmentedError<ApiType>;
            /**
             * The asset status is not the expected status.
             **/
            IncorrectStatus: AugmentedError<ApiType>;
            /**
             * The asset ID is already taken.
             **/
            InUse: AugmentedError<ApiType>;
            /**
             * The asset is a live asset and is actively being used. Usually emit for operations such
             * as `start_destroy` which require the asset to be in a destroying state.
             **/
            LiveAsset: AugmentedError<ApiType>;
            /**
             * Minimum balance should be non-zero.
             **/
            MinBalanceZero: AugmentedError<ApiType>;
            /**
             * The account to alter does not exist.
             **/
            NoAccount: AugmentedError<ApiType>;
            /**
             * The asset-account doesn't have an associated deposit.
             **/
            NoDeposit: AugmentedError<ApiType>;
            /**
             * The signing account has no permission to do the operation.
             **/
            NoPermission: AugmentedError<ApiType>;
            /**
             * The asset should be frozen before the given operation.
             **/
            NotFrozen: AugmentedError<ApiType>;
            /**
             * No approval exists that would allow the transfer.
             **/
            Unapproved: AugmentedError<ApiType>;
            /**
             * Unable to increment the consumer reference counters on the account. Either no provider
             * reference exists to allow a non-zero balance of a non-self-sufficient asset, or one
             * fewer then the maximum number of consumers has been reached.
             **/
            UnavailableConsumer: AugmentedError<ApiType>;
            /**
             * The given asset ID is unknown.
             **/
            Unknown: AugmentedError<ApiType>;
            /**
             * The operation would result in funds being burned.
             **/
            WouldBurn: AugmentedError<ApiType>;
            /**
             * The source account would not survive the transfer and it needs to stay alive.
             **/
            WouldDie: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        assetsFreezer: {
            /**
             * Number of freezes on an account would exceed `MaxFreezes`.
             **/
            TooManyFreezes: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        babe: {
            /**
             * A given equivocation report is valid but already previously reported.
             **/
            DuplicateOffenceReport: AugmentedError<ApiType>;
            /**
             * Submitted configuration is invalid.
             **/
            InvalidConfiguration: AugmentedError<ApiType>;
            /**
             * An equivocation proof provided as part of an equivocation report is invalid.
             **/
            InvalidEquivocationProof: AugmentedError<ApiType>;
            /**
             * A key ownership proof provided as part of an equivocation report is invalid.
             **/
            InvalidKeyOwnershipProof: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        balances: {
            /**
             * Beneficiary account must pre-exist.
             **/
            DeadAccount: AugmentedError<ApiType>;
            /**
             * The delta cannot be zero.
             **/
            DeltaZero: AugmentedError<ApiType>;
            /**
             * Value too low to create account due to existential deposit.
             **/
            ExistentialDeposit: AugmentedError<ApiType>;
            /**
             * A vesting schedule already exists for this account.
             **/
            ExistingVestingSchedule: AugmentedError<ApiType>;
            /**
             * Transfer/payment would kill account.
             **/
            Expendability: AugmentedError<ApiType>;
            /**
             * Balance too low to send value.
             **/
            InsufficientBalance: AugmentedError<ApiType>;
            /**
             * The issuance cannot be modified since it is already deactivated.
             **/
            IssuanceDeactivated: AugmentedError<ApiType>;
            /**
             * Account liquidity restrictions prevent withdrawal.
             **/
            LiquidityRestrictions: AugmentedError<ApiType>;
            /**
             * Number of freezes exceed `MaxFreezes`.
             **/
            TooManyFreezes: AugmentedError<ApiType>;
            /**
             * Number of holds exceed `VariantCountOf<T::RuntimeHoldReason>`.
             **/
            TooManyHolds: AugmentedError<ApiType>;
            /**
             * Number of named reserves exceed `MaxReserves`.
             **/
            TooManyReserves: AugmentedError<ApiType>;
            /**
             * Vesting balance too high to send value.
             **/
            VestingBalance: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        beefy: {
            /**
             * A given equivocation report is valid but already previously reported.
             **/
            DuplicateOffenceReport: AugmentedError<ApiType>;
            /**
             * Submitted configuration is invalid.
             **/
            InvalidConfiguration: AugmentedError<ApiType>;
            /**
             * A double voting proof provided as part of an equivocation report is invalid.
             **/
            InvalidDoubleVotingProof: AugmentedError<ApiType>;
            /**
             * The session of the equivocation proof is invalid
             **/
            InvalidEquivocationProofSession: AugmentedError<ApiType>;
            /**
             * A fork voting proof provided as part of an equivocation report is invalid.
             **/
            InvalidForkVotingProof: AugmentedError<ApiType>;
            /**
             * A future block voting proof provided as part of an equivocation report is invalid.
             **/
            InvalidFutureBlockVotingProof: AugmentedError<ApiType>;
            /**
             * A key ownership proof provided as part of an equivocation report is invalid.
             **/
            InvalidKeyOwnershipProof: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        bounties: {
            /**
             * The bounty cannot be closed because it has active child bounties.
             **/
            HasActiveChildBounty: AugmentedError<ApiType>;
            /**
             * Proposer's balance is too low.
             **/
            InsufficientProposersBalance: AugmentedError<ApiType>;
            /**
             * Invalid bounty fee.
             **/
            InvalidFee: AugmentedError<ApiType>;
            /**
             * No proposal or bounty at that index.
             **/
            InvalidIndex: AugmentedError<ApiType>;
            /**
             * Invalid bounty value.
             **/
            InvalidValue: AugmentedError<ApiType>;
            /**
             * A bounty payout is pending.
             * To cancel the bounty, you must unassign and slash the curator.
             **/
            PendingPayout: AugmentedError<ApiType>;
            /**
             * The bounties cannot be claimed/closed because it's still in the countdown period.
             **/
            Premature: AugmentedError<ApiType>;
            /**
             * The reason given is just too big.
             **/
            ReasonTooBig: AugmentedError<ApiType>;
            /**
             * Require bounty curator.
             **/
            RequireCurator: AugmentedError<ApiType>;
            /**
             * Too many approvals are already queued.
             **/
            TooManyQueued: AugmentedError<ApiType>;
            /**
             * The bounty status is unexpected.
             **/
            UnexpectedStatus: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        broker: {
            /**
             * The lease expiry time has already passed.
             **/
            AlreadyExpired: AugmentedError<ApiType>;
            /**
             * Attempted to force remove an assignment that doesn't exist.
             **/
            AssignmentNotFound: AugmentedError<ApiType>;
            /**
             * Attempted to disable auto-renewal for a core that didn't have it enabled.
             **/
            AutoRenewalNotEnabled: AugmentedError<ApiType>;
            /**
             * The pivot mask for the interlacing is complete (and therefore not a strict subset).
             **/
            CompletePivot: AugmentedError<ApiType>;
            /**
             * The workplan of the pallet's state is invalid. This indicates a state corruption.
             **/
            CorruptWorkplan: AugmentedError<ApiType>;
            /**
             * Needed to prevent spam attacks.The amount of credits the user attempted to purchase is
             * below `T::MinimumCreditPurchase`.
             **/
            CreditPurchaseTooSmall: AugmentedError<ApiType>;
            /**
             * The pivot mask for the interlacing is not contained within the region's interlace mask.
             **/
            ExteriorPivot: AugmentedError<ApiType>;
            /**
             * The workload assigned for renewal is incomplete. This is unexpected and indicates a
             * logic error.
             **/
            IncompleteAssignment: AugmentedError<ApiType>;
            /**
             * The configuration could not be applied because it is invalid.
             **/
            InvalidConfig: AugmentedError<ApiType>;
            /**
             * The lease does not exist.
             **/
            LeaseNotFound: AugmentedError<ApiType>;
            /**
             * The revenue must be claimed for 1 or more timeslices.
             **/
            NoClaimTimeslices: AugmentedError<ApiType>;
            /**
             * The history item does not exist.
             **/
            NoHistory: AugmentedError<ApiType>;
            /**
             * Only cores which are assigned to a task can be auto-renewed.
             **/
            NonTaskAutoRenewal: AugmentedError<ApiType>;
            /**
             * The caller doesn't have the permission to enable or disable auto-renewal.
             **/
            NoPermission: AugmentedError<ApiType>;
            /**
             * There is no sale happening currently.
             **/
            NoSales: AugmentedError<ApiType>;
            /**
             * Invalid attempt to renew.
             **/
            NotAllowed: AugmentedError<ApiType>;
            /**
             * There is no work to be done.
             **/
            NothingToDo: AugmentedError<ApiType>;
            /**
             * The owner of the region is not the origin.
             **/
            NotOwner: AugmentedError<ApiType>;
            /**
             * The price limit is exceeded.
             **/
            Overpriced: AugmentedError<ApiType>;
            /**
             * The pivot point of the partition at the beginning of the region.
             **/
            PivotTooEarly: AugmentedError<ApiType>;
            /**
             * The pivot point of the partition at or after the end of the region.
             **/
            PivotTooLate: AugmentedError<ApiType>;
            /**
             * The sale limit has been reached.
             **/
            SoldOut: AugmentedError<ApiType>;
            /**
             * Failed to get the sovereign account of a task.
             **/
            SovereignAccountNotFound: AugmentedError<ApiType>;
            /**
             * An item cannot be dropped because it is still valid.
             **/
            StillValid: AugmentedError<ApiType>;
            /**
             * The purchase cannot happen yet as the sale period is yet to begin.
             **/
            TooEarly: AugmentedError<ApiType>;
            /**
             * We reached the limit for auto-renewals.
             **/
            TooManyAutoRenewals: AugmentedError<ApiType>;
            /**
             * The maximum amount of leases has already been reached.
             **/
            TooManyLeases: AugmentedError<ApiType>;
            /**
             * The maximum amount of reservations has already been reached.
             **/
            TooManyReservations: AugmentedError<ApiType>;
            /**
             * There are no cores available.
             **/
            Unavailable: AugmentedError<ApiType>;
            /**
             * This pallet has not yet been initialized.
             **/
            Uninitialized: AugmentedError<ApiType>;
            /**
             * The identified contribution to the Instantaneous Core Pool is unknown.
             **/
            UnknownContribution: AugmentedError<ApiType>;
            /**
             * The given region identity is not known.
             **/
            UnknownRegion: AugmentedError<ApiType>;
            /**
             * The renewal record cannot be found.
             **/
            UnknownRenewal: AugmentedError<ApiType>;
            /**
             * No reservation of the given index exists.
             **/
            UnknownReservation: AugmentedError<ApiType>;
            /**
             * The revenue for the Instantaneous Core Sales of this period is not (yet) known and thus
             * this operation cannot proceed.
             **/
            UnknownRevenue: AugmentedError<ApiType>;
            /**
             * The pivot mask for the interlacing is void (and therefore unschedulable).
             **/
            VoidPivot: AugmentedError<ApiType>;
            /**
             * The renewal operation is not valid at the current time (it may become valid in the next
             * sale).
             **/
            WrongTime: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        childBounties: {
            /**
             * The bounty balance is not enough to add new child-bounty.
             **/
            InsufficientBountyBalance: AugmentedError<ApiType>;
            /**
             * The parent bounty is not in active state.
             **/
            ParentBountyNotActive: AugmentedError<ApiType>;
            /**
             * Number of child bounties exceeds limit `MaxActiveChildBountyCount`.
             **/
            TooManyChildBounties: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        contracts: {
            /**
             * Can not add a delegate dependency to the code hash of the contract itself.
             **/
            CannotAddSelfAsDelegateDependency: AugmentedError<ApiType>;
            /**
             * No code info could be found at the supplied code hash.
             **/
            CodeInfoNotFound: AugmentedError<ApiType>;
            /**
             * Code removal was denied because the code is still in use by at least one contract.
             **/
            CodeInUse: AugmentedError<ApiType>;
            /**
             * No code could be found at the supplied code hash.
             **/
            CodeNotFound: AugmentedError<ApiType>;
            /**
             * The contract's code was found to be invalid during validation.
             *
             * The most likely cause of this is that an API was used which is not supported by the
             * node. This happens if an older node is used with a new version of ink!. Try updating
             * your node to the newest available version.
             *
             * A more detailed error can be found on the node console if debug messages are enabled
             * by supplying `-lruntime::contracts=debug`.
             **/
            CodeRejected: AugmentedError<ApiType>;
            /**
             * The code supplied to `instantiate_with_code` exceeds the limit specified in the
             * current schedule.
             **/
            CodeTooLarge: AugmentedError<ApiType>;
            /**
             * No contract was found at the specified address.
             **/
            ContractNotFound: AugmentedError<ApiType>;
            /**
             * The contract ran to completion but decided to revert its storage changes.
             * Please note that this error is only returned from extrinsics. When called directly
             * 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: AugmentedError<ApiType>;
            /**
             * Contract trapped during execution.
             **/
            ContractTrapped: AugmentedError<ApiType>;
            /**
             * Input passed to a contract API function failed to decode as expected type.
             **/
            DecodingFailed: AugmentedError<ApiType>;
            /**
             * The contract already depends on the given delegate dependency.
             **/
            DelegateDependencyAlreadyExists: AugmentedError<ApiType>;
            /**
             * The dependency was not found in the contract's delegate dependencies.
             **/
            DelegateDependencyNotFound: AugmentedError<ApiType>;
            /**
             * A contract with the same AccountId already exists.
             **/
            DuplicateContract: AugmentedError<ApiType>;
            /**
             * An indeterministic code was used in a context where this is not permitted.
             **/
            Indeterministic: AugmentedError<ApiType>;
            /**
             * `seal_call` forwarded this contracts input. It therefore is no longer available.
             **/
            InputForwarded: AugmentedError<ApiType>;
            /**
             * Invalid combination of flags supplied to `seal_call` or `seal_delegate_call`.
             **/
            InvalidCallFlags: AugmentedError<ApiType>;
            /**
             * Invalid schedule supplied, e.g. with zero weight of a basic operation.
             **/
            InvalidSchedule: AugmentedError<ApiType>;
            /**
             * Performing a call was denied because the calling depth reached the limit
             * of what is specified in the schedule.
             **/
            MaxCallDepthReached: AugmentedError<ApiType>;
            /**
             * The contract has reached its maximum number of delegate dependencies.
             **/
            MaxDelegateDependenciesReached: AugmentedError<ApiType>;
            /**
             * A pending migration needs to complete before the extrinsic can be called.
             **/
            MigrationInProgress: AugmentedError<ApiType>;
            /**
             * 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: AugmentedError<ApiType>;
            /**
             * Migrate dispatch call was attempted but no migration was performed.
             **/
            NoMigrationPerformed: AugmentedError<ApiType>;
            /**
             * A buffer outside of sandbox memory was passed to a contract API function.
             **/
            OutOfBounds: AugmentedError<ApiType>;
            /**
             * The executed contract exhausted its gas limit.
             **/
            OutOfGas: AugmentedError<ApiType>;
            /**
             * Can not add more data to transient storage.
             **/
            OutOfTransientStorage: AugmentedError<ApiType>;
            /**
             * The output buffer supplied to a contract API call was too small.
             **/
            OutputBufferTooSmall: AugmentedError<ApiType>;
            /**
             * The subject passed to `seal_random` exceeds the limit.
             **/
            RandomSubjectTooLong: AugmentedError<ApiType>;
            /**
             * A call tried to invoke a contract that is flagged as non-reentrant.
             * The only other cause is that a call from a contract into the runtime tried to call back
             * into `pallet-contracts`. This would make the whole pallet reentrant with regard to
             * contract code execution which is not supported.
             **/
            ReentranceDenied: AugmentedError<ApiType>;
            /**
             * A contract attempted to invoke a state modifying API while being in read-only mode.
             **/
            StateChangeDenied: AugmentedError<ApiType>;
            /**
             * More storage was created than allowed by the storage deposit limit.
             **/
            StorageDepositLimitExhausted: AugmentedError<ApiType>;
            /**
             * Origin doesn't have enough balance to pay the required storage deposits.
             **/
            StorageDepositNotEnoughFunds: AugmentedError<ApiType>;
            /**
             * A contract self destructed in its constructor.
             *
             * This can be triggered by a call to `seal_terminate`.
             **/
            TerminatedInConstructor: AugmentedError<ApiType>;
            /**
             * Termination of a contract is not allowed while the contract is already
             * on the call stack. Can be triggered by `seal_terminate`.
             **/
            TerminatedWhileReentrant: AugmentedError<ApiType>;
            /**
             * The amount of topics passed to `seal_deposit_events` exceeds the limit.
             **/
            TooManyTopics: AugmentedError<ApiType>;
            /**
             * Performing the requested transfer failed. Probably because there isn't enough
             * free balance in the sender's account.
             **/
            TransferFailed: AugmentedError<ApiType>;
            /**
             * The size defined in `T::MaxValueSize` was exceeded.
             **/
            ValueTooLarge: AugmentedError<ApiType>;
            /**
             * Failed to decode the XCM program.
             **/
            XCMDecodeFailed: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        convictionVoting: {
            /**
             * The account is already delegating.
             **/
            AlreadyDelegating: AugmentedError<ApiType>;
            /**
             * The account currently has votes attached to it and the operation cannot succeed until
             * these are removed through `remove_vote`.
             **/
            AlreadyVoting: AugmentedError<ApiType>;
            /**
             * The class ID supplied is invalid.
             **/
            BadClass: AugmentedError<ApiType>;
            /**
             * The class must be supplied since it is not easily determinable from the state.
             **/
            ClassNeeded: AugmentedError<ApiType>;
            /**
             * Too high a balance was provided that the account cannot afford.
             **/
            InsufficientFunds: AugmentedError<ApiType>;
            /**
             * Maximum number of votes reached.
             **/
            MaxVotesReached: AugmentedError<ApiType>;
            /**
             * Delegation to oneself makes no sense.
             **/
            Nonsense: AugmentedError<ApiType>;
            /**
             * The actor has no permission to conduct the action.
             **/
            NoPermission: AugmentedError<ApiType>;
            /**
             * The actor has no permission to conduct the action right now but will do in the future.
             **/
            NoPermissionYet: AugmentedError<ApiType>;
            /**
             * The account is not currently delegating.
             **/
            NotDelegating: AugmentedError<ApiType>;
            /**
             * Poll is not ongoing.
             **/
            NotOngoing: AugmentedError<ApiType>;
            /**
             * The given account did not vote on the poll.
             **/
            NotVoter: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        coreFellowship: {
            /**
             * The candidate has already been inducted. This should never happen since it would
             * require a candidate (rank 0) to already be tracked in the pallet.
             **/
            AlreadyInducted: AugmentedError<ApiType>;
            /**
             * The given rank is invalid - this generally means it's not between 1 and `RANK_COUNT`.
             **/
            InvalidRank: AugmentedError<ApiType>;
            /**
             * The origin does not have enough permission to do this operation.
             **/
            NoPermission: AugmentedError<ApiType>;
            /**
             * No work needs to be done at present for this member.
             **/
            NothingDoing: AugmentedError<ApiType>;
            /**
             * The candidate has not been inducted, so cannot be offboarded from this pallet.
             **/
            NotTracked: AugmentedError<ApiType>;
            /**
             * Member's rank is not zero.
             **/
            Ranked: AugmentedError<ApiType>;
            /**
             * Operation cannot be done yet since not enough time has passed.
             **/
            TooSoon: AugmentedError<ApiType>;
            /**
             * Member's rank is not as expected - generally means that the rank provided to the call
             * does not agree with the state of the system.
             **/
            UnexpectedRank: AugmentedError<ApiType>;
            /**
             * Member's rank is too low.
             **/
            Unranked: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        council: {
            /**
             * Members are already initialized!
             **/
            AlreadyInitialized: AugmentedError<ApiType>;
            /**
             * Duplicate proposals not allowed
             **/
            DuplicateProposal: AugmentedError<ApiType>;
            /**
             * Duplicate vote ignored
             **/
            DuplicateVote: AugmentedError<ApiType>;
            /**
             * Account is not a member
             **/
            NotMember: AugmentedError<ApiType>;
            /**
             * Prime account is not a member
             **/
            PrimeAccountNotMember: AugmentedError<ApiType>;
            /**
             * Proposal is still active.
             **/
            ProposalActive: AugmentedError<ApiType>;
            /**
             * Proposal must exist
             **/
            ProposalMissing: AugmentedError<ApiType>;
            /**
             * The close call was made too early, before the end of the voting.
             **/
            TooEarly: AugmentedError<ApiType>;
            /**
             * There can only be a maximum of `MaxProposals` active proposals.
             **/
            TooManyProposals: AugmentedError<ApiType>;
            /**
             * Mismatched index
             **/
            WrongIndex: AugmentedError<ApiType>;
            /**
             * The given length bound for the proposal was too low.
             **/
            WrongProposalLength: AugmentedError<ApiType>;
            /**
             * The given weight bound for the proposal was too low.
             **/
            WrongProposalWeight: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        delegatedStaking: {
            /**
             * An existing staker cannot perform this action.
             **/
            AlreadyStaking: AugmentedError<ApiType>;
            /**
             * Some corruption in internal state.
             **/
            BadState: AugmentedError<ApiType>;
            /**
             * Delegation conditions are not met.
             *
             * Possible issues are
             * 1) Cannot delegate to self,
             * 2) Cannot delegate to multiple delegates.
             **/
            InvalidDelegation: AugmentedError<ApiType>;
            /**
             * Reward Destination cannot be same as `Agent` account.
             **/
            InvalidRewardDestination: AugmentedError<ApiType>;
            /**
             * Not an existing `Agent` account.
             **/
            NotAgent: AugmentedError<ApiType>;
            /**
             * The account cannot perform this operation.
             **/
            NotAllowed: AugmentedError<ApiType>;
            /**
             * Not a Delegator account.
             **/
            NotDelegator: AugmentedError<ApiType>;
            /**
             * The account does not have enough funds to perform the operation.
             **/
            NotEnoughFunds: AugmentedError<ApiType>;
            /**
             * `Agent` has no pending slash to be applied.
             **/
            NothingToSlash: AugmentedError<ApiType>;
            /**
             * Operation not supported by this pallet.
             **/
            NotSupported: AugmentedError<ApiType>;
            /**
             * Unapplied pending slash restricts operation on `Agent`.
             **/
            UnappliedSlash: AugmentedError<ApiType>;
            /**
             * Failed to withdraw amount from Core Staking.
             **/
            WithdrawFailed: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        democracy: {
            /**
             * Cannot cancel the same proposal twice
             **/
            AlreadyCanceled: AugmentedError<ApiType>;
            /**
             * The account is already delegating.
             **/
            AlreadyDelegating: AugmentedError<ApiType>;
            /**
             * Identity may not veto a proposal twice
             **/
            AlreadyVetoed: AugmentedError<ApiType>;
            /**
             * Proposal already made
             **/
            DuplicateProposal: AugmentedError<ApiType>;
            /**
             * The instant referendum origin is currently disallowed.
             **/
            InstantNotAllowed: AugmentedError<ApiType>;
            /**
             * Too high a balance was provided that the account cannot afford.
             **/
            InsufficientFunds: AugmentedError<ApiType>;
            /**
             * Invalid hash
             **/
            InvalidHash: AugmentedError<ApiType>;
            /**
             * Maximum number of votes reached.
             **/
            MaxVotesReached: AugmentedError<ApiType>;
            /**
             * No proposals waiting
             **/
            NoneWaiting: AugmentedError<ApiType>;
            /**
             * Delegation to oneself makes no sense.
             **/
            Nonsense: AugmentedError<ApiType>;
            /**
             * The actor has no permission to conduct the action.
             **/
            NoPermission: AugmentedError<ApiType>;
            /**
             * No external proposal
             **/
            NoProposal: AugmentedError<ApiType>;
            /**
             * The account is not currently delegating.
             **/
            NotDelegating: AugmentedError<ApiType>;
            /**
             * Next external proposal not simple majority
             **/
            NotSimpleMajority: AugmentedError<ApiType>;
            /**
             * The given account did not vote on the referendum.
             **/
            NotVoter: AugmentedError<ApiType>;
            /**
             * The preimage does not exist.
             **/
            PreimageNotExist: AugmentedError<ApiType>;
            /**
             * Proposal still blacklisted
             **/
            ProposalBlacklisted: AugmentedError<ApiType>;
            /**
             * Proposal does not exist
             **/
            ProposalMissing: AugmentedError<ApiType>;
            /**
             * Vote given for invalid referendum
             **/
            ReferendumInvalid: AugmentedError<ApiType>;
            /**
             * Maximum number of items reached.
             **/
            TooMany: AugmentedError<ApiType>;
            /**
             * Value too low
             **/
            ValueLow: AugmentedError<ApiType>;
            /**
             * The account currently has votes attached to it and the operation cannot succeed until
             * these are removed, either through `unvote` or `reap_vote`.
             **/
            VotesExist: AugmentedError<ApiType>;
            /**
             * Voting period too low
             **/
            VotingPeriodLow: AugmentedError<ApiType>;
            /**
             * Invalid upper bound.
             **/
            WrongUpperBound: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        electionProviderMultiPhase: {
            /**
             * Some bound not met
             **/
            BoundNotMet: AugmentedError<ApiType>;
            /**
             * The call is not allowed at this point.
             **/
            CallNotAllowed: AugmentedError<ApiType>;
            /**
             * The fallback failed
             **/
            FallbackFailed: AugmentedError<ApiType>;
            /**
             * `Self::insert_submission` returned an invalid index.
             **/
            InvalidSubmissionIndex: AugmentedError<ApiType>;
            /**
             * Snapshot metadata should exist but didn't.
             **/
            MissingSnapshotMetadata: AugmentedError<ApiType>;
            /**
             * OCW submitted solution for wrong round
             **/
            OcwCallWrongEra: AugmentedError<ApiType>;
            /**
             * Submission was prepared for a different round.
             **/
            PreDispatchDifferentRound: AugmentedError<ApiType>;
            /**
             * Submission was too early.
             **/
            PreDispatchEarlySubmission: AugmentedError<ApiType>;
            /**
             * Submission was too weak, score-wise.
             **/
            PreDispatchWeakSubmission: AugmentedError<ApiType>;