import '@polkadot/api-base/types/errors';
import type { ApiTypes, AugmentedError } from '@polkadot/api-base/types';
export declare type __AugmentedError<ApiType extends ApiTypes> = AugmentedError<ApiType>;
declare module '@polkadot/api-base/types/errors' {
    interface AugmentedErrors<ApiType extends ApiTypes> {
        authorship: {
            /**
             * The uncle is genesis.
             **/
            GenesisUncle: AugmentedError<ApiType>;
            /**
             * The uncle parent not in the chain.
             **/
            InvalidUncleParent: AugmentedError<ApiType>;
            /**
             * The uncle isn't recent enough to be included.
             **/
            OldUncle: AugmentedError<ApiType>;
            /**
             * The uncle is too high in chain.
             **/
            TooHighUncle: AugmentedError<ApiType>;
            /**
             * Too many uncles.
             **/
            TooManyUncles: AugmentedError<ApiType>;
            /**
             * The uncle is already included.
             **/
            UncleAlreadyIncluded: AugmentedError<ApiType>;
            /**
             * Uncles already set in the block.
             **/
            UnclesAlreadySet: AugmentedError<ApiType>;
        };
        bailsman: {
            /**
             * Cannot register account as bailsman because account is already a bailsman
             **/
            AlreadyBailsman: AugmentedError<ApiType>;
            /**
             * Cannot register/unregister or transfer from bailsman: bailsman account should not have negative balances
             **/
            BailsmanHasDebt: AugmentedError<ApiType>;
            /**
             * Account has insufficient balance to register as bailsman
             **/
            CollateralMustBeMoreThanMin: AugmentedError<ApiType>;
            /**
             * Balance convertion error
             **/
            Convert: AugmentedError<ApiType>;
            /**
             * Bailsman cannot have debt > collat
             **/
            NeedToMcBailsmanFirstly: AugmentedError<ApiType>;
            /**
             * Cannot unregister bailsman account - account is not bailsman
             **/
            NotBailsman: AugmentedError<ApiType>;
            /**
             * Price not found for redistribution
             **/
            PriceNotFound: AugmentedError<ApiType>;
            /**
             * Prices received from oracle are outdated
             **/
            PricesAreOutdated: AugmentedError<ApiType>;
            /**
             * Need to distribute temp balances
             **/
            TempBalancesNotDistributed: AugmentedError<ApiType>;
            /**
             * No basic transfers from / to bailsman temp balances
             **/
            TempBalancesTransfer: AugmentedError<ApiType>;
            /**
             * Bailsmen cannot have negative total balance
             **/
            TotalBailsmenPoolBalanceIsNegative: AugmentedError<ApiType>;
            /**
             * Wrong margin for operation performing
             **/
            WrongMargin: AugmentedError<ApiType>;
        };
        chainBridge: {
            /**
             * Bridge transfers to this chain have equal allowability
             **/
            AllowabilityEqual: AugmentedError<ApiType>;
            /**
             * Chain has already been enabled
             **/
            ChainAlreadyWhitelisted: AugmentedError<ApiType>;
            /**
             * Interactions with this chain is not permitted
             **/
            ChainNotWhitelisted: AugmentedError<ApiType>;
            /**
             * Bridge transfers to this chain are disabled
             **/
            DisabledChain: AugmentedError<ApiType>;
            /**
             * Provided chain Id is not valid
             **/
            InvalidChainId: AugmentedError<ApiType>;
            /**
             * Fee cannot be less than 0
             **/
            InvalidFee: AugmentedError<ApiType>;
            /**
             * Proposal lifetime cannot be equal 0
             **/
            InvalidProposalLifetime: AugmentedError<ApiType>;
            /**
             * Relayer threshold cannot be 0
             **/
            InvalidThreshold: AugmentedError<ApiType>;
            /**
             * Protected operation, must be performed by relayer
             **/
            MustBeRelayer: AugmentedError<ApiType>;
            /**
             * Proposal has either failed or succeeded
             **/
            ProposalAlreadyComplete: AugmentedError<ApiType>;
            /**
             * A proposal with these parameters has already been submitted
             **/
            ProposalAlreadyExists: AugmentedError<ApiType>;
            /**
             * No proposal with the ID was found
             **/
            ProposalDoesNotExist: AugmentedError<ApiType>;
            /**
             * Lifetime of proposal has been exceeded
             **/
            ProposalExpired: AugmentedError<ApiType>;
            /**
             * Cannot complete proposal, needs more votes
             **/
            ProposalNotComplete: AugmentedError<ApiType>;
            /**
             * Relayer already in set
             **/
            RelayerAlreadyExists: AugmentedError<ApiType>;
            /**
             * Relayer has already submitted some vote for this proposal
             **/
            RelayerAlreadyVoted: AugmentedError<ApiType>;
            /**
             * Provided accountId is not a relayer
             **/
            RelayerInvalid: AugmentedError<ApiType>;
            /**
             * Resource ID provided isn't mapped to anything
             **/
            ResourceDoesNotExist: AugmentedError<ApiType>;
            /**
             * Relayer threshold not set
             **/
            ThresholdNotSet: AugmentedError<ApiType>;
        };
        claims: {
            /**
             * Invalid Ethereum signature
             **/
            InvalidEthereumSignature: AugmentedError<ApiType>;
            /**
             * Invalid receiver
             **/
            InvalidReceiver: AugmentedError<ApiType>;
            /**
             * A needed statement was not included.
             **/
            InvalidStatement: AugmentedError<ApiType>;
            /**
             * This method is not allowed in production
             **/
            MethodNotAllowed: AugmentedError<ApiType>;
            /**
             * There's not enough in the pot to pay out some unvested amount. Generally
             * implies a logic error
             **/
            PotUnderflow: AugmentedError<ApiType>;
            /**
             * Account sending transaction has no claim
             **/
            SenderHasNoClaim: AugmentedError<ApiType>;
            /**
             * Ethereum address has no claim
             **/
            SignerHasNoClaim: AugmentedError<ApiType>;
            /**
             * The account already has a vested balance
             **/
            VestedBalanceExists: AugmentedError<ApiType>;
        };
        council: {
            /**
             * Members are already initialized!
             **/
            AlreadyInitialized: AugmentedError<ApiType>;
            /**
             * Duplicate proposals not allowed
             **/
            DuplicateProposal: AugmentedError<ApiType>;
            /**
             * Duplicate vote ignored
             **/
            DuplicateVote: AugmentedError<ApiType>;
            /**
             * Account is not a member
             **/
            NotMember: AugmentedError<ApiType>;
            /**
             * Proposal must exist
             **/
            ProposalMissing: AugmentedError<ApiType>;
            /**
             * The close call was made too early, before the end of the voting.
             **/
            TooEarly: AugmentedError<ApiType>;
            /**
             * There can only be a maximum of `MaxProposals` active proposals.
             **/
            TooManyProposals: AugmentedError<ApiType>;
            /**
             * Mismatched index
             **/
            WrongIndex: AugmentedError<ApiType>;
            /**
             * The given length bound for the proposal was too low.
             **/
            WrongProposalLength: AugmentedError<ApiType>;
            /**
             * The given weight bound for the proposal was too low.
             **/
            WrongProposalWeight: AugmentedError<ApiType>;
        };
        councilMembership: {
            /**
             * Already a member.
             **/
            AlreadyMember: AugmentedError<ApiType>;
            /**
             * Not a member.
             **/
            NotMember: AugmentedError<ApiType>;
            /**
             * Too many members.
             **/
            TooManyMembers: AugmentedError<ApiType>;
        };
        curveAmm: {
            /**
             * Could not create new asset
             **/
            AssetNotCreated: AugmentedError<ApiType>;
            /**
             * Some provided assets are not unique
             **/
            DuplicateAssets: AugmentedError<ApiType>;
            /**
             * The `AssetChecker` can use this error in case it can't provide better error
             **/
            ExternalAssetCheckFailed: AugmentedError<ApiType>;
            /**
             * Values in the storage are inconsistent
             **/
            InconsistentStorage: AugmentedError<ApiType>;
            /**
             * Specified index is out of range
             **/
            IndexOutOfRange: AugmentedError<ApiType>;
            /**
             * Source does not have required amount of coins to complete operation
             **/
            InsufficientFunds: AugmentedError<ApiType>;
            /**
             * Error occurred while performing math calculations
             **/
            Math: AugmentedError<ApiType>;
            /**
             * Not enough assets provided
             **/
            NotEnoughAssets: AugmentedError<ApiType>;
            /**
             * Pool with specified id is not found
             **/
            PoolNotFound: AugmentedError<ApiType>;
            /**
             * Required amount of some token did not reached during adding or removing liquidity
             **/
            RequiredAmountNotReached: AugmentedError<ApiType>;
            /**
             * Specified asset amount is wrong
             **/
            WrongAssetAmount: AugmentedError<ApiType>;
        };
        democracy: {
            /**
             * Cannot cancel the same proposal twice
             **/
            AlreadyCanceled: AugmentedError<ApiType>;
            /**
             * The account is already delegating.
             **/
            AlreadyDelegating: AugmentedError<ApiType>;
            /**
             * Identity may not veto a proposal twice
             **/
            AlreadyVetoed: AugmentedError<ApiType>;
            /**
             * Preimage already noted
             **/
            DuplicatePreimage: AugmentedError<ApiType>;
            /**
             * Proposal already made
             **/
            DuplicateProposal: AugmentedError<ApiType>;
            /**
             * Imminent
             **/
            Imminent: AugmentedError<ApiType>;
            /**
             * The instant referendum origin is currently disallowed.
             **/
            InstantNotAllowed: AugmentedError<ApiType>;
            /**
             * Too high a balance was provided that the account cannot afford.
             **/
            InsufficientFunds: AugmentedError<ApiType>;
            /**
             * Invalid hash
             **/
            InvalidHash: AugmentedError<ApiType>;
            /**
             * Maximum number of votes reached.
             **/
            MaxVotesReached: AugmentedError<ApiType>;
            /**
             * No proposals waiting
             **/
            NoneWaiting: AugmentedError<ApiType>;
            /**
             * Delegation to oneself makes no sense.
             **/
            Nonsense: AugmentedError<ApiType>;
            /**
             * The actor has no permission to conduct the action.
             **/
            NoPermission: AugmentedError<ApiType>;
            /**
             * No external proposal
             **/
            NoProposal: AugmentedError<ApiType>;
            /**
             * The account is not currently delegating.
             **/
            NotDelegating: AugmentedError<ApiType>;
            /**
             * Not imminent
             **/
            NotImminent: AugmentedError<ApiType>;
            /**
             * Next external proposal not simple majority
             **/
            NotSimpleMajority: AugmentedError<ApiType>;
            /**
             * The given account did not vote on the referendum.
             **/
            NotVoter: AugmentedError<ApiType>;
            /**
             * Invalid preimage
             **/
            PreimageInvalid: AugmentedError<ApiType>;
            /**
             * Preimage not found
             **/
            PreimageMissing: AugmentedError<ApiType>;
            /**
             * Proposal still blacklisted
             **/
            ProposalBlacklisted: AugmentedError<ApiType>;
            /**
             * Proposal does not exist
             **/
            ProposalMissing: AugmentedError<ApiType>;
            /**
             * Vote given for invalid referendum
             **/
            ReferendumInvalid: AugmentedError<ApiType>;
            /**
             * Too early
             **/
            TooEarly: AugmentedError<ApiType>;
            /**
             * Maximum number of proposals reached.
             **/
            TooManyProposals: AugmentedError<ApiType>;
            /**
             * Value too low
             **/
            ValueLow: AugmentedError<ApiType>;
            /**
             * The account currently has votes attached to it and the operation cannot succeed until
             * these are removed, either through `unvote` or `reap_vote`.
             **/
            VotesExist: AugmentedError<ApiType>;
            /**
             * Voting period too low
             **/
            VotingPeriodLow: AugmentedError<ApiType>;
            /**
             * Invalid upper bound.
             **/
            WrongUpperBound: AugmentedError<ApiType>;
        };
        dmpQueue: {
            /**
             * The amount of weight given is possibly not enough for executing the message.
             **/
            OverLimit: AugmentedError<ApiType>;
            /**
             * The message index given is unknown.
             **/
            Unknown: AugmentedError<ApiType>;
        };
        eqAssets: {
            /**
             * Asset with the same AssetId already exists
             **/
            AssetAlreadyExists: AugmentedError<ApiType>;
            /**
             * Asset was already requested to be removed
             **/
            AssetAlreadyToBeRemoved: AugmentedError<ApiType>;
            /**
             * Asset name is too long
             **/
            AssetNameWrongLength: AugmentedError<ApiType>;
            /**
             * Asset name contains a wrong symbol.
             * Only standard latin letters and digits are allowed.
             **/
            AssetNameWrongSymbols: AugmentedError<ApiType>;
            /**
             * Cannot delete an asset that does not exist
             **/
            AssetNotExists: AugmentedError<ApiType>;
            /**
             * Collateral discount is negative
             **/
            CollateralDiscountNegative: AugmentedError<ApiType>;
            /**
             * New asset without prices cannot be collateral.
             **/
            CollateralMustBeDisabledWithoutPrices: AugmentedError<ApiType>;
            /**
             * Debt weight cannot be over 100%
             **/
            DebtWeightMoreThanOne: AugmentedError<ApiType>;
            /**
             * Debt weight cannot be negative
             **/
            DebtWeightNegative: AugmentedError<ApiType>;
            /**
             * Operation not allowed for native asset
             **/
            Native: AugmentedError<ApiType>;
            /**
             * Price step cannot be negative
             **/
            PriceStepNegative: AugmentedError<ApiType>;
        };
        eqBalances: {
            /**
             * Beneficiary account must pre-exist
             **/
            DeadAccount: AugmentedError<ApiType>;
            /**
             * Exchange asset to itself
             **/
            ExchangeSameAsset: AugmentedError<ApiType>;
            /**
             * Balance is less than locked amount
             **/
            Locked: AugmentedError<ApiType>;
            /**
             * This method is not allowed in production
             **/
            MethodNotAllowed: AugmentedError<ApiType>;
            /**
             * Unimplemented method
             **/
            MethodUnimplemented: AugmentedError<ApiType>;
            /**
             * no migration needed
             **/
            NoMigration: AugmentedError<ApiType>;
            /**
             * Is thrown in case of removing non-zero balance
             **/
            NonZeroBalance: AugmentedError<ApiType>;
            /**
             * Transfer checks failed
             **/
            NotAllowedToChangeBalance: AugmentedError<ApiType>;
            /**
             * Not allowed to delete account
             **/
            NotAllowedToDeleteAccount: AugmentedError<ApiType>;
            /**
             * Deposit is not enough to buyout Eq from Treasury
             **/
            NotEnoughToBuyoutEq: AugmentedError<ApiType>;
            /**
             * Deposit is not enough to keep account alive
             **/
            NotEnoughToKeepAlive: AugmentedError<ApiType>;
            /**
             * Transfers are disabled
             **/
            TransfersAreDisabled: AugmentedError<ApiType>;
            /**
             * Direct transfer to subaccount not allowed from EqBalances
             **/
            TransferToSubaccount: AugmentedError<ApiType>;
            /**
             * XCM withdraw disabled
             **/
            XcmDisabled: AugmentedError<ApiType>;
            /**
             * Destination is not valid multilocation for transfer
             **/
            XcmInvalidDestination: AugmentedError<ApiType>;
            /**
             * Not enough to pay fee on destination chain
             **/
            XcmNotEnoughToPayFee: AugmentedError<ApiType>;
            /**
             * Error with xcm sending
             **/
            XcmSend: AugmentedError<ApiType>;
            /**
             * Daily XCM transfers limit exceeded
             **/
            XcmTransfersLimitExceeded: AugmentedError<ApiType>;
            /**
             * XCM native transfers not allowed for current account
             **/
            XcmTransfersNotAllowedForAccount: AugmentedError<ApiType>;
            /**
             * Asset is not suitable for XCM transfer
             **/
            XcmUnknownAsset: AugmentedError<ApiType>;
            /**
             * Fee asset should be the same for self reserved assets
             **/
            XcmWrongFeeAsset: AugmentedError<ApiType>;
        };
        eqBridge: {
            /**
             * Interactions with this chain is not permitted
             **/
            ChainNotWhitelisted: AugmentedError<ApiType>;
            /**
             * Bridge transfers to this chain are disabled
             **/
            DisabledChain: AugmentedError<ApiType>;
            /**
             * Asset withdrawals to this chain are disabled
             **/
            DisabledWithdrawals: AugmentedError<ApiType>;
            /**
             * Invalid destination Account for XCM transfer
             **/
            InvalidAccount: AugmentedError<ApiType>;
            /**
             * not allowed to bridge tokens of this type
             **/
            InvalidAssetType: AugmentedError<ApiType>;
            /**
             * Resource id not mapped to `Asset`
             **/
            InvalidResourceId: AugmentedError<ApiType>;
            InvalidTransfer: AugmentedError<ApiType>;
            /**
             * Transfer amount is lower than a minimum for given `ChainId` and `ResourceId`
             **/
            TransferAmountLowerMinimum: AugmentedError<ApiType>;
            /**
             * Withdrawals to this resource id and chain id have equal allowability
             **/
            WithdrawalsAllowabilityEqual: AugmentedError<ApiType>;
        };
        eqDex: {
            /**
             * Only trader subaccounts may create DEX orders.
             **/
            AccountIsNotTrader: AugmentedError<ApiType>;
            /**
             * Insufficient margin to place an order
             **/
            BadMargin: AugmentedError<ApiType>;
            /**
             * Asset trading is disabled
             **/
            DexIsDisabledForAsset: AugmentedError<ApiType>;
            /**
             * Inconsistent storage state
             **/
            InconsistentStorage: AugmentedError<ApiType>;
            /**
             * There is no best price for market order
             **/
            NoBestPriceForMarketOrder: AugmentedError<ApiType>;
            /**
             * Only order originator may cancel an order
             **/
            OnlyOwnerCanRemoveOrder: AugmentedError<ApiType>;
            /**
             * Order quantity should be a positive value
             **/
            OrderAmountShouldBePositive: AugmentedError<ApiType>;
            /**
             * Order amount should satisfy instrument lot size
             **/
            OrderAmountShouldSatisfyLot: AugmentedError<ApiType>;
            /**
             * No order found by order id and/or price
             **/
            OrderNotFound: AugmentedError<ApiType>;
            /**
             * Order price should be in a corridor
             **/
            OrderPriceShouldBeInCorridor: AugmentedError<ApiType>;
            /**
             * Order price should be a positive value
             **/
            OrderPriceShouldBePositive: AugmentedError<ApiType>;
            /**
             * Order price should satisfy instrument price step
             **/
            OrderPriceShouldSatisfyPriceStep: AugmentedError<ApiType>;
            /**
             * Price step should be a positive value
             **/
            PriceStepShouldBePositive: AugmentedError<ApiType>;
        };
        eqInvestors: {
            /**
             * Amount being transferred is too low to create a vesting schedule
             **/
            AmountLow: AugmentedError<ApiType>;
            /**
             * An existing vesting schedule already exists for this account that cannot be clobbered
             **/
            ExistingVestingSchedule: AugmentedError<ApiType>;
        };
        eqLending: {
            /**
             * Bailsman can not be unregistered because of debt weight
             **/
            BailsmanCantBeUnregistered: AugmentedError<ApiType>;
            /**
             * Bailsman can't generate debt
             **/
            BailsmanCantGenerateDebt: AugmentedError<ApiType>;
            /**
             * Not allowed because of debt weight
             **/
            DebtExceedLiquidity: AugmentedError<ApiType>;
            /**
             * Try to add reward to pool without lenders
             **/
            NoLendersToClaim: AugmentedError<ApiType>;
            /**
             * User do not deposit to lending pool
             **/
            NotALender: AugmentedError<ApiType>;
            /**
             * Try to withdraw more than deposited
             **/
            NotEnoughToWithdraw: AugmentedError<ApiType>;
            /**
             * Overflow
             **/
            Overflow: AugmentedError<ApiType>;
            /**
             * Only physical asset types allowed to deposit/withdraw in lending pool
             **/
            WrongAssetType: AugmentedError<ApiType>;
        };
        eqLiquidityFarming: {
            /**
             * Amount being transferred is too low to create a vesting schedule
             **/
            AmountLow: AugmentedError<ApiType>;
            /**
             * An existing vesting schedule already exists for this account that cannot be clobbered
             **/
            ExistingVestingSchedule: AugmentedError<ApiType>;
        };
        eqLockdrop: {
            /**
             * Lock amount is lower than minimum allowed
             **/
            LockAmountLow: AugmentedError<ApiType>;
            /**
             * Not allowed to make unlock in the period of the lock program
             **/
            LockPeriodNotOver: AugmentedError<ApiType>;
            /**
             * Lock start is already initialized
             **/
            LockStartNotEmpty: AugmentedError<ApiType>;
            /**
             * Not allowed to make multiple locks if account has vesting schedule
             **/
            MultipleTransferWithVesting: AugmentedError<ApiType>;
            /**
             * Not allowed to make lock not in the period of the lock program
             **/
            OutOfLockPeriod: AugmentedError<ApiType>;
        };
        eqMarginCall: {
            /**
             * Not allowed with zero collateral
             **/
            ZeroCollateral: AugmentedError<ApiType>;
        };
        eqMarketMaker: {
            /**
             * Attempt to execute from not whitelisted account
             **/
            NotWhitelistedAccount: AugmentedError<ApiType>;
        };
        eqMultisigSudo: {
            /**
             * The account already approved a proposal
             **/
            AlreadyApproved: AugmentedError<ApiType>;
            /**
             * The account already voted to cancel a proposal
             **/
            AlreadyCancelled: AugmentedError<ApiType>;
            /**
             * The key is already in the multisig signatory list
             **/
            AlreadyInKeyList: AugmentedError<ApiType>;
            /**
             * Too few signatories for the set threshold
             **/
            FewSignatories: AugmentedError<ApiType>;
            /**
             * The threshold is invalid
             **/
            InvalidThresholdValue: AugmentedError<ApiType>;
            /**
             * The key is not in the multisig signatory list
             **/
            NotInKeyList: AugmentedError<ApiType>;
            /**
             * Trying to delete a proposal that is not ours
             **/
            NotProposalOwner: AugmentedError<ApiType>;
            /**
             * The proposal not found in the map
             **/
            ProposalNotFound: AugmentedError<ApiType>;
        };
        eqRate: {
            /**
             * Asset is not in removal queue
             **/
            AssetNotInRemovalQueue: AugmentedError<ApiType>;
            /**
             * Auto reinit is disabled
             **/
            AutoReinitIsDisabled: AugmentedError<ApiType>;
            /**
             * Some external error while rate calculation
             **/
            ExternalError: AugmentedError<ApiType>;
            /**
             * Error used during time offset in test builds
             **/
            InvalidOffset: AugmentedError<ApiType>;
            /**
             * Last update in fututure
             **/
            LastUpdateInFuture: AugmentedError<ApiType>;
            /**
             * Math error in rate calculation
             **/
            MathError: AugmentedError<ApiType>;
            /**
             * This method is not allowed in production
             **/
            MethodNotAllowed: AugmentedError<ApiType>;
            /**
             * Financial parameters are outdated
             **/
            NoFinancial: AugmentedError<ApiType>;
            /**
             * Prices are outdated
             **/
            NoPrices: AugmentedError<ApiType>;
            /**
             * Validation error
             **/
            ValidationError: AugmentedError<ApiType>;
            /**
             * Error in rate calculation
             **/
            ValueError: AugmentedError<ApiType>;
        };
        eqSessionManager: {
            /**
             * Validator was not added because he is already active
             **/
            AlreadyAdded: AugmentedError<ApiType>;
            /**
             * Validator was not removed: there is no active validator with this id
             **/
            AlreadyRemoved: AugmentedError<ApiType>;
            /**
             * Validator was not added because validator is not registered
             **/
            NotRegistered: AugmentedError<ApiType>;
        };
        eqStaking: {
            /**
             * No funds to stake
             **/
            InsufficientFunds: AugmentedError<ApiType>;
            /**
             * The funds blocking period has not ended yet
             **/
            LockPeriodNotEnded: AugmentedError<ApiType>;
            /**
             * The account reached stakes max number
             **/
            MaxStakesNumberReached: AugmentedError<ApiType>;
            /**
             * No stake with this arguments
             **/
            StakeNotFound: AugmentedError<ApiType>;
        };
        eqTreasury: {
            /**
             * Amount being transferred is too low to create a vesting schedule
             **/
            AmountLow: AugmentedError<ApiType>;
            /**
             * An existing vesting schedule already exists for this account that cannot be clobbered
             **/
            ExistingVestingSchedule: AugmentedError<ApiType>;
        };
        eqWrappedDot: {
            /**
             * Amount to deposit less than min deposit amount
             **/
            InsufficientDeposit: AugmentedError<ApiType>;
            /**
             * Amount to withdraw less than min amount to withdraw
             **/
            InsufficientWithdraw: AugmentedError<ApiType>;
            /**
             * Math error
             **/
            MathError: AugmentedError<ApiType>;
            /**
             * Not a price source for an asset
             **/
            NotSupportedAsset: AugmentedError<ApiType>;
            /**
             * Error while converting balance to relay chain balance
             **/
            XcmBalanceConversionError: AugmentedError<ApiType>;
            /**
             * Xcm call pallet_staking::bond_extra failed
             **/
            XcmStakingBondExtraFailed: AugmentedError<ApiType>;
            /**
             * Xcm call pallet_staking::unbond failed
             **/
            XcmStakingUnbondFailed: AugmentedError<ApiType>;
            /**
             * Xcm call pallet_staking::withraw_unbonded failed
             **/
            XcmStakingWithdrawUnbondedFailed: AugmentedError<ApiType>;
            /**
             * Asset without xcm information
             **/
            XcmUnknownAsset: AugmentedError<ApiType>;
        };
        financial: {
            /**
             * Division by zero occurred during financial calculation process.
             **/
            DivisionByZero: AugmentedError<ApiType>;
            /**
             * An invalid argument passed to the function.
             **/
            InvalidArgument: AugmentedError<ApiType>;
            /**
             * Default return type or default correlation type is initialized with a value that can
             * not be converted to type `CalcReturnType` or `CalcVolatilityType` respectively.
             **/
            InvalidConstant: AugmentedError<ApiType>;
            /**
             * Specified period start timestamp is invalid for current
             * [`PricePeriod`](./trait.Config.html#associatedtype.PricePeriod) value.
             **/
            InvalidPeriodStart: AugmentedError<ApiType>;
            /**
             * Storage of the pallet is in an unexpected state.
             **/
            InvalidStorage: AugmentedError<ApiType>;
            /**
             * This method is not allowed in production. Method is used in testing only
             **/
            MethodNotAllowed: AugmentedError<ApiType>;
            /**
             * Price log is not long enough to calculate required value.
             **/
            NotEnoughPoints: AugmentedError<ApiType>;
            /**
             * Required functionality is not implemented.
             **/
            NotImplemented: AugmentedError<ApiType>;
            /**
             * Overflow occurred during financial calculation process.
             **/
            Overflow: AugmentedError<ApiType>;
            /**
             * Timestamp of the received price is in the past.
             **/
            PeriodIsInThePast: AugmentedError<ApiType>;
            /**
             * An invalid argument passed to the transcendental function (i.e. log, sqrt, etc.)
             * during financial calculation process.
             **/
            Transcendental: AugmentedError<ApiType>;
        };
        migration: {
            /**
             * We cannot start new migration before current ended
             **/
            MigrationIsInProgress: AugmentedError<ApiType>;
        };
        multisig: {
            /**
             * Call is already approved by this signatory.
             **/
            AlreadyApproved: AugmentedError<ApiType>;
            /**
             * The data to be stored is already stored.
             **/
            AlreadyStored: AugmentedError<ApiType>;
            /**
             * The maximum weight information provided was too low.
             **/
            MaxWeightTooLow: AugmentedError<ApiType>;
            /**
             * Threshold must be 2 or greater.
             **/
            MinimumThreshold: AugmentedError<ApiType>;
            /**
             * Call doesn't need any (more) approvals.
             **/
            NoApprovalsNeeded: AugmentedError<ApiType>;
            /**
             * Multisig operation not found when attempting to cancel.
             **/
            NotFound: AugmentedError<ApiType>;
            /**
             * No timepoint was given, yet the multisig operation is already underway.
             **/
            NoTimepoint: AugmentedError<ApiType>;
            /**
             * Only the account that originally created the multisig is able to cancel it.
             **/
            NotOwner: AugmentedError<ApiType>;
            /**
             * The sender was contained in the other signatories; it shouldn't be.
             **/
            SenderInSignatories: AugmentedError<ApiType>;
            /**
             * The signatories were provided out of order; they should be ordered.
             **/
            SignatoriesOutOfOrder: AugmentedError<ApiType>;
            /**
             * There are too few signatories in the list.
             **/
            TooFewSignatories: AugmentedError<ApiType>;
            /**
             * There are too many signatories in the list.
             **/
            TooManySignatories: AugmentedError<ApiType>;
            /**
             * A timepoint was given, yet no multisig operation is underway.
             **/
            UnexpectedTimepoint: AugmentedError<ApiType>;
            /**
             * A different timepoint was given to the multisig operation that is underway.
             **/
            WrongTimepoint: AugmentedError<ApiType>;
        };
        oracle: {
            /**
             * Incorrect asset
             **/
            CurrencyNotFound: AugmentedError<ApiType>;
            /**
             * This method is not allowed in production
             **/
            MethodNotAllowed: AugmentedError<ApiType>;
            /**
             * The account is not allowed to set prices
             **/
            NotAllowedToSubmitPrice: AugmentedError<ApiType>;
            /**
             * LP token pool is not found
             **/
            PoolNotFound: AugmentedError<ApiType>;
            /**
             * The same price data point has been already added
             **/
            PriceAlreadyAdded: AugmentedError<ApiType>;
            /**
             * The price cannot be negative
             **/
            PriceIsNegative: AugmentedError<ApiType>;
            /**
             * The price cannot be zero
             **/
            PriceIsZero: AugmentedError<ApiType>;
            /**
             * The price data point is too old and cannot be used
             **/
            PriceTimeout: AugmentedError<ApiType>;
            /**
             * A primitive asset is expected
             **/
            PrimitiveAssetExpected: AugmentedError<ApiType>;
            /**
             * Attempting to submit a new price for constant price currencies
             **/
            WrongCurrency: AugmentedError<ApiType>;
        };
        parachainSystem: {
            /**
             * The inherent which supplies the host configuration did not run this block
             **/
            HostConfigurationNotAvailable: AugmentedError<ApiType>;
            /**
             * No code upgrade has been authorized.
             **/
            NothingAuthorized: AugmentedError<ApiType>;
            /**
             * No validation function upgrade is currently scheduled.
             **/
            NotScheduled: AugmentedError<ApiType>;
            /**
             * Attempt to upgrade validation function while existing upgrade pending
             **/
            OverlappingUpgrades: AugmentedError<ApiType>;
            /**
             * Polkadot currently prohibits this parachain from upgrading its validation function
             **/
            ProhibitedByPolkadot: AugmentedError<ApiType>;
            /**
             * The supplied validation function has compiled into a blob larger than Polkadot is
             * willing to run
             **/
            TooBig: AugmentedError<ApiType>;
            /**
             * The given code upgrade has not been authorized.
             **/
            Unauthorized: AugmentedError<ApiType>;
            /**
             * The inherent which supplies the validation data did not run this block
             **/
            ValidationDataNotAvailable: AugmentedError<ApiType>;
        };
        polkadotXcm: {
            /**
             * The location is invalid since it already has a subscription from us.
             **/
            AlreadySubscribed: AugmentedError<ApiType>;
            /**
             * The given location could not be used (e.g. because it cannot be expressed in the
             * desired version of XCM).
             **/
            BadLocation: AugmentedError<ApiType>;
            /**
             * The version of the `Versioned` value used is not able to be interpreted.
             **/
            BadVersion: AugmentedError<ApiType>;
            /**
             * Could not re-anchor the assets to declare the fees for the destination chain.
             **/
            CannotReanchor: AugmentedError<ApiType>;
            /**
             * The destination `MultiLocation` provided cannot be inverted.
             **/
            DestinationNotInvertible: AugmentedError<ApiType>;
            /**
             * The assets to be sent are empty.
             **/
            Empty: AugmentedError<ApiType>;
            /**
             * The message execution fails the filter.
             **/
            Filtered: AugmentedError<ApiType>;
            /**
             * Origin is invalid for sending.
             **/
            InvalidOrigin: AugmentedError<ApiType>;
            /**
             * The referenced subscription could not be found.
             **/
            NoSubscription: AugmentedError<ApiType>;
            /**
             * There was some other issue (i.e. not to do with routing) in sending the message. Perhaps
             * a lack of space for buffering the message.
             **/
            SendFailure: AugmentedError<ApiType>;
            /**
             * Too many assets have been attempted for transfer.
             **/
            TooManyAssets: AugmentedError<ApiType>;
            /**
             * The desired destination was unreachable, generally because there is a no way of routing
             * to it.
             **/
            Unreachable: AugmentedError<ApiType>;
            /**
             * The message's weight could not be determined.
             **/
            UnweighableMessage: AugmentedError<ApiType>;
        };
        preimage: {
            /**
             * Preimage has already been noted on-chain.
             **/
            AlreadyNoted: AugmentedError<ApiType>;
            /**
             * The user is not authorized to perform this action.
             **/
            NotAuthorized: AugmentedError<ApiType>;
            /**
             * The preimage cannot be removed since it has not yet been noted.
             **/
            NotNoted: AugmentedError<ApiType>;
            /**
             * The preimage request cannot be removed since no outstanding requests exist.
             **/
            NotRequested: AugmentedError<ApiType>;
            /**
             * A preimage may not be removed when there are outstanding requests.
             **/
            Requested: AugmentedError<ApiType>;
            /**
             * Preimage is too large to store on-chain.
             **/
            TooLarge: AugmentedError<ApiType>;
        };
        proxy: {
            /**
             * Account is already a proxy.
             **/
            Duplicate: AugmentedError<ApiType>;
            /**
             * Call may not be made by proxy because it may escalate its privileges.
             **/
            NoPermission: AugmentedError<ApiType>;
            /**
             * Cannot add self as proxy.
             **/
            NoSelfProxy: AugmentedError<ApiType>;
            /**
             * Proxy registration not found.
             **/
            NotFound: AugmentedError<ApiType>;
            /**
             * Sender is not a proxy of the account to be proxied.
             **/
            NotProxy: AugmentedError<ApiType>;
            /**
             * There are too many proxies registered or too many announcements pending.
             **/
            TooMany: AugmentedError<ApiType>;
            /**
             * Announcement, if made at all, was made too recently.
             **/
            Unannounced: AugmentedError<ApiType>;
            /**
             * A call which is incompatible with the proxy type's filter was attempted.
             **/
            Unproxyable: AugmentedError<ApiType>;
        };
        republic: {
            /**
             * Amount being transferred is too low to create a vesting schedule
             **/
            AmountLow: AugmentedError<ApiType>;
            /**
             * An existing vesting schedule already exists for this account that cannot be clobbered
             **/
            ExistingVestingSchedule: AugmentedError<ApiType>;
        };
        scheduler: {
            /**
             * Failed to schedule a call
             **/
            FailedToSchedule: AugmentedError<ApiType>;
            /**
             * Cannot find the scheduled call.
             **/
            NotFound: AugmentedError<ApiType>;
            /**
             * Reschedule failed because it does not change scheduled time.
             **/
            RescheduleNoChange: AugmentedError<ApiType>;
            /**
             * Given target block number is in the past.
             **/
            TargetBlockNumberInPast: AugmentedError<ApiType>;
        };
        session: {
            /**
             * Registered duplicate key.
             **/
            DuplicatedKey: AugmentedError<ApiType>;
            /**
             * Invalid ownership proof.
             **/
            InvalidProof: AugmentedError<ApiType>;
            /**
             * Key setting account is not live, so it's impossible to associate keys.
             **/
            NoAccount: AugmentedError<ApiType>;
            /**
             * No associated validator ID for account.
             **/
            NoAssociatedValidatorId: AugmentedError<ApiType>;
            /**
             * No keys are associated with this account.
             **/
            NoKeys: AugmentedError<ApiType>;
        };
        subaccounts: {
            /**
             * Cannot create a subaccount: account in whitelist
             **/
            AccountInWhiteList: AugmentedError<ApiType>;
            /**
             * Account is not a master account. Transfers to external subaccounts prohibited.
             **/
            AccountIsNotMaster: AugmentedError<ApiType>;
            /**
             * Cannot create a subaccount: user already has subaccount of
             * this type
             **/
            AlreadyHasSubaccount: AugmentedError<ApiType>;
            /**
             * Debt not allowed to be creating in this operation
             **/
            Debt: AugmentedError<ApiType>;
            /**
             * Entropy is not allow to generate subaccount. Try one more time.
             **/
            EntropyError: AugmentedError<ApiType>;
            /**
             * Cannot delete subaccount or transfer from it: no subaccount of this type
             **/
            NoSubaccountOfThisType: AugmentedError<ApiType>;
            /**
             * Transfers are disabled
             **/
            TransfersAreDisabled: AugmentedError<ApiType>;
        };
        system: {
            /**
             * The origin filter prevent the call to be dispatched.
             **/
            CallFiltered: AugmentedError<ApiType>;
            /**
             * Failed to extract the runtime version from the new runtime.
             *
             * Either calling `Core_version` or decoding `RuntimeVersion` failed.
             **/
            FailedToExtractRuntimeVersion: AugmentedError<ApiType>;
            /**
             * The name of specification does not match between the current runtime
             * and the new runtime.
             **/
            InvalidSpecName: AugmentedError<ApiType>;
            /**
             * Suicide called when the account has non-default composite data.
             **/
            NonDefaultComposite: AugmentedError<ApiType>;
            /**
             * There is a non-zero reference count preventing the account from being purged.
             **/
            NonZeroRefCount: AugmentedError<ApiType>;
            /**
             * The specification version is not allowed to decrease between the current runtime
             * and the new runtime.
             **/
            SpecVersionNeedsToIncrease: AugmentedError<ApiType>;
        };
        technicalCommittee: {
            /**
             * Members are already initialized!
             **/
            AlreadyInitialized: AugmentedError<ApiType>;
            /**
             * Duplicate proposals not allowed
             **/
            DuplicateProposal: AugmentedError<ApiType>;
            /**
             * Duplicate vote ignored
             **/
            DuplicateVote: AugmentedError<ApiType>;
            /**
             * Account is not a member
             **/
            NotMember: AugmentedError<ApiType>;
            /**
             * Proposal must exist
             **/
            ProposalMissing: AugmentedError<ApiType>;
            /**
             * The close call was made too early, before the end of the voting.
             **/
            TooEarly: AugmentedError<ApiType>;
            /**
             * There can only be a maximum of `MaxProposals` active proposals.
             **/
            TooManyProposals: AugmentedError<ApiType>;
            /**
             * Mismatched index
             **/
            WrongIndex: AugmentedError<ApiType>;
            /**
             * The given length bound for the proposal was too low.
             **/
            WrongProposalLength: AugmentedError<ApiType>;
            /**
             * The given weight bound for the proposal was too low.
             **/
            WrongProposalWeight: AugmentedError<ApiType>;
        };
        technicalCommitteeMembership: {
            /**
             * Already a member.
             **/
            AlreadyMember: AugmentedError<ApiType>;
            /**
             * Not a member.
             **/
            NotMember: AugmentedError<ApiType>;
            /**
             * Too many members.
             **/
            TooManyMembers: AugmentedError<ApiType>;
        };
        treasury: {
            /**
             * Daily buyout limit exceeded
             **/
            BuyoutLimitExceeded: AugmentedError<ApiType>;
            /**
             * The account balance is too low for an operation
             **/
            InsufficientAccountBalance: AugmentedError<ApiType>;
            /**
             * The treasury balance is too low for an operation
             **/
            InsufficientTreasuryBalance: AugmentedError<ApiType>;
            /**
             * One of transacted currencies is missing price information
             * or the price is outdated
             **/
            NoPrice: AugmentedError<ApiType>;
            /**
             * Attempt to exchange native token to native token
             **/
            WrongAssetToBuyout: AugmentedError<ApiType>;
        };
        utility: {
            /**
             * Too many calls batched.
             **/
            TooManyCalls: AugmentedError<ApiType>;
        };
        vesting: {
            /**
             * Amount being transferred is too low to create a vesting schedule
             **/
            AmountLow: AugmentedError<ApiType>;
            /**
             * An existing vesting schedule already exists for this account that cannot be clobbered
             **/
            ExistingVestingSchedule: AugmentedError<ApiType>;
            /**
             * This method is not allowed in production
             **/
            MethodNotAllowed: AugmentedError<ApiType>;
            /**
             * The account given is not vesting
             **/
            NotVesting: AugmentedError<ApiType>;
            /**
             * Self documented error code
             **/
            TransfersAreDisabled: AugmentedError<ApiType>;
        };
        vesting2: {
            /**
             * Amount being transferred is too low to create a vesting schedule
             **/
            AmountLow: AugmentedError<ApiType>;
            /**
             * An existing vesting schedule already exists for this account that cannot be clobbered
             **/
            ExistingVestingSchedule: AugmentedError<ApiType>;
            /**
             * This method is not allowed in production
             **/
            MethodNotAllowed: AugmentedError<ApiType>;
            /**
             * The account given is not vesting
             **/
            NotVesting: AugmentedError<ApiType>;
            /**
             * Self documented error code
             **/
            TransfersAreDisabled: AugmentedError<ApiType>;
        };
        whitelists: {
            /**
             * Account was not added to whitelist: already in whitelist
             **/
            AlreadyAdded: AugmentedError<ApiType>;
            /**
             * Account was not removed from whitelist: not in whitelist
             **/
            AlreadyRemoved: AugmentedError<ApiType>;
        };
        xcmpQueue: {
            /**
             * Bad overweight index.
             **/
            BadOverweightIndex: AugmentedError<ApiType>;
            /**
             * Bad XCM data.
             **/
            BadXcm: AugmentedError<ApiType>;
            /**
             * Bad XCM origin.
             **/
            BadXcmOrigin: AugmentedError<ApiType>;
            /**
             * Failed to send XCM message.
             **/
            FailedToSend: AugmentedError<ApiType>;
            /**
             * Provided weight is possibly not enough to execute the message.
             **/
            WeightOverLimit: AugmentedError<ApiType>;
        };
        xdot: {
            BalanceConvertOverflow: AugmentedError<ApiType>;
            BuyBaseTooMuchForMax: AugmentedError<ApiType>;
            BuyXbaseTooMuchForMax: AugmentedError<ApiType>;
            CalcRatioMathError: AugmentedError<ApiType>;
            CalcVirtualXbaseOverflow: AugmentedError<ApiType>;
            ExternalAssetCheckFailed: AugmentedError<ApiType>;
            ExternalError: AugmentedError<ApiType>;
            InconsistentStorage: AugmentedError<ApiType>;
            LPAssetNotCreated: AugmentedError<ApiType>;
            MathError: AugmentedError<ApiType>;
            MaturityInThePast: AugmentedError<ApiType>;
            MaturityTooFarFromNow: AugmentedError<ApiType>;
            MethodNotAllowed: AugmentedError<ApiType>;
            NeedToInitialize: AugmentedError<ApiType>;
            NoNeedToInitialize: AugmentedError<ApiType>;
            NotAuthorized: AugmentedError<ApiType>;
            PoolCountOverflow: AugmentedError<ApiType>;
            PoolNotFound: AugmentedError<ApiType>;
            SellBaseTooLowForMin: AugmentedError<ApiType>;
            SellXBaseTooLowForMin: AugmentedError<ApiType>;
            TooLowBaseIn: AugmentedError<ApiType>;
            TooLowXbaseIn: AugmentedError<ApiType>;
            TooMuchBaseIn: AugmentedError<ApiType>;
            TooMuchXbaseOut: AugmentedError<ApiType>;
            TsPeriodTooLarge: AugmentedError<ApiType>;
            WrongMaxRatio: AugmentedError<ApiType>;
            WrongMinRatio: AugmentedError<ApiType>;
            XbaseBalanceTooLow: AugmentedError<ApiType>;
            YieldMathBaseInForFyOut: AugmentedError<ApiType>;
            YieldMathBaseOutForFyIn: AugmentedError<ApiType>;
            YieldMathFyInForBaseOut: AugmentedError<ApiType>;
            YieldMathFyOutForBaseIn: AugmentedError<ApiType>;
            YieldMathInvariant: AugmentedError<ApiType>;
        };
    }
}
