import '@polkadot/api-base/types/events';
import type { ApiTypes, AugmentedEvent } from '@polkadot/api-base/types';
import type { Bytes, Null, Option, Result, U8aFixed, Vec, i64, u128, u16, u32, u64, u8 } from '@polkadot/types-codec';
import type { AccountId32, H256 } from '@polkadot/types/interfaces/runtime';
import type { FrameSupportDispatchDispatchInfo, FrameSupportTokensMiscBalanceStatus, PalletReactionsReactionKind, SpRuntimeDispatchError, SpWeightsWeightV2Weight, SubsocialParachainRuntimeProxyType, SubsocialSupportUser, XcmV1MultiLocation, XcmV2Response, XcmV2TraitsError, XcmV2TraitsOutcome, XcmV2Xcm, XcmVersionedMultiAssets, XcmVersionedMultiLocation } from '@polkadot/types/lookup';
export declare type __AugmentedEvent<ApiType extends ApiTypes> = AugmentedEvent<ApiType>;
declare module '@polkadot/api-base/types/events' {
    interface AugmentedEvents<ApiType extends ApiTypes> {
        accountFollows: {
            AccountFollowed: AugmentedEvent<ApiType, [follower: AccountId32, account: AccountId32], {
                follower: AccountId32;
                account: AccountId32;
            }>;
            AccountUnfollowed: AugmentedEvent<ApiType, [follower: AccountId32, account: AccountId32], {
                follower: AccountId32;
                account: AccountId32;
            }>;
        };
        balances: {
            /**
             * A balance was set by root.
             **/
            BalanceSet: AugmentedEvent<ApiType, [who: AccountId32, free: u128, reserved: u128], {
                who: AccountId32;
                free: u128;
                reserved: u128;
            }>;
            /**
             * Some amount was deposited (e.g. for transaction fees).
             **/
            Deposit: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * An account was removed whose balance was non-zero but below ExistentialDeposit,
             * resulting in an outright loss.
             **/
            DustLost: AugmentedEvent<ApiType, [account: AccountId32, amount: u128], {
                account: AccountId32;
                amount: u128;
            }>;
            /**
             * An account was created with some free balance.
             **/
            Endowed: AugmentedEvent<ApiType, [account: AccountId32, freeBalance: u128], {
                account: AccountId32;
                freeBalance: u128;
            }>;
            /**
             * Some balance was reserved (moved from free to reserved).
             **/
            Reserved: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * Some balance was moved from the reserve of the first account to the second account.
             * Final argument indicates the destination balance type.
             **/
            ReserveRepatriated: AugmentedEvent<ApiType, [from: AccountId32, to: AccountId32, amount: u128, destinationStatus: FrameSupportTokensMiscBalanceStatus], {
                from: AccountId32;
                to: AccountId32;
                amount: u128;
                destinationStatus: FrameSupportTokensMiscBalanceStatus;
            }>;
            /**
             * Some amount was removed from the account (e.g. for misbehavior).
             **/
            Slashed: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * Transfer succeeded.
             **/
            Transfer: AugmentedEvent<ApiType, [from: AccountId32, to: AccountId32, amount: u128], {
                from: AccountId32;
                to: AccountId32;
                amount: u128;
            }>;
            /**
             * Some balance was unreserved (moved from reserved to free).
             **/
            Unreserved: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
            /**
             * Some amount was withdrawn from the account (e.g. for transaction fees).
             **/
            Withdraw: AugmentedEvent<ApiType, [who: AccountId32, amount: u128], {
                who: AccountId32;
                amount: u128;
            }>;
        };
        collatorSelection: {
            CandidateAdded: AugmentedEvent<ApiType, [accountId: AccountId32, deposit: u128], {
                accountId: AccountId32;
                deposit: u128;
            }>;
            CandidateRemoved: AugmentedEvent<ApiType, [accountId: AccountId32], {
                accountId: AccountId32;
            }>;
            NewCandidacyBond: AugmentedEvent<ApiType, [bondAmount: u128], {
                bondAmount: u128;
            }>;
            NewDesiredCandidates: AugmentedEvent<ApiType, [desiredCandidates: u32], {
                desiredCandidates: u32;
            }>;
            NewInvulnerables: AugmentedEvent<ApiType, [invulnerables: Vec<AccountId32>], {
                invulnerables: Vec<AccountId32>;
            }>;
        };
        cumulusXcm: {
            /**
             * Downward message executed with the given outcome.
             * \[ id, outcome \]
             **/
            ExecutedDownward: AugmentedEvent<ApiType, [U8aFixed, XcmV2TraitsOutcome]>;
            /**
             * Downward message is invalid XCM.
             * \[ id \]
             **/
            InvalidFormat: AugmentedEvent<ApiType, [U8aFixed]>;
            /**
             * Downward message is unsupported version of XCM.
             * \[ id \]
             **/
            UnsupportedVersion: AugmentedEvent<ApiType, [U8aFixed]>;
        };
        dmpQueue: {
            /**
             * Downward message executed with the given outcome.
             **/
            ExecutedDownward: AugmentedEvent<ApiType, [messageId: U8aFixed, outcome: XcmV2TraitsOutcome], {
                messageId: U8aFixed;
                outcome: XcmV2TraitsOutcome;
            }>;
            /**
             * Downward message is invalid XCM.
             **/
            InvalidFormat: AugmentedEvent<ApiType, [messageId: U8aFixed], {
                messageId: U8aFixed;
            }>;
            /**
             * Downward message is overweight and was placed in the overweight queue.
             **/
            OverweightEnqueued: AugmentedEvent<ApiType, [messageId: U8aFixed, overweightIndex: u64, requiredWeight: SpWeightsWeightV2Weight], {
                messageId: U8aFixed;
                overweightIndex: u64;
                requiredWeight: SpWeightsWeightV2Weight;
            }>;
            /**
             * Downward message from the overweight queue was executed.
             **/
            OverweightServiced: AugmentedEvent<ApiType, [overweightIndex: u64, weightUsed: SpWeightsWeightV2Weight], {
                overweightIndex: u64;
                weightUsed: SpWeightsWeightV2Weight;
            }>;
            /**
             * Downward message is unsupported version of XCM.
             **/
            UnsupportedVersion: AugmentedEvent<ApiType, [messageId: U8aFixed], {
                messageId: U8aFixed;
            }>;
            /**
             * The weight limit for handling downward messages was reached.
             **/
            WeightExhausted: AugmentedEvent<ApiType, [messageId: U8aFixed, remainingWeight: SpWeightsWeightV2Weight, requiredWeight: SpWeightsWeightV2Weight], {
                messageId: U8aFixed;
                remainingWeight: SpWeightsWeightV2Weight;
                requiredWeight: SpWeightsWeightV2Weight;
            }>;
        };
        domains: {
            /**
             * The domain meta was successfully updated.
             **/
            DomainMetaUpdated: AugmentedEvent<ApiType, [who: AccountId32, domain: Bytes], {
                who: AccountId32;
                domain: Bytes;
            }>;
            /**
             * The domain name was successfully registered.
             **/
            DomainRegistered: AugmentedEvent<ApiType, [who: AccountId32, domain: Bytes], {
                who: AccountId32;
                domain: Bytes;
            }>;
            /**
             * Added support for new TLDs (top-level domains).
             **/
            NewTldsSupported: AugmentedEvent<ApiType, [count: u32], {
                count: u32;
            }>;
            /**
             * New words have been reserved.
             **/
            NewWordsReserved: AugmentedEvent<ApiType, [count: u32], {
                count: u32;
            }>;
        };
        energy: {
            /**
             * An account was removed whose balance was non-zero but below
             * ExistentialDeposit, resulting in an outright loss.
             **/
            DustLost: AugmentedEvent<ApiType, [account: AccountId32, amount: u128], {
                account: AccountId32;
                amount: u128;
            }>;
            /**
             * Energy have been generated to an account.
             **/
            EnergyGenerated: AugmentedEvent<ApiType, [generator: AccountId32, receiver: AccountId32, balanceBurned: u128], {
                generator: AccountId32;
                receiver: AccountId32;
                balanceBurned: u128;
            }>;
            /**
             * Energy value coefficient has been updated.
             **/
            ValueCoefficientUpdated: AugmentedEvent<ApiType, [newCoefficient: i64], {
                newCoefficient: i64;
            }>;
        };
        parachainSystem: {
            /**
             * Downward messages were processed using the given weight.
             **/
            DownwardMessagesProcessed: AugmentedEvent<ApiType, [weightUsed: SpWeightsWeightV2Weight, dmqHead: H256], {
                weightUsed: SpWeightsWeightV2Weight;
                dmqHead: H256;
            }>;
            /**
             * Some downward messages have been received and will be processed.
             **/
            DownwardMessagesReceived: AugmentedEvent<ApiType, [count: u32], {
                count: u32;
            }>;
            /**
             * An upgrade has been authorized.
             **/
            UpgradeAuthorized: AugmentedEvent<ApiType, [codeHash: H256], {
                codeHash: H256;
            }>;
            /**
             * The validation function was applied as of the contained relay chain block number.
             **/
            ValidationFunctionApplied: AugmentedEvent<ApiType, [relayChainBlockNum: u32], {
                relayChainBlockNum: u32;
            }>;
            /**
             * The relay-chain aborted the upgrade process.
             **/
            ValidationFunctionDiscarded: AugmentedEvent<ApiType, []>;
            /**
             * The validation function has been scheduled to apply.
             **/
            ValidationFunctionStored: AugmentedEvent<ApiType, []>;
        };
        polkadotXcm: {
            /**
             * Some assets have been claimed from an asset trap
             *
             * \[ hash, origin, assets \]
             **/
            AssetsClaimed: AugmentedEvent<ApiType, [H256, XcmV1MultiLocation, XcmVersionedMultiAssets]>;
            /**
             * Some assets have been placed in an asset trap.
             *
             * \[ hash, origin, assets \]
             **/
            AssetsTrapped: AugmentedEvent<ApiType, [H256, XcmV1MultiLocation, XcmVersionedMultiAssets]>;
            /**
             * Execution of an XCM message was attempted.
             *
             * \[ outcome \]
             **/
            Attempted: AugmentedEvent<ApiType, [XcmV2TraitsOutcome]>;
            /**
             * Expected query response has been received but the origin location of the response does
             * not match that expected. The query remains registered for a later, valid, response to
             * be received and acted upon.
             *
             * \[ origin location, id, expected location \]
             **/
            InvalidResponder: AugmentedEvent<ApiType, [XcmV1MultiLocation, u64, Option<XcmV1MultiLocation>]>;
            /**
             * Expected query response has been received but the expected origin location placed in
             * storage by this runtime previously cannot be decoded. The query remains registered.
             *
             * This is unexpected (since a location placed in storage in a previously executing
             * runtime should be readable prior to query timeout) and dangerous since the possibly
             * valid response will be dropped. Manual governance intervention is probably going to be
             * needed.
             *
             * \[ origin location, id \]
             **/
            InvalidResponderVersion: AugmentedEvent<ApiType, [XcmV1MultiLocation, u64]>;
            /**
             * Query response has been received and query is removed. The registered notification has
             * been dispatched and executed successfully.
             *
             * \[ id, pallet index, call index \]
             **/
            Notified: AugmentedEvent<ApiType, [u64, u8, u8]>;
            /**
             * Query response has been received and query is removed. The dispatch was unable to be
             * decoded into a `Call`; this might be due to dispatch function having a signature which
             * is not `(origin, QueryId, Response)`.
             *
             * \[ id, pallet index, call index \]
             **/
            NotifyDecodeFailed: AugmentedEvent<ApiType, [u64, u8, u8]>;
            /**
             * Query response has been received and query is removed. There was a general error with
             * dispatching the notification call.
             *
             * \[ id, pallet index, call index \]
             **/
            NotifyDispatchError: AugmentedEvent<ApiType, [u64, u8, u8]>;
            /**
             * Query response has been received and query is removed. The registered notification could
             * not be dispatched because the dispatch weight is greater than the maximum weight
             * originally budgeted by this runtime for the query result.
             *
             * \[ id, pallet index, call index, actual weight, max budgeted weight \]
             **/
            NotifyOverweight: AugmentedEvent<ApiType, [u64, u8, u8, SpWeightsWeightV2Weight, SpWeightsWeightV2Weight]>;
            /**
             * A given location which had a version change subscription was dropped owing to an error
             * migrating the location to our new XCM format.
             *
             * \[ location, query ID \]
             **/
            NotifyTargetMigrationFail: AugmentedEvent<ApiType, [XcmVersionedMultiLocation, u64]>;
            /**
             * A given location which had a version change subscription was dropped owing to an error
             * sending the notification to it.
             *
             * \[ location, query ID, error \]
             **/
            NotifyTargetSendFail: AugmentedEvent<ApiType, [XcmV1MultiLocation, u64, XcmV2TraitsError]>;
            /**
             * Query response has been received and is ready for taking with `take_response`. There is
             * no registered notification call.
             *
             * \[ id, response \]
             **/
            ResponseReady: AugmentedEvent<ApiType, [u64, XcmV2Response]>;
            /**
             * Received query response has been read and removed.
             *
             * \[ id \]
             **/
            ResponseTaken: AugmentedEvent<ApiType, [u64]>;
            /**
             * A XCM message was sent.
             *
             * \[ origin, destination, message \]
             **/
            Sent: AugmentedEvent<ApiType, [XcmV1MultiLocation, XcmV1MultiLocation, XcmV2Xcm]>;
            /**
             * The supported version of a location has been changed. This might be through an
             * automatic notification or a manual intervention.
             *
             * \[ location, XCM version \]
             **/
            SupportedVersionChanged: AugmentedEvent<ApiType, [XcmV1MultiLocation, u32]>;
            /**
             * Query response received which does not match a registered query. This may be because a
             * matching query was never registered, it may be because it is a duplicate response, or
             * because the query timed out.
             *
             * \[ origin location, id \]
             **/
            UnexpectedResponse: AugmentedEvent<ApiType, [XcmV1MultiLocation, u64]>;
            /**
             * An XCM version change notification message has been attempted to be sent.
             *
             * \[ destination, result \]
             **/
            VersionChangeNotified: AugmentedEvent<ApiType, [XcmV1MultiLocation, u32]>;
        };
        posts: {
            PostCreated: AugmentedEvent<ApiType, [account: AccountId32, postId: u64], {
                account: AccountId32;
                postId: u64;
            }>;
            PostMoved: AugmentedEvent<ApiType, [account: AccountId32, postId: u64, fromSpace: Option<u64>, toSpace: Option<u64>], {
                account: AccountId32;
                postId: u64;
                fromSpace: Option<u64>;
                toSpace: Option<u64>;
            }>;
            PostUpdated: AugmentedEvent<ApiType, [account: AccountId32, postId: u64], {
                account: AccountId32;
                postId: u64;
            }>;
        };
        profiles: {
            /**
             * Profile's space id was updated for this account.
             **/
            ProfileUpdated: AugmentedEvent<ApiType, [account: AccountId32, spaceId: Option<u64>], {
                account: AccountId32;
                spaceId: Option<u64>;
            }>;
        };
        proxy: {
            /**
             * An announcement was placed to make a call in the future.
             **/
            Announced: AugmentedEvent<ApiType, [real: AccountId32, proxy: AccountId32, callHash: H256], {
                real: AccountId32;
                proxy: AccountId32;
                callHash: H256;
            }>;
            /**
             * A proxy was added.
             **/
            ProxyAdded: AugmentedEvent<ApiType, [delegator: AccountId32, delegatee: AccountId32, proxyType: SubsocialParachainRuntimeProxyType, delay: u32], {
                delegator: AccountId32;
                delegatee: AccountId32;
                proxyType: SubsocialParachainRuntimeProxyType;
                delay: u32;
            }>;
            /**
             * A proxy was executed correctly, with the given.
             **/
            ProxyExecuted: AugmentedEvent<ApiType, [result: Result<Null, SpRuntimeDispatchError>], {
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * A proxy was removed.
             **/
            ProxyRemoved: AugmentedEvent<ApiType, [delegator: AccountId32, delegatee: AccountId32, proxyType: SubsocialParachainRuntimeProxyType, delay: u32], {
                delegator: AccountId32;
                delegatee: AccountId32;
                proxyType: SubsocialParachainRuntimeProxyType;
                delay: u32;
            }>;
            /**
             * A pure account has been created by new proxy with given
             * disambiguation index and proxy type.
             **/
            PureCreated: AugmentedEvent<ApiType, [pure: AccountId32, who: AccountId32, proxyType: SubsocialParachainRuntimeProxyType, disambiguationIndex: u16], {
                pure: AccountId32;
                who: AccountId32;
                proxyType: SubsocialParachainRuntimeProxyType;
                disambiguationIndex: u16;
            }>;
        };
        reactions: {
            PostReactionCreated: AugmentedEvent<ApiType, [account: AccountId32, postId: u64, reactionId: u64, reactionKind: PalletReactionsReactionKind], {
                account: AccountId32;
                postId: u64;
                reactionId: u64;
                reactionKind: PalletReactionsReactionKind;
            }>;
            PostReactionDeleted: AugmentedEvent<ApiType, [account: AccountId32, postId: u64, reactionId: u64, reactionKind: PalletReactionsReactionKind], {
                account: AccountId32;
                postId: u64;
                reactionId: u64;
                reactionKind: PalletReactionsReactionKind;
            }>;
            PostReactionUpdated: AugmentedEvent<ApiType, [account: AccountId32, postId: u64, reactionId: u64, reactionKind: PalletReactionsReactionKind], {
                account: AccountId32;
                postId: u64;
                reactionId: u64;
                reactionKind: PalletReactionsReactionKind;
            }>;
        };
        roles: {
            RoleCreated: AugmentedEvent<ApiType, [account: AccountId32, spaceId: u64, roleId: u64], {
                account: AccountId32;
                spaceId: u64;
                roleId: u64;
            }>;
            RoleDeleted: AugmentedEvent<ApiType, [account: AccountId32, roleId: u64], {
                account: AccountId32;
                roleId: u64;
            }>;
            RoleGranted: AugmentedEvent<ApiType, [account: AccountId32, roleId: u64, users: Vec<SubsocialSupportUser>], {
                account: AccountId32;
                roleId: u64;
                users: Vec<SubsocialSupportUser>;
            }>;
            RoleRevoked: AugmentedEvent<ApiType, [account: AccountId32, roleId: u64, users: Vec<SubsocialSupportUser>], {
                account: AccountId32;
                roleId: u64;
                users: Vec<SubsocialSupportUser>;
            }>;
            RoleUpdated: AugmentedEvent<ApiType, [account: AccountId32, roleId: u64], {
                account: AccountId32;
                roleId: u64;
            }>;
        };
        session: {
            /**
             * New session has happened. Note that the argument is the session index, not the
             * block number as the type might suggest.
             **/
            NewSession: AugmentedEvent<ApiType, [sessionIndex: u32], {
                sessionIndex: u32;
            }>;
        };
        spaceFollows: {
            SpaceFollowed: AugmentedEvent<ApiType, [follower: AccountId32, spaceId: u64], {
                follower: AccountId32;
                spaceId: u64;
            }>;
            SpaceUnfollowed: AugmentedEvent<ApiType, [follower: AccountId32, spaceId: u64], {
                follower: AccountId32;
                spaceId: u64;
            }>;
        };
        spaceOwnership: {
            SpaceOwnershipTransferAccepted: AugmentedEvent<ApiType, [account: AccountId32, spaceId: u64], {
                account: AccountId32;
                spaceId: u64;
            }>;
            SpaceOwnershipTransferCreated: AugmentedEvent<ApiType, [currentOwner: AccountId32, spaceId: u64, newOwner: AccountId32], {
                currentOwner: AccountId32;
                spaceId: u64;
                newOwner: AccountId32;
            }>;
            SpaceOwnershipTransferRejected: AugmentedEvent<ApiType, [account: AccountId32, spaceId: u64], {
                account: AccountId32;
                spaceId: u64;
            }>;
        };
        spaces: {
            SpaceCreated: AugmentedEvent<ApiType, [account: AccountId32, spaceId: u64], {
                account: AccountId32;
                spaceId: u64;
            }>;
            SpaceUpdated: AugmentedEvent<ApiType, [account: AccountId32, spaceId: u64], {
                account: AccountId32;
                spaceId: u64;
            }>;
        };
        sudo: {
            /**
             * The \[sudoer\] just switched identity; the old key is supplied if one existed.
             **/
            KeyChanged: AugmentedEvent<ApiType, [oldSudoer: Option<AccountId32>], {
                oldSudoer: Option<AccountId32>;
            }>;
            /**
             * A sudo just took place. \[result\]
             **/
            Sudid: AugmentedEvent<ApiType, [sudoResult: Result<Null, SpRuntimeDispatchError>], {
                sudoResult: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * A sudo just took place. \[result\]
             **/
            SudoAsDone: AugmentedEvent<ApiType, [sudoResult: Result<Null, SpRuntimeDispatchError>], {
                sudoResult: Result<Null, SpRuntimeDispatchError>;
            }>;
        };
        system: {
            /**
             * `:code` was updated.
             **/
            CodeUpdated: AugmentedEvent<ApiType, []>;
            /**
             * An extrinsic failed.
             **/
            ExtrinsicFailed: AugmentedEvent<ApiType, [dispatchError: SpRuntimeDispatchError, dispatchInfo: FrameSupportDispatchDispatchInfo], {
                dispatchError: SpRuntimeDispatchError;
                dispatchInfo: FrameSupportDispatchDispatchInfo;
            }>;
            /**
             * An extrinsic completed successfully.
             **/
            ExtrinsicSuccess: AugmentedEvent<ApiType, [dispatchInfo: FrameSupportDispatchDispatchInfo], {
                dispatchInfo: FrameSupportDispatchDispatchInfo;
            }>;
            /**
             * An account was reaped.
             **/
            KilledAccount: AugmentedEvent<ApiType, [account: AccountId32], {
                account: AccountId32;
            }>;
            /**
             * A new account was created.
             **/
            NewAccount: AugmentedEvent<ApiType, [account: AccountId32], {
                account: AccountId32;
            }>;
            /**
             * On on-chain remark happened.
             **/
            Remarked: AugmentedEvent<ApiType, [sender: AccountId32, hash_: H256], {
                sender: AccountId32;
                hash_: H256;
            }>;
        };
        transactionPayment: {
            /**
             * A transaction fee `actual_fee`, of which `tip` was added to the minimum inclusion fee,
             * has been paid by `who`.
             **/
            TransactionFeePaid: AugmentedEvent<ApiType, [who: AccountId32, actualFee: u128, tip: u128], {
                who: AccountId32;
                actualFee: u128;
                tip: u128;
            }>;
        };
        utility: {
            /**
             * Batch of dispatches completed fully with no error.
             **/
            BatchCompleted: AugmentedEvent<ApiType, []>;
            /**
             * Batch of dispatches completed but has errors.
             **/
            BatchCompletedWithErrors: AugmentedEvent<ApiType, []>;
            /**
             * Batch of dispatches did not complete fully. Index of first failing dispatch given, as
             * well as the error.
             **/
            BatchInterrupted: AugmentedEvent<ApiType, [index: u32, error: SpRuntimeDispatchError], {
                index: u32;
                error: SpRuntimeDispatchError;
            }>;
            /**
             * A call was dispatched.
             **/
            DispatchedAs: AugmentedEvent<ApiType, [result: Result<Null, SpRuntimeDispatchError>], {
                result: Result<Null, SpRuntimeDispatchError>;
            }>;
            /**
             * A single item within a Batch of dispatches has completed with no error.
             **/
            ItemCompleted: AugmentedEvent<ApiType, []>;
            /**
             * A single item within a Batch of dispatches has completed with error.
             **/
            ItemFailed: AugmentedEvent<ApiType, [error: SpRuntimeDispatchError], {
                error: SpRuntimeDispatchError;
            }>;
        };
        vesting: {
            /**
             * An \[account\] has become fully vested.
             **/
            VestingCompleted: AugmentedEvent<ApiType, [account: AccountId32], {
                account: AccountId32;
            }>;
            /**
             * The amount vested has been updated. This could indicate a change in funds available.
             * The balance given is the amount which is left unvested (and thus locked).
             **/
            VestingUpdated: AugmentedEvent<ApiType, [account: AccountId32, unvested: u128], {
                account: AccountId32;
                unvested: u128;
            }>;
        };
        xcmpQueue: {
            /**
             * Bad XCM format used.
             **/
            BadFormat: AugmentedEvent<ApiType, [messageHash: Option<H256>], {
                messageHash: Option<H256>;
            }>;
            /**
             * Bad XCM version used.
             **/
            BadVersion: AugmentedEvent<ApiType, [messageHash: Option<H256>], {
                messageHash: Option<H256>;
            }>;
            /**
             * Some XCM failed.
             **/
            Fail: AugmentedEvent<ApiType, [messageHash: Option<H256>, error: XcmV2TraitsError, weight: SpWeightsWeightV2Weight], {
                messageHash: Option<H256>;
                error: XcmV2TraitsError;
                weight: SpWeightsWeightV2Weight;
            }>;
            /**
             * An XCM exceeded the individual message weight budget.
             **/
            OverweightEnqueued: AugmentedEvent<ApiType, [sender: u32, sentAt: u32, index: u64, required: SpWeightsWeightV2Weight], {
                sender: u32;
                sentAt: u32;
                index: u64;
                required: SpWeightsWeightV2Weight;
            }>;
            /**
             * An XCM from the overweight queue was executed with the given actual weight used.
             **/
            OverweightServiced: AugmentedEvent<ApiType, [index: u64, used: SpWeightsWeightV2Weight], {
                index: u64;
                used: SpWeightsWeightV2Weight;
            }>;
            /**
             * Some XCM was executed ok.
             **/
            Success: AugmentedEvent<ApiType, [messageHash: Option<H256>, weight: SpWeightsWeightV2Weight], {
                messageHash: Option<H256>;
                weight: SpWeightsWeightV2Weight;
            }>;
            /**
             * An upward message was sent to the relay chain.
             **/
            UpwardMessageSent: AugmentedEvent<ApiType, [messageHash: Option<H256>], {
                messageHash: Option<H256>;
            }>;
            /**
             * An HRMP message was sent to a sibling parachain.
             **/
            XcmpMessageSent: AugmentedEvent<ApiType, [messageHash: Option<H256>], {
                messageHash: Option<H256>;
            }>;
        };
    }
}