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> {
        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>;
        };
        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>;
            /**
             * 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>;
            /**
             * 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>;
            /**
             * 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>;
            /**
             * 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>;
            /**
             * 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: {
            /**
             * Preimage already noted
             **/
            DuplicatePreimage: AugmentedError<ApiType>;
            /**
             * Proposal already made
             **/
            DuplicateProposal: AugmentedError<ApiType>;
            /**
             * 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>;
            /**
             * Invalid preimage
             **/
            PreimageInvalid: AugmentedError<ApiType>;
            /**
             * Preimage not found
             **/
            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 proposals reached.
             **/
            TooManyProposals: AugmentedError<ApiType>;
            /**
             * Value too low
             **/
            ValueLow: AugmentedError<ApiType>;
            /**
             * Invalid upper bound.
             **/
            WrongUpperBound: 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: {
            /**
             * 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>;
            /**
             * 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>;
            /**
             * Judgement given.
             **/
            JudgementGiven: 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>;
        };
        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>;
        };
        nomination: {
            /**
             * Account cannot withdraw.
             **/
            CannotWithdrawCollateral: AugmentedError<ApiType>;
            /**
             * Vault cannot withdraw.
             **/
            CollateralizationTooLow: AugmentedError<ApiType>;
            /**
             * Nomination would overburden Vault.
             **/
            DepositViolatesMaxNominationRatio: 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 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>;
            /**
             * 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.
             **/
            TooLarge: 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>;
            /**
             * 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: {
            /**
             * Parachain is not running.
             **/
            ParachainNotRunning: AugmentedError<ApiType>;
            /**
             * 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>;
        };
        treasury: {
            /**
             * The spend origin is valid but the amount it is allowed to spend is lower than the
             * amount to be spent.
             **/
            InsufficientPermission: AugmentedError<ApiType>;
            /**
             * Proposer's balance is too low.
             **/
            InsufficientProposersBalance: AugmentedError<ApiType>;
            /**
             * No proposal or bounty at that index.
             **/
            InvalidIndex: AugmentedError<ApiType>;
            /**
             * Proposal has not been approved.
             **/
            ProposalNotApproved: AugmentedError<ApiType>;
            /**
             * Too many approvals in the queue.
             **/
            TooManyApprovals: 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>;
        };
        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>;
            /**
             * The Max Nomination Ratio would be exceeded.
             **/
            MaxNominationRatioViolation: 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>;
            /**
             * The Bitcoin Address has already been registered
             **/
            ReservedDepositAddress: 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>;
            /**
             * 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>;
        };
    }
}
