@polkadot/api-augment/assetHubKusama/errors.d.ts

API generated augmentation

import '@polkadot/api-base/types/errors';
import type { ApiTypes, AugmentedError } from '@polkadot/api-base/types';
export type __AugmentedError<ApiType extends ApiTypes> = AugmentedError<ApiType>;
declare module '@polkadot/api-base/types/errors' {
    interface AugmentedErrors<ApiType extends ApiTypes> {
        assetConversion: {
            /**
             * Provided amount should be greater than or equal to the existential deposit/asset's
             * minimal amount.
             **/
            AmountOneLessThanMinimal: AugmentedError<ApiType>;
            /**
             * Desired amount can't be equal to the pool reserve.
             **/
            AmountOutTooHigh: AugmentedError<ApiType>;
            /**
             * Provided amount should be greater than or equal to the existential deposit/asset's
             * minimal amount.
             **/
            AmountTwoLessThanMinimal: AugmentedError<ApiType>;
            /**
             * The minimal amount requirement for the first token in the pair wasn't met.
             **/
            AssetOneDepositDidNotMeetMinimum: AugmentedError<ApiType>;
            /**
             * The minimal amount requirement for the first token in the pair wasn't met.
             **/
            AssetOneWithdrawalDidNotMeetMinimum: AugmentedError<ApiType>;
            /**
             * The minimal amount requirement for the second token in the pair wasn't met.
             **/
            AssetTwoDepositDidNotMeetMinimum: AugmentedError<ApiType>;
            /**
             * The minimal amount requirement for the second token in the pair wasn't met.
             **/
            AssetTwoWithdrawalDidNotMeetMinimum: AugmentedError<ApiType>;
            /**
             * The destination account cannot exist with the swapped funds.
             **/
            BelowMinimum: AugmentedError<ApiType>;
            /**
             * It was not possible to get or increment the Id of the pool.
             **/
            IncorrectPoolAssetId: AugmentedError<ApiType>;
            /**
             * Insufficient liquidity minted.
             **/
            InsufficientLiquidityMinted: AugmentedError<ApiType>;
            /**
             * Provided asset pair is not supported for pool.
             **/
            InvalidAssetPair: AugmentedError<ApiType>;
            /**
             * The provided path must consists of 2 assets at least.
             **/
            InvalidPath: AugmentedError<ApiType>;
            /**
             * The provided path must consists of unique assets.
             **/
            NonUniquePath: AugmentedError<ApiType>;
            /**
             * Optimal calculated amount is less than desired.
             **/
            OptimalAmountLessThanDesired: AugmentedError<ApiType>;
            /**
             * An overflow happened.
             **/
            Overflow: AugmentedError<ApiType>;
            /**
             * Pool already exists.
             **/
            PoolExists: AugmentedError<ApiType>;
            /**
             * The pool doesn't exist.
             **/
            PoolNotFound: AugmentedError<ApiType>;
            /**
             * Provided maximum amount is not sufficient for swap.
             **/
            ProvidedMaximumNotSufficientForSwap: AugmentedError<ApiType>;
            /**
             * Calculated amount out is less than provided minimum amount.
             **/
            ProvidedMinimumNotSufficientForSwap: AugmentedError<ApiType>;
            /**
             * Reserve needs to always be greater than or equal to the existential deposit/asset's
             * minimal amount.
             **/
            ReserveLeftLessThanMinimal: AugmentedError<ApiType>;
            /**
             * Desired amount can't be zero.
             **/
            WrongDesiredAmount: AugmentedError<ApiType>;
            /**
             * Amount can't be zero.
             **/
            ZeroAmount: AugmentedError<ApiType>;
            /**
             * Requested liquidity can't be zero.
             **/
            ZeroLiquidity: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        assets: {
            /**
             * The asset-account already exists.
             **/
            AlreadyExists: AugmentedError<ApiType>;
            /**
             * The asset is not live, and likely being destroyed.
             **/
            AssetNotLive: AugmentedError<ApiType>;
            /**
             * The asset ID must be equal to the [`NextAssetId`].
             **/
            BadAssetId: AugmentedError<ApiType>;
            /**
             * Invalid metadata given.
             **/
            BadMetadata: AugmentedError<ApiType>;
            /**
             * Invalid witness data given.
             **/
            BadWitness: AugmentedError<ApiType>;
            /**
             * Account balance must be greater than or equal to the transfer amount.
             **/
            BalanceLow: AugmentedError<ApiType>;
            /**
             * Callback action resulted in error
             **/
            CallbackFailed: AugmentedError<ApiType>;
            /**
             * The origin account is frozen.
             **/
            Frozen: AugmentedError<ApiType>;
            /**
             * The asset status is not the expected status.
             **/
            IncorrectStatus: AugmentedError<ApiType>;
            /**
             * The asset ID is already taken.
             **/
            InUse: AugmentedError<ApiType>;
            /**
             * The asset is a live asset and is actively being used. Usually emit for operations such
             * as `start_destroy` which require the asset to be in a destroying state.
             **/
            LiveAsset: AugmentedError<ApiType>;
            /**
             * Minimum balance should be non-zero.
             **/
            MinBalanceZero: AugmentedError<ApiType>;
            /**
             * The account to alter does not exist.
             **/
            NoAccount: AugmentedError<ApiType>;
            /**
             * The asset-account doesn't have an associated deposit.
             **/
            NoDeposit: AugmentedError<ApiType>;
            /**
             * The signing account has no permission to do the operation.
             **/
            NoPermission: AugmentedError<ApiType>;
            /**
             * The asset should be frozen before the given operation.
             **/
            NotFrozen: AugmentedError<ApiType>;
            /**
             * No approval exists that would allow the transfer.
             **/
            Unapproved: AugmentedError<ApiType>;
            /**
             * Unable to increment the consumer reference counters on the account. Either no provider
             * reference exists to allow a non-zero balance of a non-self-sufficient asset, or one
             * fewer then the maximum number of consumers has been reached.
             **/
            UnavailableConsumer: AugmentedError<ApiType>;
            /**
             * The given asset ID is unknown.
             **/
            Unknown: AugmentedError<ApiType>;
            /**
             * The operation would result in funds being burned.
             **/
            WouldBurn: AugmentedError<ApiType>;
            /**
             * The source account would not survive the transfer and it needs to stay alive.
             **/
            WouldDie: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        balances: {
            /**
             * Beneficiary account must pre-exist.
             **/
            DeadAccount: AugmentedError<ApiType>;
            /**
             * The delta cannot be zero.
             **/
            DeltaZero: AugmentedError<ApiType>;
            /**
             * Value too low to create account due to existential deposit.
             **/
            ExistentialDeposit: AugmentedError<ApiType>;
            /**
             * A vesting schedule already exists for this account.
             **/
            ExistingVestingSchedule: AugmentedError<ApiType>;
            /**
             * Transfer/payment would kill account.
             **/
            Expendability: AugmentedError<ApiType>;
            /**
             * Balance too low to send value.
             **/
            InsufficientBalance: AugmentedError<ApiType>;
            /**
             * The issuance cannot be modified since it is already deactivated.
             **/
            IssuanceDeactivated: AugmentedError<ApiType>;
            /**
             * Account liquidity restrictions prevent withdrawal.
             **/
            LiquidityRestrictions: AugmentedError<ApiType>;
            /**
             * Number of freezes exceed `MaxFreezes`.
             **/
            TooManyFreezes: AugmentedError<ApiType>;
            /**
             * Number of holds exceed `VariantCountOf<T::RuntimeHoldReason>`.
             **/
            TooManyHolds: AugmentedError<ApiType>;
            /**
             * Number of named reserves exceed `MaxReserves`.
             **/
            TooManyReserves: AugmentedError<ApiType>;
            /**
             * Vesting balance too high to send value.
             **/
            VestingBalance: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        collatorSelection: {
            /**
             * Account is already a candidate.
             **/
            AlreadyCandidate: AugmentedError<ApiType>;
            /**
             * Account is already an Invulnerable.
             **/
            AlreadyInvulnerable: AugmentedError<ApiType>;
            /**
             * New deposit amount would be below the minimum candidacy bond.
             **/
            DepositTooLow: AugmentedError<ApiType>;
            /**
             * The updated deposit amount is equal to the amount already reserved.
             **/
            IdenticalDeposit: AugmentedError<ApiType>;
            /**
             * Could not insert in the candidate list.
             **/
            InsertToCandidateListFailed: AugmentedError<ApiType>;
            /**
             * Deposit amount is too low to take the target's slot in the candidate list.
             **/
            InsufficientBond: AugmentedError<ApiType>;
            /**
             * Cannot lower candidacy bond while occupying a future collator slot in the list.
             **/
            InvalidUnreserve: AugmentedError<ApiType>;
            /**
             * Account has no associated validator ID.
             **/
            NoAssociatedValidatorId: AugmentedError<ApiType>;
            /**
             * Account is not a candidate.
             **/
            NotCandidate: AugmentedError<ApiType>;
            /**
             * Account is not an Invulnerable.
             **/
            NotInvulnerable: AugmentedError<ApiType>;
            /**
             * Could not remove from the candidate list.
             **/
            RemoveFromCandidateListFailed: AugmentedError<ApiType>;
            /**
             * The target account to be replaced in the candidate list is not a candidate.
             **/
            TargetIsNotCandidate: AugmentedError<ApiType>;
            /**
             * Leaving would result in too few candidates.
             **/
            TooFewEligibleCollators: AugmentedError<ApiType>;
            /**
             * The pallet has too many candidates.
             **/
            TooManyCandidates: AugmentedError<ApiType>;
            /**
             * There are too many Invulnerables.
             **/
            TooManyInvulnerables: AugmentedError<ApiType>;
            /**
             * Could not update the candidate list.
             **/
            UpdateCandidateListFailed: AugmentedError<ApiType>;
            /**
             * Validator ID is not yet registered.
             **/
            ValidatorNotRegistered: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        foreignAssets: {
            /**
             * The asset-account already exists.
             **/
            AlreadyExists: AugmentedError<ApiType>;
            /**
             * The asset is not live, and likely being destroyed.
             **/
            AssetNotLive: AugmentedError<ApiType>;
            /**
             * The asset ID must be equal to the [`NextAssetId`].
             **/
            BadAssetId: AugmentedError<ApiType>;
            /**
             * Invalid metadata given.
             **/
            BadMetadata: AugmentedError<ApiType>;
            /**
             * Invalid witness data given.
             **/
            BadWitness: AugmentedError<ApiType>;
            /**
             * Account balance must be greater than or equal to the transfer amount.
             **/
            BalanceLow: AugmentedError<ApiType>;
            /**
             * Callback action resulted in error
             **/
            CallbackFailed: AugmentedError<ApiType>;
            /**
             * The origin account is frozen.
             **/
            Frozen: AugmentedError<ApiType>;
            /**
             * The asset status is not the expected status.
             **/
            IncorrectStatus: AugmentedError<ApiType>;
            /**
             * The asset ID is already taken.
             **/
            InUse: AugmentedError<ApiType>;
            /**
             * The asset is a live asset and is actively being used. Usually emit for operations such
             * as `start_destroy` which require the asset to be in a destroying state.
             **/
            LiveAsset: AugmentedError<ApiType>;
            /**
             * Minimum balance should be non-zero.
             **/
            MinBalanceZero: AugmentedError<ApiType>;
            /**
             * The account to alter does not exist.
             **/
            NoAccount: AugmentedError<ApiType>;
            /**
             * The asset-account doesn't have an associated deposit.
             **/
            NoDeposit: AugmentedError<ApiType>;
            /**
             * The signing account has no permission to do the operation.
             **/
            NoPermission: AugmentedError<ApiType>;
            /**
             * The asset should be frozen before the given operation.
             **/
            NotFrozen: AugmentedError<ApiType>;
            /**
             * No approval exists that would allow the transfer.
             **/
            Unapproved: AugmentedError<ApiType>;
            /**
             * Unable to increment the consumer reference counters on the account. Either no provider
             * reference exists to allow a non-zero balance of a non-self-sufficient asset, or one
             * fewer then the maximum number of consumers has been reached.
             **/
            UnavailableConsumer: AugmentedError<ApiType>;
            /**
             * The given asset ID is unknown.
             **/
            Unknown: AugmentedError<ApiType>;
            /**
             * The operation would result in funds being burned.
             **/
            WouldBurn: AugmentedError<ApiType>;
            /**
             * The source account would not survive the transfer and it needs to stay alive.
             **/
            WouldDie: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        messageQueue: {
            /**
             * The message was already processed and cannot be processed again.
             **/
            AlreadyProcessed: AugmentedError<ApiType>;
            /**
             * There is temporarily not enough weight to continue servicing messages.
             **/
            InsufficientWeight: AugmentedError<ApiType>;
            /**
             * The referenced message could not be found.
             **/
            NoMessage: AugmentedError<ApiType>;
            /**
             * Page to be reaped does not exist.
             **/
            NoPage: AugmentedError<ApiType>;
            /**
             * Page is not reapable because it has items remaining to be processed and is not old
             * enough.
             **/
            NotReapable: AugmentedError<ApiType>;
            /**
             * The message is queued for future execution.
             **/
            Queued: AugmentedError<ApiType>;
            /**
             * The queue is paused and no message can be executed from it.
             *
             * This can change at any time and may resolve in the future by re-trying.
             **/
            QueuePaused: AugmentedError<ApiType>;
            /**
             * Another call is in progress and needs to finish before this call can happen.
             **/
            RecursiveDisallowed: AugmentedError<ApiType>;
            /**
             * This message is temporarily unprocessable.
             *
             * Such errors are expected, but not guaranteed, to resolve themselves eventually through
             * retrying.
             **/
            TemporarilyUnprocessable: 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>;
        };
        nftFractionalization: {
            /**
             * Asset ID does not correspond to locked NFT.
             **/
            IncorrectAssetId: AugmentedError<ApiType>;
            /**
             * NFT doesn't exist.
             **/
            NftNotFound: AugmentedError<ApiType>;
            /**
             * NFT has not yet been fractionalised.
             **/
            NftNotFractionalized: AugmentedError<ApiType>;
            /**
             * The signing account has no permission to do the operation.
             **/
            NoPermission: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        nfts: {
            /**
             * The provided Item was already used for claiming.
             **/
            AlreadyClaimed: AugmentedError<ApiType>;
            /**
             * The item ID has already been used for an item.
             **/
            AlreadyExists: AugmentedError<ApiType>;
            /**
             * The approval had a deadline that expired, so the approval isn't valid anymore.
             **/
            ApprovalExpired: AugmentedError<ApiType>;
            /**
             * The provided attribute can't be found.
             **/
            AttributeNotFound: AugmentedError<ApiType>;
            /**
             * The witness data given does not match the current state of the chain.
             **/
            BadWitness: AugmentedError<ApiType>;
            /**
             * The provided bid is too low.
             **/
            BidTooLow: AugmentedError<ApiType>;
            /**
             * Collection ID is already taken.
             **/
            CollectionIdInUse: AugmentedError<ApiType>;
            /**
             * Can't delete non-empty collections.
             **/
            CollectionNotEmpty: AugmentedError<ApiType>;
            /**
             * The deadline has already expired.
             **/
            DeadlineExpired: AugmentedError<ApiType>;
            /**
             * Item's config already exists and should be equal to the provided one.
             **/
            InconsistentItemConfig: AugmentedError<ApiType>;
            /**
             * The provided data is incorrect.
             **/
            IncorrectData: AugmentedError<ApiType>;
            /**
             * The provided metadata might be too long.
             **/
            IncorrectMetadata: AugmentedError<ApiType>;
            /**
             * The item is locked (non-transferable).
             **/
            ItemLocked: AugmentedError<ApiType>;
            /**
             * Items within that collection are non-transferable.
             **/
            ItemsNonTransferable: AugmentedError<ApiType>;
            /**
             * Collection's attributes are locked.
             **/
            LockedCollectionAttributes: AugmentedError<ApiType>;
            /**
             * Collection's metadata is locked.
             **/
            LockedCollectionMetadata: AugmentedError<ApiType>;
            /**
             * Item's attributes are locked.
             **/
            LockedItemAttributes: AugmentedError<ApiType>;
            /**
             * Item's metadata is locked.
             **/
            LockedItemMetadata: AugmentedError<ApiType>;
            /**
             * Can't set more attributes per one call.
             **/
            MaxAttributesLimitReached: AugmentedError<ApiType>;
            /**
             * The max supply is locked and can't be changed.
             **/
            MaxSupplyLocked: AugmentedError<ApiType>;
            /**
             * All items have been minted.
             **/
            MaxSupplyReached: AugmentedError<ApiType>;
            /**
             * The provided max supply is less than the number of items a collection already has.
             **/
            MaxSupplyTooSmall: AugmentedError<ApiType>;
            /**
             * The given item has no metadata set.
             **/
            MetadataNotFound: AugmentedError<ApiType>;
            /**
             * The method is disabled by system settings.
             **/
            MethodDisabled: AugmentedError<ApiType>;
            /**
             * Mint has already ended.
             **/
            MintEnded: AugmentedError<ApiType>;
            /**
             * Mint has not started yet.
             **/
            MintNotStarted: AugmentedError<ApiType>;
            /**
             * Config for a collection or an item can't be found.
             **/
            NoConfig: AugmentedError<ApiType>;
            /**
             * The signing account has no permission to do the operation.
             **/
            NoPermission: AugmentedError<ApiType>;
            /**
             * The provided account is not a delegate.
             **/
            NotDelegate: AugmentedError<ApiType>;
            /**
             * Item is not for sale.
             **/
            NotForSale: AugmentedError<ApiType>;
            /**
             * The item has reached its approval limit.
             **/
            ReachedApprovalLimit: AugmentedError<ApiType>;
            /**
             * Some roles were not cleared.
             **/
            RolesNotCleared: AugmentedError<ApiType>;
            /**
             * The named owner has not signed ownership acceptance of the collection.
             **/
            Unaccepted: AugmentedError<ApiType>;
            /**
             * No approval exists that would allow the transfer.
             **/
            Unapproved: AugmentedError<ApiType>;
            /**
             * The given item ID is unknown.
             **/
            UnknownCollection: AugmentedError<ApiType>;
            /**
             * The given item ID is unknown.
             **/
            UnknownItem: AugmentedError<ApiType>;
            /**
             * Swap doesn't exist.
             **/
            UnknownSwap: AugmentedError<ApiType>;
            /**
             * The witness data should be provided.
             **/
            WitnessRequired: AugmentedError<ApiType>;
            /**
             * The delegate turned out to be different to what was expected.
             **/
            WrongDelegate: AugmentedError<ApiType>;
            /**
             * The duration provided should be less than or equal to `MaxDeadlineDuration`.
             **/
            WrongDuration: AugmentedError<ApiType>;
            /**
             * The provided namespace isn't supported in this call.
             **/
            WrongNamespace: AugmentedError<ApiType>;
            /**
             * The extrinsic was sent by the wrong origin.
             **/
            WrongOrigin: AugmentedError<ApiType>;
            /**
             * The owner turned out to be different to what was expected.
             **/
            WrongOwner: AugmentedError<ApiType>;
            /**
             * The provided setting can't be set.
             **/
            WrongSetting: AugmentedError<ApiType>;
            /**
             * The provided signature is incorrect.
             **/
            WrongSignature: 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 check-out the assets for teleportation to the destination chain.
             **/
            CannotCheckOutTeleport: AugmentedError<ApiType>;
            /**
             * Could not re-anchor the assets to declare the fees for the destination chain.
             **/
            CannotReanchor: AugmentedError<ApiType>;
            /**
             * The destination `Location` 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 consumers of the lock.
             **/
            InUse: AugmentedError<ApiType>;
            /**
             * Invalid asset, reserve chain could not be determined for it.
             **/
            InvalidAssetUnknownReserve: AugmentedError<ApiType>;
            /**
             * Invalid asset, do not support remote asset reserves with different fees reserves.
             **/
            InvalidAssetUnsupportedReserve: AugmentedError<ApiType>;
            /**
             * Origin is invalid for sending.
             **/
            InvalidOrigin: AugmentedError<ApiType>;
            /**
             * Local XCM execution incomplete.
             **/
            LocalExecutionIncomplete: 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>;
            /**
             * Too many assets with different reserve locations have been attempted for transfer.
             **/
            TooManyReserves: 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>;
        };
        poolAssets: {
            /**
             * The asset-account already exists.
             **/
            AlreadyExists: AugmentedError<ApiType>;
            /**
             * The asset is not live, and likely being destroyed.
             **/
            AssetNotLive: AugmentedError<ApiType>;
            /**
             * The asset ID must be equal to the [`NextAssetId`].
             **/
            BadAssetId: AugmentedError<ApiType>;
            /**
             * Invalid metadata given.
             **/
            BadMetadata: AugmentedError<ApiType>;
            /**
             * Invalid witness data given.
             **/
            BadWitness: AugmentedError<ApiType>;
            /**
             * Account balance must be greater than or equal to the transfer amount.
             **/
            BalanceLow: AugmentedError<ApiType>;
            /**
             * Callback action resulted in error
             **/
            CallbackFailed: AugmentedError<ApiType>;
            /**
             * The origin account is frozen.
             **/
            Frozen: AugmentedError<ApiType>;
            /**
             * The asset status is not the expected status.
             **/
            IncorrectStatus: AugmentedError<ApiType>;
            /**
             * The asset ID is already taken.
             **/
            InUse: AugmentedError<ApiType>;
            /**
             * The asset is a live asset and is actively being used. Usually emit for operations such
             * as `start_destroy` which require the asset to be in a destroying state.
             **/
            LiveAsset: AugmentedError<ApiType>;
            /**
             * Minimum balance should be non-zero.
             **/
            MinBalanceZero: AugmentedError<ApiType>;
            /**
             * The account to alter does not exist.
             **/
            NoAccount: AugmentedError<ApiType>;
            /**
             * The asset-account doesn't have an associated deposit.
             **/
            NoDeposit: AugmentedError<ApiType>;
            /**
             * The signing account has no permission to do the operation.
             **/
            NoPermission: AugmentedError<ApiType>;
            /**
             * The asset should be frozen before the given operation.
             **/
            NotFrozen: AugmentedError<ApiType>;
            /**
             * No approval exists that would allow the transfer.
             **/
            Unapproved: AugmentedError<ApiType>;
            /**
             * Unable to increment the consumer reference counters on the account. Either no provider
             * reference exists to allow a non-zero balance of a non-self-sufficient asset, or one
             * fewer then the maximum number of consumers has been reached.
             **/
            UnavailableConsumer: AugmentedError<ApiType>;
            /**
             * The given asset ID is unknown.
             **/
            Unknown: AugmentedError<ApiType>;
            /**
             * The operation would result in funds being burned.
             **/
            WouldBurn: AugmentedError<ApiType>;
            /**
             * The source account would not survive the transfer and it needs to stay alive.
             **/
            WouldDie: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        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>;
        };
        remoteProxyRelayChain: {
            /**
             * The local account id could not converted to the remote account id.
             **/
            CouldNotConvertLocalToRemoteAccountId: AugmentedError<ApiType>;
            /**
             * Could not find any matching proxy definition in the proof.
             **/
            DidNotFindMatchingProxyDefinition: AugmentedError<ApiType>;
            /**
             * The proxy definition could not be found in the proof.
             **/
            InvalidProof: AugmentedError<ApiType>;
            /**
             * Failed to decode the remote proxy definition from the proof.
             **/
            ProxyDefinitionDecodingFailed: AugmentedError<ApiType>;
            /**
             * Proxy proof not registered.
             **/
            ProxyProofNotRegistered: AugmentedError<ApiType>;
            /**
             * Announcement, if made at all, was made too recently.
             **/
            Unannounced: AugmentedError<ApiType>;
            /**
             * The anchor block of the remote proof is unknown.
             **/
            UnknownProofAnchorBlock: 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>;
        };
        stateTrieMigration: {
            /**
             * Bad child root provided.
             **/
            BadChildRoot: AugmentedError<ApiType>;
            /**
             * Bad witness data provided.
             **/
            BadWitness: AugmentedError<ApiType>;
            /**
             * A key was longer than the configured maximum.
             *
             * This means that the migration halted at the current [`Progress`] and
             * can be resumed with a larger [`crate::Config::MaxKeyLen`] value.
             * Retrying with the same [`crate::Config::MaxKeyLen`] value will not work.
             * The value should only be increased to avoid a storage migration for the currently
             * stored [`crate::Progress::LastKey`].
             **/
            KeyTooLong: AugmentedError<ApiType>;
            /**
             * Max signed limits not respected.
             **/
            MaxSignedLimits: AugmentedError<ApiType>;
            /**
             * submitter does not have enough funds.
             **/
            NotEnoughFunds: AugmentedError<ApiType>;
            /**
             * Signed migration is not allowed because the maximum limit is not set yet.
             **/
            SignedMigrationNotAllowed: AugmentedError<ApiType>;
            /**
             * 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>;
            /**
             * A multi-block migration is ongoing and prevents the current code from being replaced.
             **/
            MultiBlockMigrationsOngoing: 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>;
            /**
             * No upgrade authorized.
             **/
            NothingAuthorized: AugmentedError<ApiType>;
            /**
             * The specification version is not allowed to decrease between the current runtime
             * and the new runtime.
             **/
            SpecVersionNeedsToIncrease: AugmentedError<ApiType>;
            /**
             * The submitted code is not authorized.
             **/
            Unauthorized: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        uniques: {
            /**
             * The item ID has already been used for an item.
             **/
            AlreadyExists: AugmentedError<ApiType>;
            /**
             * Invalid witness data given.
             **/
            BadWitness: AugmentedError<ApiType>;
            /**
             * The provided bid is too low.
             **/
            BidTooLow: AugmentedError<ApiType>;
            /**
             * The item or collection is frozen.
             **/
            Frozen: AugmentedError<ApiType>;
            /**
             * The item ID is already taken.
             **/
            InUse: AugmentedError<ApiType>;
            /**
             * The item is locked.
             **/
            Locked: AugmentedError<ApiType>;
            /**
             * The max supply has already been set.
             **/
            MaxSupplyAlreadySet: AugmentedError<ApiType>;
            /**
             * All items have been minted.
             **/
            MaxSupplyReached: AugmentedError<ApiType>;
            /**
             * The provided max supply is less to the amount of items a collection already has.
             **/
            MaxSupplyTooSmall: AugmentedError<ApiType>;
            /**
             * There is no delegate approved.
             **/
            NoDelegate: AugmentedError<ApiType>;
            /**
             * The signing account has no permission to do the operation.
             **/
            NoPermission: AugmentedError<ApiType>;
            /**
             * Item is not for sale.
             **/
            NotForSale: AugmentedError<ApiType>;
            /**
             * The named owner has not signed ownership of the collection is acceptable.
             **/
            Unaccepted: AugmentedError<ApiType>;
            /**
             * No approval exists that would allow the transfer.
             **/
            Unapproved: AugmentedError<ApiType>;
            /**
             * The given item ID is unknown.
             **/
            UnknownCollection: AugmentedError<ApiType>;
            /**
             * The given item ID is unknown.
             **/
            UnknownItem: AugmentedError<ApiType>;
            /**
             * The delegate turned out to be different to what was expected.
             **/
            WrongDelegate: AugmentedError<ApiType>;
            /**
             * The owner turned out to be different to what was expected.
             **/
            WrongOwner: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        utility: {
            /**
             * Too many calls batched.
             **/
            TooManyCalls: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        vesting: {
            /**
             * Amount being transferred is too low to create a vesting schedule.
             **/
            AmountLow: AugmentedError<ApiType>;
            /**
             * The account already has `MaxVestingSchedules` count of schedules and thus
             * cannot add another one. Consider merging existing schedules in order to add another.
             **/
            AtMaxVestingSchedules: AugmentedError<ApiType>;
            /**
             * Failed to create a new schedule because some parameter was invalid.
             **/
            InvalidScheduleParams: AugmentedError<ApiType>;
            /**
             * The account given is not vesting.
             **/
            NotVesting: AugmentedError<ApiType>;
            /**
             * An index was out of bounds of the vesting schedules.
             **/
            ScheduleIndexOutOfBounds: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
        xcmpQueue: {
            /**
             * The execution is already resumed.
             **/
            AlreadyResumed: AugmentedError<ApiType>;
            /**
             * The execution is already suspended.
             **/
            AlreadySuspended: AugmentedError<ApiType>;
            /**
             * Setting the queue config failed since one of its values was invalid.
             **/
            BadQueueConfig: AugmentedError<ApiType>;
            /**
             * The message is too big.
             **/
            TooBig: AugmentedError<ApiType>;
            /**
             * There are too many active outbound channels.
             **/
            TooManyActiveOutboundChannels: AugmentedError<ApiType>;
            /**
             * Generic error
             **/
            [key: string]: AugmentedError<ApiType>;
        };
    }
}