import type { GenericChainErrors, GenericPalletError } from '@dedot/types';
export interface ChainErrors extends GenericChainErrors {
    /**
     * Pallet `System`'s errors
     **/
    system: {
        /**
         * The name of specification does not match between the current runtime
         * and the new runtime.
         **/
        InvalidSpecName: GenericPalletError;
        /**
         * The specification version is not allowed to decrease between the current runtime
         * and the new runtime.
         **/
        SpecVersionNeedsToIncrease: GenericPalletError;
        /**
         * Failed to extract the runtime version from the new runtime.
         *
         * Either calling `Core_version` or decoding `RuntimeVersion` failed.
         **/
        FailedToExtractRuntimeVersion: GenericPalletError;
        /**
         * Suicide called when the account has non-default composite data.
         **/
        NonDefaultComposite: GenericPalletError;
        /**
         * There is a non-zero reference count preventing the account from being purged.
         **/
        NonZeroRefCount: GenericPalletError;
        /**
         * The origin filter prevent the call to be dispatched.
         **/
        CallFiltered: GenericPalletError;
        /**
         * A multi-block migration is ongoing and prevents the current code from being replaced.
         **/
        MultiBlockMigrationsOngoing: GenericPalletError;
        /**
         * No upgrade authorized.
         **/
        NothingAuthorized: GenericPalletError;
        /**
         * The submitted code is not authorized.
         **/
        Unauthorized: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Utility`'s errors
     **/
    utility: {
        /**
         * Too many calls batched.
         **/
        TooManyCalls: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Babe`'s errors
     **/
    babe: {
        /**
         * An equivocation proof provided as part of an equivocation report is invalid.
         **/
        InvalidEquivocationProof: GenericPalletError;
        /**
         * A key ownership proof provided as part of an equivocation report is invalid.
         **/
        InvalidKeyOwnershipProof: GenericPalletError;
        /**
         * A given equivocation report is valid but already previously reported.
         **/
        DuplicateOffenceReport: GenericPalletError;
        /**
         * Submitted configuration is invalid.
         **/
        InvalidConfiguration: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Indices`'s errors
     **/
    indices: {
        /**
         * The index was not already assigned.
         **/
        NotAssigned: GenericPalletError;
        /**
         * The index is assigned to another account.
         **/
        NotOwner: GenericPalletError;
        /**
         * The index was not available.
         **/
        InUse: GenericPalletError;
        /**
         * The source and destination accounts are identical.
         **/
        NotTransfer: GenericPalletError;
        /**
         * The index is permanent and may not be freed/changed.
         **/
        Permanent: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Balances`'s errors
     **/
    balances: {
        /**
         * Vesting balance too high to send value.
         **/
        VestingBalance: GenericPalletError;
        /**
         * Account liquidity restrictions prevent withdrawal.
         **/
        LiquidityRestrictions: GenericPalletError;
        /**
         * Balance too low to send value.
         **/
        InsufficientBalance: GenericPalletError;
        /**
         * Value too low to create account due to existential deposit.
         **/
        ExistentialDeposit: GenericPalletError;
        /**
         * Transfer/payment would kill account.
         **/
        Expendability: GenericPalletError;
        /**
         * A vesting schedule already exists for this account.
         **/
        ExistingVestingSchedule: GenericPalletError;
        /**
         * Beneficiary account must pre-exist.
         **/
        DeadAccount: GenericPalletError;
        /**
         * Number of named reserves exceed `MaxReserves`.
         **/
        TooManyReserves: GenericPalletError;
        /**
         * Number of holds exceed `VariantCountOf<T::RuntimeHoldReason>`.
         **/
        TooManyHolds: GenericPalletError;
        /**
         * Number of freezes exceed `MaxFreezes`.
         **/
        TooManyFreezes: GenericPalletError;
        /**
         * The issuance cannot be modified since it is already deactivated.
         **/
        IssuanceDeactivated: GenericPalletError;
        /**
         * The delta cannot be zero.
         **/
        DeltaZero: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `ElectionProviderMultiPhase`'s errors
     **/
    electionProviderMultiPhase: {
        /**
         * Submission was too early.
         **/
        PreDispatchEarlySubmission: GenericPalletError;
        /**
         * Wrong number of winners presented.
         **/
        PreDispatchWrongWinnerCount: GenericPalletError;
        /**
         * Submission was too weak, score-wise.
         **/
        PreDispatchWeakSubmission: GenericPalletError;
        /**
         * The queue was full, and the solution was not better than any of the existing ones.
         **/
        SignedQueueFull: GenericPalletError;
        /**
         * The origin failed to pay the deposit.
         **/
        SignedCannotPayDeposit: GenericPalletError;
        /**
         * Witness data to dispatchable is invalid.
         **/
        SignedInvalidWitness: GenericPalletError;
        /**
         * The signed submission consumes too much weight
         **/
        SignedTooMuchWeight: GenericPalletError;
        /**
         * OCW submitted solution for wrong round
         **/
        OcwCallWrongEra: GenericPalletError;
        /**
         * Snapshot metadata should exist but didn't.
         **/
        MissingSnapshotMetadata: GenericPalletError;
        /**
         * `Self::insert_submission` returned an invalid index.
         **/
        InvalidSubmissionIndex: GenericPalletError;
        /**
         * The call is not allowed at this point.
         **/
        CallNotAllowed: GenericPalletError;
        /**
         * The fallback failed
         **/
        FallbackFailed: GenericPalletError;
        /**
         * Some bound not met
         **/
        BoundNotMet: GenericPalletError;
        /**
         * Submitted solution has too many winners
         **/
        TooManyWinners: GenericPalletError;
        /**
         * Submission was prepared for a different round.
         **/
        PreDispatchDifferentRound: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Staking`'s errors
     **/
    staking: {
        /**
         * Not a controller account.
         **/
        NotController: GenericPalletError;
        /**
         * Not a stash account.
         **/
        NotStash: GenericPalletError;
        /**
         * Stash is already bonded.
         **/
        AlreadyBonded: GenericPalletError;
        /**
         * Controller is already paired.
         **/
        AlreadyPaired: GenericPalletError;
        /**
         * Targets cannot be empty.
         **/
        EmptyTargets: GenericPalletError;
        /**
         * Duplicate index.
         **/
        DuplicateIndex: GenericPalletError;
        /**
         * Slash record index out of bounds.
         **/
        InvalidSlashIndex: GenericPalletError;
        /**
         * Cannot have a validator or nominator role, with value less than the minimum defined by
         * governance (see `MinValidatorBond` and `MinNominatorBond`). If unbonding is the
         * intention, `chill` first to remove one's role as validator/nominator.
         **/
        InsufficientBond: GenericPalletError;
        /**
         * Can not schedule more unlock chunks.
         **/
        NoMoreChunks: GenericPalletError;
        /**
         * Can not rebond without unlocking chunks.
         **/
        NoUnlockChunk: GenericPalletError;
        /**
         * Attempting to target a stash that still has funds.
         **/
        FundedTarget: GenericPalletError;
        /**
         * Invalid era to reward.
         **/
        InvalidEraToReward: GenericPalletError;
        /**
         * Invalid number of nominations.
         **/
        InvalidNumberOfNominations: GenericPalletError;
        /**
         * Items are not sorted and unique.
         **/
        NotSortedAndUnique: GenericPalletError;
        /**
         * Rewards for this era have already been claimed for this validator.
         **/
        AlreadyClaimed: GenericPalletError;
        /**
         * No nominators exist on this page.
         **/
        InvalidPage: GenericPalletError;
        /**
         * Incorrect previous history depth input provided.
         **/
        IncorrectHistoryDepth: GenericPalletError;
        /**
         * Incorrect number of slashing spans provided.
         **/
        IncorrectSlashingSpans: GenericPalletError;
        /**
         * Internal state has become somehow corrupted and the operation cannot continue.
         **/
        BadState: GenericPalletError;
        /**
         * Too many nomination targets supplied.
         **/
        TooManyTargets: GenericPalletError;
        /**
         * A nomination target was supplied that was blocked or otherwise not a validator.
         **/
        BadTarget: GenericPalletError;
        /**
         * The user has enough bond and thus cannot be chilled forcefully by an external person.
         **/
        CannotChillOther: GenericPalletError;
        /**
         * There are too many nominators in the system. Governance needs to adjust the staking
         * settings to keep things safe for the runtime.
         **/
        TooManyNominators: GenericPalletError;
        /**
         * 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;
        /**
         * Commission is too low. Must be at least `MinCommission`.
         **/
        CommissionTooLow: GenericPalletError;
        /**
         * Some bound is not met.
         **/
        BoundNotMet: GenericPalletError;
        /**
         * Used when attempting to use deprecated controller account logic.
         **/
        ControllerDeprecated: GenericPalletError;
        /**
         * Cannot reset a ledger.
         **/
        CannotRestoreLedger: GenericPalletError;
        /**
         * Provided reward destination is not allowed.
         **/
        RewardDestinationRestricted: GenericPalletError;
        /**
         * Not enough funds available to withdraw.
         **/
        NotEnoughFunds: GenericPalletError;
        /**
         * Operation not allowed for virtual stakers.
         **/
        VirtualStakerNotAllowed: GenericPalletError;
        /**
         * Stash could not be reaped as other pallet might depend on it.
         **/
        CannotReapStash: GenericPalletError;
        /**
         * The stake of this account is already migrated to `Fungible` holds.
         **/
        AlreadyMigrated: GenericPalletError;
        /**
         * Account is restricted from participation in staking. This may happen if the account is
         * staking in another way already, such as via pool.
         **/
        Restricted: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Session`'s errors
     **/
    session: {
        /**
         * Invalid ownership proof.
         **/
        InvalidProof: GenericPalletError;
        /**
         * No associated validator ID for account.
         **/
        NoAssociatedValidatorId: GenericPalletError;
        /**
         * Registered duplicate key.
         **/
        DuplicatedKey: GenericPalletError;
        /**
         * No keys are associated with this account.
         **/
        NoKeys: GenericPalletError;
        /**
         * Key setting account is not live, so it's impossible to associate keys.
         **/
        NoAccount: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Democracy`'s errors
     **/
    democracy: {
        /**
         * Value too low
         **/
        ValueLow: GenericPalletError;
        /**
         * Proposal does not exist
         **/
        ProposalMissing: GenericPalletError;
        /**
         * Cannot cancel the same proposal twice
         **/
        AlreadyCanceled: GenericPalletError;
        /**
         * Proposal already made
         **/
        DuplicateProposal: GenericPalletError;
        /**
         * Proposal still blacklisted
         **/
        ProposalBlacklisted: GenericPalletError;
        /**
         * Next external proposal not simple majority
         **/
        NotSimpleMajority: GenericPalletError;
        /**
         * Invalid hash
         **/
        InvalidHash: GenericPalletError;
        /**
         * No external proposal
         **/
        NoProposal: GenericPalletError;
        /**
         * Identity may not veto a proposal twice
         **/
        AlreadyVetoed: GenericPalletError;
        /**
         * Vote given for invalid referendum
         **/
        ReferendumInvalid: GenericPalletError;
        /**
         * No proposals waiting
         **/
        NoneWaiting: GenericPalletError;
        /**
         * The given account did not vote on the referendum.
         **/
        NotVoter: GenericPalletError;
        /**
         * The actor has no permission to conduct the action.
         **/
        NoPermission: GenericPalletError;
        /**
         * The account is already delegating.
         **/
        AlreadyDelegating: GenericPalletError;
        /**
         * Too high a balance was provided that the account cannot afford.
         **/
        InsufficientFunds: GenericPalletError;
        /**
         * The account is not currently delegating.
         **/
        NotDelegating: GenericPalletError;
        /**
         * The account currently has votes attached to it and the operation cannot succeed until
         * these are removed, either through `unvote` or `reap_vote`.
         **/
        VotesExist: GenericPalletError;
        /**
         * The instant referendum origin is currently disallowed.
         **/
        InstantNotAllowed: GenericPalletError;
        /**
         * Delegation to oneself makes no sense.
         **/
        Nonsense: GenericPalletError;
        /**
         * Invalid upper bound.
         **/
        WrongUpperBound: GenericPalletError;
        /**
         * Maximum number of votes reached.
         **/
        MaxVotesReached: GenericPalletError;
        /**
         * Maximum number of items reached.
         **/
        TooMany: GenericPalletError;
        /**
         * Voting period too low
         **/
        VotingPeriodLow: GenericPalletError;
        /**
         * The preimage does not exist.
         **/
        PreimageNotExist: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Council`'s errors
     **/
    council: {
        /**
         * Account is not a member
         **/
        NotMember: GenericPalletError;
        /**
         * Duplicate proposals not allowed
         **/
        DuplicateProposal: GenericPalletError;
        /**
         * Proposal must exist
         **/
        ProposalMissing: GenericPalletError;
        /**
         * Mismatched index
         **/
        WrongIndex: GenericPalletError;
        /**
         * Duplicate vote ignored
         **/
        DuplicateVote: GenericPalletError;
        /**
         * Members are already initialized!
         **/
        AlreadyInitialized: GenericPalletError;
        /**
         * The close call was made too early, before the end of the voting.
         **/
        TooEarly: GenericPalletError;
        /**
         * There can only be a maximum of `MaxProposals` active proposals.
         **/
        TooManyProposals: GenericPalletError;
        /**
         * The given weight bound for the proposal was too low.
         **/
        WrongProposalWeight: GenericPalletError;
        /**
         * The given length bound for the proposal was too low.
         **/
        WrongProposalLength: GenericPalletError;
        /**
         * Prime account is not a member
         **/
        PrimeAccountNotMember: GenericPalletError;
        /**
         * Proposal is still active.
         **/
        ProposalActive: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `TechnicalCommittee`'s errors
     **/
    technicalCommittee: {
        /**
         * Account is not a member
         **/
        NotMember: GenericPalletError;
        /**
         * Duplicate proposals not allowed
         **/
        DuplicateProposal: GenericPalletError;
        /**
         * Proposal must exist
         **/
        ProposalMissing: GenericPalletError;
        /**
         * Mismatched index
         **/
        WrongIndex: GenericPalletError;
        /**
         * Duplicate vote ignored
         **/
        DuplicateVote: GenericPalletError;
        /**
         * Members are already initialized!
         **/
        AlreadyInitialized: GenericPalletError;
        /**
         * The close call was made too early, before the end of the voting.
         **/
        TooEarly: GenericPalletError;
        /**
         * There can only be a maximum of `MaxProposals` active proposals.
         **/
        TooManyProposals: GenericPalletError;
        /**
         * The given weight bound for the proposal was too low.
         **/
        WrongProposalWeight: GenericPalletError;
        /**
         * The given length bound for the proposal was too low.
         **/
        WrongProposalLength: GenericPalletError;
        /**
         * Prime account is not a member
         **/
        PrimeAccountNotMember: GenericPalletError;
        /**
         * Proposal is still active.
         **/
        ProposalActive: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Elections`'s errors
     **/
    elections: {
        /**
         * Cannot vote when no candidates or members exist.
         **/
        UnableToVote: GenericPalletError;
        /**
         * Must vote for at least one candidate.
         **/
        NoVotes: GenericPalletError;
        /**
         * Cannot vote more than candidates.
         **/
        TooManyVotes: GenericPalletError;
        /**
         * Cannot vote more than maximum allowed.
         **/
        MaximumVotesExceeded: GenericPalletError;
        /**
         * Cannot vote with stake less than minimum balance.
         **/
        LowBalance: GenericPalletError;
        /**
         * Voter can not pay voting bond.
         **/
        UnableToPayBond: GenericPalletError;
        /**
         * Must be a voter.
         **/
        MustBeVoter: GenericPalletError;
        /**
         * Duplicated candidate submission.
         **/
        DuplicatedCandidate: GenericPalletError;
        /**
         * Too many candidates have been created.
         **/
        TooManyCandidates: GenericPalletError;
        /**
         * Member cannot re-submit candidacy.
         **/
        MemberSubmit: GenericPalletError;
        /**
         * Runner cannot re-submit candidacy.
         **/
        RunnerUpSubmit: GenericPalletError;
        /**
         * Candidate does not have enough funds.
         **/
        InsufficientCandidateFunds: GenericPalletError;
        /**
         * Not a member.
         **/
        NotMember: GenericPalletError;
        /**
         * The provided count of number of candidates is incorrect.
         **/
        InvalidWitnessData: GenericPalletError;
        /**
         * The provided count of number of votes is incorrect.
         **/
        InvalidVoteCount: GenericPalletError;
        /**
         * The renouncing origin presented a wrong `Renouncing` parameter.
         **/
        InvalidRenouncing: GenericPalletError;
        /**
         * Prediction regarding replacement after member removal is wrong.
         **/
        InvalidReplacement: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `TechnicalMembership`'s errors
     **/
    technicalMembership: {
        /**
         * Already a member.
         **/
        AlreadyMember: GenericPalletError;
        /**
         * Not a member.
         **/
        NotMember: GenericPalletError;
        /**
         * Too many members.
         **/
        TooManyMembers: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Grandpa`'s errors
     **/
    grandpa: {
        /**
         * Attempt to signal GRANDPA pause when the authority set isn't live
         * (either paused or already pending pause).
         **/
        PauseFailed: GenericPalletError;
        /**
         * Attempt to signal GRANDPA resume when the authority set isn't paused
         * (either live or already pending resume).
         **/
        ResumeFailed: GenericPalletError;
        /**
         * Attempt to signal GRANDPA change with one already pending.
         **/
        ChangePending: GenericPalletError;
        /**
         * Cannot signal forced change so soon after last.
         **/
        TooSoon: GenericPalletError;
        /**
         * A key ownership proof provided as part of an equivocation report is invalid.
         **/
        InvalidKeyOwnershipProof: GenericPalletError;
        /**
         * An equivocation proof provided as part of an equivocation report is invalid.
         **/
        InvalidEquivocationProof: GenericPalletError;
        /**
         * A given equivocation report is valid but already previously reported.
         **/
        DuplicateOffenceReport: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Treasury`'s errors
     **/
    treasury: {
        /**
         * No proposal, bounty or spend at that index.
         **/
        InvalidIndex: GenericPalletError;
        /**
         * Too many approvals in the queue.
         **/
        TooManyApprovals: GenericPalletError;
        /**
         * The spend origin is valid but the amount it is allowed to spend is lower than the
         * amount to be spent.
         **/
        InsufficientPermission: GenericPalletError;
        /**
         * Proposal has not been approved.
         **/
        ProposalNotApproved: GenericPalletError;
        /**
         * The balance of the asset kind is not convertible to the balance of the native asset.
         **/
        FailedToConvertBalance: GenericPalletError;
        /**
         * The spend has expired and cannot be claimed.
         **/
        SpendExpired: GenericPalletError;
        /**
         * The spend is not yet eligible for payout.
         **/
        EarlyPayout: GenericPalletError;
        /**
         * The payment has already been attempted.
         **/
        AlreadyAttempted: GenericPalletError;
        /**
         * There was some issue with the mechanism of payment.
         **/
        PayoutError: GenericPalletError;
        /**
         * The payout was not yet attempted/claimed.
         **/
        NotAttempted: GenericPalletError;
        /**
         * The payment has neither failed nor succeeded yet.
         **/
        Inconclusive: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `AssetRate`'s errors
     **/
    assetRate: {
        /**
         * The given asset ID is unknown.
         **/
        UnknownAssetKind: GenericPalletError;
        /**
         * The given asset ID already has an assigned conversion rate and cannot be re-created.
         **/
        AlreadyExists: GenericPalletError;
        /**
         * Overflow ocurred when calculating the inverse rate.
         **/
        Overflow: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Contracts`'s errors
     **/
    contracts: {
        /**
         * Invalid schedule supplied, e.g. with zero weight of a basic operation.
         **/
        InvalidSchedule: GenericPalletError;
        /**
         * Invalid combination of flags supplied to `seal_call` or `seal_delegate_call`.
         **/
        InvalidCallFlags: GenericPalletError;
        /**
         * The executed contract exhausted its gas limit.
         **/
        OutOfGas: GenericPalletError;
        /**
         * The output buffer supplied to a contract API call was too small.
         **/
        OutputBufferTooSmall: GenericPalletError;
        /**
         * Performing the requested transfer failed. Probably because there isn't enough
         * free balance in the sender's account.
         **/
        TransferFailed: GenericPalletError;
        /**
         * Performing a call was denied because the calling depth reached the limit
         * of what is specified in the schedule.
         **/
        MaxCallDepthReached: GenericPalletError;
        /**
         * No contract was found at the specified address.
         **/
        ContractNotFound: GenericPalletError;
        /**
         * The code supplied to `instantiate_with_code` exceeds the limit specified in the
         * current schedule.
         **/
        CodeTooLarge: GenericPalletError;
        /**
         * No code could be found at the supplied code hash.
         **/
        CodeNotFound: GenericPalletError;
        /**
         * No code info could be found at the supplied code hash.
         **/
        CodeInfoNotFound: GenericPalletError;
        /**
         * A buffer outside of sandbox memory was passed to a contract API function.
         **/
        OutOfBounds: GenericPalletError;
        /**
         * Input passed to a contract API function failed to decode as expected type.
         **/
        DecodingFailed: GenericPalletError;
        /**
         * Contract trapped during execution.
         **/
        ContractTrapped: GenericPalletError;
        /**
         * The size defined in `T::MaxValueSize` was exceeded.
         **/
        ValueTooLarge: GenericPalletError;
        /**
         * Termination of a contract is not allowed while the contract is already
         * on the call stack. Can be triggered by `seal_terminate`.
         **/
        TerminatedWhileReentrant: GenericPalletError;
        /**
         * `seal_call` forwarded this contracts input. It therefore is no longer available.
         **/
        InputForwarded: GenericPalletError;
        /**
         * The subject passed to `seal_random` exceeds the limit.
         **/
        RandomSubjectTooLong: GenericPalletError;
        /**
         * The amount of topics passed to `seal_deposit_events` exceeds the limit.
         **/
        TooManyTopics: GenericPalletError;
        /**
         * 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;
        /**
         * Failed to decode the XCM program.
         **/
        XcmDecodeFailed: GenericPalletError;
        /**
         * A contract with the same AccountId already exists.
         **/
        DuplicateContract: GenericPalletError;
        /**
         * A contract self destructed in its constructor.
         *
         * This can be triggered by a call to `seal_terminate`.
         **/
        TerminatedInConstructor: GenericPalletError;
        /**
         * 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: GenericPalletError;
        /**
         * A contract attempted to invoke a state modifying API while being in read-only mode.
         **/
        StateChangeDenied: GenericPalletError;
        /**
         * Origin doesn't have enough balance to pay the required storage deposits.
         **/
        StorageDepositNotEnoughFunds: GenericPalletError;
        /**
         * More storage was created than allowed by the storage deposit limit.
         **/
        StorageDepositLimitExhausted: GenericPalletError;
        /**
         * Code removal was denied because the code is still in use by at least one contract.
         **/
        CodeInUse: GenericPalletError;
        /**
         * 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: GenericPalletError;
        /**
         * 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: GenericPalletError;
        /**
         * An indeterministic code was used in a context where this is not permitted.
         **/
        Indeterministic: GenericPalletError;
        /**
         * A pending migration needs to complete before the extrinsic can be called.
         **/
        MigrationInProgress: GenericPalletError;
        /**
         * Migrate dispatch call was attempted but no migration was performed.
         **/
        NoMigrationPerformed: GenericPalletError;
        /**
         * The contract has reached its maximum number of delegate dependencies.
         **/
        MaxDelegateDependenciesReached: GenericPalletError;
        /**
         * The dependency was not found in the contract's delegate dependencies.
         **/
        DelegateDependencyNotFound: GenericPalletError;
        /**
         * The contract already depends on the given delegate dependency.
         **/
        DelegateDependencyAlreadyExists: GenericPalletError;
        /**
         * Can not add a delegate dependency to the code hash of the contract itself.
         **/
        CannotAddSelfAsDelegateDependency: GenericPalletError;
        /**
         * Can not add more data to transient storage.
         **/
        OutOfTransientStorage: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Sudo`'s errors
     **/
    sudo: {
        /**
         * Sender must be the Sudo account.
         **/
        RequireSudo: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `ImOnline`'s errors
     **/
    imOnline: {
        /**
         * Non existent public key.
         **/
        InvalidKey: GenericPalletError;
        /**
         * Duplicated heartbeat.
         **/
        DuplicatedHeartbeat: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Identity`'s errors
     **/
    identity: {
        /**
         * Too many subs-accounts.
         **/
        TooManySubAccounts: GenericPalletError;
        /**
         * Account isn't found.
         **/
        NotFound: GenericPalletError;
        /**
         * Account isn't named.
         **/
        NotNamed: GenericPalletError;
        /**
         * Empty index.
         **/
        EmptyIndex: GenericPalletError;
        /**
         * Fee is changed.
         **/
        FeeChanged: GenericPalletError;
        /**
         * No identity found.
         **/
        NoIdentity: GenericPalletError;
        /**
         * Sticky judgement.
         **/
        StickyJudgement: GenericPalletError;
        /**
         * Judgement given.
         **/
        JudgementGiven: GenericPalletError;
        /**
         * Invalid judgement.
         **/
        InvalidJudgement: GenericPalletError;
        /**
         * The index is invalid.
         **/
        InvalidIndex: GenericPalletError;
        /**
         * The target is invalid.
         **/
        InvalidTarget: GenericPalletError;
        /**
         * Maximum amount of registrars reached. Cannot add any more.
         **/
        TooManyRegistrars: GenericPalletError;
        /**
         * Account ID is already named.
         **/
        AlreadyClaimed: GenericPalletError;
        /**
         * Sender is not a sub-account.
         **/
        NotSub: GenericPalletError;
        /**
         * Sub-account isn't owned by sender.
         **/
        NotOwned: GenericPalletError;
        /**
         * The provided judgement was for a different identity.
         **/
        JudgementForDifferentIdentity: GenericPalletError;
        /**
         * Error that occurs when there is an issue paying for judgement.
         **/
        JudgementPaymentFailed: GenericPalletError;
        /**
         * The provided suffix is too long.
         **/
        InvalidSuffix: GenericPalletError;
        /**
         * The sender does not have permission to issue a username.
         **/
        NotUsernameAuthority: GenericPalletError;
        /**
         * The authority cannot allocate any more usernames.
         **/
        NoAllocation: GenericPalletError;
        /**
         * The signature on a username was not valid.
         **/
        InvalidSignature: GenericPalletError;
        /**
         * Setting this username requires a signature, but none was provided.
         **/
        RequiresSignature: GenericPalletError;
        /**
         * The username does not meet the requirements.
         **/
        InvalidUsername: GenericPalletError;
        /**
         * The username is already taken.
         **/
        UsernameTaken: GenericPalletError;
        /**
         * The requested username does not exist.
         **/
        NoUsername: GenericPalletError;
        /**
         * The username cannot be forcefully removed because it can still be accepted.
         **/
        NotExpired: GenericPalletError;
        /**
         * The username cannot be removed because it's still in the grace period.
         **/
        TooEarly: GenericPalletError;
        /**
         * The username cannot be removed because it is not unbinding.
         **/
        NotUnbinding: GenericPalletError;
        /**
         * The username cannot be unbound because it is already unbinding.
         **/
        AlreadyUnbinding: GenericPalletError;
        /**
         * The action cannot be performed because of insufficient privileges (e.g. authority
         * trying to unbind a username provided by the system).
         **/
        InsufficientPrivileges: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Society`'s errors
     **/
    society: {
        /**
         * User is not a member.
         **/
        NotMember: GenericPalletError;
        /**
         * User is already a member.
         **/
        AlreadyMember: GenericPalletError;
        /**
         * User is suspended.
         **/
        Suspended: GenericPalletError;
        /**
         * User is not suspended.
         **/
        NotSuspended: GenericPalletError;
        /**
         * Nothing to payout.
         **/
        NoPayout: GenericPalletError;
        /**
         * Society already founded.
         **/
        AlreadyFounded: GenericPalletError;
        /**
         * Not enough in pot to accept candidate.
         **/
        InsufficientPot: GenericPalletError;
        /**
         * Member is already vouching or banned from vouching again.
         **/
        AlreadyVouching: GenericPalletError;
        /**
         * Member is not vouching.
         **/
        NotVouchingOnBidder: GenericPalletError;
        /**
         * Cannot remove the head of the chain.
         **/
        Head: GenericPalletError;
        /**
         * Cannot remove the founder.
         **/
        Founder: GenericPalletError;
        /**
         * User has already made a bid.
         **/
        AlreadyBid: GenericPalletError;
        /**
         * User is already a candidate.
         **/
        AlreadyCandidate: GenericPalletError;
        /**
         * User is not a candidate.
         **/
        NotCandidate: GenericPalletError;
        /**
         * Too many members in the society.
         **/
        MaxMembers: GenericPalletError;
        /**
         * The caller is not the founder.
         **/
        NotFounder: GenericPalletError;
        /**
         * The caller is not the head.
         **/
        NotHead: GenericPalletError;
        /**
         * The membership cannot be claimed as the candidate was not clearly approved.
         **/
        NotApproved: GenericPalletError;
        /**
         * The candidate cannot be kicked as the candidate was not clearly rejected.
         **/
        NotRejected: GenericPalletError;
        /**
         * The candidacy cannot be dropped as the candidate was clearly approved.
         **/
        Approved: GenericPalletError;
        /**
         * The candidacy cannot be bestowed as the candidate was clearly rejected.
         **/
        Rejected: GenericPalletError;
        /**
         * The candidacy cannot be concluded as the voting is still in progress.
         **/
        InProgress: GenericPalletError;
        /**
         * The candidacy cannot be pruned until a full additional intake period has passed.
         **/
        TooEarly: GenericPalletError;
        /**
         * The skeptic already voted.
         **/
        Voted: GenericPalletError;
        /**
         * The skeptic need not vote on candidates from expired rounds.
         **/
        Expired: GenericPalletError;
        /**
         * User is not a bidder.
         **/
        NotBidder: GenericPalletError;
        /**
         * There is no defender currently.
         **/
        NoDefender: GenericPalletError;
        /**
         * Group doesn't exist.
         **/
        NotGroup: GenericPalletError;
        /**
         * The member is already elevated to this rank.
         **/
        AlreadyElevated: GenericPalletError;
        /**
         * The skeptic has already been punished for this offence.
         **/
        AlreadyPunished: GenericPalletError;
        /**
         * Funds are insufficient to pay off society debts.
         **/
        InsufficientFunds: GenericPalletError;
        /**
         * The candidate/defender has no stale votes to remove.
         **/
        NoVotes: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Recovery`'s errors
     **/
    recovery: {
        /**
         * User is not allowed to make a call on behalf of this account
         **/
        NotAllowed: GenericPalletError;
        /**
         * Threshold must be greater than zero
         **/
        ZeroThreshold: GenericPalletError;
        /**
         * Friends list must be greater than zero and threshold
         **/
        NotEnoughFriends: GenericPalletError;
        /**
         * Friends list must be less than max friends
         **/
        MaxFriends: GenericPalletError;
        /**
         * Friends list must be sorted and free of duplicates
         **/
        NotSorted: GenericPalletError;
        /**
         * This account is not set up for recovery
         **/
        NotRecoverable: GenericPalletError;
        /**
         * This account is already set up for recovery
         **/
        AlreadyRecoverable: GenericPalletError;
        /**
         * A recovery process has already started for this account
         **/
        AlreadyStarted: GenericPalletError;
        /**
         * A recovery process has not started for this rescuer
         **/
        NotStarted: GenericPalletError;
        /**
         * This account is not a friend who can vouch
         **/
        NotFriend: GenericPalletError;
        /**
         * The friend must wait until the delay period to vouch for this recovery
         **/
        DelayPeriod: GenericPalletError;
        /**
         * This user has already vouched for this recovery
         **/
        AlreadyVouched: GenericPalletError;
        /**
         * The threshold for recovering this account has not been met
         **/
        Threshold: GenericPalletError;
        /**
         * There are still active recovery attempts that need to be closed
         **/
        StillActive: GenericPalletError;
        /**
         * This account is already set up for recovery
         **/
        AlreadyProxy: GenericPalletError;
        /**
         * Some internal state is broken.
         **/
        BadState: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Vesting`'s errors
     **/
    vesting: {
        /**
         * The account given is not vesting.
         **/
        NotVesting: GenericPalletError;
        /**
         * The account already has `MaxVestingSchedules` count of schedules and thus
         * cannot add another one. Consider merging existing schedules in order to add another.
         **/
        AtMaxVestingSchedules: GenericPalletError;
        /**
         * Amount being transferred is too low to create a vesting schedule.
         **/
        AmountLow: GenericPalletError;
        /**
         * An index was out of bounds of the vesting schedules.
         **/
        ScheduleIndexOutOfBounds: GenericPalletError;
        /**
         * Failed to create a new schedule because some parameter was invalid.
         **/
        InvalidScheduleParams: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Scheduler`'s errors
     **/
    scheduler: {
        /**
         * Failed to schedule a call
         **/
        FailedToSchedule: GenericPalletError;
        /**
         * Cannot find the scheduled call.
         **/
        NotFound: GenericPalletError;
        /**
         * Given target block number is in the past.
         **/
        TargetBlockNumberInPast: GenericPalletError;
        /**
         * Reschedule failed because it does not change scheduled time.
         **/
        RescheduleNoChange: GenericPalletError;
        /**
         * Attempt to use a non-named function on a named task.
         **/
        Named: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Glutton`'s errors
     **/
    glutton: {
        /**
         * The pallet was already initialized.
         *
         * Set `witness_count` to `Some` to bypass this error.
         **/
        AlreadyInitialized: GenericPalletError;
        /**
         * The limit was over [`crate::RESOURCE_HARD_LIMIT`].
         **/
        InsaneLimit: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Preimage`'s errors
     **/
    preimage: {
        /**
         * Preimage is too large to store on-chain.
         **/
        TooBig: GenericPalletError;
        /**
         * Preimage has already been noted on-chain.
         **/
        AlreadyNoted: GenericPalletError;
        /**
         * The user is not authorized to perform this action.
         **/
        NotAuthorized: GenericPalletError;
        /**
         * The preimage cannot be removed since it has not yet been noted.
         **/
        NotNoted: GenericPalletError;
        /**
         * A preimage may not be removed when there are outstanding requests.
         **/
        Requested: GenericPalletError;
        /**
         * The preimage request cannot be removed since no outstanding requests exist.
         **/
        NotRequested: GenericPalletError;
        /**
         * More than `MAX_HASH_UPGRADE_BULK_COUNT` hashes were requested to be upgraded at once.
         **/
        TooMany: GenericPalletError;
        /**
         * Too few hashes were requested to be upgraded (i.e. zero).
         **/
        TooFew: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Proxy`'s errors
     **/
    proxy: {
        /**
         * There are too many proxies registered or too many announcements pending.
         **/
        TooMany: GenericPalletError;
        /**
         * Proxy registration not found.
         **/
        NotFound: GenericPalletError;
        /**
         * Sender is not a proxy of the account to be proxied.
         **/
        NotProxy: GenericPalletError;
        /**
         * A call which is incompatible with the proxy type's filter was attempted.
         **/
        Unproxyable: GenericPalletError;
        /**
         * Account is already a proxy.
         **/
        Duplicate: GenericPalletError;
        /**
         * Call may not be made by proxy because it may escalate its privileges.
         **/
        NoPermission: GenericPalletError;
        /**
         * Announcement, if made at all, was made too recently.
         **/
        Unannounced: GenericPalletError;
        /**
         * Cannot add self as proxy.
         **/
        NoSelfProxy: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Multisig`'s errors
     **/
    multisig: {
        /**
         * Threshold must be 2 or greater.
         **/
        MinimumThreshold: GenericPalletError;
        /**
         * Call is already approved by this signatory.
         **/
        AlreadyApproved: GenericPalletError;
        /**
         * Call doesn't need any (more) approvals.
         **/
        NoApprovalsNeeded: GenericPalletError;
        /**
         * There are too few signatories in the list.
         **/
        TooFewSignatories: GenericPalletError;
        /**
         * There are too many signatories in the list.
         **/
        TooManySignatories: GenericPalletError;
        /**
         * The signatories were provided out of order; they should be ordered.
         **/
        SignatoriesOutOfOrder: GenericPalletError;
        /**
         * The sender was contained in the other signatories; it shouldn't be.
         **/
        SenderInSignatories: GenericPalletError;
        /**
         * Multisig operation not found in storage.
         **/
        NotFound: GenericPalletError;
        /**
         * Only the account that originally created the multisig is able to cancel it or update
         * its deposits.
         **/
        NotOwner: GenericPalletError;
        /**
         * No timepoint was given, yet the multisig operation is already underway.
         **/
        NoTimepoint: GenericPalletError;
        /**
         * A different timepoint was given to the multisig operation that is underway.
         **/
        WrongTimepoint: GenericPalletError;
        /**
         * A timepoint was given, yet no multisig operation is underway.
         **/
        UnexpectedTimepoint: GenericPalletError;
        /**
         * The maximum weight information provided was too low.
         **/
        MaxWeightTooLow: GenericPalletError;
        /**
         * The data to be stored is already stored.
         **/
        AlreadyStored: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Bounties`'s errors
     **/
    bounties: {
        /**
         * Proposer's balance is too low.
         **/
        InsufficientProposersBalance: GenericPalletError;
        /**
         * No proposal or bounty at that index.
         **/
        InvalidIndex: GenericPalletError;
        /**
         * The reason given is just too big.
         **/
        ReasonTooBig: GenericPalletError;
        /**
         * The bounty status is unexpected.
         **/
        UnexpectedStatus: GenericPalletError;
        /**
         * Require bounty curator.
         **/
        RequireCurator: GenericPalletError;
        /**
         * Invalid bounty value.
         **/
        InvalidValue: GenericPalletError;
        /**
         * Invalid bounty fee.
         **/
        InvalidFee: GenericPalletError;
        /**
         * A bounty payout is pending.
         * To cancel the bounty, you must unassign and slash the curator.
         **/
        PendingPayout: GenericPalletError;
        /**
         * The bounties cannot be claimed/closed because it's still in the countdown period.
         **/
        Premature: GenericPalletError;
        /**
         * The bounty cannot be closed because it has active child bounties.
         **/
        HasActiveChildBounty: GenericPalletError;
        /**
         * Too many approvals are already queued.
         **/
        TooManyQueued: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Tips`'s errors
     **/
    tips: {
        /**
         * The reason given is just too big.
         **/
        ReasonTooBig: GenericPalletError;
        /**
         * The tip was already found/started.
         **/
        AlreadyKnown: GenericPalletError;
        /**
         * The tip hash is unknown.
         **/
        UnknownTip: GenericPalletError;
        /**
         * The tip given was too generous.
         **/
        MaxTipAmountExceeded: GenericPalletError;
        /**
         * The account attempting to retract the tip is not the finder of the tip.
         **/
        NotFinder: GenericPalletError;
        /**
         * The tip cannot be claimed/closed because there are not enough tippers yet.
         **/
        StillOpen: GenericPalletError;
        /**
         * The tip cannot be claimed/closed because it's still in the countdown period.
         **/
        Premature: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Assets`'s errors
     **/
    assets: {
        /**
         * Account balance must be greater than or equal to the transfer amount.
         **/
        BalanceLow: GenericPalletError;
        /**
         * The account to alter does not exist.
         **/
        NoAccount: GenericPalletError;
        /**
         * The signing account has no permission to do the operation.
         **/
        NoPermission: GenericPalletError;
        /**
         * The given asset ID is unknown.
         **/
        Unknown: GenericPalletError;
        /**
         * The origin account is frozen.
         **/
        Frozen: GenericPalletError;
        /**
         * The asset ID is already taken.
         **/
        InUse: GenericPalletError;
        /**
         * Invalid witness data given.
         **/
        BadWitness: GenericPalletError;
        /**
         * Minimum balance should be non-zero.
         **/
        MinBalanceZero: GenericPalletError;
        /**
         * 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: GenericPalletError;
        /**
         * Invalid metadata given.
         **/
        BadMetadata: GenericPalletError;
        /**
         * No approval exists that would allow the transfer.
         **/
        Unapproved: GenericPalletError;
        /**
         * The source account would not survive the transfer and it needs to stay alive.
         **/
        WouldDie: GenericPalletError;
        /**
         * The asset-account already exists.
         **/
        AlreadyExists: GenericPalletError;
        /**
         * The asset-account doesn't have an associated deposit.
         **/
        NoDeposit: GenericPalletError;
        /**
         * The operation would result in funds being burned.
         **/
        WouldBurn: GenericPalletError;
        /**
         * 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: GenericPalletError;
        /**
         * The asset is not live, and likely being destroyed.
         **/
        AssetNotLive: GenericPalletError;
        /**
         * The asset status is not the expected status.
         **/
        IncorrectStatus: GenericPalletError;
        /**
         * The asset should be frozen before the given operation.
         **/
        NotFrozen: GenericPalletError;
        /**
         * Callback action resulted in error
         **/
        CallbackFailed: GenericPalletError;
        /**
         * The asset ID must be equal to the [`NextAssetId`].
         **/
        BadAssetId: GenericPalletError;
        /**
         * The asset cannot be destroyed because some accounts for this asset contain freezes.
         **/
        ContainsFreezes: GenericPalletError;
        /**
         * The asset cannot be destroyed because some accounts for this asset contain holds.
         **/
        ContainsHolds: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `PoolAssets`'s errors
     **/
    poolAssets: {
        /**
         * Account balance must be greater than or equal to the transfer amount.
         **/
        BalanceLow: GenericPalletError;
        /**
         * The account to alter does not exist.
         **/
        NoAccount: GenericPalletError;
        /**
         * The signing account has no permission to do the operation.
         **/
        NoPermission: GenericPalletError;
        /**
         * The given asset ID is unknown.
         **/
        Unknown: GenericPalletError;
        /**
         * The origin account is frozen.
         **/
        Frozen: GenericPalletError;
        /**
         * The asset ID is already taken.
         **/
        InUse: GenericPalletError;
        /**
         * Invalid witness data given.
         **/
        BadWitness: GenericPalletError;
        /**
         * Minimum balance should be non-zero.
         **/
        MinBalanceZero: GenericPalletError;
        /**
         * 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: GenericPalletError;
        /**
         * Invalid metadata given.
         **/
        BadMetadata: GenericPalletError;
        /**
         * No approval exists that would allow the transfer.
         **/
        Unapproved: GenericPalletError;
        /**
         * The source account would not survive the transfer and it needs to stay alive.
         **/
        WouldDie: GenericPalletError;
        /**
         * The asset-account already exists.
         **/
        AlreadyExists: GenericPalletError;
        /**
         * The asset-account doesn't have an associated deposit.
         **/
        NoDeposit: GenericPalletError;
        /**
         * The operation would result in funds being burned.
         **/
        WouldBurn: GenericPalletError;
        /**
         * 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: GenericPalletError;
        /**
         * The asset is not live, and likely being destroyed.
         **/
        AssetNotLive: GenericPalletError;
        /**
         * The asset status is not the expected status.
         **/
        IncorrectStatus: GenericPalletError;
        /**
         * The asset should be frozen before the given operation.
         **/
        NotFrozen: GenericPalletError;
        /**
         * Callback action resulted in error
         **/
        CallbackFailed: GenericPalletError;
        /**
         * The asset ID must be equal to the [`NextAssetId`].
         **/
        BadAssetId: GenericPalletError;
        /**
         * The asset cannot be destroyed because some accounts for this asset contain freezes.
         **/
        ContainsFreezes: GenericPalletError;
        /**
         * The asset cannot be destroyed because some accounts for this asset contain holds.
         **/
        ContainsHolds: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Beefy`'s errors
     **/
    beefy: {
        /**
         * A key ownership proof provided as part of an equivocation report is invalid.
         **/
        InvalidKeyOwnershipProof: GenericPalletError;
        /**
         * A double voting proof provided as part of an equivocation report is invalid.
         **/
        InvalidDoubleVotingProof: GenericPalletError;
        /**
         * A fork voting proof provided as part of an equivocation report is invalid.
         **/
        InvalidForkVotingProof: GenericPalletError;
        /**
         * A future block voting proof provided as part of an equivocation report is invalid.
         **/
        InvalidFutureBlockVotingProof: GenericPalletError;
        /**
         * The session of the equivocation proof is invalid
         **/
        InvalidEquivocationProofSession: GenericPalletError;
        /**
         * A given equivocation report is valid but already previously reported.
         **/
        DuplicateOffenceReport: GenericPalletError;
        /**
         * Submitted configuration is invalid.
         **/
        InvalidConfiguration: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Lottery`'s errors
     **/
    lottery: {
        /**
         * A lottery has not been configured.
         **/
        NotConfigured: GenericPalletError;
        /**
         * A lottery is already in progress.
         **/
        InProgress: GenericPalletError;
        /**
         * A lottery has already ended.
         **/
        AlreadyEnded: GenericPalletError;
        /**
         * The call is not valid for an open lottery.
         **/
        InvalidCall: GenericPalletError;
        /**
         * You are already participating in the lottery with this call.
         **/
        AlreadyParticipating: GenericPalletError;
        /**
         * Too many calls for a single lottery.
         **/
        TooManyCalls: GenericPalletError;
        /**
         * Failed to encode calls
         **/
        EncodingFailed: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Nis`'s errors
     **/
    nis: {
        /**
         * The duration of the bid is less than one.
         **/
        DurationTooSmall: GenericPalletError;
        /**
         * The duration is the bid is greater than the number of queues.
         **/
        DurationTooBig: GenericPalletError;
        /**
         * The amount of the bid is less than the minimum allowed.
         **/
        AmountTooSmall: GenericPalletError;
        /**
         * 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;
        /**
         * Receipt index is unknown.
         **/
        UnknownReceipt: GenericPalletError;
        /**
         * Not the owner of the receipt.
         **/
        NotOwner: GenericPalletError;
        /**
         * Bond not yet at expiry date.
         **/
        NotExpired: GenericPalletError;
        /**
         * The given bid for retraction is not found.
         **/
        UnknownBid: GenericPalletError;
        /**
         * The portion supplied is beyond the value of the receipt.
         **/
        PortionTooBig: GenericPalletError;
        /**
         * Not enough funds are held to pay out.
         **/
        Unfunded: GenericPalletError;
        /**
         * There are enough funds for what is required.
         **/
        AlreadyFunded: GenericPalletError;
        /**
         * The thaw throttle has been reached for this period.
         **/
        Throttled: GenericPalletError;
        /**
         * The operation would result in a receipt worth an insignificant value.
         **/
        MakesDust: GenericPalletError;
        /**
         * The receipt is already communal.
         **/
        AlreadyCommunal: GenericPalletError;
        /**
         * The receipt is already private.
         **/
        AlreadyPrivate: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Uniques`'s errors
     **/
    uniques: {
        /**
         * The signing account has no permission to do the operation.
         **/
        NoPermission: GenericPalletError;
        /**
         * The given item ID is unknown.
         **/
        UnknownCollection: GenericPalletError;
        /**
         * The item ID has already been used for an item.
         **/
        AlreadyExists: GenericPalletError;
        /**
         * The owner turned out to be different to what was expected.
         **/
        WrongOwner: GenericPalletError;
        /**
         * Invalid witness data given.
         **/
        BadWitness: GenericPalletError;
        /**
         * The item ID is already taken.
         **/
        InUse: GenericPalletError;
        /**
         * The item or collection is frozen.
         **/
        Frozen: GenericPalletError;
        /**
         * The delegate turned out to be different to what was expected.
         **/
        WrongDelegate: GenericPalletError;
        /**
         * There is no delegate approved.
         **/
        NoDelegate: GenericPalletError;
        /**
         * No approval exists that would allow the transfer.
         **/
        Unapproved: GenericPalletError;
        /**
         * The named owner has not signed ownership of the collection is acceptable.
         **/
        Unaccepted: GenericPalletError;
        /**
         * The item is locked.
         **/
        Locked: GenericPalletError;
        /**
         * All items have been minted.
         **/
        MaxSupplyReached: GenericPalletError;
        /**
         * The max supply has already been set.
         **/
        MaxSupplyAlreadySet: GenericPalletError;
        /**
         * The provided max supply is less to the amount of items a collection already has.
         **/
        MaxSupplyTooSmall: GenericPalletError;
        /**
         * The given item ID is unknown.
         **/
        UnknownItem: GenericPalletError;
        /**
         * Item is not for sale.
         **/
        NotForSale: GenericPalletError;
        /**
         * The provided bid is too low.
         **/
        BidTooLow: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Nfts`'s errors
     **/
    nfts: {
        /**
         * The signing account has no permission to do the operation.
         **/
        NoPermission: GenericPalletError;
        /**
         * The given item ID is unknown.
         **/
        UnknownCollection: GenericPalletError;
        /**
         * The item ID has already been used for an item.
         **/
        AlreadyExists: GenericPalletError;
        /**
         * The approval had a deadline that expired, so the approval isn't valid anymore.
         **/
        ApprovalExpired: GenericPalletError;
        /**
         * The owner turned out to be different to what was expected.
         **/
        WrongOwner: GenericPalletError;
        /**
         * The witness data given does not match the current state of the chain.
         **/
        BadWitness: GenericPalletError;
        /**
         * Collection ID is already taken.
         **/
        CollectionIdInUse: GenericPalletError;
        /**
         * Items within that collection are non-transferable.
         **/
        ItemsNonTransferable: GenericPalletError;
        /**
         * The provided account is not a delegate.
         **/
        NotDelegate: GenericPalletError;
        /**
         * The delegate turned out to be different to what was expected.
         **/
        WrongDelegate: GenericPalletError;
        /**
         * No approval exists that would allow the transfer.
         **/
        Unapproved: GenericPalletError;
        /**
         * The named owner has not signed ownership acceptance of the collection.
         **/
        Unaccepted: GenericPalletError;
        /**
         * The item is locked (non-transferable).
         **/
        ItemLocked: GenericPalletError;
        /**
         * Item's attributes are locked.
         **/
        LockedItemAttributes: GenericPalletError;
        /**
         * Collection's attributes are locked.
         **/
        LockedCollectionAttributes: GenericPalletError;
        /**
         * Item's metadata is locked.
         **/
        LockedItemMetadata: GenericPalletError;
        /**
         * Collection's metadata is locked.
         **/
        LockedCollectionMetadata: GenericPalletError;
        /**
         * All items have been minted.
         **/
        MaxSupplyReached: GenericPalletError;
        /**
         * The max supply is locked and can't be changed.
         **/
        MaxSupplyLocked: GenericPalletError;
        /**
         * The provided max supply is less than the number of items a collection already has.
         **/
        MaxSupplyTooSmall: GenericPalletError;
        /**
         * The given item ID is unknown.
         **/
        UnknownItem: GenericPalletError;
        /**
         * Swap doesn't exist.
         **/
        UnknownSwap: GenericPalletError;
        /**
         * The given item has no metadata set.
         **/
        MetadataNotFound: GenericPalletError;
        /**
         * The provided attribute can't be found.
         **/
        AttributeNotFound: GenericPalletError;
        /**
         * Item is not for sale.
         **/
        NotForSale: GenericPalletError;
        /**
         * The provided bid is too low.
         **/
        BidTooLow: GenericPalletError;
        /**
         * The item has reached its approval limit.
         **/
        ReachedApprovalLimit: GenericPalletError;
        /**
         * The deadline has already expired.
         **/
        DeadlineExpired: GenericPalletError;
        /**
         * The duration provided should be less than or equal to `MaxDeadlineDuration`.
         **/
        WrongDuration: GenericPalletError;
        /**
         * The method is disabled by system settings.
         **/
        MethodDisabled: GenericPalletError;
        /**
         * The provided setting can't be set.
         **/
        WrongSetting: GenericPalletError;
        /**
         * Item's config already exists and should be equal to the provided one.
         **/
        InconsistentItemConfig: GenericPalletError;
        /**
         * Config for a collection or an item can't be found.
         **/
        NoConfig: GenericPalletError;
        /**
         * Some roles were not cleared.
         **/
        RolesNotCleared: GenericPalletError;
        /**
         * Mint has not started yet.
         **/
        MintNotStarted: GenericPalletError;
        /**
         * Mint has already ended.
         **/
        MintEnded: GenericPalletError;
        /**
         * The provided Item was already used for claiming.
         **/
        AlreadyClaimed: GenericPalletError;
        /**
         * The provided data is incorrect.
         **/
        IncorrectData: GenericPalletError;
        /**
         * The extrinsic was sent by the wrong origin.
         **/
        WrongOrigin: GenericPalletError;
        /**
         * The provided signature is incorrect.
         **/
        WrongSignature: GenericPalletError;
        /**
         * The provided metadata might be too long.
         **/
        IncorrectMetadata: GenericPalletError;
        /**
         * Can't set more attributes per one call.
         **/
        MaxAttributesLimitReached: GenericPalletError;
        /**
         * The provided namespace isn't supported in this call.
         **/
        WrongNamespace: GenericPalletError;
        /**
         * Can't delete non-empty collections.
         **/
        CollectionNotEmpty: GenericPalletError;
        /**
         * The witness data should be provided.
         **/
        WitnessRequired: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `NftFractionalization`'s errors
     **/
    nftFractionalization: {
        /**
         * Asset ID does not correspond to locked NFT.
         **/
        IncorrectAssetId: GenericPalletError;
        /**
         * The signing account has no permission to do the operation.
         **/
        NoPermission: GenericPalletError;
        /**
         * NFT doesn't exist.
         **/
        NftNotFound: GenericPalletError;
        /**
         * NFT has not yet been fractionalised.
         **/
        NftNotFractionalized: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Salary`'s errors
     **/
    salary: {
        /**
         * The salary system has already been started.
         **/
        AlreadyStarted: GenericPalletError;
        /**
         * The account is not a ranked member.
         **/
        NotMember: GenericPalletError;
        /**
         * The account is already inducted.
         **/
        AlreadyInducted: GenericPalletError;
        NotInducted: GenericPalletError;
        /**
         * The member does not have a current valid claim.
         **/
        NoClaim: GenericPalletError;
        /**
         * The member's claim is zero.
         **/
        ClaimZero: GenericPalletError;
        /**
         * Current cycle's registration period is over.
         **/
        TooLate: GenericPalletError;
        /**
         * Current cycle's payment period is not yet begun.
         **/
        TooEarly: GenericPalletError;
        /**
         * Cycle is not yet over.
         **/
        NotYet: GenericPalletError;
        /**
         * The payout cycles have not yet started.
         **/
        NotStarted: GenericPalletError;
        /**
         * There is no budget left for the payout.
         **/
        Bankrupt: GenericPalletError;
        /**
         * There was some issue with the mechanism of payment.
         **/
        PayError: GenericPalletError;
        /**
         * The payment has neither failed nor succeeded yet.
         **/
        Inconclusive: GenericPalletError;
        /**
         * The cycle is after that in which the payment was made.
         **/
        NotCurrent: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `CoreFellowship`'s errors
     **/
    coreFellowship: {
        /**
         * Member's rank is too low.
         **/
        Unranked: GenericPalletError;
        /**
         * Member's rank is not zero.
         **/
        Ranked: GenericPalletError;
        /**
         * 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: GenericPalletError;
        /**
         * The given rank is invalid - this generally means it's not between 1 and `RANK_COUNT`.
         **/
        InvalidRank: GenericPalletError;
        /**
         * The origin does not have enough permission to do this operation.
         **/
        NoPermission: GenericPalletError;
        /**
         * No work needs to be done at present for this member.
         **/
        NothingDoing: GenericPalletError;
        /**
         * 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: GenericPalletError;
        /**
         * The candidate has not been inducted, so cannot be offboarded from this pallet.
         **/
        NotTracked: GenericPalletError;
        /**
         * Operation cannot be done yet since not enough time has passed.
         **/
        TooSoon: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `TransactionStorage`'s errors
     **/
    transactionStorage: {
        /**
         * Invalid configuration.
         **/
        NotConfigured: GenericPalletError;
        /**
         * Renewed extrinsic is not found.
         **/
        RenewedNotFound: GenericPalletError;
        /**
         * Attempting to store empty transaction
         **/
        EmptyTransaction: GenericPalletError;
        /**
         * Proof was not expected in this block.
         **/
        UnexpectedProof: GenericPalletError;
        /**
         * Proof failed verification.
         **/
        InvalidProof: GenericPalletError;
        /**
         * Missing storage proof.
         **/
        MissingProof: GenericPalletError;
        /**
         * Unable to verify proof because state data is missing.
         **/
        MissingStateData: GenericPalletError;
        /**
         * Double proof check in the block.
         **/
        DoubleCheck: GenericPalletError;
        /**
         * Storage proof was not checked in the block.
         **/
        ProofNotChecked: GenericPalletError;
        /**
         * Transaction is too large.
         **/
        TransactionTooLarge: GenericPalletError;
        /**
         * Too many transactions in the block.
         **/
        TooManyTransactions: GenericPalletError;
        /**
         * Attempted to call `store` outside of block execution.
         **/
        BadContext: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `VoterList`'s errors
     **/
    voterList: {
        /**
         * A error in the list interface implementation.
         **/
        List: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `StateTrieMigration`'s errors
     **/
    stateTrieMigration: {
        /**
         * Max signed limits not respected.
         **/
        MaxSignedLimits: GenericPalletError;
        /**
         * A key was longer than the configured maximum.
         *
         * This means that the migration halted at the current [`Progress`] and
         * can be resumed with a larger [`crate::Config::MaxKeyLen`] value.
         * Retrying with the same [`crate::Config::MaxKeyLen`] value will not work.
         * The value should only be increased to avoid a storage migration for the currently
         * stored [`crate::Progress::LastKey`].
         **/
        KeyTooLong: GenericPalletError;
        /**
         * submitter does not have enough funds.
         **/
        NotEnoughFunds: GenericPalletError;
        /**
         * Bad witness data provided.
         **/
        BadWitness: GenericPalletError;
        /**
         * Signed migration is not allowed because the maximum limit is not set yet.
         **/
        SignedMigrationNotAllowed: GenericPalletError;
        /**
         * Bad child root provided.
         **/
        BadChildRoot: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `ChildBounties`'s errors
     **/
    childBounties: {
        /**
         * The parent bounty is not in active state.
         **/
        ParentBountyNotActive: GenericPalletError;
        /**
         * The bounty balance is not enough to add new child-bounty.
         **/
        InsufficientBountyBalance: GenericPalletError;
        /**
         * Number of child bounties exceeds limit `MaxActiveChildBountyCount`.
         **/
        TooManyChildBounties: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Referenda`'s errors
     **/
    referenda: {
        /**
         * Referendum is not ongoing.
         **/
        NotOngoing: GenericPalletError;
        /**
         * Referendum's decision deposit is already paid.
         **/
        HasDeposit: GenericPalletError;
        /**
         * The track identifier given was invalid.
         **/
        BadTrack: GenericPalletError;
        /**
         * There are already a full complement of referenda in progress for this track.
         **/
        Full: GenericPalletError;
        /**
         * The queue of the track is empty.
         **/
        QueueEmpty: GenericPalletError;
        /**
         * The referendum index provided is invalid in this context.
         **/
        BadReferendum: GenericPalletError;
        /**
         * There was nothing to do in the advancement.
         **/
        NothingToDo: GenericPalletError;
        /**
         * No track exists for the proposal origin.
         **/
        NoTrack: GenericPalletError;
        /**
         * Any deposit cannot be refunded until after the decision is over.
         **/
        Unfinished: GenericPalletError;
        /**
         * The deposit refunder is not the depositor.
         **/
        NoPermission: GenericPalletError;
        /**
         * The deposit cannot be refunded since none was made.
         **/
        NoDeposit: GenericPalletError;
        /**
         * The referendum status is invalid for this operation.
         **/
        BadStatus: GenericPalletError;
        /**
         * The preimage does not exist.
         **/
        PreimageNotExist: GenericPalletError;
        /**
         * The preimage is stored with a different length than the one provided.
         **/
        PreimageStoredWithDifferentLength: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Remark`'s errors
     **/
    remark: {
        /**
         * Attempting to store empty data.
         **/
        Empty: GenericPalletError;
        /**
         * Attempted to call `store` outside of block execution.
         **/
        BadContext: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `ConvictionVoting`'s errors
     **/
    convictionVoting: {
        /**
         * Poll is not ongoing.
         **/
        NotOngoing: GenericPalletError;
        /**
         * The given account did not vote on the poll.
         **/
        NotVoter: GenericPalletError;
        /**
         * The actor has no permission to conduct the action.
         **/
        NoPermission: GenericPalletError;
        /**
         * The actor has no permission to conduct the action right now but will do in the future.
         **/
        NoPermissionYet: GenericPalletError;
        /**
         * The account is already delegating.
         **/
        AlreadyDelegating: GenericPalletError;
        /**
         * The account currently has votes attached to it and the operation cannot succeed until
         * these are removed through `remove_vote`.
         **/
        AlreadyVoting: GenericPalletError;
        /**
         * Too high a balance was provided that the account cannot afford.
         **/
        InsufficientFunds: GenericPalletError;
        /**
         * The account is not currently delegating.
         **/
        NotDelegating: GenericPalletError;
        /**
         * Delegation to oneself makes no sense.
         **/
        Nonsense: GenericPalletError;
        /**
         * Maximum number of votes reached.
         **/
        MaxVotesReached: GenericPalletError;
        /**
         * The class must be supplied since it is not easily determinable from the state.
         **/
        ClassNeeded: GenericPalletError;
        /**
         * The class ID supplied is invalid.
         **/
        BadClass: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Whitelist`'s errors
     **/
    whitelist: {
        /**
         * The preimage of the call hash could not be loaded.
         **/
        UnavailablePreImage: GenericPalletError;
        /**
         * The call could not be decoded.
         **/
        UndecodableCall: GenericPalletError;
        /**
         * The weight of the decoded call was higher than the witness.
         **/
        InvalidCallWeightWitness: GenericPalletError;
        /**
         * The call was not whitelisted.
         **/
        CallIsNotWhitelisted: GenericPalletError;
        /**
         * The call was already whitelisted; No-Op.
         **/
        CallAlreadyWhitelisted: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `AllianceMotion`'s errors
     **/
    allianceMotion: {
        /**
         * Account is not a member
         **/
        NotMember: GenericPalletError;
        /**
         * Duplicate proposals not allowed
         **/
        DuplicateProposal: GenericPalletError;
        /**
         * Proposal must exist
         **/
        ProposalMissing: GenericPalletError;
        /**
         * Mismatched index
         **/
        WrongIndex: GenericPalletError;
        /**
         * Duplicate vote ignored
         **/
        DuplicateVote: GenericPalletError;
        /**
         * Members are already initialized!
         **/
        AlreadyInitialized: GenericPalletError;
        /**
         * The close call was made too early, before the end of the voting.
         **/
        TooEarly: GenericPalletError;
        /**
         * There can only be a maximum of `MaxProposals` active proposals.
         **/
        TooManyProposals: GenericPalletError;
        /**
         * The given weight bound for the proposal was too low.
         **/
        WrongProposalWeight: GenericPalletError;
        /**
         * The given length bound for the proposal was too low.
         **/
        WrongProposalLength: GenericPalletError;
        /**
         * Prime account is not a member
         **/
        PrimeAccountNotMember: GenericPalletError;
        /**
         * Proposal is still active.
         **/
        ProposalActive: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Alliance`'s errors
     **/
    alliance: {
        /**
         * The Alliance has not been initialized yet, therefore accounts cannot join it.
         **/
        AllianceNotYetInitialized: GenericPalletError;
        /**
         * The Alliance has been initialized, therefore cannot be initialized again.
         **/
        AllianceAlreadyInitialized: GenericPalletError;
        /**
         * Account is already a member.
         **/
        AlreadyMember: GenericPalletError;
        /**
         * Account is not a member.
         **/
        NotMember: GenericPalletError;
        /**
         * Account is not an ally.
         **/
        NotAlly: GenericPalletError;
        /**
         * Account does not have voting rights.
         **/
        NoVotingRights: GenericPalletError;
        /**
         * Account is already an elevated (fellow) member.
         **/
        AlreadyElevated: GenericPalletError;
        /**
         * Item is already listed as unscrupulous.
         **/
        AlreadyUnscrupulous: GenericPalletError;
        /**
         * Account has been deemed unscrupulous by the Alliance and is not welcome to join or be
         * nominated.
         **/
        AccountNonGrata: GenericPalletError;
        /**
         * Item has not been deemed unscrupulous.
         **/
        NotListedAsUnscrupulous: GenericPalletError;
        /**
         * The number of unscrupulous items exceeds `MaxUnscrupulousItems`.
         **/
        TooManyUnscrupulousItems: GenericPalletError;
        /**
         * Length of website URL exceeds `MaxWebsiteUrlLength`.
         **/
        TooLongWebsiteUrl: GenericPalletError;
        /**
         * Balance is insufficient for the required deposit.
         **/
        InsufficientFunds: GenericPalletError;
        /**
         * The account's identity does not have display field and website field.
         **/
        WithoutRequiredIdentityFields: GenericPalletError;
        /**
         * The account's identity has no good judgement.
         **/
        WithoutGoodIdentityJudgement: GenericPalletError;
        /**
         * The proposal hash is not found.
         **/
        MissingProposalHash: GenericPalletError;
        /**
         * The announcement is not found.
         **/
        MissingAnnouncement: GenericPalletError;
        /**
         * Number of members exceeds `MaxMembersCount`.
         **/
        TooManyMembers: GenericPalletError;
        /**
         * Number of announcements exceeds `MaxAnnouncementsCount`.
         **/
        TooManyAnnouncements: GenericPalletError;
        /**
         * Invalid witness data given.
         **/
        BadWitness: GenericPalletError;
        /**
         * Account already gave retirement notice
         **/
        AlreadyRetiring: GenericPalletError;
        /**
         * Account did not give a retirement notice required to retire.
         **/
        RetirementNoticeNotGiven: GenericPalletError;
        /**
         * Retirement period has not passed.
         **/
        RetirementPeriodNotPassed: GenericPalletError;
        /**
         * Fellows must be provided to initialize the Alliance.
         **/
        FellowsMissing: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `NominationPools`'s errors
     **/
    nominationPools: {
        /**
         * A (bonded) pool id does not exist.
         **/
        PoolNotFound: GenericPalletError;
        /**
         * An account is not a member.
         **/
        PoolMemberNotFound: GenericPalletError;
        /**
         * A reward pool does not exist. In all cases this is a system logic error.
         **/
        RewardPoolNotFound: GenericPalletError;
        /**
         * A sub pool does not exist.
         **/
        SubPoolsNotFound: GenericPalletError;
        /**
         * An account is already delegating in another pool. An account may only belong to one
         * pool at a time.
         **/
        AccountBelongsToOtherPool: GenericPalletError;
        /**
         * The member is fully unbonded (and thus cannot access the bonded and reward pool
         * anymore to, for example, collect rewards).
         **/
        FullyUnbonding: GenericPalletError;
        /**
         * The member cannot unbond further chunks due to reaching the limit.
         **/
        MaxUnbondingLimit: GenericPalletError;
        /**
         * None of the funds can be withdrawn yet because the bonding duration has not passed.
         **/
        CannotWithdrawAny: GenericPalletError;
        /**
         * The amount does not meet the minimum bond to either join or create a pool.
         *
         * The depositor can never unbond to a value less than `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;
        /**
         * The transaction could not be executed due to overflow risk for the pool.
         **/
        OverflowRisk: GenericPalletError;
        /**
         * A pool must be in [`PoolState::Destroying`] in order for the depositor to unbond or for
         * other members to be permissionlessly unbonded.
         **/
        NotDestroying: GenericPalletError;
        /**
         * The caller does not have nominating permissions for the pool.
         **/
        NotNominator: GenericPalletError;
        /**
         * Either a) the caller cannot make a valid kick or b) the pool is not destroying.
         **/
        NotKickerOrDestroying: GenericPalletError;
        /**
         * The pool is not open to join
         **/
        NotOpen: GenericPalletError;
        /**
         * The system is maxed out on pools.
         **/
        MaxPools: GenericPalletError;
        /**
         * Too many members in the pool or system.
         **/
        MaxPoolMembers: GenericPalletError;
        /**
         * The pools state cannot be changed.
         **/
        CanNotChangeState: GenericPalletError;
        /**
         * The caller does not have adequate permissions.
         **/
        DoesNotHavePermission: GenericPalletError;
        /**
         * Metadata exceeds [`Config::MaxMetadataLen`]
         **/
        MetadataExceedsMaxLen: GenericPalletError;
        /**
         * Some error occurred that should never happen. This should be reported to the
         * maintainers.
         **/
        Defensive: GenericPalletError;
        /**
         * Partial unbonding now allowed permissionlessly.
         **/
        PartialUnbondNotAllowedPermissionlessly: GenericPalletError;
        /**
         * The pool's max commission cannot be set higher than the existing value.
         **/
        MaxCommissionRestricted: GenericPalletError;
        /**
         * The supplied commission exceeds the max allowed commission.
         **/
        CommissionExceedsMaximum: GenericPalletError;
        /**
         * The supplied commission exceeds global maximum commission.
         **/
        CommissionExceedsGlobalMaximum: GenericPalletError;
        /**
         * Not enough blocks have surpassed since the last commission update.
         **/
        CommissionChangeThrottled: GenericPalletError;
        /**
         * The submitted changes to commission change rate are not allowed.
         **/
        CommissionChangeRateNotAllowed: GenericPalletError;
        /**
         * There is no pending commission to claim.
         **/
        NoPendingCommission: GenericPalletError;
        /**
         * No commission current has been set.
         **/
        NoCommissionCurrentSet: GenericPalletError;
        /**
         * Pool id currently in use.
         **/
        PoolIdInUse: GenericPalletError;
        /**
         * Pool id provided is not correct/usable.
         **/
        InvalidPoolId: GenericPalletError;
        /**
         * Bonding extra is restricted to the exact pending reward amount.
         **/
        BondExtraRestricted: GenericPalletError;
        /**
         * No imbalance in the ED deposit for the pool.
         **/
        NothingToAdjust: GenericPalletError;
        /**
         * No slash pending that can be applied to the member.
         **/
        NothingToSlash: GenericPalletError;
        /**
         * The slash amount is too low to be applied.
         **/
        SlashTooLow: GenericPalletError;
        /**
         * The pool or member delegation has already migrated to delegate stake.
         **/
        AlreadyMigrated: GenericPalletError;
        /**
         * The pool or member delegation has not migrated yet to delegate stake.
         **/
        NotMigrated: GenericPalletError;
        /**
         * This call is not allowed in the current state of the pallet.
         **/
        NotSupported: GenericPalletError;
        /**
         * Account is restricted from participation in pools. This may happen if the account is
         * staking in another way already.
         **/
        Restricted: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `RankedPolls`'s errors
     **/
    rankedPolls: {
        /**
         * Referendum is not ongoing.
         **/
        NotOngoing: GenericPalletError;
        /**
         * Referendum's decision deposit is already paid.
         **/
        HasDeposit: GenericPalletError;
        /**
         * The track identifier given was invalid.
         **/
        BadTrack: GenericPalletError;
        /**
         * There are already a full complement of referenda in progress for this track.
         **/
        Full: GenericPalletError;
        /**
         * The queue of the track is empty.
         **/
        QueueEmpty: GenericPalletError;
        /**
         * The referendum index provided is invalid in this context.
         **/
        BadReferendum: GenericPalletError;
        /**
         * There was nothing to do in the advancement.
         **/
        NothingToDo: GenericPalletError;
        /**
         * No track exists for the proposal origin.
         **/
        NoTrack: GenericPalletError;
        /**
         * Any deposit cannot be refunded until after the decision is over.
         **/
        Unfinished: GenericPalletError;
        /**
         * The deposit refunder is not the depositor.
         **/
        NoPermission: GenericPalletError;
        /**
         * The deposit cannot be refunded since none was made.
         **/
        NoDeposit: GenericPalletError;
        /**
         * The referendum status is invalid for this operation.
         **/
        BadStatus: GenericPalletError;
        /**
         * The preimage does not exist.
         **/
        PreimageNotExist: GenericPalletError;
        /**
         * The preimage is stored with a different length than the one provided.
         **/
        PreimageStoredWithDifferentLength: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `RankedCollective`'s errors
     **/
    rankedCollective: {
        /**
         * Account is already a member.
         **/
        AlreadyMember: GenericPalletError;
        /**
         * Account is not a member.
         **/
        NotMember: GenericPalletError;
        /**
         * The given poll index is unknown or has closed.
         **/
        NotPolling: GenericPalletError;
        /**
         * The given poll is still ongoing.
         **/
        Ongoing: GenericPalletError;
        /**
         * There are no further records to be removed.
         **/
        NoneRemaining: GenericPalletError;
        /**
         * Unexpected error in state.
         **/
        Corruption: GenericPalletError;
        /**
         * The member's rank is too low to vote.
         **/
        RankTooLow: GenericPalletError;
        /**
         * The information provided is incorrect.
         **/
        InvalidWitness: GenericPalletError;
        /**
         * The origin is not sufficiently privileged to do the operation.
         **/
        NoPermission: GenericPalletError;
        /**
         * The new member to exchange is the same as the old member
         **/
        SameMember: GenericPalletError;
        /**
         * The max member count for the rank has been reached.
         **/
        TooManyMembers: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `AssetConversion`'s errors
     **/
    assetConversion: {
        /**
         * Provided asset pair is not supported for pool.
         **/
        InvalidAssetPair: GenericPalletError;
        /**
         * Pool already exists.
         **/
        PoolExists: GenericPalletError;
        /**
         * Desired amount can't be zero.
         **/
        WrongDesiredAmount: GenericPalletError;
        /**
         * Provided amount should be greater than or equal to the existential deposit/asset's
         * minimal amount.
         **/
        AmountOneLessThanMinimal: GenericPalletError;
        /**
         * Provided amount should be greater than or equal to the existential deposit/asset's
         * minimal amount.
         **/
        AmountTwoLessThanMinimal: GenericPalletError;
        /**
         * Reserve needs to always be greater than or equal to the existential deposit/asset's
         * minimal amount.
         **/
        ReserveLeftLessThanMinimal: GenericPalletError;
        /**
         * Desired amount can't be equal to the pool reserve.
         **/
        AmountOutTooHigh: GenericPalletError;
        /**
         * The pool doesn't exist.
         **/
        PoolNotFound: GenericPalletError;
        /**
         * An overflow happened.
         **/
        Overflow: GenericPalletError;
        /**
         * The minimal amount requirement for the first token in the pair wasn't met.
         **/
        AssetOneDepositDidNotMeetMinimum: GenericPalletError;
        /**
         * The minimal amount requirement for the second token in the pair wasn't met.
         **/
        AssetTwoDepositDidNotMeetMinimum: GenericPalletError;
        /**
         * The minimal amount requirement for the first token in the pair wasn't met.
         **/
        AssetOneWithdrawalDidNotMeetMinimum: GenericPalletError;
        /**
         * The minimal amount requirement for the second token in the pair wasn't met.
         **/
        AssetTwoWithdrawalDidNotMeetMinimum: GenericPalletError;
        /**
         * Optimal calculated amount is less than desired.
         **/
        OptimalAmountLessThanDesired: GenericPalletError;
        /**
         * Insufficient liquidity minted.
         **/
        InsufficientLiquidityMinted: GenericPalletError;
        /**
         * Requested liquidity can't be zero.
         **/
        ZeroLiquidity: GenericPalletError;
        /**
         * Amount can't be zero.
         **/
        ZeroAmount: GenericPalletError;
        /**
         * Calculated amount out is less than provided minimum amount.
         **/
        ProvidedMinimumNotSufficientForSwap: GenericPalletError;
        /**
         * Provided maximum amount is not sufficient for swap.
         **/
        ProvidedMaximumNotSufficientForSwap: GenericPalletError;
        /**
         * The provided path must consists of 2 assets at least.
         **/
        InvalidPath: GenericPalletError;
        /**
         * The provided path must consists of unique assets.
         **/
        NonUniquePath: GenericPalletError;
        /**
         * It was not possible to get or increment the Id of the pool.
         **/
        IncorrectPoolAssetId: GenericPalletError;
        /**
         * The destination account cannot exist with the swapped funds.
         **/
        BelowMinimum: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `FastUnstake`'s errors
     **/
    fastUnstake: {
        /**
         * The provided Controller account was not found.
         *
         * This means that the given account is not bonded.
         **/
        NotController: GenericPalletError;
        /**
         * The bonded account has already been queued.
         **/
        AlreadyQueued: GenericPalletError;
        /**
         * The bonded account has active unlocking chunks.
         **/
        NotFullyBonded: GenericPalletError;
        /**
         * The provided un-staker is not in the `Queue`.
         **/
        NotQueued: GenericPalletError;
        /**
         * The provided un-staker is already in Head, and cannot deregister.
         **/
        AlreadyHead: GenericPalletError;
        /**
         * The call is not allowed at this point because the pallet is not active.
         **/
        CallNotAllowed: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `MessageQueue`'s errors
     **/
    messageQueue: {
        /**
         * Page is not reapable because it has items remaining to be processed and is not old
         * enough.
         **/
        NotReapable: GenericPalletError;
        /**
         * Page to be reaped does not exist.
         **/
        NoPage: GenericPalletError;
        /**
         * The referenced message could not be found.
         **/
        NoMessage: GenericPalletError;
        /**
         * The message was already processed and cannot be processed again.
         **/
        AlreadyProcessed: GenericPalletError;
        /**
         * The message is queued for future execution.
         **/
        Queued: GenericPalletError;
        /**
         * There is temporarily not enough weight to continue servicing messages.
         **/
        InsufficientWeight: GenericPalletError;
        /**
         * This message is temporarily unprocessable.
         *
         * Such errors are expected, but not guaranteed, to resolve themselves eventually through
         * retrying.
         **/
        TemporarilyUnprocessable: GenericPalletError;
        /**
         * The queue is paused and no message can be executed from it.
         *
         * This can change at any time and may resolve in the future by re-trying.
         **/
        QueuePaused: GenericPalletError;
        /**
         * Another call is in progress and needs to finish before this call can happen.
         **/
        RecursiveDisallowed: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `TxPause`'s errors
     **/
    txPause: {
        /**
         * The call is paused.
         **/
        IsPaused: GenericPalletError;
        /**
         * The call is unpaused.
         **/
        IsUnpaused: GenericPalletError;
        /**
         * The call is whitelisted and cannot be paused.
         **/
        Unpausable: GenericPalletError;
        NotFound: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `SafeMode`'s errors
     **/
    safeMode: {
        /**
         * The safe-mode is (already or still) entered.
         **/
        Entered: GenericPalletError;
        /**
         * The safe-mode is (already or still) exited.
         **/
        Exited: GenericPalletError;
        /**
         * This functionality of the pallet is disabled by the configuration.
         **/
        NotConfigured: GenericPalletError;
        /**
         * There is no balance reserved.
         **/
        NoDeposit: GenericPalletError;
        /**
         * The account already has a deposit reserved and can therefore not enter or extend again.
         **/
        AlreadyDeposited: GenericPalletError;
        /**
         * This deposit cannot be released yet.
         **/
        CannotReleaseYet: GenericPalletError;
        /**
         * An error from the underlying `Currency`.
         **/
        CurrencyError: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `MultiBlockMigrations`'s errors
     **/
    multiBlockMigrations: {
        /**
         * The operation cannot complete since some MBMs are ongoing.
         **/
        Ongoing: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Broker`'s errors
     **/
    broker: {
        /**
         * The given region identity is not known.
         **/
        UnknownRegion: GenericPalletError;
        /**
         * The owner of the region is not the origin.
         **/
        NotOwner: GenericPalletError;
        /**
         * The pivot point of the partition at or after the end of the region.
         **/
        PivotTooLate: GenericPalletError;
        /**
         * The pivot point of the partition at the beginning of the region.
         **/
        PivotTooEarly: GenericPalletError;
        /**
         * The pivot mask for the interlacing is not contained within the region's interlace mask.
         **/
        ExteriorPivot: GenericPalletError;
        /**
         * The pivot mask for the interlacing is void (and therefore unschedulable).
         **/
        VoidPivot: GenericPalletError;
        /**
         * The pivot mask for the interlacing is complete (and therefore not a strict subset).
         **/
        CompletePivot: GenericPalletError;
        /**
         * The workplan of the pallet's state is invalid. This indicates a state corruption.
         **/
        CorruptWorkplan: GenericPalletError;
        /**
         * There is no sale happening currently.
         **/
        NoSales: GenericPalletError;
        /**
         * The price limit is exceeded.
         **/
        Overpriced: GenericPalletError;
        /**
         * There are no cores available.
         **/
        Unavailable: GenericPalletError;
        /**
         * The sale limit has been reached.
         **/
        SoldOut: GenericPalletError;
        /**
         * The renewal operation is not valid at the current time (it may become valid in the next
         * sale).
         **/
        WrongTime: GenericPalletError;
        /**
         * Invalid attempt to renew.
         **/
        NotAllowed: GenericPalletError;
        /**
         * This pallet has not yet been initialized.
         **/
        Uninitialized: GenericPalletError;
        /**
         * The purchase cannot happen yet as the sale period is yet to begin.
         **/
        TooEarly: GenericPalletError;
        /**
         * There is no work to be done.
         **/
        NothingToDo: GenericPalletError;
        /**
         * The maximum amount of reservations has already been reached.
         **/
        TooManyReservations: GenericPalletError;
        /**
         * The maximum amount of leases has already been reached.
         **/
        TooManyLeases: GenericPalletError;
        /**
         * The lease does not exist.
         **/
        LeaseNotFound: GenericPalletError;
        /**
         * The revenue for the Instantaneous Core Sales of this period is not (yet) known and thus
         * this operation cannot proceed.
         **/
        UnknownRevenue: GenericPalletError;
        /**
         * The identified contribution to the Instantaneous Core Pool is unknown.
         **/
        UnknownContribution: GenericPalletError;
        /**
         * The workload assigned for renewal is incomplete. This is unexpected and indicates a
         * logic error.
         **/
        IncompleteAssignment: GenericPalletError;
        /**
         * An item cannot be dropped because it is still valid.
         **/
        StillValid: GenericPalletError;
        /**
         * The history item does not exist.
         **/
        NoHistory: GenericPalletError;
        /**
         * No reservation of the given index exists.
         **/
        UnknownReservation: GenericPalletError;
        /**
         * The renewal record cannot be found.
         **/
        UnknownRenewal: GenericPalletError;
        /**
         * The lease expiry time has already passed.
         **/
        AlreadyExpired: GenericPalletError;
        /**
         * The configuration could not be applied because it is invalid.
         **/
        InvalidConfig: GenericPalletError;
        /**
         * The revenue must be claimed for 1 or more timeslices.
         **/
        NoClaimTimeslices: GenericPalletError;
        /**
         * The caller doesn't have the permission to enable or disable auto-renewal.
         **/
        NoPermission: GenericPalletError;
        /**
         * We reached the limit for auto-renewals.
         **/
        TooManyAutoRenewals: GenericPalletError;
        /**
         * Only cores which are assigned to a task can be auto-renewed.
         **/
        NonTaskAutoRenewal: GenericPalletError;
        /**
         * Failed to get the sovereign account of a task.
         **/
        SovereignAccountNotFound: GenericPalletError;
        /**
         * Attempted to disable auto-renewal for a core that didn't have it enabled.
         **/
        AutoRenewalNotEnabled: GenericPalletError;
        /**
         * Attempted to force remove an assignment that doesn't exist.
         **/
        AssignmentNotFound: GenericPalletError;
        /**
         * Needed to prevent spam attacks.The amount of credits the user attempted to purchase is
         * below `T::MinimumCreditPurchase`.
         **/
        CreditPurchaseTooSmall: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `TasksExample`'s errors
     **/
    tasksExample: {
        /**
         * The referenced task was not found.
         **/
        NotFound: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `AssetConversionMigration`'s errors
     **/
    assetConversionMigration: {
        /**
         * Provided asset pair is not supported for pool.
         **/
        InvalidAssetPair: GenericPalletError;
        /**
         * The pool doesn't exist.
         **/
        PoolNotFound: GenericPalletError;
        /**
         * Pool's balance cannot be zero.
         **/
        ZeroBalance: GenericPalletError;
        /**
         * Indicates a partial transfer of balance to the new account during a migration.
         **/
        PartialTransfer: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `Revive`'s errors
     **/
    revive: {
        /**
         * Invalid schedule supplied, e.g. with zero weight of a basic operation.
         **/
        InvalidSchedule: GenericPalletError;
        /**
         * Invalid combination of flags supplied to `seal_call` or `seal_delegate_call`.
         **/
        InvalidCallFlags: GenericPalletError;
        /**
         * The executed contract exhausted its gas limit.
         **/
        OutOfGas: GenericPalletError;
        /**
         * Performing the requested transfer failed. Probably because there isn't enough
         * free balance in the sender's account.
         **/
        TransferFailed: GenericPalletError;
        /**
         * Performing a call was denied because the calling depth reached the limit
         * of what is specified in the schedule.
         **/
        MaxCallDepthReached: GenericPalletError;
        /**
         * No contract was found at the specified address.
         **/
        ContractNotFound: GenericPalletError;
        /**
         * No code could be found at the supplied code hash.
         **/
        CodeNotFound: GenericPalletError;
        /**
         * No code info could be found at the supplied code hash.
         **/
        CodeInfoNotFound: GenericPalletError;
        /**
         * A buffer outside of sandbox memory was passed to a contract API function.
         **/
        OutOfBounds: GenericPalletError;
        /**
         * Input passed to a contract API function failed to decode as expected type.
         **/
        DecodingFailed: GenericPalletError;
        /**
         * Contract trapped during execution.
         **/
        ContractTrapped: GenericPalletError;
        /**
         * The size defined in `T::MaxValueSize` was exceeded.
         **/
        ValueTooLarge: GenericPalletError;
        /**
         * Termination of a contract is not allowed while the contract is already
         * on the call stack. Can be triggered by `seal_terminate`.
         **/
        TerminatedWhileReentrant: GenericPalletError;
        /**
         * `seal_call` forwarded this contracts input. It therefore is no longer available.
         **/
        InputForwarded: GenericPalletError;
        /**
         * The amount of topics passed to `seal_deposit_events` exceeds the limit.
         **/
        TooManyTopics: GenericPalletError;
        /**
         * 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;
        /**
         * Failed to decode the XCM program.
         **/
        XcmDecodeFailed: GenericPalletError;
        /**
         * A contract with the same AccountId already exists.
         **/
        DuplicateContract: GenericPalletError;
        /**
         * A contract self destructed in its constructor.
         *
         * This can be triggered by a call to `seal_terminate`.
         **/
        TerminatedInConstructor: GenericPalletError;
        /**
         * A call tried to invoke a contract that is flagged as non-reentrant.
         **/
        ReentranceDenied: GenericPalletError;
        /**
         * A contract called into the runtime which then called back into this pallet.
         **/
        ReenteredPallet: GenericPalletError;
        /**
         * A contract attempted to invoke a state modifying API while being in read-only mode.
         **/
        StateChangeDenied: GenericPalletError;
        /**
         * Origin doesn't have enough balance to pay the required storage deposits.
         **/
        StorageDepositNotEnoughFunds: GenericPalletError;
        /**
         * More storage was created than allowed by the storage deposit limit.
         **/
        StorageDepositLimitExhausted: GenericPalletError;
        /**
         * Code removal was denied because the code is still in use by at least one contract.
         **/
        CodeInUse: GenericPalletError;
        /**
         * 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: GenericPalletError;
        /**
         * The contract failed to compile or is missing the correct entry points.
         *
         * A more detailed error can be found on the node console if debug messages are enabled
         * by supplying `-lruntime::revive=debug`.
         **/
        CodeRejected: GenericPalletError;
        /**
         * The code blob supplied is larger than [`limits::code::BLOB_BYTES`].
         **/
        BlobTooLarge: GenericPalletError;
        /**
         * The static memory consumption of the blob will be larger than
         * [`limits::code::STATIC_MEMORY_BYTES`].
         **/
        StaticMemoryTooLarge: GenericPalletError;
        /**
         * The program contains a basic block that is larger than allowed.
         **/
        BasicBlockTooLarge: GenericPalletError;
        /**
         * The program contains an invalid instruction.
         **/
        InvalidInstruction: GenericPalletError;
        /**
         * The contract has reached its maximum number of delegate dependencies.
         **/
        MaxDelegateDependenciesReached: GenericPalletError;
        /**
         * The dependency was not found in the contract's delegate dependencies.
         **/
        DelegateDependencyNotFound: GenericPalletError;
        /**
         * The contract already depends on the given delegate dependency.
         **/
        DelegateDependencyAlreadyExists: GenericPalletError;
        /**
         * Can not add a delegate dependency to the code hash of the contract itself.
         **/
        CannotAddSelfAsDelegateDependency: GenericPalletError;
        /**
         * Can not add more data to transient storage.
         **/
        OutOfTransientStorage: GenericPalletError;
        /**
         * The contract tried to call a syscall which does not exist (at its current api level).
         **/
        InvalidSyscall: GenericPalletError;
        /**
         * Invalid storage flags were passed to one of the storage syscalls.
         **/
        InvalidStorageFlags: GenericPalletError;
        /**
         * PolkaVM failed during code execution. Probably due to a malformed program.
         **/
        ExecutionFailed: GenericPalletError;
        /**
         * Failed to convert a U256 to a Balance.
         **/
        BalanceConversionFailed: GenericPalletError;
        /**
         * Failed to convert an EVM balance to a native balance.
         **/
        DecimalPrecisionLoss: GenericPalletError;
        /**
         * Immutable data can only be set during deploys and only be read during calls.
         * Additionally, it is only valid to set the data once and it must not be empty.
         **/
        InvalidImmutableAccess: GenericPalletError;
        /**
         * An `AccountID32` account tried to interact with the pallet without having a mapping.
         *
         * Call [`Pallet::map_account`] in order to create a mapping for the account.
         **/
        AccountUnmapped: GenericPalletError;
        /**
         * Tried to map an account that is already mapped.
         **/
        AccountAlreadyMapped: GenericPalletError;
        /**
         * The transaction used to dry-run a contract is invalid.
         **/
        InvalidGenericTransaction: GenericPalletError;
        /**
         * The refcount of a code either over or underflowed.
         **/
        RefcountOverOrUnderflow: GenericPalletError;
        /**
         * Unsupported precompile address
         **/
        UnsupportedPrecompileAddress: GenericPalletError;
        /**
         * Precompile Error
         **/
        PrecompileFailure: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `DelegatedStaking`'s errors
     **/
    delegatedStaking: {
        /**
         * The account cannot perform this operation.
         **/
        NotAllowed: GenericPalletError;
        /**
         * An existing staker cannot perform this action.
         **/
        AlreadyStaking: GenericPalletError;
        /**
         * Reward Destination cannot be same as `Agent` account.
         **/
        InvalidRewardDestination: GenericPalletError;
        /**
         * Delegation conditions are not met.
         *
         * Possible issues are
         * 1) Cannot delegate to self,
         * 2) Cannot delegate to multiple delegates.
         **/
        InvalidDelegation: GenericPalletError;
        /**
         * The account does not have enough funds to perform the operation.
         **/
        NotEnoughFunds: GenericPalletError;
        /**
         * Not an existing `Agent` account.
         **/
        NotAgent: GenericPalletError;
        /**
         * Not a Delegator account.
         **/
        NotDelegator: GenericPalletError;
        /**
         * Some corruption in internal state.
         **/
        BadState: GenericPalletError;
        /**
         * Unapplied pending slash restricts operation on `Agent`.
         **/
        UnappliedSlash: GenericPalletError;
        /**
         * `Agent` has no pending slash to be applied.
         **/
        NothingToSlash: GenericPalletError;
        /**
         * Failed to withdraw amount from Core Staking.
         **/
        WithdrawFailed: GenericPalletError;
        /**
         * Operation not supported by this pallet.
         **/
        NotSupported: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `AssetRewards`'s errors
     **/
    assetRewards: {
        /**
         * The staker does not have enough tokens to perform the operation.
         **/
        NotEnoughTokens: GenericPalletError;
        /**
         * An operation was attempted on a non-existent pool.
         **/
        NonExistentPool: GenericPalletError;
        /**
         * An operation was attempted for a non-existent staker.
         **/
        NonExistentStaker: GenericPalletError;
        /**
         * An operation was attempted with a non-existent asset.
         **/
        NonExistentAsset: GenericPalletError;
        /**
         * There was an error converting a block number.
         **/
        BlockNumberConversionError: GenericPalletError;
        /**
         * The expiry block must be in the future.
         **/
        ExpiryBlockMustBeInTheFuture: GenericPalletError;
        /**
         * Insufficient funds to create the freeze.
         **/
        InsufficientFunds: GenericPalletError;
        /**
         * The expiry block can be only extended.
         **/
        ExpiryCut: GenericPalletError;
        /**
         * The reward rate per block can be only increased.
         **/
        RewardRateCut: GenericPalletError;
        /**
         * The pool still has staked tokens or rewards.
         **/
        NonEmptyPool: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `AssetsFreezer`'s errors
     **/
    assetsFreezer: {
        /**
         * Number of freezes on an account would exceed `MaxFreezes`.
         **/
        TooManyFreezes: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
    /**
     * Pallet `MetaTx`'s errors
     **/
    metaTx: {
        /**
         * Invalid proof (e.g. signature).
         **/
        BadProof: GenericPalletError;
        /**
         * The meta transaction is not yet valid (e.g. nonce too high).
         **/
        Future: GenericPalletError;
        /**
         * The meta transaction is outdated (e.g. nonce too low).
         **/
        Stale: GenericPalletError;
        /**
         * The meta transactions's birth block is ancient.
         **/
        AncientBirthBlock: GenericPalletError;
        /**
         * The transaction extension did not authorize any origin.
         **/
        UnknownOrigin: GenericPalletError;
        /**
         * The meta transaction is invalid.
         **/
        Invalid: GenericPalletError;
        /**
         * Generic pallet error
         **/
        [error: string]: GenericPalletError;
    };
}