import '@polkadot/api-base/types/errors';
import type { ApiTypes, AugmentedError } from '@polkadot/api-base/types';
export type __AugmentedError<ApiType extends ApiTypes> = AugmentedError<ApiType>;
declare module '@polkadot/api-base/types/errors' {
    interface AugmentedErrors<ApiType extends ApiTypes> {
        assetRegistry: {
            /**
             * Asset was not found.
             **/
            AssetNotFound: AugmentedError<ApiType>;
            /**
             * The version of the `VersionedMultiLocation` value used is not able
             * to be interpreted.
             **/
            BadVersion: AugmentedError<ApiType>;
            /**
             * Another asset was already register with this asset id.
             **/
            ConflictingAssetId: AugmentedError<ApiType>;
            /**
             * Another asset was already register with this location.
             **/
            ConflictingLocation: AugmentedError<ApiType>;
            /**
             * The asset id is invalid.
             **/
            InvalidAssetId: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        btcRelay: {
            /**
             * Already initialized
             **/
            AlreadyInitialized: AugmentedError<ApiType>;
            /**
             * Error code already reported
             **/
            AlreadyReported: AugmentedError<ApiType>;
            /**
             * Arithmetic overflow
             **/
            ArithmeticOverflow: AugmentedError<ApiType>;
            /**
             * Arithmetic underflow
             **/
            ArithmeticUnderflow: AugmentedError<ApiType>;
            /**
             * Transaction has less confirmations of Bitcoin blocks than required
             **/
            BitcoinConfirmations: AugmentedError<ApiType>;
            /**
             * Overflow of block height
             **/
            BlockHeightOverflow: AugmentedError<ApiType>;
            /**
             * Block header not found for given hash
             **/
            BlockNotFound: AugmentedError<ApiType>;
            /**
             * Weight bound exceeded
             **/
            BoundExceeded: AugmentedError<ApiType>;
            /**
             * Overflow of chain counter
             **/
            ChainCounterOverflow: AugmentedError<ApiType>;
            /**
             * Underflow of stored blockchains counter
             **/
            ChainsUnderflow: AugmentedError<ApiType>;
            /**
             * Incorrect difficulty target specified in block header
             **/
            DiffTargetHeader: AugmentedError<ApiType>;
            /**
             * Block already stored
             **/
            DuplicateBlock: AugmentedError<ApiType>;
            /**
             * EndOfFile reached while parsing
             **/
            EndOfFile: AugmentedError<ApiType>;
            /**
             * Blockchain with requested ID not found
             **/
            ForkIdNotFound: AugmentedError<ApiType>;
            /**
             * Invalid block header version
             **/
            InvalidBlockVersion: AugmentedError<ApiType>;
            /**
             * Specified invalid Bitcoin address
             **/
            InvalidBtcAddress: AugmentedError<ApiType>;
            /**
             * User supplied an invalid address
             **/
            InvalidBtcHash: AugmentedError<ApiType>;
            /**
             * Invalid chain ID
             **/
            InvalidChainID: AugmentedError<ApiType>;
            /**
             * Coinbase tx must be the first transaction in the block
             **/
            InvalidCoinbasePosition: AugmentedError<ApiType>;
            /**
             * Invalid compact value in header
             **/
            InvalidCompact: AugmentedError<ApiType>;
            /**
             * Invalid block header size
             **/
            InvalidHeaderSize: AugmentedError<ApiType>;
            /**
             * Invalid merkle proof
             **/
            InvalidMerkleProof: AugmentedError<ApiType>;
            /**
             * Incorrect identifier in OP_RETURN field
             **/
            InvalidOpReturn: AugmentedError<ApiType>;
            /**
             * Transaction does meet the requirements to be a valid op-return payment
             **/
            InvalidOpReturnTransaction: AugmentedError<ApiType>;
            /**
             * Incorrect transaction output format
             **/
            InvalidOutputFormat: AugmentedError<ApiType>;
            /**
             * Incorrect recipient Bitcoin address
             **/
            InvalidPayment: AugmentedError<ApiType>;
            /**
             * Invalid payment amount
             **/
            InvalidPaymentAmount: AugmentedError<ApiType>;
            /**
             * User supplied an invalid script
             **/
            InvalidScript: AugmentedError<ApiType>;
            /**
             * Start height must be start of difficulty period
             **/
            InvalidStartHeight: AugmentedError<ApiType>;
            /**
             * Transaction does meet the requirements to be considered valid
             **/
            InvalidTransaction: AugmentedError<ApiType>;
            /**
             * Transaction hash does not match given txid
             **/
            InvalidTxid: AugmentedError<ApiType>;
            /**
             * Invalid transaction version
             **/
            InvalidTxVersion: AugmentedError<ApiType>;
            /**
             * PoW hash does not meet difficulty target of header
             **/
            LowDiff: AugmentedError<ApiType>;
            /**
             * Format of the header is invalid
             **/
            MalformedHeader: AugmentedError<ApiType>;
            /**
             * Merkle proof is malformed
             **/
            MalformedMerkleProof: AugmentedError<ApiType>;
            /**
             * Format of the OP_RETURN transaction output is invalid
             **/
            MalformedOpReturnOutput: AugmentedError<ApiType>;
            MalformedP2PKHOutput: AugmentedError<ApiType>;
            MalformedP2SHOutput: AugmentedError<ApiType>;
            /**
             * Transaction has incorrect format
             **/
            MalformedTransaction: AugmentedError<ApiType>;
            /**
             * Malformed transaction identifier
             **/
            MalformedTxid: AugmentedError<ApiType>;
            /**
             * Format of the BIP141 witness transaction output is invalid
             **/
            MalformedWitnessOutput: AugmentedError<ApiType>;
            /**
             * Missing the block at this height
             **/
            MissingBlockHeight: AugmentedError<ApiType>;
            /**
             * Current fork ongoing
             **/
            OngoingFork: AugmentedError<ApiType>;
            /**
             * Transaction has less confirmations of Parachain blocks than required
             **/
            ParachainConfirmations: AugmentedError<ApiType>;
            /**
             * Previous block hash not found
             **/
            PrevBlock: AugmentedError<ApiType>;
            /**
             * BTC Parachain has shut down
             **/
            Shutdown: AugmentedError<ApiType>;
            /**
             * TryInto failed on integer
             **/
            TryIntoIntError: AugmentedError<ApiType>;
            /**
             * Unauthorized staked relayer
             **/
            UnauthorizedRelayer: AugmentedError<ApiType>;
            /**
             * Error code not applicable to blocks
             **/
            UnknownErrorcode: AugmentedError<ApiType>;
            UnsupportedInputFormat: AugmentedError<ApiType>;
            UnsupportedOutputFormat: AugmentedError<ApiType>;
            /**
             * Wrong fork bound, should be higher
             **/
            WrongForkBound: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        clientsInfo: {
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        collatorSelection: {
            /**
             * User is already a candidate
             **/
            AlreadyCandidate: AugmentedError<ApiType>;
            /**
             * User is already an Invulnerable
             **/
            AlreadyInvulnerable: AugmentedError<ApiType>;
            /**
             * Account has no associated validator ID
             **/
            NoAssociatedValidatorId: AugmentedError<ApiType>;
            /**
             * User is not a candidate
             **/
            NotCandidate: AugmentedError<ApiType>;
            /**
             * Permission issue
             **/
            Permission: AugmentedError<ApiType>;
            /**
             * Too few candidates
             **/
            TooFewCandidates: AugmentedError<ApiType>;
            /**
             * Too many candidates
             **/
            TooManyCandidates: AugmentedError<ApiType>;
            /**
             * Too many invulnerables
             **/
            TooManyInvulnerables: AugmentedError<ApiType>;
            /**
             * Unknown error
             **/
            Unknown: AugmentedError<ApiType>;
            /**
             * Validator ID is not yet registered
             **/
            ValidatorNotRegistered: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        cumulusXcm: {
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        currency: {
            InvalidCurrency: AugmentedError<ApiType>;
            TryIntoIntError: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        democracy: {
            /**
             * Imminent
             **/
            Imminent: AugmentedError<ApiType>;
            /**
             * Too high a balance was provided that the account cannot afford.
             **/
            InsufficientFunds: AugmentedError<ApiType>;
            /**
             * Maximum number of votes reached.
             **/
            MaxVotesReached: AugmentedError<ApiType>;
            /**
             * No proposals waiting
             **/
            NoneWaiting: AugmentedError<ApiType>;
            /**
             * Not imminent
             **/
            NotImminent: AugmentedError<ApiType>;
            /**
             * The given account did not make this proposal.
             **/
            NotProposer: AugmentedError<ApiType>;
            /**
             * The given account did not vote on the referendum.
             **/
            NotVoter: AugmentedError<ApiType>;
            /**
             * Preimage does not exist
             **/
            PreimageMissing: AugmentedError<ApiType>;
            /**
             * Proposal does not exist
             **/
            ProposalMissing: AugmentedError<ApiType>;
            /**
             * Fast tracking failed, because the referendum is
             * ending sooner than the fast track voting period.
             **/
            ReferendumFastTrackFailed: AugmentedError<ApiType>;
            /**
             * Vote given for invalid referendum
             **/
            ReferendumInvalid: AugmentedError<ApiType>;
            /**
             * Too early
             **/
            TooEarly: AugmentedError<ApiType>;
            /**
             * Maximum number of items reached.
             **/
            TooMany: AugmentedError<ApiType>;
            /**
             * Unable to convert value.
             **/
            TryIntoIntError: AugmentedError<ApiType>;
            /**
             * Value too low
             **/
            ValueLow: AugmentedError<ApiType>;
            /**
             * Invalid upper bound.
             **/
            WrongUpperBound: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        dexGeneral: {
            /**
             * Asset does not exist.
             **/
            AssetNotExists: AugmentedError<ApiType>;
            /**
             * Charge bootstrap extrinsic args has error,
             **/
            ChargeRewardParamsError: AugmentedError<ApiType>;
            /**
             * Transaction block number is larger than the end block number.
             **/
            Deadline: AugmentedError<ApiType>;
            /**
             * Trading pair can't be created.
             **/
            DeniedCreatePair: AugmentedError<ApiType>;
            /**
             * Bootstrap deny refund
             **/
            DenyRefund: AugmentedError<ApiType>;
            /**
             * Bootstrap is disable
             **/
            DisableBootstrap: AugmentedError<ApiType>;
            /**
             * Sold amount is more than exception.
             **/
            ExcessiveSoldAmount: AugmentedError<ApiType>;
            /**
             * Exist some reward in bootstrap,
             **/
            ExistRewardsInBootstrap: AugmentedError<ApiType>;
            /**
             * Incorrect amount range.
             **/
            IncorrectAssetAmountRange: AugmentedError<ApiType>;
            /**
             * Account balance must be greater than or equal to the transfer amount.
             **/
            InsufficientAssetBalance: AugmentedError<ApiType>;
            /**
             * Liquidity is not enough.
             **/
            InsufficientLiquidity: AugmentedError<ApiType>;
            /**
             * Trading pair does have enough.
             **/
            InsufficientPairReserve: AugmentedError<ApiType>;
            /**
             * Get target amount is less than exception.
             **/
            InsufficientTargetAmount: AugmentedError<ApiType>;
            /**
             * Amount of contribution is invalid.
             **/
            InvalidContributionAmount: AugmentedError<ApiType>;
            /**
             * Invalid fee_rate
             **/
            InvalidFeeRate: AugmentedError<ApiType>;
            /**
             * Can't find pair though trading path.
             **/
            InvalidPath: AugmentedError<ApiType>;
            /**
             * Can't pass the K value check
             **/
            InvariantCheckFailed: AugmentedError<ApiType>;
            /**
             * Reward of bootstrap is not set.
             **/
            NoRewardTokens: AugmentedError<ApiType>;
            /**
             * Pair is not in bootstrap
             **/
            NotInBootstrap: AugmentedError<ApiType>;
            /**
             * Not eligible to contribute
             **/
            NotQualifiedAccount: AugmentedError<ApiType>;
            /**
             * Overflow.
             **/
            Overflow: AugmentedError<ApiType>;
            /**
             * Trading pair already exists.
             **/
            PairAlreadyExists: AugmentedError<ApiType>;
            /**
             * Trading pair does not exist.
             **/
            PairNotExists: AugmentedError<ApiType>;
            /**
             * The number of limits exceeds the storage limit
             **/
            TooManyLimits: AugmentedError<ApiType>;
            /**
             * The number of rewards exceeds the storage limit
             **/
            TooManyRewards: AugmentedError<ApiType>;
            /**
             * Amount of contribution is invalid.
             **/
            UnqualifiedBootstrap: AugmentedError<ApiType>;
            /**
             * Unsupported AssetId.
             **/
            UnsupportedAssetType: AugmentedError<ApiType>;
            /**
             * Zero contribute in bootstrap
             **/
            ZeroContribute: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        dexStable: {
            /**
             * The ramping A of this pool is already stopped.
             **/
            AlreadyStoppedRampA: AugmentedError<ApiType>;
            /**
             * Slippage is too large.
             **/
            AmountSlippage: AugmentedError<ApiType>;
            /**
             * The error generate by some arithmetic function.
             **/
            Arithmetic: AugmentedError<ApiType>;
            /**
             * The symbol of created pool exceeds the length limit.
             **/
            BadPoolCurrencySymbol: AugmentedError<ApiType>;
            /**
             * The new d below then older.
             **/
            CheckDFailed: AugmentedError<ApiType>;
            /**
             * The index of currency id bigger the length of pool's currencies.
             **/
            CurrencyIndexOutRange: AugmentedError<ApiType>;
            /**
             * The call already expired.
             **/
            Deadline: AugmentedError<ApiType>;
            /**
             * The A parameter exceed MAX_A when creating the pool.
             **/
            ExceedMaxA: AugmentedError<ApiType>;
            /**
             * Forbid change A of a pool bigger than MAX_A.
             **/
            ExceedMaxAChange: AugmentedError<ApiType>;
            /**
             * The admin fee parameter exceeds MAX_ADMIN_FEE when creating the pool.
             **/
            ExceedMaxAdminFee: AugmentedError<ApiType>;
            /**
             * The fee parameter exceeds MAX_SWAP_FEE when creating the pool.
             **/
            ExceedMaxFee: AugmentedError<ApiType>;
            /**
             * The setting value exceed threshold.
             **/
            ExceedThreshold: AugmentedError<ApiType>;
            /**
             * The pool does not have enough lp currency.
             **/
            InsufficientLpReserve: AugmentedError<ApiType>;
            /**
             * The pool does not have enough currencies.
             **/
            InsufficientReserve: AugmentedError<ApiType>;
            /**
             * The caller does not have enough currencies.
             **/
            InsufficientSupply: AugmentedError<ApiType>;
            /**
             * The base pool mismatch this pool.
             **/
            InvalidBasePool: AugmentedError<ApiType>;
            /**
             * The base pool lp currency is invalid when create meta pool.
             **/
            InvalidBasePoolLpCurrency: AugmentedError<ApiType>;
            /**
             * The decimal of currency is invalid when create pool.
             **/
            InvalidCurrencyDecimal: AugmentedError<ApiType>;
            /**
             * The currency id can't become the lp currency id of stable amm pool.
             **/
            InvalidLpCurrency: AugmentedError<ApiType>;
            /**
             * The currency id can't join stable amm pool.
             **/
            InvalidPooledCurrency: AugmentedError<ApiType>;
            /**
             * The pool id is invalid.
             **/
            InvalidPoolId: AugmentedError<ApiType>;
            /**
             * The transaction change nothing.
             **/
            InvalidTransaction: AugmentedError<ApiType>;
            /**
             * The lp currency id is already used when create pool.
             **/
            LpCurrencyAlreadyUsed: AugmentedError<ApiType>;
            /**
             * The value of feature_a_time is too small.
             **/
            MinRampTime: AugmentedError<ApiType>;
            /**
             * The parameters of a call are contradictory.
             **/
            MismatchParameter: AugmentedError<ApiType>;
            /**
             * The A of this pool is already ramped in current period.
             **/
            RampADelay: AugmentedError<ApiType>;
            /**
             * Require all currencies of this pool when first supply.
             **/
            RequireAllCurrencies: AugmentedError<ApiType>;
            /**
             * Forbid swap same currency.
             **/
            SwapSameCurrency: AugmentedError<ApiType>;
            /**
             * The token index out of range.
             **/
            TokenIndexOutOfRange: AugmentedError<ApiType>;
            /**
             * The number of currencies exceeds the length limit.
             **/
            TooManyCurrencies: AugmentedError<ApiType>;
            /**
             * The A parameter cannot be zero when creating the pool.
             **/
            ZeroA: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        dexSwapRouter: {
            AmountSlippage: AugmentedError<ApiType>;
            ConvertCurrencyFailed: AugmentedError<ApiType>;
            Deadline: AugmentedError<ApiType>;
            InvalidPath: AugmentedError<ApiType>;
            InvalidRoutes: AugmentedError<ApiType>;
            MismatchPoolAndCurrencyId: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: 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>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        escrow: {
            /**
             * Incorrect Percent
             **/
            IncorrectPercent: AugmentedError<ApiType>;
            /**
             * Input amount must be non-zero.
             **/
            InputAmountZero: AugmentedError<ApiType>;
            /**
             * Insufficient account balance.
             **/
            InsufficientFunds: AugmentedError<ApiType>;
            /**
             * Lock amount is too large.
             **/
            LockAmountTooLow: AugmentedError<ApiType>;
            /**
             * Lock amount must be non-zero.
             **/
            LockAmountZero: AugmentedError<ApiType>;
            /**
             * Lock already exists.
             **/
            LockFound: AugmentedError<ApiType>;
            /**
             * Previous lock has expired.
             **/
            LockHasExpired: AugmentedError<ApiType>;
            /**
             * Previous lock has not expired.
             **/
            LockNotExpired: AugmentedError<ApiType>;
            /**
             * Lock does not exist.
             **/
            LockNotFound: AugmentedError<ApiType>;
            /**
             * Not supported.
             **/
            NotSupported: AugmentedError<ApiType>;
            /**
             * Unlock height should be greater than lock.
             **/
            UnlockHeightMustIncrease: AugmentedError<ApiType>;
            /**
             * Unlock height is not in the future.
             **/
            UnlockHeightNotInTheFuture: AugmentedError<ApiType>;
            /**
             * Unlock height is greater than max period.
             **/
            UnlockHeightTooFarInTheFuture: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        escrowAnnuity: {
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        escrowRewards: {
            /**
             * Balance not sufficient to withdraw stake.
             **/
            InsufficientFunds: AugmentedError<ApiType>;
            /**
             * Maximum rewards currencies reached.
             **/
            MaxRewardCurrencies: AugmentedError<ApiType>;
            /**
             * Unable to convert value.
             **/
            TryIntoIntError: AugmentedError<ApiType>;
            /**
             * Cannot distribute rewards without stake.
             **/
            ZeroTotalStake: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        ethereum: {
            /**
             * Signature is invalid.
             **/
            InvalidSignature: AugmentedError<ApiType>;
            /**
             * Pre-log is present, therefore transact is not allowed.
             **/
            PreLogExists: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        evm: {
            /**
             * Not enough balance to perform action
             **/
            BalanceLow: AugmentedError<ApiType>;
            /**
             * Calculating total fee overflowed
             **/
            FeeOverflow: AugmentedError<ApiType>;
            /**
             * Gas limit is too high.
             **/
            GasLimitTooHigh: AugmentedError<ApiType>;
            /**
             * Gas limit is too low.
             **/
            GasLimitTooLow: AugmentedError<ApiType>;
            /**
             * Gas price is too low.
             **/
            GasPriceTooLow: AugmentedError<ApiType>;
            /**
             * Nonce is invalid
             **/
            InvalidNonce: AugmentedError<ApiType>;
            /**
             * Calculating total payment overflowed
             **/
            PaymentOverflow: AugmentedError<ApiType>;
            /**
             * EVM reentrancy
             **/
            Reentrancy: AugmentedError<ApiType>;
            /**
             * EIP-3607,
             **/
            TransactionMustComeFromEOA: AugmentedError<ApiType>;
            /**
             * Undefined error.
             **/
            Undefined: AugmentedError<ApiType>;
            /**
             * Withdraw fee failed
             **/
            WithdrawFailed: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        farming: {
            BadRewardLength: AugmentedError<ApiType>;
            InsufficientStake: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        farmingRewards: {
            /**
             * Balance not sufficient to withdraw stake.
             **/
            InsufficientFunds: AugmentedError<ApiType>;
            /**
             * Maximum rewards currencies reached.
             **/
            MaxRewardCurrencies: AugmentedError<ApiType>;
            /**
             * Unable to convert value.
             **/
            TryIntoIntError: AugmentedError<ApiType>;
            /**
             * Cannot distribute rewards without stake.
             **/
            ZeroTotalStake: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        fee: {
            /**
             * Value exceeds the expected upper bound for storage fields in this pallet.
             **/
            AboveMaxExpectedValue: AugmentedError<ApiType>;
            /**
             * Unable to convert value.
             **/
            TryIntoIntError: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        identity: {
            /**
             * Account ID is already named.
             **/
            AlreadyClaimed: AugmentedError<ApiType>;
            /**
             * Empty index.
             **/
            EmptyIndex: AugmentedError<ApiType>;
            /**
             * Fee is changed.
             **/
            FeeChanged: AugmentedError<ApiType>;
            /**
             * The index is invalid.
             **/
            InvalidIndex: AugmentedError<ApiType>;
            /**
             * Invalid judgement.
             **/
            InvalidJudgement: AugmentedError<ApiType>;
            /**
             * The target is invalid.
             **/
            InvalidTarget: AugmentedError<ApiType>;
            /**
             * The provided judgement was for a different identity.
             **/
            JudgementForDifferentIdentity: AugmentedError<ApiType>;
            /**
             * Judgement given.
             **/
            JudgementGiven: AugmentedError<ApiType>;
            /**
             * Error that occurs when there is an issue paying for judgement.
             **/
            JudgementPaymentFailed: AugmentedError<ApiType>;
            /**
             * No identity found.
             **/
            NoIdentity: AugmentedError<ApiType>;
            /**
             * Account isn't found.
             **/
            NotFound: AugmentedError<ApiType>;
            /**
             * Account isn't named.
             **/
            NotNamed: AugmentedError<ApiType>;
            /**
             * Sub-account isn't owned by sender.
             **/
            NotOwned: AugmentedError<ApiType>;
            /**
             * Sender is not a sub-account.
             **/
            NotSub: AugmentedError<ApiType>;
            /**
             * Sticky judgement.
             **/
            StickyJudgement: AugmentedError<ApiType>;
            /**
             * Too many additional fields.
             **/
            TooManyFields: AugmentedError<ApiType>;
            /**
             * Maximum amount of registrars reached. Cannot add any more.
             **/
            TooManyRegistrars: AugmentedError<ApiType>;
            /**
             * Too many subs-accounts.
             **/
            TooManySubAccounts: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        issue: {
            /**
             * Issue amount is too small.
             **/
            AmountBelowDustAmount: AugmentedError<ApiType>;
            /**
             * Issue request has expired.
             **/
            CommitPeriodExpired: AugmentedError<ApiType>;
            /**
             * Not expected origin.
             **/
            InvalidExecutor: AugmentedError<ApiType>;
            /**
             * Issue request already cancelled.
             **/
            IssueCancelled: AugmentedError<ApiType>;
            /**
             * Issue request already completed.
             **/
            IssueCompleted: AugmentedError<ApiType>;
            /**
             * Issue request not found.
             **/
            IssueIdNotFound: AugmentedError<ApiType>;
            /**
             * Issue request has not expired.
             **/
            TimeNotExpired: AugmentedError<ApiType>;
            /**
             * Vault is not active.
             **/
            VaultNotAcceptingNewIssues: AugmentedError<ApiType>;
            /**
             * Relay is not initialized.
             **/
            WaitingForRelayerInitialization: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        loans: {
            /**
             * Upper bound of borrowing is exceeded
             **/
            BorrowCapacityExceeded: AugmentedError<ApiType>;
            /**
             * Locking collateral failed. The account has no `free` tokens.
             **/
            DepositAllCollateralFailed: AugmentedError<ApiType>;
            /**
             * Deposits are not used as a collateral
             **/
            DepositsAreNotCollateral: AugmentedError<ApiType>;
            /**
             * Insufficient cash in the pool
             **/
            InsufficientCash: AugmentedError<ApiType>;
            /**
             * Repay amount more than collateral amount
             **/
            InsufficientCollateral: AugmentedError<ApiType>;
            /**
             * Insufficient deposit to redeem
             **/
            InsufficientDeposit: AugmentedError<ApiType>;
            /**
             * Insufficient liquidity to borrow more or disable collateral
             **/
            InsufficientLiquidity: AugmentedError<ApiType>;
            /**
             * Insufficient reserves
             **/
            InsufficientReserves: AugmentedError<ApiType>;
            /**
             * Insufficient shortfall to repay
             **/
            InsufficientShortfall: AugmentedError<ApiType>;
            /**
             * Amount cannot be zero
             **/
            InvalidAmount: AugmentedError<ApiType>;
            /**
             * The exchange rate should be a value between `MinExchangeRate` and `MaxExchangeRate`
             **/
            InvalidExchangeRate: AugmentedError<ApiType>;
            /**
             * The factor should be greater than 0% and less than 100%
             **/
            InvalidFactor: AugmentedError<ApiType>;
            /**
             * Invalid lend_token id
             **/
            InvalidLendTokenId: AugmentedError<ApiType>;
            /**
             * Invalid rate model params
             **/
            InvalidRateModelParam: AugmentedError<ApiType>;
            /**
             * The supply cap cannot be zero
             **/
            InvalidSupplyCap: AugmentedError<ApiType>;
            /**
             * Liquidator is same as borrower
             **/
            LiquidatorIsBorrower: AugmentedError<ApiType>;
            /**
             * Only free lend tokens are redeemable
             **/
            LockedTokensCannotBeRedeemed: AugmentedError<ApiType>;
            /**
             * Market already activated
             **/
            MarketAlreadyActivated: AugmentedError<ApiType>;
            /**
             * Market already exists
             **/
            MarketAlreadyExists: AugmentedError<ApiType>;
            /**
             * Market does not exist
             **/
            MarketDoesNotExist: AugmentedError<ApiType>;
            /**
             * Market not activated
             **/
            MarketNotActivated: AugmentedError<ApiType>;
            /**
             * New markets must have a pending state
             **/
            NewMarketMustHavePendingState: AugmentedError<ApiType>;
            /**
             * Upper bound of supplying is exceeded
             **/
            SupplyCapacityExceeded: AugmentedError<ApiType>;
            /**
             * Tokens already locked for a different purpose than borrow collateral
             **/
            TokensAlreadyLocked: AugmentedError<ApiType>;
            /**
             * Repay amount greater than allowed (either repays more than the existing debt, or
             * exceeds the close factor)
             **/
            TooMuchRepay: AugmentedError<ApiType>;
            /**
             * Unlocking collateral failed. The account has no `reserved` tokens.
             **/
            WithdrawAllCollateralFailed: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: 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>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        multiTransactionPayment: {
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        nomination: {
            /**
             * Account cannot withdraw.
             **/
            CannotWithdrawCollateral: AugmentedError<ApiType>;
            /**
             * Vault cannot withdraw.
             **/
            CollateralizationTooLow: AugmentedError<ApiType>;
            /**
             * Nomination would overburden Vault.
             **/
            NominationExceedsLimit: AugmentedError<ApiType>;
            /**
             * Vault has already enabled nomination.
             **/
            VaultAlreadyOptedInToNomination: AugmentedError<ApiType>;
            /**
             * Nomination is not enabled.
             **/
            VaultNominationDisabled: AugmentedError<ApiType>;
            /**
             * Vault not found.
             **/
            VaultNotFound: AugmentedError<ApiType>;
            /**
             * Vault has not enabled nomination.
             **/
            VaultNotOptedInToNomination: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        oracle: {
            /**
             * Not authorized to set exchange rate
             **/
            InvalidOracleSource: AugmentedError<ApiType>;
            /**
             * Exchange rate not specified or has expired
             **/
            MissingExchangeRate: AugmentedError<ApiType>;
            /**
             * Unable to convert value
             **/
            TryIntoIntError: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: 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>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        polkadotXcm: {
            /**
             * The given account is not an identifiable sovereign account for any location.
             **/
            AccountNotSovereign: AugmentedError<ApiType>;
            /**
             * 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 operation required fees to be paid which the initiator could not meet.
             **/
            FeesNotMet: AugmentedError<ApiType>;
            /**
             * The message execution fails the filter.
             **/
            Filtered: AugmentedError<ApiType>;
            /**
             * The unlock operation cannot succeed because there are still users of the lock.
             **/
            InUse: AugmentedError<ApiType>;
            /**
             * Invalid asset for the operation.
             **/
            InvalidAsset: AugmentedError<ApiType>;
            /**
             * Origin is invalid for sending.
             **/
            InvalidOrigin: AugmentedError<ApiType>;
            /**
             * A remote lock with the corresponding data could not be found.
             **/
            LockNotFound: AugmentedError<ApiType>;
            /**
             * The owner does not own (all) of the asset that they wish to do the operation on.
             **/
            LowBalance: 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 asset owner has too many locks on the asset.
             **/
            TooManyLocks: 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>;
            /**
             * Generic error
             **/
            [key: string]: 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.
             **/
            TooBig: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: 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>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        redeem: {
            /**
             * Redeem amount is too small.
             **/
            AmountBelowDustAmount: AugmentedError<ApiType>;
            /**
             * Account has insufficient balance.
             **/
            AmountExceedsUserBalance: AugmentedError<ApiType>;
            /**
             * Redeem request already cancelled.
             **/
            RedeemCancelled: AugmentedError<ApiType>;
            /**
             * Redeem request already completed.
             **/
            RedeemCompleted: AugmentedError<ApiType>;
            /**
             * Redeem request not found.
             **/
            RedeemIdNotFound: AugmentedError<ApiType>;
            /**
             * Redeem request has not expired.
             **/
            TimeNotExpired: AugmentedError<ApiType>;
            /**
             * Unable to convert value.
             **/
            TryIntoIntError: AugmentedError<ApiType>;
            /**
             * Unexpected redeem account.
             **/
            UnauthorizedRedeemer: AugmentedError<ApiType>;
            /**
             * Unexpected vault account.
             **/
            UnauthorizedVault: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        replace: {
            /**
             * Replace amount is too small.
             **/
            AmountBelowDustAmount: AugmentedError<ApiType>;
            /**
             * Vault cannot replace different currency.
             **/
            InvalidWrappedCurrency: AugmentedError<ApiType>;
            /**
             * No replace request found.
             **/
            NoPendingRequest: AugmentedError<ApiType>;
            /**
             * Replace requires non-zero increase.
             **/
            ReplaceAmountZero: AugmentedError<ApiType>;
            /**
             * Replace request already cancelled.
             **/
            ReplaceCancelled: AugmentedError<ApiType>;
            /**
             * Replace request already completed.
             **/
            ReplaceCompleted: AugmentedError<ApiType>;
            /**
             * Replace request not found.
             **/
            ReplaceIdNotFound: AugmentedError<ApiType>;
            /**
             * Replace request has not expired.
             **/
            ReplacePeriodNotExpired: AugmentedError<ApiType>;
            /**
             * Cannot replace self.
             **/
            ReplaceSelfNotAllowed: AugmentedError<ApiType>;
            /**
             * Unexpected vault account.
             **/
            UnauthorizedVault: AugmentedError<ApiType>;
            /**
             * Cannot replace with nominated collateral.
             **/
            VaultHasEnabledNomination: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        scheduler: {
            /**
             * Failed to schedule a call
             **/
            FailedToSchedule: AugmentedError<ApiType>;
            /**
             * Attempt to use a non-named function on a named task.
             **/
            Named: 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>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        security: {
            /**
             * Generic error
             **/
            [key: string]: 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>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        sudo: {
            /**
             * Sender must be the Sudo account
             **/
            RequireSudo: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        supply: {
            /**
             * Generic error
             **/
            [key: string]: 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>;
            /**
             * Generic error
             **/
            [key: string]: 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>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        technicalMembership: {
            /**
             * Already a member.
             **/
            AlreadyMember: AugmentedError<ApiType>;
            /**
             * Not a member.
             **/
            NotMember: AugmentedError<ApiType>;
            /**
             * Too many members.
             **/
            TooManyMembers: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        tokens: {
            /**
             * Cannot convert Amount into Balance type
             **/
            AmountIntoBalanceFailed: AugmentedError<ApiType>;
            /**
             * The balance is too low
             **/
            BalanceTooLow: AugmentedError<ApiType>;
            /**
             * Beneficiary account must pre-exist
             **/
            DeadAccount: AugmentedError<ApiType>;
            /**
             * Value too low to create account due to existential deposit
             **/
            ExistentialDeposit: AugmentedError<ApiType>;
            /**
             * Transfer/payment would kill account
             **/
            KeepAlive: AugmentedError<ApiType>;
            /**
             * Failed because liquidity restrictions due to locking
             **/
            LiquidityRestrictions: AugmentedError<ApiType>;
            /**
             * Failed because the maximum locks was exceeded
             **/
            MaxLocksExceeded: AugmentedError<ApiType>;
            TooManyReserves: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        txPause: {
            /**
             * The call is (already or still) paused.
             **/
            IsPaused: AugmentedError<ApiType>;
            /**
             * The call is listed as safe and cannot be paused.
             **/
            IsUnpausable: AugmentedError<ApiType>;
            /**
             * The call is (already or still) unpaused.
             **/
            IsUnpaused: AugmentedError<ApiType>;
            NotFound: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        unknownTokens: {
            /**
             * The operation will cause balance to overflow.
             **/
            BalanceOverflow: AugmentedError<ApiType>;
            /**
             * The balance is too low.
             **/
            BalanceTooLow: AugmentedError<ApiType>;
            /**
             * Unhandled asset.
             **/
            UnhandledAsset: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        utility: {
            /**
             * Too many calls batched.
             **/
            TooManyCalls: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        vaultAnnuity: {
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        vaultCapacity: {
            /**
             * Balance not sufficient to withdraw stake.
             **/
            InsufficientFunds: AugmentedError<ApiType>;
            /**
             * Maximum rewards currencies reached.
             **/
            MaxRewardCurrencies: AugmentedError<ApiType>;
            /**
             * Unable to convert value.
             **/
            TryIntoIntError: AugmentedError<ApiType>;
            /**
             * Cannot distribute rewards without stake.
             **/
            ZeroTotalStake: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        vaultRegistry: {
            /**
             * Ceiling was not found for the given currency
             **/
            CeilingNotSet: AugmentedError<ApiType>;
            /**
             * The collateral ceiling would be exceeded for the vault's currency.
             **/
            CurrencyCeilingExceeded: AugmentedError<ApiType>;
            /**
             * The amount of tokens to be issued is higher than the issuable amount by the vault
             **/
            ExceedingVaultLimit: AugmentedError<ApiType>;
            /**
             * Not enough free collateral available.
             **/
            InsufficientCollateral: AugmentedError<ApiType>;
            /**
             * The requested amount of tokens exceeds the amount available to this vault.
             **/
            InsufficientTokensCommitted: AugmentedError<ApiType>;
            /**
             * The provided collateral was insufficient - it must be above ``MinimumCollateralVault``.
             **/
            InsufficientVaultCollateralAmount: AugmentedError<ApiType>;
            /**
             * Failed attempt to modify vault's collateral because it was in the wrong currency
             **/
            InvalidCurrency: AugmentedError<ApiType>;
            /**
             * Deposit address could not be generated with the given public key.
             **/
            InvalidPublicKey: AugmentedError<ApiType>;
            MinimumCollateralNotSet: AugmentedError<ApiType>;
            /**
             * No bitcoin public key is registered for the vault.
             **/
            NoBitcoinPublicKey: AugmentedError<ApiType>;
            /**
             * Collateralization is infinite if no tokens are issued
             **/
            NoTokensIssued: AugmentedError<ApiType>;
            NoVaultUnderThePremiumRedeemThreshold: AugmentedError<ApiType>;
            NoVaultWithSufficientCollateral: AugmentedError<ApiType>;
            NoVaultWithSufficientTokens: AugmentedError<ApiType>;
            /**
             * A bitcoin public key was already registered for this account.
             **/
            PublicKeyAlreadyRegistered: AugmentedError<ApiType>;
            /**
             * Vault attempted to set secure threshold below the global secure threshold
             **/
            ThresholdNotAboveGlobalThreshold: AugmentedError<ApiType>;
            /**
             * Threshold was not found for the given currency
             **/
            ThresholdNotSet: AugmentedError<ApiType>;
            /**
             * Unable to convert value
             **/
            TryIntoIntError: AugmentedError<ApiType>;
            /**
             * Returned if a vault tries to register while already being registered
             **/
            VaultAlreadyRegistered: AugmentedError<ApiType>;
            /**
             * Action not allowed on banned vault.
             **/
            VaultBanned: AugmentedError<ApiType>;
            /**
             * Vault is no longer usable as it was liquidated due to undercollateralization.
             **/
            VaultLiquidated: AugmentedError<ApiType>;
            /**
             * Vault is not accepting new issue requests.
             **/
            VaultNotAcceptingIssueRequests: AugmentedError<ApiType>;
            /**
             * Attempted to liquidate a vault that is not undercollateralized.
             **/
            VaultNotBelowLiquidationThreshold: AugmentedError<ApiType>;
            /**
             * The specified vault does not exist.
             **/
            VaultNotFound: AugmentedError<ApiType>;
            /**
             * Vault must be liquidated.
             **/
            VaultNotRecoverable: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        vaultRewards: {
            /**
             * Balance not sufficient to withdraw stake.
             **/
            InsufficientFunds: AugmentedError<ApiType>;
            /**
             * Maximum rewards currencies reached.
             **/
            MaxRewardCurrencies: AugmentedError<ApiType>;
            /**
             * Unable to convert value.
             **/
            TryIntoIntError: AugmentedError<ApiType>;
            /**
             * Cannot distribute rewards without stake.
             **/
            ZeroTotalStake: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        vaultStaking: {
            /**
             * Balance not sufficient to withdraw stake.
             **/
            InsufficientFunds: AugmentedError<ApiType>;
            /**
             * Cannot slash zero total stake.
             **/
            SlashZeroTotalStake: AugmentedError<ApiType>;
            /**
             * Unable to convert value.
             **/
            TryIntoIntError: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        vesting: {
            /**
             * The vested transfer amount is too low
             **/
            AmountLow: AugmentedError<ApiType>;
            /**
             * Insufficient amount of balance to lock
             **/
            InsufficientBalanceToLock: AugmentedError<ApiType>;
            /**
             * Failed because the maximum vesting schedules was exceeded
             **/
            MaxVestingSchedulesExceeded: AugmentedError<ApiType>;
            /**
             * This account have too many vesting schedules
             **/
            TooManyVestingSchedules: AugmentedError<ApiType>;
            /**
             * Vesting period is zero
             **/
            ZeroVestingPeriod: AugmentedError<ApiType>;
            /**
             * Number of vests is zero
             **/
            ZeroVestingPeriodCount: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: 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>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        xTokens: {
            /**
             * Asset has no reserve location.
             **/
            AssetHasNoReserve: AugmentedError<ApiType>;
            /**
             * The specified index does not exist in a MultiAssets struct.
             **/
            AssetIndexNonExistent: 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>;
            /**
             * We tried sending distinct asset and fee but they have different
             * reserve chains.
             **/
            DistinctReserveForAssetAndFee: AugmentedError<ApiType>;
            /**
             * Fee is not enough.
             **/
            FeeNotEnough: AugmentedError<ApiType>;
            /**
             * Could not get ancestry of asset reserve location.
             **/
            InvalidAncestry: AugmentedError<ApiType>;
            /**
             * The MultiAsset is invalid.
             **/
            InvalidAsset: AugmentedError<ApiType>;
            /**
             * Invalid transfer destination.
             **/
            InvalidDest: AugmentedError<ApiType>;
            /**
             * MinXcmFee not registered for certain reserve location
             **/
            MinXcmFeeNotDefined: AugmentedError<ApiType>;
            /**
             * Not cross-chain transfer.
             **/
            NotCrossChainTransfer: AugmentedError<ApiType>;
            /**
             * Currency is not cross-chain transferable.
             **/
            NotCrossChainTransferableCurrency: AugmentedError<ApiType>;
            /**
             * Not supported MultiLocation
             **/
            NotSupportedMultiLocation: AugmentedError<ApiType>;
            /**
             * The number of assets to be sent is over the maximum.
             **/
            TooManyAssetsBeingSent: AugmentedError<ApiType>;
            /**
             * The message's weight could not be determined.
             **/
            UnweighableMessage: AugmentedError<ApiType>;
            /**
             * XCM execution failed.
             **/
            XcmExecutionFailed: AugmentedError<ApiType>;
            /**
             * The transfering asset amount is zero.
             **/
            ZeroAmount: AugmentedError<ApiType>;
            /**
             * The fee is zero.
             **/
            ZeroFee: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
    }
}